Merge branch '4.6' into mmfphonon

126 files changed, 2788 insertions, 1448 deletions

diff --git a/src/gui/accessible/qaccessible.h b/src/gui/accessible/qaccessible.h
index 8f6d9d9..c493054 100644
--- a/src/gui/accessible/qaccessible.h
+++ b/src/gui/accessible/qaccessible.h
@@ -311,7 +311,8 @@ namespace QAccessible2
         EditableTextInterface,
         ValueInterface,
         TableInterface,
-        ActionInterface
+        ActionInterface,
+        ImageInterface
     };
 }
 
@@ -321,6 +322,7 @@ class QAccessibleEditableTextInterface;
 class QAccessibleValueInterface;
 class QAccessibleTableInterface;
 class QAccessibleActionInterface;
+class QAccessibleImageInterface;
 
 class Q_GUI_EXPORT QAccessibleInterface : public QAccessible
 {
@@ -381,6 +383,9 @@ public:
     inline QAccessibleActionInterface *actionInterface()
     { return reinterpret_cast<QAccessibleActionInterface *>(cast_helper(QAccessible2::ActionInterface)); }
 
+    inline QAccessibleImageInterface *imageInterface()
+    { return reinterpret_cast<QAccessibleImageInterface *>(cast_helper(QAccessible2::ImageInterface)); }
+
 private:
     QAccessible2Interface *cast_helper(QAccessible2::InterfaceType);
 };
diff --git a/src/gui/accessible/qaccessible2.cpp b/src/gui/accessible/qaccessible2.cpp
index 0867368..b878cf1 100644
--- a/src/gui/accessible/qaccessible2.cpp
+++ b/src/gui/accessible/qaccessible2.cpp
@@ -120,6 +120,18 @@ QT_BEGIN_NAMESPACE
     \link http://www.linux-foundation.org/en/Accessibility/IAccessible2 IAccessible2 Specification \endlink
 */
 
+/*!
+    \class QAccessibleImageInterface
+    \ingroup accessibility
+    \internal
+    \preliminary
+
+    \brief The QAccessibleImageInterface class implements support for
+    the IAccessibleImage interface.
+
+    \link http://www.linux-foundation.org/en/Accessibility/IAccessible2 IAccessible2 Specification \endlink
+*/
+
 QAccessibleSimpleEditableTextInterface::QAccessibleSimpleEditableTextInterface(
                 QAccessibleInterface *accessibleInterface)
     : iface(accessibleInterface)
diff --git a/src/gui/accessible/qaccessible2.h b/src/gui/accessible/qaccessible2.h
index 435c640..ba12a7c 100644
--- a/src/gui/accessible/qaccessible2.h
+++ b/src/gui/accessible/qaccessible2.h
@@ -82,6 +82,7 @@ inline QAccessible2Interface *qAccessibleTextCastHelper() { return 0; }
 inline QAccessible2Interface *qAccessibleEditableTextCastHelper() { return 0; }
 inline QAccessible2Interface *qAccessibleTableCastHelper() { return 0; }
 inline QAccessible2Interface *qAccessibleActionCastHelper() { return 0; }
+inline QAccessible2Interface *qAccessibleImageCastHelper() { return 0; }
 
 #define Q_ACCESSIBLE_OBJECT \
     public: \
@@ -98,6 +99,8 @@ inline QAccessible2Interface *qAccessibleActionCastHelper() { return 0; }
             return qAccessibleTableCastHelper(); \
         case QAccessible2::ActionInterface: \
             return qAccessibleActionCastHelper(); \
+        case QAccessible2::ImageInterface: \
+            return qAccessibleImageCastHelper(); \
         } \
         return 0; \
     } \
@@ -224,6 +227,16 @@ public:
     virtual QStringList keyBindings(int actionIndex) = 0;
 };
 
+class Q_GUI_EXPORT QAccessibleImageInterface : public QAccessible2Interface
+{
+public:
+    inline QAccessible2Interface *qAccessibleImageCastHelper() { return this; }
+
+    virtual QString imageDescription() = 0;
+    virtual QSize imageSize() = 0;
+    virtual QRect imagePosition(QAccessible2::CoordinateType coordType) = 0;
+};
+
 #endif // QT_NO_ACCESSIBILITY
 
 QT_END_NAMESPACE
diff --git a/src/gui/accessible/qaccessible_mac.mm b/src/gui/accessible/qaccessible_mac.mm
index 9575ad8..030c1a9 100644
--- a/src/gui/accessible/qaccessible_mac.mm
+++ b/src/gui/accessible/qaccessible_mac.mm
@@ -504,11 +504,6 @@ QAElement::QAElement(const QAElement &element)
 }
 
 QAElement::QAElement(HIObjectRef object, int child)
-    :elementRef(
-#ifndef QT_MAC_USE_COCOA
-                AXUIElementCreateWithHIObjectAndIdentifier(object, child)
-#endif
-)
 {
 #ifndef QT_MAC_USE_COCOA
     if (object == 0) {
diff --git a/src/gui/dialogs/qcolordialog_mac.mm b/src/gui/dialogs/qcolordialog_mac.mm
index 9e4fdd1..5f074c0 100644
--- a/src/gui/dialogs/qcolordialog_mac.mm
+++ b/src/gui/dialogs/qcolordialog_mac.mm
@@ -252,15 +252,20 @@ QT_USE_NAMESPACE
     delete mQtColor;
     mQtColor = new QColor();
     NSColor *color = [mColorPanel color];
-    NSString *colorSpace = [color colorSpaceName];
-    if (colorSpace == NSDeviceCMYKColorSpace) {
-        CGFloat cyan, magenta, yellow, black, alpha;
+    NSString *colorSpaceName = [color colorSpaceName];
+    if (colorSpaceName == NSDeviceCMYKColorSpace) {
+        CGFloat cyan = 0, magenta = 0, yellow = 0, black = 0, alpha = 0;
         [color getCyan:&cyan magenta:&magenta yellow:&yellow black:&black alpha:&alpha];
         mQtColor->setCmykF(cyan, magenta, yellow, black, alpha);
-    } else if (colorSpace == NSCalibratedRGBColorSpace || colorSpace == NSDeviceRGBColorSpace)  {
-        CGFloat red, green, blue, alpha;
+    } else if (colorSpaceName == NSCalibratedRGBColorSpace || colorSpaceName == NSDeviceRGBColorSpace)  {
+        CGFloat red = 0, green = 0, blue = 0, alpha = 0;
         [color getRed:&red green:&green blue:&blue alpha:&alpha];
         mQtColor->setRgbF(red, green, blue, alpha);
+    } else if (colorSpaceName == NSNamedColorSpace) {
+        NSColor *tmpColor = [color colorUsingColorSpaceName:NSCalibratedRGBColorSpace];
+        CGFloat red = 0, green = 0, blue = 0, alpha = 0;
+        [tmpColor getRed:&red green:&green blue:&blue alpha:&alpha];
+        mQtColor->setRgbF(red, green, blue, alpha);
     } else {
         NSColorSpace *colorSpace = [color colorSpace];
         if ([colorSpace colorSpaceModel] == NSCMYKColorSpaceModel && [color numberOfComponents] == 5){
@@ -269,7 +274,7 @@ QT_USE_NAMESPACE
             mQtColor->setCmykF(components[0], components[1], components[2], components[3], components[4]);
         } else {
             NSColor *tmpColor = [color colorUsingColorSpaceName:NSCalibratedRGBColorSpace];
-            CGFloat red, green, blue, alpha;
+            CGFloat red = 0, green = 0, blue = 0, alpha = 0;
             [tmpColor getRed:&red green:&green blue:&blue alpha:&alpha];
             mQtColor->setRgbF(red, green, blue, alpha);
         }
@@ -319,7 +324,18 @@ QT_USE_NAMESPACE
     QBoolBlocker nativeDialogOnTop(QApplicationPrivate::native_modal_dialog_active);
     QMacCocoaAutoReleasePool pool;
     mDialogIsExecuting = true;
-    [NSApp runModalForWindow:mColorPanel];
+    bool modalEnded = false;
+    while (!modalEnded) {
+        @try {
+            [NSApp runModalForWindow:mColorPanel];
+            modalEnded = true;
+        } @catch (NSException *) {
+            // For some reason, NSColorPanel throws an exception when
+            // clicking on 'SelectedMenuItemColor' from the 'Developer'
+            // palette (tab three).
+        }
+    }
+
     QAbstractEventDispatcher::instance()->interrupt();
     if (mResultCode == NSCancelButton)
         mPriv->colorDialog()->reject();
diff --git a/src/gui/dialogs/qfiledialog.cpp b/src/gui/dialogs/qfiledialog.cpp
index 6bc6b76..3b1befd 100644
--- a/src/gui/dialogs/qfiledialog.cpp
+++ b/src/gui/dialogs/qfiledialog.cpp
@@ -3022,12 +3022,6 @@ bool QFileDialogPrivate::itemViewKeyboardEvent(QKeyEvent *event) {
     case Qt::Key_Escape:
         q->hide();
         return true;
-#ifdef QT_KEYPAD_NAVIGATION
-    case Qt::Key_Down:
-    case Qt::Key_Up:
-        return (QApplication::navigationMode() != Qt::NavigationModeKeypadTabOrder
-                && QApplication::navigationMode() != Qt::NavigationModeKeypadDirectional);
-#endif
     default:
         break;
     }
@@ -3145,20 +3139,16 @@ QSize QFileDialogListView::sizeHint() const
 
 void QFileDialogListView::keyPressEvent(QKeyEvent *e)
 {
-    if (!d_ptr->itemViewKeyboardEvent(e)) {
-        QListView::keyPressEvent(e);
-    }
 #ifdef QT_KEYPAD_NAVIGATION
-    else if ((QApplication::navigationMode() == Qt::NavigationModeKeypadTabOrder
-         || QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional)
-         && !hasEditFocus()) {
-         e->ignore();
-    } else {
-        e->accept();
+    if (QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional) {
+        QListView::keyPressEvent(e);
+        return;
     }
-#else
+#endif // QT_KEYPAD_NAVIGATION
+
+    if (!d_ptr->itemViewKeyboardEvent(e))
+        QListView::keyPressEvent(e);
     e->accept();
-#endif
 }
 
 QFileDialogTreeView::QFileDialogTreeView(QWidget *parent) : QTreeView(parent)
@@ -3184,20 +3174,16 @@ void QFileDialogTreeView::init(QFileDialogPrivate *d_pointer)
 
 void QFileDialogTreeView::keyPressEvent(QKeyEvent *e)
 {
-    if (!d_ptr->itemViewKeyboardEvent(e)) {
-        QTreeView::keyPressEvent(e);
-    }
 #ifdef QT_KEYPAD_NAVIGATION
-    else if ((QApplication::navigationMode() == Qt::NavigationModeKeypadTabOrder
-         || QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional)
-         && !hasEditFocus()) {
-         e->ignore();
-    } else {
-        e->accept();
+    if (QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional) {
+        QTreeView::keyPressEvent(e);
+        return;
     }
-#else
+#endif // QT_KEYPAD_NAVIGATION
+
+    if (!d_ptr->itemViewKeyboardEvent(e))
+        QTreeView::keyPressEvent(e);
     e->accept();
-#endif
 }
 
 QSize QFileDialogTreeView::sizeHint() const
@@ -3213,13 +3199,16 @@ QSize QFileDialogTreeView::sizeHint() const
 */
 void QFileDialogLineEdit::keyPressEvent(QKeyEvent *e)
 {
+#ifdef QT_KEYPAD_NAVIGATION
+    if (QApplication::navigationMode() == Qt::NavigationModeKeypadDirectional) {
+        QLineEdit::keyPressEvent(e);
+        return;
+    }
+#endif // QT_KEYPAD_NAVIGATION
+
     int key = e->key();
     QLineEdit::keyPressEvent(e);
-    if (key != Qt::Key_Escape
-#ifdef QT_KEYPAD_NAVIGATION
-        && QApplication::navigationMode() == Qt::NavigationModeNone
-#endif
-        )
+    if (key != Qt::Key_Escape)
         e->accept();
     if (hideOnEsc && (key == Qt::Key_Escape || key == Qt::Key_Return || key == Qt::Key_Enter)) {
         e->accept();
diff --git a/src/gui/dialogs/qfiledialog_mac.mm b/src/gui/dialogs/qfiledialog_mac.mm
index 4af5688..b0e6575 100644
--- a/src/gui/dialogs/qfiledialog_mac.mm
+++ b/src/gui/dialogs/qfiledialog_mac.mm
@@ -830,8 +830,8 @@ void QFileDialogPrivate::qt_mac_filedialog_event_proc(const NavEventCallbackMess
                     || mode == QFileDialog::ExistingFiles){
                 // When changing directory, the current selection is cleared if
                 // we are supposed to be selecting files only:
-                fileDialogPrivate->mCurrentSelectionList.clear();
                 if (!fileDialogPrivate->mCurrentSelection.isEmpty()){
+                    fileDialogPrivate->mCurrentSelectionList.clear();
                     fileDialogPrivate->mCurrentSelection.clear();
                     emit fileDialogPrivate->q_func()->currentChanged(fileDialogPrivate->mCurrentSelection);
                 }
diff --git a/src/gui/effects/qgraphicseffect.cpp b/src/gui/effects/qgraphicseffect.cpp
index b170254..568ff73 100644
--- a/src/gui/effects/qgraphicseffect.cpp
+++ b/src/gui/effects/qgraphicseffect.cpp
@@ -108,6 +108,7 @@
 #include <QtCore/qdebug.h>
 #include <private/qdrawhelper_p.h>
 
+#ifndef QT_NO_GRAPHICSEFFECT
 QT_BEGIN_NAMESPACE
 
 /*!
@@ -127,6 +128,19 @@ QT_BEGIN_NAMESPACE
 */
 
 /*!
+    \enum QGraphicsEffectSource::PixmapPadMode
+
+    This enum describes how much of the effect will be rendered to a pixmap
+    created using the pixmap() function.
+
+    \value NoExpandPadMode  The pixmap is the size of the widget or graphics item.
+    \value ExpandToTransparentBorderPadMode  The pixmap is expanded to include
+        the widget or graphics item plus a transparent border.
+    \value ExpandToEffectRectPadMode  The pixmap is expanded to include the widget
+        or graphics item and the effect.
+*/
+
+/*!
     \internal
 */
 QGraphicsEffectSource::QGraphicsEffectSource(QGraphicsEffectSourcePrivate &dd, QObject *parent)
@@ -263,6 +277,9 @@ bool QGraphicsEffectSource::isPixmap() const
     The optional \a offset parameter returns the offset where the pixmap should
     be painted at using the current painter.
 
+    The \a mode determines how much of the effect the pixmap will contain.
+    By default, the pixmap will contain the whole effect.
+
     The returned pixmap is bound to the current painter's device rectangle when
     \a system is Qt::DeviceCoordinates.
 
@@ -739,7 +756,7 @@ void QGraphicsBlurEffect::setBlurHint(QGraphicsBlurEffect::BlurHint hint)
 }
 
 /*!
-    \fn void QGraphicsBlurEffect::blurHintChanged(Qt::BlurHint hint)
+    \fn void QGraphicsBlurEffect::blurHintChanged(QGraphicsBlurEffect::BlurHint hint)
 
     This signal is emitted whenever the effect's blur hint changes.
     The \a hint parameter holds the effect's new blur hint.
@@ -1133,3 +1150,4 @@ void QGraphicsOpacityEffect::draw(QPainter *painter, QGraphicsEffectSource *sour
 
 QT_END_NAMESPACE
 
+#endif //QT_NO_GRAPHICSEFFECT
diff --git a/src/gui/effects/qgraphicseffect.h b/src/gui/effects/qgraphicseffect.h
index 7335a25..5c73f4b 100644
--- a/src/gui/effects/qgraphicseffect.h
+++ b/src/gui/effects/qgraphicseffect.h
@@ -48,6 +48,7 @@
 #include <QtGui/qcolor.h>
 #include <QtGui/qbrush.h>
 
+#ifndef QT_NO_GRAPHICSEFFECT
 QT_BEGIN_HEADER
 
 QT_BEGIN_NAMESPACE
@@ -302,6 +303,7 @@ private:
 QT_END_NAMESPACE
 
 QT_END_HEADER
+#endif //QT_NO_GRAPHICSEFFECT
 
 #endif // QGRAPHICSEFFECT_H
 
diff --git a/src/gui/effects/qgraphicseffect_p.h b/src/gui/effects/qgraphicseffect_p.h
index 370efdd..d94d08d 100644
--- a/src/gui/effects/qgraphicseffect_p.h
+++ b/src/gui/effects/qgraphicseffect_p.h
@@ -60,6 +60,7 @@
 #include <private/qobject_p.h>
 #include <private/qpixmapfilter_p.h>
 
+#ifndef QT_NO_GRAPHICSEFFECT
 QT_BEGIN_NAMESPACE
 
 class QGraphicsEffectSourcePrivate : public QObjectPrivate
@@ -179,5 +180,6 @@ public:
 
 QT_END_NAMESPACE
 
+#endif //QT_NO_GRAPHICSEFFECT
 #endif // QGRAPHICSEFFECT_P_H
 
diff --git a/src/gui/egl/egl.pri b/src/gui/egl/egl.pri
index 627d511..669d311 100644
--- a/src/gui/egl/egl.pri
+++ b/src/gui/egl/egl.pri
@@ -1,3 +1,5 @@
+CONFIG += egl
+
 HEADERS += \
     egl/qegl_p.h \
     egl/qeglproperties_p.h
@@ -19,11 +21,3 @@ unix {
         }
     }
 }
-
-for(p, QMAKE_LIBDIR_EGL) {
-    exists($$p):LIBS_PRIVATE += -L$$p
-}
-
-!isEmpty(QMAKE_INCDIR_EGL): INCLUDEPATH += $$QMAKE_INCDIR_EGL
-!isEmpty(QMAKE_LIBS_EGL): LIBS_PRIVATE += $$QMAKE_LIBS_EGL
-!isEmpty(QMAKE_LFLAGS_EGL): LIBS += $$QMAKE_LFLAGS_EGL
diff --git a/src/gui/graphicsview/qgraph_p.h b/src/gui/graphicsview/qgraph_p.h
index f1fa185..0a2bf27 100644
--- a/src/gui/graphicsview/qgraph_p.h
+++ b/src/gui/graphicsview/qgraph_p.h
@@ -201,11 +201,6 @@ public:
         return l;
     }
 
-    void setRootVertex(Vertex *vertex)
-    {
-        userVertex = vertex;
-    }
-
     QSet<Vertex*> vertices() const {
         QSet<Vertex *> setOfVertices;
         for (const_iterator it = constBegin(); it != constEnd(); ++it) {
@@ -241,7 +236,7 @@ public:
                 EdgeData *data = edgeData(v, v1);
                 bool forward = data->from == v;
                 if (forward) {
-                    edges += QString::fromAscii("%1->%2 [label=\"[%3,%4,%5]\" dir=both color=\"#000000:#a0a0a0\"] \n")
+                    edges += QString::fromAscii("\"%1\"->\"%2\" [label=\"[%3,%4,%5]\" dir=both color=\"#000000:#a0a0a0\"] \n")
                         .arg(v->toString())
                         .arg(v1->toString())
                         .arg(data->minSize)
@@ -250,17 +245,12 @@ public:
                         ;
                 }
             }
-            strVertices += QString::fromAscii("%1 [label=\"%2\"]\n").arg(v->toString()).arg(v->toString());
+            strVertices += QString::fromAscii("\"%1\" [label=\"%2\"]\n").arg(v->toString()).arg(v->toString());
         }
         return QString::fromAscii("%1\n%2\n").arg(strVertices).arg(edges);
     }
 #endif
 
-    Vertex *rootVertex() const
-    {
-        return userVertex;
-    }
-
 protected:
     void createDirectedEdge(Vertex *from, Vertex *to, EdgeData *data)
     {
@@ -286,8 +276,6 @@ protected:
     }
 
 private:
-    Vertex *userVertex;
-
     QHash<Vertex *, QHash<Vertex *, EdgeData *> *> m_graph;
 };
 
diff --git a/src/gui/graphicsview/qgraphicsanchorlayout.cpp b/src/gui/graphicsview/qgraphicsanchorlayout.cpp
index 56d70e1..872ec3c 100644
--- a/src/gui/graphicsview/qgraphicsanchorlayout.cpp
+++ b/src/gui/graphicsview/qgraphicsanchorlayout.cpp
@@ -83,10 +83,8 @@
     \clearfloat
     \section1 Size Hints and Size Policies in an Anchor Layout
 
-    QGraphicsAnchorLayout respects each item's size hints and size policies. However it does
-    not currently respect their stretch factors. This might change in the future, so avoid
-    using stretch factors in anchor layouts if you want to avoid any future regressions in
-    behavior.
+    QGraphicsAnchorLayout respects each item's size hints and size policies.
+    Note that there are some properties of QSizePolicy that are \l{Known issues}{not respected}.
 
     \section1 Spacing within an Anchor Layout
 
@@ -101,6 +99,21 @@
 
     If the spacing is negative, the items will overlap to some extent.
 
+
+    \section1 Known issues
+    There are some features that QGraphicsAnchorLayout currently does not support.
+    This might change in the future, so avoid using these features if you want to
+    avoid any future regressions in behaviour:
+    \list
+
+    \o Stretch factors are not respected.
+
+    \o QSizePolicy::ExpandFlag is not respected.
+
+    \o Height for width is not respected.
+
+    \endlist
+
     \sa QGraphicsLinearLayout, QGraphicsGridLayout, QGraphicsLayout
 */
 
diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
index 41aa8aa..182594e 100644
--- a/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
+++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.cpp
@@ -61,6 +61,8 @@ QGraphicsAnchorPrivate::QGraphicsAnchorPrivate(int version)
 
 QGraphicsAnchorPrivate::~QGraphicsAnchorPrivate()
 {
+    // ###
+    layoutPrivate->restoreSimplifiedGraph(QGraphicsAnchorLayoutPrivate::Orientation(data->orientation));
     layoutPrivate->removeAnchor(data->from, data->to);
 }
 
@@ -105,7 +107,7 @@ qreal QGraphicsAnchorPrivate::spacing() const
 static void internalSizeHints(QSizePolicy::Policy policy,
                               qreal minSizeHint, qreal prefSizeHint, qreal maxSizeHint,
                               qreal *minSize, qreal *prefSize,
-                              qreal *expSize, qreal *maxSize)
+                              qreal *maxSize)
 {
     // minSize, prefSize and maxSize are initialized
     // with item's preferred Size: this is QSizePolicy::Fixed.
@@ -135,11 +137,6 @@ static void internalSizeHints(QSizePolicy::Policy policy,
         *prefSize = *minSize;
     else
         *prefSize = prefSizeHint;
-
-    if (policy & QSizePolicy::ExpandFlag)
-        *expSize = *maxSize;
-    else
-        *expSize = *prefSize;
 }
 
 bool AnchorData::refreshSizeHints(const QLayoutStyleInfo *styleInfo)
@@ -154,7 +151,6 @@ bool AnchorData::refreshSizeHints(const QLayoutStyleInfo *styleInfo)
         if (isLayoutAnchor) {
             minSize = 0;
             prefSize = 0;
-            expSize = 0;
             maxSize = QWIDGETSIZE_MAX;
             if (isCenterAnchor)
                 maxSize /= 2;
@@ -205,8 +201,8 @@ bool AnchorData::refreshSizeHints(const QLayoutStyleInfo *styleInfo)
         }
         maxSizeHint = QWIDGETSIZE_MAX;
     }
-    internalSizeHints(policy, minSizeHint, prefSizeHint, maxSizeHint, 
-                      &minSize, &prefSize, &expSize, &maxSize);
+    internalSizeHints(policy, minSizeHint, prefSizeHint, maxSizeHint,
+                      &minSize, &prefSize, &maxSize);
 
     // Set the anchor effective sizes to preferred.
     //
@@ -217,7 +213,6 @@ bool AnchorData::refreshSizeHints(const QLayoutStyleInfo *styleInfo)
     // recalculate and override the values we set here.
     sizeAtMinimum = prefSize;
     sizeAtPreferred = prefSize;
-    sizeAtExpanding = prefSize;
     sizeAtMaximum = prefSize;
 
     return true;
@@ -225,10 +220,20 @@ bool AnchorData::refreshSizeHints(const QLayoutStyleInfo *styleInfo)
 
 void ParallelAnchorData::updateChildrenSizes()
 {
-    firstEdge->sizeAtMinimum = secondEdge->sizeAtMinimum = sizeAtMinimum;
-    firstEdge->sizeAtPreferred = secondEdge->sizeAtPreferred = sizeAtPreferred;
-    firstEdge->sizeAtExpanding = secondEdge->sizeAtExpanding = sizeAtExpanding;
-    firstEdge->sizeAtMaximum = secondEdge->sizeAtMaximum = sizeAtMaximum;
+    firstEdge->sizeAtMinimum = sizeAtMinimum;
+    firstEdge->sizeAtPreferred = sizeAtPreferred;
+    firstEdge->sizeAtMaximum = sizeAtMaximum;
+
+    const bool secondFwd = (secondEdge->from == from);
+    if (secondFwd) {
+        secondEdge->sizeAtMinimum = sizeAtMinimum;
+        secondEdge->sizeAtPreferred = sizeAtPreferred;
+        secondEdge->sizeAtMaximum = sizeAtMaximum;
+    } else {
+        secondEdge->sizeAtMinimum = -sizeAtMinimum;
+        secondEdge->sizeAtPreferred = -sizeAtPreferred;
+        secondEdge->sizeAtMaximum = -sizeAtMaximum;
+    }
 
     firstEdge->updateChildrenSizes();
     secondEdge->updateChildrenSizes();
@@ -247,8 +252,16 @@ bool ParallelAnchorData::refreshSizeHints_helper(const QLayoutStyleInfo *styleIn
         return false;
     }
 
-    minSize = qMax(firstEdge->minSize, secondEdge->minSize);
-    maxSize = qMin(firstEdge->maxSize, secondEdge->maxSize);
+    // Account for parallel anchors where the second edge is backwards.
+    // We rely on the fact that a forward anchor of sizes min, pref, max is equivalent
+    // to a backwards anchor of size (-max, -pref, -min)
+    const bool secondFwd = (secondEdge->from == from);
+    const qreal secondMin = secondFwd ? secondEdge->minSize : -secondEdge->maxSize;
+    const qreal secondPref = secondFwd ? secondEdge->prefSize : -secondEdge->prefSize;
+    const qreal secondMax = secondFwd ? secondEdge->maxSize : -secondEdge->minSize;
+
+    minSize = qMax(firstEdge->minSize, secondMin);
+    maxSize = qMin(firstEdge->maxSize, secondMax);
 
     // This condition means that the maximum size of one anchor being simplified is smaller than
     // the minimum size of the other anchor. The consequence is that there won't be a valid size
@@ -257,16 +270,27 @@ bool ParallelAnchorData::refreshSizeHints_helper(const QLayoutStyleInfo *styleIn
         return false;
     }
 
-    expSize = qMax(firstEdge->expSize, secondEdge->expSize);
-    expSize = qMin(expSize, maxSize);
+    // The equivalent preferred Size of a parallel anchor is calculated as to
+    // reduce the deviation from the original preferred sizes _and_ to avoid shrinking
+    // items below their preferred sizes, unless strictly needed.
 
-    prefSize = qMax(firstEdge->prefSize, secondEdge->prefSize);
-    prefSize = qMin(prefSize, expSize);
+    // ### This logic only holds if all anchors in the layout are "well-behaved" in the
+    // following terms:
+    //
+    // - There are no negative-sized anchors
+    // - All sequential anchors are composed of children in the same direction as the
+    //   sequential anchor itself
+    //
+    // With these assumptions we can grow a child knowing that no hidden items will
+    // have to shrink as the result of that.
+    // If any of these does not hold, we have a situation where the ParallelAnchor
+    // does not have enough information to calculate its equivalent prefSize.
+    prefSize = qMax(firstEdge->prefSize, secondPref);
+    prefSize = qMin(prefSize, maxSize);
 
     // See comment in AnchorData::refreshSizeHints() about sizeAt* values
     sizeAtMinimum = prefSize;
     sizeAtPreferred = prefSize;
-    sizeAtExpanding = prefSize;
     sizeAtMaximum = prefSize;
 
     return true;
@@ -280,8 +304,7 @@ bool ParallelAnchorData::refreshSizeHints_helper(const QLayoutStyleInfo *styleIn
      1 is at Maximum
 */
 static QPair<QGraphicsAnchorLayoutPrivate::Interval, qreal> getFactor(qreal value, qreal min,
-                                                                      qreal pref, qreal exp,
-                                                                      qreal max)
+                                                                      qreal pref, qreal max)
 {
     QGraphicsAnchorLayoutPrivate::Interval interval;
     qreal lower;
@@ -291,13 +314,9 @@ static QPair<QGraphicsAnchorLayoutPrivate::Interval, qreal> getFactor(qreal valu
         interval = QGraphicsAnchorLayoutPrivate::MinToPreferred;
         lower = min;
         upper = pref;
-    } else if (value < exp) {
-        interval = QGraphicsAnchorLayoutPrivate::PreferredToExpanding;
-        lower = pref;
-        upper = exp;
     } else {
-        interval = QGraphicsAnchorLayoutPrivate::ExpandingToMax;
-        lower = exp;
+        interval = QGraphicsAnchorLayoutPrivate::PreferredToMax;
+        lower = pref;
         upper = max;
     }
 
@@ -313,7 +332,7 @@ static QPair<QGraphicsAnchorLayoutPrivate::Interval, qreal> getFactor(qreal valu
 
 static qreal interpolate(const QPair<QGraphicsAnchorLayoutPrivate::Interval, qreal> &factor,
                          qreal min, qreal pref,
-                         qreal exp, qreal max)
+                         qreal max)
 {
     qreal lower;
     qreal upper;
@@ -323,12 +342,8 @@ static qreal interpolate(const QPair<QGraphicsAnchorLayoutPrivate::Interval, qre
         lower = min;
         upper = pref;
         break;
-    case QGraphicsAnchorLayoutPrivate::PreferredToExpanding:
+    case QGraphicsAnchorLayoutPrivate::PreferredToMax:
         lower = pref;
-        upper = exp;
-        break;
-    case QGraphicsAnchorLayoutPrivate::ExpandingToMax:
-        lower = exp;
         upper = max;
         break;
     }
@@ -341,34 +356,31 @@ void SequentialAnchorData::updateChildrenSizes()
     // ### REMOVE ME
     // ### check whether we are guarantee to get those or we need to warn stuff at this
     // point.
-    Q_ASSERT(sizeAtMinimum > minSize || qFuzzyCompare(sizeAtMinimum, minSize));
-    Q_ASSERT(sizeAtMinimum < maxSize || qFuzzyCompare(sizeAtMinimum, maxSize));
-    Q_ASSERT(sizeAtPreferred > minSize || qFuzzyCompare(sizeAtPreferred, minSize));
-    Q_ASSERT(sizeAtPreferred < maxSize || qFuzzyCompare(sizeAtPreferred, maxSize));
-    Q_ASSERT(sizeAtExpanding > minSize || qFuzzyCompare(sizeAtExpanding, minSize));
-    Q_ASSERT(sizeAtExpanding < maxSize || qFuzzyCompare(sizeAtExpanding, maxSize));
-    Q_ASSERT(sizeAtMaximum > minSize || qFuzzyCompare(sizeAtMaximum, minSize));
-    Q_ASSERT(sizeAtMaximum < maxSize || qFuzzyCompare(sizeAtMaximum, maxSize));
+    Q_ASSERT(sizeAtMinimum > minSize || qAbs(sizeAtMinimum - minSize) < 0.00000001);
+    Q_ASSERT(sizeAtPreferred > minSize || qAbs(sizeAtPreferred - minSize) < 0.00000001);
+    Q_ASSERT(sizeAtMaximum > minSize || qAbs(sizeAtMaximum - minSize) < 0.00000001);
+
+    // These may be false if this anchor was in parallel with the layout stucture
+    // Q_ASSERT(sizeAtMinimum < maxSize || qAbs(sizeAtMinimum - maxSize) < 0.00000001);
+    // Q_ASSERT(sizeAtPreferred < maxSize || qAbs(sizeAtPreferred - maxSize) < 0.00000001);
+    // Q_ASSERT(sizeAtMaximum < maxSize || qAbs(sizeAtMaximum - maxSize) < 0.00000001);
 
     // Band here refers if the value is in the Minimum To Preferred
     // band (the lower band) or the Preferred To Maximum (the upper band).
 
     const QPair<QGraphicsAnchorLayoutPrivate::Interval, qreal> minFactor =
-        getFactor(sizeAtMinimum, minSize, prefSize, expSize, maxSize);
+        getFactor(sizeAtMinimum, minSize, prefSize, maxSize);
     const QPair<QGraphicsAnchorLayoutPrivate::Interval, qreal> prefFactor =
-        getFactor(sizeAtPreferred, minSize, prefSize, expSize, maxSize);
-    const QPair<QGraphicsAnchorLayoutPrivate::Interval, qreal> expFactor =
-        getFactor(sizeAtExpanding, minSize, prefSize, expSize, maxSize);
+        getFactor(sizeAtPreferred, minSize, prefSize, maxSize);
     const QPair<QGraphicsAnchorLayoutPrivate::Interval, qreal> maxFactor =
-        getFactor(sizeAtMaximum, minSize, prefSize, expSize, maxSize);
+        getFactor(sizeAtMaximum, minSize, prefSize, maxSize);
 
     for (int i = 0; i < m_edges.count(); ++i) {
         AnchorData *e = m_edges.at(i);
 
-        e->sizeAtMinimum = interpolate(minFactor, e->minSize, e->prefSize, e->expSize, e->maxSize);
-        e->sizeAtPreferred = interpolate(prefFactor, e->minSize, e->prefSize, e->expSize, e->maxSize);
-        e->sizeAtExpanding = interpolate(expFactor, e->minSize, e->prefSize, e->expSize, e->maxSize);
-        e->sizeAtMaximum = interpolate(maxFactor, e->minSize, e->prefSize, e->expSize, e->maxSize);
+        e->sizeAtMinimum = interpolate(minFactor, e->minSize, e->prefSize, e->maxSize);
+        e->sizeAtPreferred = interpolate(prefFactor, e->minSize, e->prefSize, e->maxSize);
+        e->sizeAtMaximum = interpolate(maxFactor, e->minSize, e->prefSize, e->maxSize);
 
         e->updateChildrenSizes();
     }
@@ -384,7 +396,6 @@ bool SequentialAnchorData::refreshSizeHints_helper(const QLayoutStyleInfo *style
 {
     minSize = 0;
     prefSize = 0;
-    expSize = 0;
     maxSize = 0;
 
     for (int i = 0; i < m_edges.count(); ++i) {
@@ -396,14 +407,12 @@ bool SequentialAnchorData::refreshSizeHints_helper(const QLayoutStyleInfo *style
 
         minSize += edge->minSize;
         prefSize += edge->prefSize;
-        expSize += edge->expSize;
         maxSize += edge->maxSize;
     }
 
     // See comment in AnchorData::refreshSizeHints() about sizeAt* values
     sizeAtMinimum = prefSize;
     sizeAtPreferred = prefSize;
-    sizeAtExpanding = prefSize;
     sizeAtMaximum = prefSize;
 
     return true;
@@ -478,12 +487,15 @@ QGraphicsAnchorLayoutPrivate::QGraphicsAnchorLayoutPrivate()
         for (int j = 0; j < 3; ++j) {
             sizeHints[i][j] = -1;
         }
-        sizeAtExpanding[i] = -1;
         interpolationProgress[i] = -1;
 
         spacings[i] = -1;
         graphSimplified[i] = false;
         graphHasConflicts[i] = false;
+
+        layoutFirstVertex[i] = 0;
+        layoutCentralVertex[i] = 0;
+        layoutLastVertex[i] = 0;
     }
 }
 
@@ -526,33 +538,67 @@ inline static qreal checkAdd(qreal a, qreal b)
 /*!
     \internal
 
-    Adds \a newAnchor to the graph \a g.
+    Adds \a newAnchor to the graph.
 
     Returns the newAnchor itself if it could be added without further changes to the graph. If a
-    new parallel anchor had to be created, then returns the new parallel anchor. In case the
-    addition is unfeasible -- because a parallel setup is not possible, returns 0.
+    new parallel anchor had to be created, then returns the new parallel anchor. If a parallel anchor
+    had to be created and it results in an unfeasible setup, \a feasible is set to false, otherwise
+    true.
+
+    Note that in the case a new parallel anchor is created, it might also take over some constraints
+    from its children anchors.
 */
-static AnchorData *addAnchorMaybeParallel(Graph<AnchorVertex, AnchorData> *g,
-                                          AnchorData *newAnchor)
+AnchorData *QGraphicsAnchorLayoutPrivate::addAnchorMaybeParallel(AnchorData *newAnchor, bool *feasible)
 {
-    bool feasible = true;
+    Orientation orientation = Orientation(newAnchor->orientation);
+    Graph<AnchorVertex, AnchorData> &g = graph[orientation];
+    *feasible = true;
 
     // If already exists one anchor where newAnchor is supposed to be, we create a parallel
     // anchor.
-    if (AnchorData *oldAnchor = g->takeEdge(newAnchor->from, newAnchor->to)) {
+    if (AnchorData *oldAnchor = g.takeEdge(newAnchor->from, newAnchor->to)) {
         ParallelAnchorData *parallel = new ParallelAnchorData(oldAnchor, newAnchor);
 
+        // The parallel anchor will "replace" its children anchors in
+        // every center constraint that they appear.
+
+        // ### If the dependent (center) anchors had reference(s) to their constraints, we
+        // could avoid traversing all the itemCenterConstraints.
+        QList<QSimplexConstraint *> &constraints = itemCenterConstraints[orientation];
+
+        AnchorData *children[2] = { oldAnchor, newAnchor };
+        QList<QSimplexConstraint *> *childrenConstraints[2] = { &parallel->m_firstConstraints,
+                                                                &parallel->m_secondConstraints };
+
+        for (int i = 0; i < 2; ++i) {
+            AnchorData *child = children[i];
+            QList<QSimplexConstraint *> *childConstraints = childrenConstraints[i];
+
+            if (!child->isCenterAnchor)
+                continue;
+
+            parallel->isCenterAnchor = true;
+
+            for (int i = 0; i < constraints.count(); ++i) {
+                QSimplexConstraint *c = constraints[i];
+                if (c->variables.contains(child)) {
+                    childConstraints->append(c);
+                    qreal v = c->variables.take(child);
+                    c->variables.insert(parallel, v);
+                }
+            }
+        }
+
         // At this point we can identify that the parallel anchor is not feasible, e.g. one
         // anchor minimum size is bigger than the other anchor maximum size.
-        feasible = parallel->refreshSizeHints_helper(0, false);
+        *feasible = parallel->refreshSizeHints_helper(0, false);
         newAnchor = parallel;
     }
 
-    g->createEdge(newAnchor->from, newAnchor->to, newAnchor);
-    return feasible ? newAnchor : 0;
+    g.createEdge(newAnchor->from, newAnchor->to, newAnchor);
+    return newAnchor;
 }
 
-
 /*!
     \internal
 
@@ -656,30 +702,185 @@ bool QGraphicsAnchorLayoutPrivate::simplifyGraph(Orientation orientation)
 
     if (graphSimplified[orientation])
         return true;
-    graphSimplified[orientation] = true;
 
 #if 0
     qDebug("Simplifying Graph for %s",
            orientation == Horizontal ? "Horizontal" : "Vertical");
 #endif
 
-    if (!graph[orientation].rootVertex())
-        return true;
+    // Vertex simplification
+    if (!simplifyVertices(orientation)) {
+        restoreVertices(orientation);
+        return false;
+    }
 
+    // Anchor simplification
     bool dirty;
     bool feasible = true;
     do {
         dirty = simplifyGraphIteration(orientation, &feasible);
     } while (dirty && feasible);
 
-    if (!feasible)
-        graphSimplified[orientation] = false;
+    // Note that if we are not feasible, we fallback and make sure that the graph is fully restored
+    if (!feasible) {
+        graphSimplified[orientation] = true;
+        restoreSimplifiedGraph(orientation);
+        restoreVertices(orientation);
+        return false;
+    }
+
+    graphSimplified[orientation] = true;
+    return true;
+}
+
+static AnchorVertex *replaceVertex_helper(AnchorData *data, AnchorVertex *oldV, AnchorVertex *newV)
+{
+    AnchorVertex *other;
+    if (data->from == oldV) {
+        data->from = newV;
+        other = data->to;
+    } else {
+        data->to = newV;
+        other = data->from;
+    }
+    return other;
+}
+
+bool QGraphicsAnchorLayoutPrivate::replaceVertex(Orientation orientation, AnchorVertex *oldV,
+                                                 AnchorVertex *newV, const QList<AnchorData *> &edges)
+{
+    Graph<AnchorVertex, AnchorData> &g = graph[orientation];
+    bool feasible = true;
+
+    for (int i = 0; i < edges.count(); ++i) {
+        AnchorData *ad = edges[i];
+        AnchorVertex *otherV = replaceVertex_helper(ad, oldV, newV);
+
+#if defined(QT_DEBUG)
+        ad->name = QString::fromAscii("%1 --to--> %2").arg(ad->from->toString()).arg(ad->to->toString());
+#endif
+
+        bool newFeasible;
+        AnchorData *newAnchor = addAnchorMaybeParallel(ad, &newFeasible);
+        feasible &= newFeasible;
+
+        if (newAnchor != ad) {
+            // A parallel was created, we mark that in the list of anchors created by vertex
+            // simplification. This is needed because we want to restore them in a separate step
+            // from the restoration of anchor simplification.
+            anchorsFromSimplifiedVertices[orientation].append(newAnchor);
+        }
+
+        g.takeEdge(oldV, otherV);
+    }
 
     return feasible;
 }
 
 /*!
     \internal
+*/
+bool QGraphicsAnchorLayoutPrivate::simplifyVertices(Orientation orientation)
+{
+    Q_Q(QGraphicsAnchorLayout);
+    Graph<AnchorVertex, AnchorData> &g = graph[orientation];
+
+    // We'll walk through vertices
+    QStack<AnchorVertex *> stack;
+    stack.push(layoutFirstVertex[orientation]);
+    QSet<AnchorVertex *> visited;
+
+    while (!stack.isEmpty()) {
+        AnchorVertex *v = stack.pop();
+        visited.insert(v);
+
+        // Each adjacent of 'v' is a possible vertex to be merged. So we traverse all of
+        // them. Since once a merge is made, we might add new adjacents, and we don't want to
+        // pass two times through one adjacent. The 'index' is used to track our position.
+        QList<AnchorVertex *> adjacents = g.adjacentVertices(v);
+        int index = 0;
+
+        while (index < adjacents.count()) {
+            AnchorVertex *next = adjacents.at(index);
+            index++;
+
+            AnchorData *data = g.edgeData(v, next);
+            const bool bothLayoutVertices = v->m_item == q && next->m_item == q;
+            const bool zeroSized = !data->minSize && !data->maxSize;
+
+            if (!bothLayoutVertices && zeroSized) {
+
+                // Create a new vertex pair, note that we keep a list of those vertices so we can
+                // easily process them when restoring the graph.
+                AnchorVertexPair *newV = new AnchorVertexPair(v, next, data);
+                simplifiedVertices[orientation].append(newV);
+
+                // Collect the anchors of both vertices, the new vertex pair will take their place
+                // in those anchors
+                const QList<AnchorVertex *> &vAdjacents = g.adjacentVertices(v);
+                const QList<AnchorVertex *> &nextAdjacents = g.adjacentVertices(next);
+
+                for (int i = 0; i < vAdjacents.count(); ++i) {
+                    AnchorVertex *adjacent = vAdjacents.at(i);
+                    if (adjacent != next) {
+                        AnchorData *ad = g.edgeData(v, adjacent);
+                        newV->m_firstAnchors.append(ad);
+                    }
+                }
+
+                for (int i = 0; i < nextAdjacents.count(); ++i) {
+                    AnchorVertex *adjacent = nextAdjacents.at(i);
+                    if (adjacent != v) {
+                        AnchorData *ad = g.edgeData(next, adjacent);
+                        newV->m_secondAnchors.append(ad);
+
+                        // We'll also add new vertices to the adjacent list of the new 'v', to be
+                        // created as a vertex pair and replace the current one.
+                        if (!adjacents.contains(adjacent))
+                            adjacents.append(adjacent);
+                    }
+                }
+
+                // ### merge this loop into the ones that calculated m_firstAnchors/m_secondAnchors?
+                // Make newV take the place of v and next
+                bool feasible = replaceVertex(orientation, v, newV, newV->m_firstAnchors);
+                feasible &= replaceVertex(orientation, next, newV, newV->m_secondAnchors);
+
+                // Update the layout vertex information if one of the vertices is a layout vertex.
+                AnchorVertex *layoutVertex = 0;
+                if (v->m_item == q)
+                    layoutVertex = v;
+                else if (next->m_item == q)
+                    layoutVertex = next;
+
+                if (layoutVertex) {
+                    // Layout vertices always have m_item == q...
+                    newV->m_item = q;
+                    changeLayoutVertex(orientation, layoutVertex, newV);
+                }
+
+                g.takeEdge(v, next);
+
+                // If a non-feasibility is found, we leave early and cancel the simplification
+                if (!feasible)
+                    return false;
+
+                v = newV;
+                visited.insert(newV);
+
+            } else if (!visited.contains(next) && !stack.contains(next)) {
+                // If the adjacent is not fit for merge and it wasn't visited by the outermost
+                // loop, we add it to the stack.
+                stack.push(next);
+            }
+        }
+    }
+
+    return true;
+}
+
+/*!
+    \internal
 
     One iteration of the simplification algorithm. Returns true if another iteration is needed.
 
@@ -700,7 +901,7 @@ bool QGraphicsAnchorLayoutPrivate::simplifyGraphIteration(QGraphicsAnchorLayoutP
 
     QSet<AnchorVertex *> visited;
     QStack<QPair<AnchorVertex *, AnchorVertex *> > stack;
-    stack.push(qMakePair(static_cast<AnchorVertex *>(0), g.rootVertex()));
+    stack.push(qMakePair(static_cast<AnchorVertex *>(0), layoutFirstVertex[orientation]));
     QVector<AnchorVertex*> candidates;
     bool candidatesForward;
 
@@ -719,7 +920,8 @@ bool QGraphicsAnchorLayoutPrivate::simplifyGraphIteration(QGraphicsAnchorLayoutP
         // (a) it is a layout vertex, we don't simplify away the layout vertices;
         // (b) it does not have exactly 2 adjacents;
         // (c) it will change the direction of the sequence;
-        // (d) its next adjacent is already visited (a cycle in the graph).
+        // (d) its next adjacent is already visited (a cycle in the graph);
+        // (e) the next anchor is a center anchor.
 
         const QList<AnchorVertex *> &adjacents = g.adjacentVertices(v);
         const bool isLayoutVertex = v->m_item == q;
@@ -742,13 +944,14 @@ bool QGraphicsAnchorLayoutPrivate::simplifyGraphIteration(QGraphicsAnchorLayoutP
                 candidatesForward = (beforeSequence == data->from);
             }
 
-            // This is a tricky part. We peek at the next vertex to find out
+            // This is a tricky part. We peek at the next vertex to find out whether
             //
-            // - whether the edge from this vertex to the next vertex has the same direction;
-            // - whether we already visited the next vertex.
+            // - the edge from this vertex to the next vertex has the same direction;
+            // - we already visited the next vertex;
+            // - the next anchor is a center.
             //
-            // Those are needed to identify (c) and (d). Note that unlike (a) and (b), we preempt
-            // the end of sequence by looking into the next vertex.
+            // Those are needed to identify the remaining end of sequence cases. Note that unlike
+            // (a) and (b), we preempt the end of sequence by looking into the next vertex.
 
             // Peek at the next vertex
             AnchorVertex *after;
@@ -766,8 +969,8 @@ bool QGraphicsAnchorLayoutPrivate::simplifyGraphIteration(QGraphicsAnchorLayoutP
             const bool willChangeDirection = (candidatesForward != (v == data->from));
             const bool cycleFound = visited.contains(after);
 
-            // Now cases (c) and (d)...
-            endOfSequence = willChangeDirection || cycleFound;
+            // Now cases (c), (d) and (e)...
+            endOfSequence = willChangeDirection || cycleFound || data->isCenterAnchor;
 
             if (endOfSequence) {
                 if (!willChangeDirection) {
@@ -839,9 +1042,10 @@ bool QGraphicsAnchorLayoutPrivate::simplifyGraphIteration(QGraphicsAnchorLayoutP
 
         // If 'beforeSequence' and 'afterSequence' already had an anchor between them, we'll
         // create a parallel anchor between the new sequence and the old anchor.
-        AnchorData *newAnchor = addAnchorMaybeParallel(&g, sequence);
+        bool newFeasible;
+        AnchorData *newAnchor = addAnchorMaybeParallel(sequence, &newFeasible);
 
-        if (!newAnchor) {
+        if (!newFeasible) {
             *feasible = false;
             return false;
         }
@@ -861,48 +1065,70 @@ bool QGraphicsAnchorLayoutPrivate::simplifyGraphIteration(QGraphicsAnchorLayoutP
     return false;
 }
 
-static void restoreSimplifiedAnchor(Graph<AnchorVertex, AnchorData> &g,
-                                    AnchorData *edge,
-                                    AnchorVertex *before,
-                                    AnchorVertex *after)
+void QGraphicsAnchorLayoutPrivate::restoreSimplifiedAnchor(AnchorData *edge)
 {
-    Q_ASSERT(edge->type != AnchorData::Normal);
 #if 0
     static const char *anchortypes[] = {"Normal",
                                         "Sequential",
                                         "Parallel"};
     qDebug("Restoring %s edge.", anchortypes[int(edge->type)]);
 #endif
-    if (edge->type == AnchorData::Sequential) {
-        SequentialAnchorData* seqEdge = static_cast<SequentialAnchorData*>(edge);
-        // restore the sequential anchor
-        AnchorVertex *prev = before;
-        AnchorVertex *last = after;
-        if (edge->from != prev)
-            qSwap(last, prev);
-
-        for (int i = 0; i < seqEdge->m_edges.count(); ++i) {
-            AnchorVertex *v1 = (i < seqEdge->m_children.count()) ? seqEdge->m_children.at(i) : last;
-            AnchorData *data = seqEdge->m_edges.at(i);
-            if (data->type != AnchorData::Normal) {
-                restoreSimplifiedAnchor(g, data, prev, v1);
-            } else {
-                g.createEdge(prev, v1, data);
-            }
-            prev = v1;
+
+    Graph<AnchorVertex, AnchorData> &g = graph[edge->orientation];
+
+    if (edge->type == AnchorData::Normal) {
+        g.createEdge(edge->from, edge->to, edge);
+
+    } else if (edge->type == AnchorData::Sequential) {
+        SequentialAnchorData *sequence = static_cast<SequentialAnchorData *>(edge);
+
+        for (int i = 0; i < sequence->m_edges.count(); ++i) {
+            AnchorData *data = sequence->m_edges.at(i);
+            restoreSimplifiedAnchor(data);
         }
+
+        delete sequence;
+
     } else if (edge->type == AnchorData::Parallel) {
-        ParallelAnchorData* parallelEdge = static_cast<ParallelAnchorData*>(edge);
-        AnchorData *parallelEdges[2] = {parallelEdge->firstEdge,
-                                        parallelEdge->secondEdge};
-        for (int i = 0; i < 2; ++i) {
-            AnchorData *data = parallelEdges[i];
-            if (data->type == AnchorData::Normal) {
-                g.createEdge(before, after, data);
-            } else {
-                restoreSimplifiedAnchor(g, data, before, after);
-            }
-        }
+
+        // Skip parallel anchors that were created by vertex simplification, they will be processed
+        // later, when restoring vertex simplification.
+        // ### we could improve this check bit having a bit inside 'edge'
+        if (anchorsFromSimplifiedVertices[edge->orientation].contains(edge))
+            return;
+
+        ParallelAnchorData* parallel = static_cast<ParallelAnchorData*>(edge);
+        restoreSimplifiedConstraints(parallel);
+
+        // ### Because of the way parallel anchors are created in the anchor simplification
+        // algorithm, we know that one of these will be a sequence, so it'll be safe if the other
+        // anchor create an edge between the same vertices as the parallel.
+        Q_ASSERT(parallel->firstEdge->type == AnchorData::Sequential
+                 || parallel->secondEdge->type == AnchorData::Sequential);
+        restoreSimplifiedAnchor(parallel->firstEdge);
+        restoreSimplifiedAnchor(parallel->secondEdge);
+
+        delete parallel;
+    }
+}
+
+void QGraphicsAnchorLayoutPrivate::restoreSimplifiedConstraints(ParallelAnchorData *parallel)
+{
+    if (!parallel->isCenterAnchor)
+        return;
+
+    for (int i = 0; i < parallel->m_firstConstraints.count(); ++i) {
+        QSimplexConstraint *c = parallel->m_firstConstraints.at(i);
+        qreal v = c->variables[parallel];
+        c->variables.remove(parallel);
+        c->variables.insert(parallel->firstEdge, v);
+    }
+
+    for (int i = 0; i < parallel->m_secondConstraints.count(); ++i) {
+        QSimplexConstraint *c = parallel->m_secondConstraints.at(i);
+        qreal v = c->variables[parallel];
+        c->variables.remove(parallel);
+        c->variables.insert(parallel->secondEdge, v);
     }
 }
 
@@ -917,19 +1143,93 @@ void QGraphicsAnchorLayoutPrivate::restoreSimplifiedGraph(Orientation orientatio
            orientation == Horizontal ? "Horizontal" : "Vertical");
 #endif
 
+    // Restore anchor simplification
     Graph<AnchorVertex, AnchorData> &g = graph[orientation];
-
     QList<QPair<AnchorVertex*, AnchorVertex*> > connections = g.connections();
     for (int i = 0; i < connections.count(); ++i) {
         AnchorVertex *v1 = connections.at(i).first;
         AnchorVertex *v2 = connections.at(i).second;
         AnchorData *edge = g.edgeData(v1, v2);
-        if (edge->type != AnchorData::Normal) {
-            AnchorData *oldEdge = g.takeEdge(v1, v2);
-            restoreSimplifiedAnchor(g, edge, v1, v2);
-            delete oldEdge;
+
+        // We restore only sequential anchors and parallels that were not created by
+        // vertex simplification.
+        if (edge->type == AnchorData::Sequential
+            || (edge->type == AnchorData::Parallel &&
+                !anchorsFromSimplifiedVertices[orientation].contains(edge))) {
+
+            g.takeEdge(v1, v2);
+            restoreSimplifiedAnchor(edge);
         }
     }
+
+    restoreVertices(orientation);
+}
+
+void QGraphicsAnchorLayoutPrivate::restoreVertices(Orientation orientation)
+{
+    Q_Q(QGraphicsAnchorLayout);
+
+    Graph<AnchorVertex, AnchorData> &g = graph[orientation];
+    QList<AnchorVertexPair *> &toRestore = simplifiedVertices[orientation];
+
+    // We will restore the vertices in the inverse order of creation, this way we ensure that
+    // the vertex being restored was not wrapped by another simplification.
+    for (int i = toRestore.count() - 1; i >= 0; --i) {
+        AnchorVertexPair *pair = toRestore.at(i);
+        QList<AnchorVertex *> adjacents = g.adjacentVertices(pair);
+
+        // Restore the removed edge, this will also restore both vertices 'first' and 'second' to
+        // the graph structure.
+        AnchorVertex *first = pair->m_first;
+        AnchorVertex *second = pair->m_second;
+        g.createEdge(first, second, pair->m_removedAnchor);
+
+        // Restore the anchors for the first child vertex
+        for (int j = 0; j < pair->m_firstAnchors.count(); ++j) {
+            AnchorData *ad = pair->m_firstAnchors.at(j);
+            Q_ASSERT(ad->from == pair || ad->to == pair);
+
+            replaceVertex_helper(ad, pair, first);
+            g.createEdge(ad->from, ad->to, ad);
+        }
+
+        // Restore the anchors for the second child vertex
+        for (int j = 0; j < pair->m_secondAnchors.count(); ++j) {
+            AnchorData *ad = pair->m_secondAnchors.at(j);
+            Q_ASSERT(ad->from == pair || ad->to == pair);
+
+            replaceVertex_helper(ad, pair, second);
+            g.createEdge(ad->from, ad->to, ad);
+        }
+
+        for (int j = 0; j < adjacents.count(); ++j) {
+            g.takeEdge(pair, adjacents.at(j));
+        }
+
+        // The pair simplified a layout vertex, so place back the correct vertex in the variable
+        // that track layout vertices
+        if (pair->m_item == q) {
+            AnchorVertex *layoutVertex = first->m_item == q ? first : second;
+            Q_ASSERT(layoutVertex->m_item == q);
+            changeLayoutVertex(orientation, pair, layoutVertex);
+        }
+
+        delete pair;
+    }
+    toRestore.clear();
+
+    // The restoration process for vertex simplification also restored the effect of the
+    // parallel anchors created during vertex simplification, so we just need to restore
+    // the constraints in case of parallels that contain center anchors. For the same
+    // reason as above, order matters here.
+    QList<AnchorData *> &parallelAnchors = anchorsFromSimplifiedVertices[orientation];
+
+    for (int i = parallelAnchors.count() - 1; i >= 0; --i) {
+        ParallelAnchorData *parallel = static_cast<ParallelAnchorData *>(parallelAnchors.at(i));
+        restoreSimplifiedConstraints(parallel);
+        delete parallel;
+    }
+    parallelAnchors.clear();
 }
 
 QGraphicsAnchorLayoutPrivate::Orientation
@@ -959,9 +1259,10 @@ void QGraphicsAnchorLayoutPrivate::createLayoutEdges()
     data->maxSize = QWIDGETSIZE_MAX;
     data->skipInPreferred = 1;
 
-    // Set the Layout Left edge as the root of the horizontal graph.
-    AnchorVertex *v = internalVertex(layout, Qt::AnchorLeft);
-    graph[Horizontal].setRootVertex(v);
+    // Save a reference to layout vertices
+    layoutFirstVertex[Horizontal] = internalVertex(layout, Qt::AnchorLeft);
+    layoutCentralVertex[Horizontal] = 0;
+    layoutLastVertex[Horizontal] = internalVertex(layout, Qt::AnchorRight);
 
     // Vertical
     data = new AnchorData;
@@ -970,17 +1271,18 @@ void QGraphicsAnchorLayoutPrivate::createLayoutEdges()
     data->maxSize = QWIDGETSIZE_MAX;
     data->skipInPreferred = 1;
 
-    // Set the Layout Top edge as the root of the vertical graph.
-    v = internalVertex(layout, Qt::AnchorTop);
-    graph[Vertical].setRootVertex(v);
+    // Save a reference to layout vertices
+    layoutFirstVertex[Vertical] = internalVertex(layout, Qt::AnchorTop);
+    layoutCentralVertex[Vertical] = 0;
+    layoutLastVertex[Vertical] = internalVertex(layout, Qt::AnchorBottom);
 }
 
 void QGraphicsAnchorLayoutPrivate::deleteLayoutEdges()
 {
     Q_Q(QGraphicsAnchorLayout);
 
-    Q_ASSERT(internalVertex(q, Qt::AnchorHorizontalCenter) == NULL);
-    Q_ASSERT(internalVertex(q, Qt::AnchorVerticalCenter) == NULL);
+    Q_ASSERT(!internalVertex(q, Qt::AnchorHorizontalCenter));
+    Q_ASSERT(!internalVertex(q, Qt::AnchorVerticalCenter));
 
     removeAnchor_helper(internalVertex(q, Qt::AnchorLeft),
                         internalVertex(q, Qt::AnchorRight));
@@ -1019,6 +1321,8 @@ void QGraphicsAnchorLayoutPrivate::createItemEdges(QGraphicsLayoutItem *item)
 void QGraphicsAnchorLayoutPrivate::createCenterAnchors(
     QGraphicsLayoutItem *item, Qt::AnchorPoint centerEdge)
 {
+    Q_Q(QGraphicsAnchorLayout);
+
     Orientation orientation;
     switch (centerEdge) {
     case Qt::AnchorHorizontalCenter:
@@ -1061,24 +1365,32 @@ void QGraphicsAnchorLayoutPrivate::createCenterAnchors(
     c->variables.insert(data, 1.0);
     addAnchor_helper(item, firstEdge, item, centerEdge, data);
     data->isCenterAnchor = true;
+    data->dependency = AnchorData::Master;
     data->refreshSizeHints(0);
 
     data = new AnchorData;
     c->variables.insert(data, -1.0);
     addAnchor_helper(item, centerEdge, item, lastEdge, data);
     data->isCenterAnchor = true;
+    data->dependency = AnchorData::Slave;
     data->refreshSizeHints(0);
 
     itemCenterConstraints[orientation].append(c);
 
     // Remove old one
     removeAnchor_helper(first, last);
+
+    if (item == q) {
+        layoutCentralVertex[orientation] = internalVertex(q, centerEdge);
+    }
 }
 
 void QGraphicsAnchorLayoutPrivate::removeCenterAnchors(
     QGraphicsLayoutItem *item, Qt::AnchorPoint centerEdge,
     bool substitute)
 {
+    Q_Q(QGraphicsAnchorLayout);
+
     Orientation orientation;
     switch (centerEdge) {
     case Qt::AnchorHorizontalCenter:
@@ -1120,7 +1432,7 @@ void QGraphicsAnchorLayoutPrivate::removeCenterAnchors(
     AnchorData *oldData = g.edgeData(first, center);
     // Remove center constraint
     for (int i = itemCenterConstraints[orientation].count() - 1; i >= 0; --i) {
-        if (itemCenterConstraints[orientation][i]->variables.contains(oldData)) {
+        if (itemCenterConstraints[orientation].at(i)->variables.contains(oldData)) {
             delete itemCenterConstraints[orientation].takeAt(i);
             break;
         }
@@ -1151,6 +1463,10 @@ void QGraphicsAnchorLayoutPrivate::removeCenterAnchors(
         // by this time, the center vertex is deleted and merged into a non-centered internal anchor
         removeAnchor_helper(first, internalVertex(item, lastEdge));
     }
+
+    if (item == q) {
+        layoutCentralVertex[orientation] = 0;
+    }
 }
 
 
@@ -1180,7 +1496,7 @@ void QGraphicsAnchorLayoutPrivate::removeCenterConstraints(QGraphicsLayoutItem *
 
     // Look for our anchor in all item center constraints, then remove it
     for (int i = 0; i < itemCenterConstraints[orientation].size(); ++i) {
-        if (itemCenterConstraints[orientation][i]->variables.contains(internalAnchor)) {
+        if (itemCenterConstraints[orientation].at(i)->variables.contains(internalAnchor)) {
             delete itemCenterConstraints[orientation].takeAt(i);
             break;
         }
@@ -1690,7 +2006,7 @@ QList<AnchorData *> getVariables(QList<QSimplexConstraint *> constraints)
 {
     QSet<AnchorData *> variableSet;
     for (int i = 0; i < constraints.count(); ++i) {
-        const QSimplexConstraint *c = constraints[i];
+        const QSimplexConstraint *c = constraints.at(i);
         foreach (QSimplexVariable *var, c->variables.keys()) {
             variableSet += static_cast<AnchorData *>(var);
         }
@@ -1724,12 +2040,19 @@ QList<AnchorData *> getVariables(QList<QSimplexConstraint *> constraints)
 void QGraphicsAnchorLayoutPrivate::calculateGraphs(
     QGraphicsAnchorLayoutPrivate::Orientation orientation)
 {
-    Q_Q(QGraphicsAnchorLayout);
-
 #if defined(QT_DEBUG) || defined(Q_AUTOTEST_EXPORT)
     lastCalculationUsedSimplex[orientation] = false;
 #endif
 
+    // ### This is necessary because now we do vertex simplification, we still don't know
+    // differentiate between invalidate()s that doesn't need resimplification and those which
+    // need. For example, when size hint of an item changes, this may cause an anchor to reach 0 or to
+    // leave 0 and get a size. In both cases we need resimplify.
+    //
+    // ### one possible solution would be tracking all the 0-sized anchors, if this set change, we need
+    // resimplify.
+    restoreSimplifiedGraph(orientation);
+
     // Reset the nominal sizes of each anchor based on the current item sizes.  This function
     // works with both simplified and non-simplified graphs, so it'll work when the
     // simplification is going to be reused.
@@ -1768,12 +2091,12 @@ void QGraphicsAnchorLayoutPrivate::calculateGraphs(
     // Now run the simplex solver to calculate Minimum, Preferred and Maximum sizes
     // of the "trunk" set of constraints and variables.
     // ### does trunk always exist? empty = trunk is the layout left->center->right
-    QList<QSimplexConstraint *> trunkConstraints = parts[0];
+    QList<QSimplexConstraint *> trunkConstraints = parts.at(0);
     QList<AnchorData *> trunkVariables = getVariables(trunkConstraints);
 
     // For minimum and maximum, use the path between the two layout sides as the
     // objective function.
-    AnchorVertex *v = internalVertex(q, pickEdge(Qt::AnchorRight, orientation));
+    AnchorVertex *v = layoutLastVertex[orientation];
     GraphPath trunkPath = graphPaths[orientation].value(v);
 
     bool feasible = calculateTrunk(orientation, trunkPath, trunkConstraints, trunkVariables);
@@ -1787,7 +2110,7 @@ void QGraphicsAnchorLayoutPrivate::calculateGraphs(
         if (!feasible)
             break;
 
-        QList<QSimplexConstraint *> partConstraints = parts[i];
+        QList<QSimplexConstraint *> partConstraints = parts.at(i);
         QList<AnchorData *> partVariables = getVariables(partConstraints);
         Q_ASSERT(!partVariables.isEmpty());
         feasible &= calculateNonTrunk(partConstraints, partVariables);
@@ -1836,27 +2159,19 @@ bool QGraphicsAnchorLayoutPrivate::calculateTrunk(Orientation orientation, const
         if (feasible) {
             solvePreferred(allConstraints, variables);
 
-            // Note that we don't include the sizeHintConstraints, since they
-            // have a different logic for solveExpanding().
-            solveExpanding(constraints, variables);
-
-            // Calculate and set the preferred and expanding sizes for the layout,
+            // Calculate and set the preferred size for the layout,
             // from the edge sizes that were calculated above.
             qreal pref(0.0);
-            qreal expanding(0.0);
             foreach (const AnchorData *ad, path.positives) {
                 pref += ad->sizeAtPreferred;
-                expanding += ad->sizeAtExpanding;
             }
             foreach (const AnchorData *ad, path.negatives) {
                 pref -= ad->sizeAtPreferred;
-                expanding -= ad->sizeAtExpanding;
             }
 
             sizeHints[orientation][Qt::MinimumSize] = min;
             sizeHints[orientation][Qt::PreferredSize] = pref;
             sizeHints[orientation][Qt::MaximumSize] = max;
-            sizeAtExpanding[orientation] = expanding;
         }
 
         qDeleteAll(sizeHintConstraints);
@@ -1870,13 +2185,11 @@ bool QGraphicsAnchorLayoutPrivate::calculateTrunk(Orientation orientation, const
         AnchorData *ad = path.positives.toList()[0];
         ad->sizeAtMinimum = ad->minSize;
         ad->sizeAtPreferred = ad->prefSize;
-        ad->sizeAtExpanding = ad->expSize;
         ad->sizeAtMaximum = ad->maxSize;
 
         sizeHints[orientation][Qt::MinimumSize] = ad->sizeAtMinimum;
         sizeHints[orientation][Qt::PreferredSize] = ad->sizeAtPreferred;
         sizeHints[orientation][Qt::MaximumSize] = ad->sizeAtMaximum;
-        sizeAtExpanding[orientation] = ad->sizeAtExpanding;
     }
 
 #if defined(QT_DEBUG) || defined(Q_AUTOTEST_EXPORT)
@@ -1899,10 +2212,9 @@ bool QGraphicsAnchorLayoutPrivate::calculateNonTrunk(const QList<QSimplexConstra
         // Propagate size at preferred to other sizes. Semi-floats always will be
         // in their sizeAtPreferred.
         for (int j = 0; j < variables.count(); ++j) {
-            AnchorData *ad = variables[j];
+            AnchorData *ad = variables.at(j);
             Q_ASSERT(ad);
             ad->sizeAtMinimum = ad->sizeAtPreferred;
-            ad->sizeAtExpanding = ad->sizeAtPreferred;
             ad->sizeAtMaximum = ad->sizeAtPreferred;
         }
     }
@@ -1955,7 +2267,7 @@ void QGraphicsAnchorLayoutPrivate::findPaths(Orientation orientation)
 
     QSet<AnchorData *> visited;
 
-    AnchorVertex *root = graph[orientation].rootVertex();
+    AnchorVertex *root = layoutFirstVertex[orientation];
 
     graphPaths[orientation].insert(root, GraphPath());
 
@@ -2013,7 +2325,7 @@ void QGraphicsAnchorLayoutPrivate::constraintsFromPaths(Orientation orientation)
         QList<GraphPath> pathsToVertex = graphPaths[orientation].values(vertex);
         for (int i = 1; i < valueCount; ++i) {
             constraints[orientation] += \
-                pathsToVertex[0].constraint(pathsToVertex[i]);
+                pathsToVertex[0].constraint(pathsToVertex.at(i));
         }
     }
 }
@@ -2041,9 +2353,37 @@ void QGraphicsAnchorLayoutPrivate::updateAnchorSizes(Orientation orientation)
 QList<QSimplexConstraint *> QGraphicsAnchorLayoutPrivate::constraintsFromSizeHints(
     const QList<AnchorData *> &anchors)
 {
+    if (anchors.isEmpty())
+        return QList<QSimplexConstraint *>();
+
+    // Look for the layout edge. That can be either the first half in case the
+    // layout is split in two, or the whole layout anchor.
+    Orientation orient = Orientation(anchors.first()->orientation);
+    AnchorData *layoutEdge = 0;
+    if (layoutCentralVertex[orient]) {
+        layoutEdge = graph[orient].edgeData(layoutFirstVertex[orient], layoutCentralVertex[orient]);
+    } else {
+        layoutEdge = graph[orient].edgeData(layoutFirstVertex[orient], layoutLastVertex[orient]);
+
+        // If maxSize is less then "infinite", that means there are other anchors
+        // grouped together with this one. We can't ignore its maximum value so we
+        // set back the variable to NULL to prevent the continue condition from being
+        // satisfied in the loop below.
+        if (layoutEdge->maxSize < QWIDGETSIZE_MAX)
+            layoutEdge = 0;
+    }
+
+    // For each variable, create constraints based on size hints
     QList<QSimplexConstraint *> anchorConstraints;
+    bool unboundedProblem = true;
     for (int i = 0; i < anchors.size(); ++i) {
-        AnchorData *ad = anchors[i];
+        AnchorData *ad = anchors.at(i);
+
+        // Anchors that have their size directly linked to another one don't need constraints
+        // For exammple, the second half of an item has exactly the same size as the first half
+        // thus constraining the latter is enough.
+        if (ad->dependency == AnchorData::Slave)
+            continue;
 
         if ((ad->minSize == ad->maxSize) || qFuzzyCompare(ad->minSize, ad->maxSize)) {
             QSimplexConstraint *c = new QSimplexConstraint;
@@ -2051,6 +2391,7 @@ QList<QSimplexConstraint *> QGraphicsAnchorLayoutPrivate::constraintsFromSizeHin
             c->constant = ad->minSize;
             c->ratio = QSimplexConstraint::Equal;
             anchorConstraints += c;
+            unboundedProblem = false;
         } else {
             QSimplexConstraint *c = new QSimplexConstraint;
             c->variables.insert(ad, 1.0);
@@ -2058,14 +2399,30 @@ QList<QSimplexConstraint *> QGraphicsAnchorLayoutPrivate::constraintsFromSizeHin
             c->ratio = QSimplexConstraint::MoreOrEqual;
             anchorConstraints += c;
 
+            // We avoid adding restrictions to the layout internal anchors. That's
+            // to prevent unnecessary fair distribution from happening due to this
+            // artificial restriction.
+            if (ad == layoutEdge)
+                continue;
+
             c = new QSimplexConstraint;
             c->variables.insert(ad, 1.0);
             c->constant = ad->maxSize;
             c->ratio = QSimplexConstraint::LessOrEqual;
             anchorConstraints += c;
+            unboundedProblem = false;
         }
     }
 
+    // If no upper boundary restriction was added, add one to avoid unbounded problem
+    if (unboundedProblem) {
+        QSimplexConstraint *c = new QSimplexConstraint;
+        c->variables.insert(layoutEdge, 1.0);
+        c->constant = QWIDGETSIZE_MAX;
+        c->ratio = QSimplexConstraint::LessOrEqual;
+        anchorConstraints += c;
+    }
+
     return anchorConstraints;
 }
 
@@ -2075,38 +2432,26 @@ QList<QSimplexConstraint *> QGraphicsAnchorLayoutPrivate::constraintsFromSizeHin
 QList< QList<QSimplexConstraint *> >
 QGraphicsAnchorLayoutPrivate::getGraphParts(Orientation orientation)
 {
-    Q_Q(QGraphicsAnchorLayout);
+    Q_ASSERT(layoutFirstVertex[orientation] && layoutLastVertex[orientation]);
 
-    // Find layout vertices and edges for the current orientation.
-    AnchorVertex *layoutFirstVertex = \
-        internalVertex(q, pickEdge(Qt::AnchorLeft, orientation));
-
-    AnchorVertex *layoutCentralVertex = \
-        internalVertex(q, pickEdge(Qt::AnchorHorizontalCenter, orientation));
-
-    AnchorVertex *layoutLastVertex = \
-        internalVertex(q, pickEdge(Qt::AnchorRight, orientation));
-
-    Q_ASSERT(layoutFirstVertex && layoutLastVertex);
-
-    AnchorData *edgeL1 = NULL;
-    AnchorData *edgeL2 = NULL;
+    AnchorData *edgeL1 = 0;
+    AnchorData *edgeL2 = 0;
 
     // The layout may have a single anchor between Left and Right or two half anchors
     // passing through the center
-    if (layoutCentralVertex) {
-        edgeL1 = graph[orientation].edgeData(layoutFirstVertex, layoutCentralVertex);
-        edgeL2 = graph[orientation].edgeData(layoutCentralVertex, layoutLastVertex);
+    if (layoutCentralVertex[orientation]) {
+        edgeL1 = graph[orientation].edgeData(layoutFirstVertex[orientation], layoutCentralVertex[orientation]);
+        edgeL2 = graph[orientation].edgeData(layoutCentralVertex[orientation], layoutLastVertex[orientation]);
     } else {
-        edgeL1 = graph[orientation].edgeData(layoutFirstVertex, layoutLastVertex);
+        edgeL1 = graph[orientation].edgeData(layoutFirstVertex[orientation], layoutLastVertex[orientation]);
     }
 
     QLinkedList<QSimplexConstraint *> remainingConstraints;
     for (int i = 0; i < constraints[orientation].count(); ++i) {
-        remainingConstraints += constraints[orientation][i];
+        remainingConstraints += constraints[orientation].at(i);
     }
     for (int i = 0; i < itemCenterConstraints[orientation].count(); ++i) {
-        remainingConstraints += itemCenterConstraints[orientation][i];
+        remainingConstraints += itemCenterConstraints[orientation].at(i);
     }
 
     QList<QSimplexConstraint *> trunkConstraints;
@@ -2276,6 +2621,21 @@ void QGraphicsAnchorLayoutPrivate::setItemsGeometries(const QRectF &geom)
 }
 
 /*!
+    \internal
+
+    Fill the distance in the vertex and in the sub-vertices if its a combined vertex.
+*/
+static void setVertexDistance(AnchorVertex *v, qreal distance)
+{
+    v->distance = distance;
+    if (v->m_type == AnchorVertex::Pair) {
+        AnchorVertexPair *pair = static_cast<AnchorVertexPair *>(v);
+        setVertexDistance(pair->m_first, distance);
+        setVertexDistance(pair->m_second, distance);
+    }
+}
+
+/*!
   \internal
 
   Calculate the position of each vertex based on the paths to each of
@@ -2288,9 +2648,9 @@ void QGraphicsAnchorLayoutPrivate::calculateVertexPositions(
     QSet<AnchorVertex *> visited;
 
     // Get root vertex
-    AnchorVertex *root = graph[orientation].rootVertex();
+    AnchorVertex *root = layoutFirstVertex[orientation];
 
-    root->distance = 0;
+    setVertexDistance(root, 0);
     visited.insert(root);
 
     // Add initial edges to the queue
@@ -2314,7 +2674,7 @@ void QGraphicsAnchorLayoutPrivate::calculateVertexPositions(
             continue;
 
         visited.insert(pair.second);
-        interpolateEdge(pair.first, edge, orientation);
+        interpolateEdge(pair.first, edge);
 
         QList<AnchorVertex *> adjacents = graph[orientation].adjacentVertices(pair.second);
         for (int i = 0; i < adjacents.count(); ++i) {
@@ -2343,7 +2703,6 @@ void QGraphicsAnchorLayoutPrivate::setupEdgesInterpolation(
     result = getFactor(current,
                        sizeHints[orientation][Qt::MinimumSize],
                        sizeHints[orientation][Qt::PreferredSize],
-                       sizeAtExpanding[orientation],
                        sizeHints[orientation][Qt::MaximumSize]);
 
     interpolationInterval[orientation] = result.first;
@@ -2358,7 +2717,6 @@ void QGraphicsAnchorLayoutPrivate::setupEdgesInterpolation(
 
    - minimum size,
    - preferred size,
-   - size when all expanding anchors are expanded,
    - maximum size.
 
    These three key values are calculated in advance using linear
@@ -2370,36 +2728,32 @@ void QGraphicsAnchorLayoutPrivate::setupEdgesInterpolation(
    vertices to be initalized, so it calls specialized functions that
    will recurse back to interpolateEdge().
  */
-void QGraphicsAnchorLayoutPrivate::interpolateEdge(AnchorVertex *base,
-                                                   AnchorData *edge,
-                                                   Orientation orientation)
+void QGraphicsAnchorLayoutPrivate::interpolateEdge(AnchorVertex *base, AnchorData *edge)
 {
+    const Orientation orientation = Orientation(edge->orientation);
     const QPair<Interval, qreal> factor(interpolationInterval[orientation],
                                         interpolationProgress[orientation]);
 
     qreal edgeDistance = interpolate(factor, edge->sizeAtMinimum, edge->sizeAtPreferred,
-                                     edge->sizeAtExpanding, edge->sizeAtMaximum);
+                                     edge->sizeAtMaximum);
 
     Q_ASSERT(edge->from == base || edge->to == base);
 
-    if (edge->from == base)
-        edge->to->distance = base->distance + edgeDistance;
-    else
-        edge->from->distance = base->distance - edgeDistance;
+    // Calculate the distance for the vertex opposite to the base
+    if (edge->from == base) {
+        setVertexDistance(edge->to, base->distance + edgeDistance);
+    } else {
+        setVertexDistance(edge->from, base->distance - edgeDistance);
+    }
 
     // Process child anchors
     if (edge->type == AnchorData::Sequential)
-        interpolateSequentialEdges(edge->from,
-                                   static_cast<SequentialAnchorData *>(edge),
-                                   orientation);
+        interpolateSequentialEdges(static_cast<SequentialAnchorData *>(edge));
     else if (edge->type == AnchorData::Parallel)
-        interpolateParallelEdges(edge->from,
-                                 static_cast<ParallelAnchorData *>(edge),
-                                 orientation);
+        interpolateParallelEdges(static_cast<ParallelAnchorData *>(edge));
 }
 
-void QGraphicsAnchorLayoutPrivate::interpolateParallelEdges(
-    AnchorVertex *base, ParallelAnchorData *data, Orientation orientation)
+void QGraphicsAnchorLayoutPrivate::interpolateParallelEdges(ParallelAnchorData *data)
 {
     // In parallels the boundary vertices are already calculate, we
     // just need to look for sequential groups inside, because only
@@ -2407,46 +2761,44 @@ void QGraphicsAnchorLayoutPrivate::interpolateParallelEdges(
 
     // First edge
     if (data->firstEdge->type == AnchorData::Sequential)
-        interpolateSequentialEdges(base,
-                                   static_cast<SequentialAnchorData *>(data->firstEdge),
-                                   orientation);
+        interpolateSequentialEdges(static_cast<SequentialAnchorData *>(data->firstEdge));
     else if (data->firstEdge->type == AnchorData::Parallel)
-        interpolateParallelEdges(base,
-                                 static_cast<ParallelAnchorData *>(data->firstEdge),
-                                 orientation);
+        interpolateParallelEdges(static_cast<ParallelAnchorData *>(data->firstEdge));
 
     // Second edge
     if (data->secondEdge->type == AnchorData::Sequential)
-        interpolateSequentialEdges(base,
-                                   static_cast<SequentialAnchorData *>(data->secondEdge),
-                                   orientation);
+        interpolateSequentialEdges(static_cast<SequentialAnchorData *>(data->secondEdge));
     else if (data->secondEdge->type == AnchorData::Parallel)
-        interpolateParallelEdges(base,
-                                 static_cast<ParallelAnchorData *>(data->secondEdge),
-                                 orientation);
+        interpolateParallelEdges(static_cast<ParallelAnchorData *>(data->secondEdge));
 }
 
-void QGraphicsAnchorLayoutPrivate::interpolateSequentialEdges(
-    AnchorVertex *base, SequentialAnchorData *data, Orientation orientation)
+void QGraphicsAnchorLayoutPrivate::interpolateSequentialEdges(SequentialAnchorData *data)
 {
-    AnchorVertex *prev = base;
+    // This method is supposed to handle any sequential anchor, even out-of-order
+    // ones. However, in the current QGAL implementation we should get only the
+    // well behaved ones.
+    Q_ASSERT(data->m_edges.first()->from == data->from);
+    Q_ASSERT(data->m_edges.last()->to == data->to);
 
-    // ### I'm not sure whether this assumption is safe. If not,
-    // consider that m_edges.last() could be used instead (so
-    // at(0) would be the one to be treated specially).
-    Q_ASSERT(base == data->m_edges.at(0)->to || base == data->m_edges.at(0)->from);
+    // At this point, the two outter vertices already have their distance
+    // calculated.
+    // We use the first as the base to calculate the internal ones
+
+    AnchorVertex *prev = data->from;
 
-    // Skip the last
     for (int i = 0; i < data->m_edges.count() - 1; ++i) {
-        AnchorData *child = data->m_edges.at(i);
-        interpolateEdge(prev, child, orientation);
-        prev = child->to;
+        AnchorData *edge = data->m_edges.at(i);
+        interpolateEdge(prev, edge);
+
+        // Use the recently calculated vertex as the base for the next one
+        const bool edgeIsForward = (edge->from == prev);
+        prev = edgeIsForward ? edge->to : edge->from;
     }
 
     // Treat the last specially, since we already calculated it's end
     // vertex, so it's only interesting if it's a complex one
     if (data->m_edges.last()->type != AnchorData::Normal)
-        interpolateEdge(prev, data->m_edges.last(), orientation);
+        interpolateEdge(prev, data->m_edges.last());
 }
 
 bool QGraphicsAnchorLayoutPrivate::solveMinMax(const QList<QSimplexConstraint *> &constraints,
@@ -2472,9 +2824,10 @@ bool QGraphicsAnchorLayoutPrivate::solveMinMax(const QList<QSimplexConstraint *>
         // Save sizeAtMinimum results
         QList<AnchorData *> variables = getVariables(constraints);
         for (int i = 0; i < variables.size(); ++i) {
-            AnchorData *ad = static_cast<AnchorData *>(variables[i]);
-            Q_ASSERT(ad->result >= ad->minSize || qFuzzyCompare(ad->result, ad->minSize));
+            AnchorData *ad = static_cast<AnchorData *>(variables.at(i));
             ad->sizeAtMinimum = ad->result;
+            Q_ASSERT(ad->sizeAtMinimum >= ad->minSize ||
+                     qAbs(ad->sizeAtMinimum - ad->minSize) < 0.00000001);
         }
 
         // Calculate maximum values
@@ -2482,9 +2835,10 @@ bool QGraphicsAnchorLayoutPrivate::solveMinMax(const QList<QSimplexConstraint *>
 
         // Save sizeAtMaximum results
         for (int i = 0; i < variables.size(); ++i) {
-            AnchorData *ad = static_cast<AnchorData *>(variables[i]);
-            Q_ASSERT(ad->result <= ad->maxSize || qFuzzyCompare(ad->result, ad->maxSize));
+            AnchorData *ad = static_cast<AnchorData *>(variables.at(i));
             ad->sizeAtMaximum = ad->result;
+            // Q_ASSERT(ad->sizeAtMaximum <= ad->maxSize ||
+            //          qAbs(ad->sizeAtMaximum - ad->maxSize) < 0.00000001);
         }
     }
     return feasible;
@@ -2515,7 +2869,7 @@ bool QGraphicsAnchorLayoutPrivate::solvePreferred(const QList<QSimplexConstraint
     //      A + A_shrinker - A_grower = A_pref
     //
     for (int i = 0; i < variables.size(); ++i) {
-        AnchorData *ad = variables[i];
+        AnchorData *ad = variables.at(i);
         if (ad->skipInPreferred)
             continue;
 
@@ -2546,7 +2900,7 @@ bool QGraphicsAnchorLayoutPrivate::solvePreferred(const QList<QSimplexConstraint
 
         // Save sizeAtPreferred results
         for (int i = 0; i < variables.size(); ++i) {
-            AnchorData *ad = variables[i];
+            AnchorData *ad = variables.at(i);
             ad->sizeAtPreferred = ad->result;
         }
 
@@ -2563,139 +2917,6 @@ bool QGraphicsAnchorLayoutPrivate::solvePreferred(const QList<QSimplexConstraint
 
 /*!
     \internal
-    Calculate the "expanding" keyframe
-
-    This new keyframe sits between the already existing sizeAtPreferred and
-    sizeAtMaximum keyframes. Its goal is to modify the interpolation between
-    the latter as to respect the "expanding" size policy of some anchors.
-
-    Previously all items would be subject to a linear interpolation between
-    sizeAtPreferred and sizeAtMaximum values. This will change now, the
-    expanding anchors will change their size before the others. To calculate
-    this keyframe we use the following logic:
-
-    1) Ask each anchor for their desired expanding size (ad->expSize), this
-    value depends on the anchor expanding property in the following way:
-
-    - Expanding normal anchors want to grow towards their maximum size
-    - Non-expanding normal anchors want to remain at their preferred size.
-    - Sequential anchors wants to grow towards a size that is calculated by:
-        summarizing it's child anchors, where it will use preferred size for non-expanding anchors
-        and maximum size for expanding anchors.
-    - Parallel anchors want to grow towards the smallest maximum size of all the expanding anchors.
-
-    2) Clamp their desired values to the value they assume in the neighbour
-    keyframes (sizeAtPreferred and sizeAtExpanding)
-
-    3) Run simplex with a setup that ensures the following:
-
-      a. Anchors will change their value from their sizeAtPreferred towards
-         their sizeAtMaximum as much as required to ensure that ALL anchors
-         reach their respective "desired" expanding sizes.
-
-      b. No anchors will change their value beyond what is NEEDED to satisfy
-         the requirement above.
-
-    The final result is that, at the "expanding" keyframe expanding anchors
-    will grow and take with them all anchors that are parallel to them.
-    However, non-expanding anchors will remain at their preferred size unless
-    they are forced to grow by a parallel expanding anchor.
-
-    Note: For anchors where the sizeAtPreferred is bigger than sizeAtMaximum,
-          the visual effect when the layout grows from its preferred size is
-          the following: Expanding anchors will keep their size while non
-          expanding ones will shrink. Only after non-expanding anchors have
-          shrinked all the way, the expanding anchors will start to shrink too.
-*/
-void QGraphicsAnchorLayoutPrivate::solveExpanding(const QList<QSimplexConstraint *> &constraints,
-                                                  const QList<AnchorData *> &variables)
-{
-    QList<QSimplexConstraint *> itemConstraints;
-    QSimplexConstraint *objective = new QSimplexConstraint;
-    bool hasExpanding = false;
-
-    // Construct the simplex constraints and objective
-    for (int i = 0; i < variables.size(); ++i) {
-        // For each anchor
-        AnchorData *ad = variables[i];
-
-        // Clamp the desired expanding size
-        qreal upperBoundary = qMax(ad->sizeAtPreferred, ad->sizeAtMaximum);
-        qreal lowerBoundary = qMin(ad->sizeAtPreferred, ad->sizeAtMaximum);
-        qreal boundedExpSize = qBound(lowerBoundary, ad->expSize, upperBoundary);
-
-        // Expanding anchors are those that want to move from their preferred size
-        if (boundedExpSize != ad->sizeAtPreferred)
-            hasExpanding = true;
-
-        // Lock anchor between boundedExpSize and sizeAtMaximum (ensure 3.a)
-        if (boundedExpSize == ad->sizeAtMaximum || qFuzzyCompare(boundedExpSize, ad->sizeAtMaximum)) {
-            // The interval has only one possible value, we can use an "Equal"
-            // constraint and don't need to add this variable to the objective.
-            QSimplexConstraint *itemC = new QSimplexConstraint;
-            itemC->ratio = QSimplexConstraint::Equal;
-            itemC->variables.insert(ad, 1.0);
-            itemC->constant = boundedExpSize;
-            itemConstraints << itemC;
-        } else {
-            // Add MoreOrEqual and LessOrEqual constraints.
-            QSimplexConstraint *itemC = new QSimplexConstraint;
-            itemC->ratio = QSimplexConstraint::MoreOrEqual;
-            itemC->variables.insert(ad, 1.0);
-            itemC->constant = qMin(boundedExpSize, ad->sizeAtMaximum);
-            itemConstraints << itemC;
-
-            itemC = new QSimplexConstraint;
-            itemC->ratio = QSimplexConstraint::LessOrEqual;
-            itemC->variables.insert(ad, 1.0);
-            itemC->constant = qMax(boundedExpSize, ad->sizeAtMaximum);
-            itemConstraints << itemC;
-
-            // Create objective to avoid the anchors from moving away from
-            // the preferred size more than the needed amount. (ensure 3.b)
-            // The objective function is the distance between sizeAtPreferred
-            // and sizeAtExpanding, it will be minimized.
-            if (ad->sizeAtExpanding < ad->sizeAtMaximum) {
-                // Try to shrink this variable towards its sizeAtPreferred value
-                objective->variables.insert(ad, 1.0);
-            } else {
-                // Try to grow this variable towards its sizeAtPreferred value
-                objective->variables.insert(ad, -1.0);
-            }
-        }
-    }
-
-    // Solve
-    if (hasExpanding == false) {
-        // If no anchors are expanding, we don't need to run the simplex
-        // Set all variables to their preferred size
-        for (int i = 0; i < variables.size(); ++i) {
-            variables[i]->sizeAtExpanding = variables[i]->sizeAtPreferred;
-        }
-    } else {
-        // Run simplex
-        QSimplex simplex;
-
-        // Satisfy expanding (3.a)
-        bool feasible = simplex.setConstraints(constraints + itemConstraints);
-        Q_ASSERT(feasible);
-
-        // Reduce damage (3.b)
-        simplex.setObjective(objective);
-        simplex.solveMin();
-
-        // Collect results
-        for (int i = 0; i < variables.size(); ++i) {
-            variables[i]->sizeAtExpanding = variables[i]->result;
-        }
-    }
-
-    delete objective;
-    qDeleteAll(itemConstraints);
-}
-
-/*!
-    \internal
     Returns true if there are no arrangement that satisfies all constraints.
     Otherwise returns false.
 
diff --git a/src/gui/graphicsview/qgraphicsanchorlayout_p.h b/src/gui/graphicsview/qgraphicsanchorlayout_p.h
index 7dd0d65..3ef37f9 100644
--- a/src/gui/graphicsview/qgraphicsanchorlayout_p.h
+++ b/src/gui/graphicsview/qgraphicsanchorlayout_p.h
@@ -78,66 +78,30 @@ QT_BEGIN_NAMESPACE
   Represents a vertex (anchorage point) in the internal graph
 */
 struct AnchorVertex {
+    enum Type {
+        Normal = 0,
+        Pair
+    };
+
     AnchorVertex(QGraphicsLayoutItem *item, Qt::AnchorPoint edge)
-        : m_item(item), m_edge(edge) {}
+        : m_item(item), m_edge(edge), m_type(Normal) {}
 
     AnchorVertex()
-        : m_item(0), m_edge(Qt::AnchorPoint(0)) {}
+        : m_item(0), m_edge(Qt::AnchorPoint(0)), m_type(Normal) {}
 
 #ifdef QT_DEBUG
     inline QString toString() const;
 #endif
+
     QGraphicsLayoutItem *m_item;
     Qt::AnchorPoint m_edge;
+    uint m_type : 1;
 
     // Current distance from this vertex to the layout edge (Left or Top)
     // Value is calculated from the current anchors sizes.
     qreal distance;
 };
 
-#ifdef QT_DEBUG
-inline QString AnchorVertex::toString() const
-{
-    if (!this || !m_item) {
-        return QLatin1String("NULL");
-    }
-    QString edge;
-    switch (m_edge) {
-    case Qt::AnchorLeft:
-        edge = QLatin1String("Left");
-        break;
-    case Qt::AnchorHorizontalCenter:
-        edge = QLatin1String("HorizontalCenter");
-        break;
-    case Qt::AnchorRight:
-        edge = QLatin1String("Right");
-        break;
-    case Qt::AnchorTop:
-        edge = QLatin1String("Top");
-        break;
-    case Qt::AnchorVerticalCenter:
-        edge = QLatin1String("VerticalCenter");
-        break;
-    case Qt::AnchorBottom:
-        edge = QLatin1String("Bottom");
-        break;
-    default:
-        edge = QLatin1String("None");
-        break;
-    }
-    QString itemName;
-    if (m_item->isLayout()) {
-        itemName = QLatin1String("layout");
-    } else {
-        if (QGraphicsItem *item = m_item->graphicsItem()) {
-            itemName = item->data(0).toString();
-        }
-    }
-    edge.insert(0, QLatin1String("%1_"));
-    return edge.arg(itemName);
-}
-#endif
-
 /*!
   \internal
 
@@ -150,14 +114,21 @@ struct AnchorData : public QSimplexVariable {
         Parallel
     };
 
+    enum Dependency {
+        Independent = 0,
+        Master,
+        Slave
+    };
+
     AnchorData()
         : QSimplexVariable(), item(0), from(0), to(0),
-          minSize(0), prefSize(0), expSize(0), maxSize(0),
+          minSize(0), prefSize(0), maxSize(0),
           sizeAtMinimum(0), sizeAtPreferred(0),
-          sizeAtExpanding(0), sizeAtMaximum(0),
+          sizeAtMaximum(0),
           graphicsAnchor(0), skipInPreferred(0),
           type(Normal), hasSize(true), isLayoutAnchor(false),
-          isCenterAnchor(false), orientation(0) {}
+          isCenterAnchor(false), orientation(0),
+          dependency(Independent) {}
 
     virtual void updateChildrenSizes() {}
     virtual bool refreshSizeHints(const QLayoutStyleInfo *styleInfo);
@@ -194,7 +165,6 @@ struct AnchorData : public QSimplexVariable {
     // size.
     qreal minSize;
     qreal prefSize;
-    qreal expSize;
     qreal maxSize;
 
     // These attributes define which sizes should that anchor be in when the
@@ -202,7 +172,6 @@ struct AnchorData : public QSimplexVariable {
     // calculated by the Simplex solver based on the current layout setup.
     qreal sizeAtMinimum;
     qreal sizeAtPreferred;
-    qreal sizeAtExpanding;
     qreal sizeAtMaximum;
     QGraphicsAnchor *graphicsAnchor;
 
@@ -212,6 +181,7 @@ struct AnchorData : public QSimplexVariable {
     uint isLayoutAnchor : 1;  // if this anchor is an internal layout anchor
     uint isCenterAnchor : 1;
     uint orientation : 1;
+    uint dependency : 2;      // either Independent, Master or Slave
 };
 
 #ifdef QT_DEBUG
@@ -250,10 +220,11 @@ struct ParallelAnchorData : public AnchorData
         type = AnchorData::Parallel;
         orientation = first->orientation;
 
-        // ### Those asserts force that both child anchors have the same direction,
-        // but can't we simplify a pair of anchors in opposite directions?
-        Q_ASSERT(first->from == second->from);
-        Q_ASSERT(first->to == second->to);
+        // This assert whether the child anchors share their vertices
+        Q_ASSERT(((first->from == second->from) && (first->to == second->to)) ||
+                 ((first->from == second->to) && (first->to == second->from)));
+
+        // We arbitrarily choose the direction of the first child as "our" direction
         from = first->from;
         to = first->to;
 #ifdef QT_DEBUG
@@ -268,8 +239,73 @@ struct ParallelAnchorData : public AnchorData
 
     AnchorData* firstEdge;
     AnchorData* secondEdge;
+
+    QList<QSimplexConstraint *> m_firstConstraints;
+    QList<QSimplexConstraint *> m_secondConstraints;
 };
 
+struct AnchorVertexPair : public AnchorVertex {
+    AnchorVertexPair(AnchorVertex *v1, AnchorVertex *v2, AnchorData *data)
+        : AnchorVertex(), m_first(v1), m_second(v2), m_removedAnchor(data) {
+        m_type = AnchorVertex::Pair;
+    }
+
+    AnchorVertex *m_first;
+    AnchorVertex *m_second;
+
+    AnchorData *m_removedAnchor;
+    QList<AnchorData *> m_firstAnchors;
+    QList<AnchorData *> m_secondAnchors;
+};
+
+#ifdef QT_DEBUG
+inline QString AnchorVertex::toString() const
+{
+    if (!this) {
+        return QLatin1String("NULL");
+    } else if (m_type == Pair) {
+        const AnchorVertexPair *vp = static_cast<const AnchorVertexPair *>(this);
+        return QString::fromAscii("(%1, %2)").arg(vp->m_first->toString()).arg(vp->m_second->toString());
+    } else if (!m_item) {
+        return QString::fromAscii("NULL_%1").arg(int(this));
+    }
+    QString edge;
+    switch (m_edge) {
+    case Qt::AnchorLeft:
+        edge = QLatin1String("Left");
+        break;
+    case Qt::AnchorHorizontalCenter:
+        edge = QLatin1String("HorizontalCenter");
+        break;
+    case Qt::AnchorRight:
+        edge = QLatin1String("Right");
+        break;
+    case Qt::AnchorTop:
+        edge = QLatin1String("Top");
+        break;
+    case Qt::AnchorVerticalCenter:
+        edge = QLatin1String("VerticalCenter");
+        break;
+    case Qt::AnchorBottom:
+        edge = QLatin1String("Bottom");
+        break;
+    default:
+        edge = QLatin1String("None");
+        break;
+    }
+    QString itemName;
+    if (m_item->isLayout()) {
+        itemName = QLatin1String("layout");
+    } else {
+        if (QGraphicsItem *item = m_item->graphicsItem()) {
+            itemName = item->data(0).toString();
+        }
+    }
+    edge.insert(0, QLatin1String("%1_"));
+    return edge.arg(itemName);
+}
+#endif
+
 /*!
   \internal
 
@@ -337,8 +373,7 @@ public:
     // Interval represents which interpolation interval are we operating in.
     enum Interval {
         MinToPreferred = 0,
-        PreferredToExpanding,
-        ExpandingToMax
+        PreferredToMax
     };
 
     // Several structures internal to the layout are duplicated to handle
@@ -427,20 +462,33 @@ public:
 
     QLayoutStyleInfo &styleInfo() const;
 
-    // Activation methods
-    bool simplifyGraph(Orientation orientation);
-    bool simplifyGraphIteration(Orientation orientation, bool *feasible);
-    void restoreSimplifiedGraph(Orientation orientation);
+    AnchorData *addAnchorMaybeParallel(AnchorData *newAnchor, bool *feasible);
 
+    // Activation
     void calculateGraphs();
     void calculateGraphs(Orientation orientation);
 
+    // Simplification
+    bool simplifyGraph(Orientation orientation);
+    bool simplifyVertices(Orientation orientation);
+    bool simplifyGraphIteration(Orientation orientation, bool *feasible);
+
+    bool replaceVertex(Orientation orientation, AnchorVertex *oldV,
+                       AnchorVertex *newV, const QList<AnchorData *> &edges);
+
+
+    void restoreSimplifiedGraph(Orientation orientation);
+    void restoreSimplifiedAnchor(AnchorData *edge);
+    void restoreSimplifiedConstraints(ParallelAnchorData *parallel);
+    void restoreVertices(Orientation orientation);
+
     bool calculateTrunk(Orientation orientation, const GraphPath &trunkPath,
                         const QList<QSimplexConstraint *> &constraints,
                         const QList<AnchorData *> &variables);
     bool calculateNonTrunk(const QList<QSimplexConstraint *> &constraints,
                            const QList<AnchorData *> &variables);
 
+    // Support functions for calculateGraph()
     bool refreshAllSizeHints(Orientation orientation);
     void findPaths(Orientation orientation);
     void constraintsFromPaths(Orientation orientation);
@@ -460,6 +508,17 @@ public:
         return internalVertex(qMakePair(const_cast<QGraphicsLayoutItem *>(item), edge));
     }
 
+    inline void changeLayoutVertex(Orientation orientation, AnchorVertex *oldV, AnchorVertex *newV)
+    {
+        if (layoutFirstVertex[orientation] == oldV)
+            layoutFirstVertex[orientation] = newV;
+        else if (layoutCentralVertex[orientation] == oldV)
+            layoutCentralVertex[orientation] = newV;
+        else if (layoutLastVertex[orientation] == oldV)
+            layoutLastVertex[orientation] = newV;
+    }
+
+
     AnchorVertex *addInternalVertex(QGraphicsLayoutItem *item, Qt::AnchorPoint edge);
     void removeInternalVertex(QGraphicsLayoutItem *item, Qt::AnchorPoint edge);
 
@@ -468,19 +527,15 @@ public:
 
     void calculateVertexPositions(Orientation orientation);
     void setupEdgesInterpolation(Orientation orientation);
-    void interpolateEdge(AnchorVertex *base, AnchorData *edge, Orientation orientation);
-    void interpolateSequentialEdges(AnchorVertex *base, SequentialAnchorData *edge,
-                                    Orientation orientation);
-    void interpolateParallelEdges(AnchorVertex *base, ParallelAnchorData *edge,
-                                  Orientation orientation);
+    void interpolateEdge(AnchorVertex *base, AnchorData *edge);
+    void interpolateSequentialEdges(SequentialAnchorData *edge);
+    void interpolateParallelEdges(ParallelAnchorData *edge);
 
     // Linear Programming solver methods
     bool solveMinMax(const QList<QSimplexConstraint *> &constraints,
                      GraphPath path, qreal *min, qreal *max);
     bool solvePreferred(const QList<QSimplexConstraint *> &constraints,
                         const QList<AnchorData *> &variables);
-    void solveExpanding(const QList<QSimplexConstraint *> &constraints,
-                        const QList<AnchorData *> &variables);
     bool hasConflicts() const;
 
 #ifdef QT_DEBUG
@@ -491,7 +546,6 @@ public:
     qreal spacings[NOrientations];
     // Size hints from simplex engine
     qreal sizeHints[2][3];
-    qreal sizeAtExpanding[2];
 
     // Items
     QVector<QGraphicsLayoutItem *> items;
@@ -504,6 +558,14 @@ public:
     // Internal graph of anchorage points and anchors, for both orientations
     Graph<AnchorVertex, AnchorData> graph[2];
 
+    AnchorVertex *layoutFirstVertex[2];
+    AnchorVertex *layoutCentralVertex[2];
+    AnchorVertex *layoutLastVertex[2];
+
+    // Combined anchors in order of creation
+    QList<AnchorVertexPair *> simplifiedVertices[2];
+    QList<AnchorData *> anchorsFromSimplifiedVertices[2];
+
     // Graph paths and constraints, for both orientations
     QMultiHash<AnchorVertex *, GraphPath> graphPaths[2];
     QList<QSimplexConstraint *> constraints[2];
diff --git a/src/gui/graphicsview/qgraphicsitem.cpp b/src/gui/graphicsview/qgraphicsitem.cpp
index 2fd499d..70457b5 100644
--- a/src/gui/graphicsview/qgraphicsitem.cpp
+++ b/src/gui/graphicsview/qgraphicsitem.cpp
@@ -386,6 +386,12 @@
     introduced in Qt 4.6.
 
     \omitvalue ItemIsFocusScope Internal only (for now).
+
+    \value ItemSendsScenePositionChanges The item enables itemChange()
+    notifications for ItemScenePositionHasChanged. For performance reasons,
+    these notifications are disabled by default. You must enable this flag
+    to receive notifications for scene position changes. This flag was
+    introduced in Qt 4.6.
 */
 
 /*!
@@ -562,6 +568,14 @@
     \value ItemOpacityHasChanged The item's opacity has changed. The value
     argument is the new opacity (i.e., a double). Do not call setOpacity() as
     this notification is delivered. The return value is ignored.
+
+    \value ItemScenePositionHasChanged The item's scene position has changed.
+    This notification is sent if the ItemSendsScenePositionChanges flag is
+    enabled, and after the item's scene position has changed (i.e., the
+    position or transformation of the item itself or the position or
+    transformation of any ancestor has changed). The value argument is the
+    new scene position (the same as scenePos()), and QGraphicsItem ignores
+    the return value for this notification (i.e., a read-only notification).
 */
 
 /*!
@@ -990,6 +1004,10 @@ void QGraphicsItemPrivate::setParentItemHelper(QGraphicsItem *newParent)
     if (scene) {
         // Deliver the change to the index
         scene->d_func()->index->itemChange(q, QGraphicsItem::ItemParentChange, newParentVariant);
+
+        // Disable scene pos notifications for old ancestors
+        if (scenePosDescendants || (flags & QGraphicsItem::ItemSendsScenePositionChanges))
+            scene->d_func()->setScenePosItemEnabled(q, false);
     }
 
     if (subFocusItem && parent) {
@@ -1084,10 +1102,15 @@ void QGraphicsItemPrivate::setParentItemHelper(QGraphicsItem *newParent)
 
         parent->d_ptr->addChild(q);
         parent->itemChange(QGraphicsItem::ItemChildAddedChange, thisPointerVariant);
-        if (!implicitUpdate && scene) {
-            scene->d_func()->markDirty(q_ptr, QRect(),
-                                       /*invalidateChildren=*/false,
-                                       /*maybeDirtyClipPath=*/true);
+        if (scene) {
+            if (!implicitUpdate)
+                scene->d_func()->markDirty(q_ptr, QRect(),
+                                           /*invalidateChildren=*/false,
+                                           /*maybeDirtyClipPath=*/true);
+
+            // Re-enable scene pos notifications for new ancestors
+            if (scenePosDescendants || (flags & QGraphicsItem::ItemSendsScenePositionChanges))
+                scene->d_func()->setScenePosItemEnabled(q, true);
         }
 
         // Inherit ancestor flags from the new parent.
@@ -1336,7 +1359,9 @@ QGraphicsItem::~QGraphicsItem()
         d_ptr->setParentItemHelper(0);
     }
 
+#ifndef QT_NO_GRAPHICSEFFECT
     delete d_ptr->graphicsEffect;
+#endif //QT_NO_GRAPHICSEFFECT
     if (d_ptr->transformData) {
         for(int i = 0; i < d_ptr->transformData->graphicsTransforms.size(); ++i) {
             QGraphicsTransform *t = d_ptr->transformData->graphicsTransforms.at(i);
@@ -1746,6 +1771,12 @@ void QGraphicsItem::setFlags(GraphicsItemFlags flags)
     }
 
     if (d_ptr->scene) {
+        if ((flags & ItemSendsScenePositionChanges) != (oldFlags & ItemSendsScenePositionChanges)) {
+            if (flags & ItemSendsScenePositionChanges)
+                d_ptr->scene->d_func()->registerScenePosItem(this);
+            else
+                d_ptr->scene->d_func()->unregisterScenePosItem(this);
+        }
         d_ptr->scene->d_func()->markDirty(this, QRectF(),
                                           /*invalidateChildren=*/true,
                                           /*maybeDirtyClipPath*/true);
@@ -2506,7 +2537,9 @@ void QGraphicsItem::setOpacity(qreal opacity)
 
     // Update.
     if (d_ptr->scene) {
+#ifndef QT_NO_GRAPHICSEFFECT
         d_ptr->invalidateGraphicsEffectsRecursively();
+#endif //QT_NO_GRAPHICSEFFECT
         d_ptr->scene->d_func()->markDirty(this, QRectF(),
                                           /*invalidateChildren=*/true,
                                           /*maybeDirtyClipPath=*/false,
@@ -2523,6 +2556,7 @@ void QGraphicsItem::setOpacity(qreal opacity)
 
     \since 4.6
 */
+#ifndef QT_NO_GRAPHICSEFFECT
 QGraphicsEffect *QGraphicsItem::graphicsEffect() const
 {
     return d_ptr->graphicsEffect;
@@ -2569,6 +2603,7 @@ void QGraphicsItem::setGraphicsEffect(QGraphicsEffect *effect)
 
     prepareGeometryChange();
 }
+#endif //QT_NO_GRAPHICSEFFECT
 
 /*!
     \internal
@@ -2582,6 +2617,7 @@ void QGraphicsItem::setGraphicsEffect(QGraphicsEffect *effect)
 */
 QRectF QGraphicsItemPrivate::effectiveBoundingRect() const
 {
+#ifndef QT_NO_GRAPHICSEFFECT
     QGraphicsEffect *effect = graphicsEffect;
     QRectF brect = effect && effect->isEnabled() ? effect->boundingRect() : q_ptr->boundingRect();
     if (ancestorFlags & QGraphicsItemPrivate::AncestorClipsChildren)
@@ -2598,6 +2634,10 @@ QRectF QGraphicsItemPrivate::effectiveBoundingRect() const
     }
 
     return brect;
+#else //QT_NO_GRAPHICSEFFECT
+    return q_ptr->boundingRect();
+#endif //QT_NO_GRAPHICSEFFECT
+
 }
 
 /*!
@@ -2951,7 +2991,7 @@ bool QGraphicsItem::hasFocus() const
 {
     if (d_ptr->focusProxy)
         return d_ptr->focusProxy->hasFocus();
-    return (d_ptr->scene && d_ptr->scene->focusItem() == this);
+    return isActive() && (d_ptr->scene && d_ptr->scene->focusItem() == this);
 }
 
 /*!
@@ -3412,6 +3452,7 @@ void QGraphicsItem::setPos(const QPointF &pos)
 
     // Send post-notification.
     itemChange(QGraphicsItem::ItemPositionHasChanged, newPosVariant);
+    d_ptr->sendScenePosChange();
 }
 
 /*!
@@ -4022,6 +4063,7 @@ void QGraphicsItem::setTransform(const QTransform &matrix, bool combine)
 
     // Send post-notification.
     itemChange(ItemTransformHasChanged, newTransformVariant);
+    d_ptr->sendScenePosChange();
 }
 
 /*!
@@ -4246,6 +4288,24 @@ void QGraphicsItemPrivate::ensureSequentialSiblingIndex()
 }
 
 /*!
+    \internal
+*/
+inline void QGraphicsItemPrivate::sendScenePosChange()
+{
+    Q_Q(QGraphicsItem);
+    if (scene) {
+        if (flags & QGraphicsItem::ItemSendsScenePositionChanges)
+            q->itemChange(QGraphicsItem::ItemScenePositionHasChanged, q->scenePos());
+        if (scenePosDescendants) {
+            foreach (QGraphicsItem *item, scene->d_func()->scenePosItems) {
+                if (q->isAncestorOf(item))
+                    item->itemChange(QGraphicsItem::ItemScenePositionHasChanged, item->scenePos());
+            }
+        }
+    }
+}
+
+/*!
     \since 4.6
 
     Stacks this item before \a sibling, which must be a sibling item (i.e., the
@@ -4296,6 +4356,12 @@ void QGraphicsItem::stackBefore(const QGraphicsItem *sibling)
                 ++index;
         }
         d_ptr->siblingIndex = siblingIndex;
+        for (int i = 0; i < siblings->size(); ++i) {
+            int &index = siblings->at(i)->d_ptr->siblingIndex;
+            if (i != siblingIndex && index >= siblingIndex && index <= myIndex)
+                siblings->at(i)->d_ptr->siblingOrderChange();
+        }
+        d_ptr->siblingOrderChange();
     }
 }
 
@@ -4977,6 +5043,7 @@ int QGraphicsItemPrivate::depth() const
 /*!
     \internal
 */
+#ifndef QT_NO_GRAPHICSEFFECT
 void QGraphicsItemPrivate::invalidateGraphicsEffectsRecursively()
 {
     QGraphicsItemPrivate *itemPrivate = this;
@@ -4989,6 +5056,7 @@ void QGraphicsItemPrivate::invalidateGraphicsEffectsRecursively()
         }
     } while ((itemPrivate = itemPrivate->parent ? itemPrivate->parent->d_ptr.data() : 0));
 }
+#endif //QT_NO_GRAPHICSEFFECT
 
 /*!
     \internal
@@ -5293,6 +5361,16 @@ void QGraphicsItemPrivate::subFocusItemChange()
 /*!
     \internal
 
+    Subclasses can reimplement this function to be notified when its
+    siblingIndex order is changed.
+*/
+void QGraphicsItemPrivate::siblingOrderChange()
+{
+}
+
+/*!
+    \internal
+
     Tells us if it is a proxy widget
 */
 bool QGraphicsItemPrivate::isProxyWidget() const
@@ -5324,7 +5402,9 @@ void QGraphicsItem::update(const QRectF &rect)
         return;
 
     // Make sure we notify effects about invalidated source.
+#ifndef QT_NO_GRAPHICSEFFECT
     d_ptr->invalidateGraphicsEffectsRecursively();
+#endif //QT_NO_GRAPHICSEFFECT
 
     if (CacheMode(d_ptr->cacheMode) != NoCache) {
         // Invalidate cache.
@@ -8371,8 +8451,9 @@ QPainterPath QGraphicsEllipseItem::shape() const
     if (d->rect.isNull())
         return path;
     if (d->spanAngle != 360 * 16) {
+        const qreal inv_16 = 1 / qreal(16.0);
         path.moveTo(d->rect.center());
-        path.arcTo(d->rect, d->startAngle / 16.0, d->spanAngle / 16.0);
+        path.arcTo(d->rect, d->startAngle * inv_16, d->spanAngle * inv_16);
     } else {
         path.addEllipse(d->rect);
     }
@@ -10678,6 +10759,7 @@ int QGraphicsItemGroup::type() const
     return Type;
 }
 
+#ifndef QT_NO_GRAPHICSEFFECT
 QRectF QGraphicsItemEffectSourcePrivate::boundingRect(Qt::CoordinateSystem system) const
 {
     const bool deviceCoordinates = (system == Qt::DeviceCoordinates);
@@ -10817,6 +10899,7 @@ QPixmap QGraphicsItemEffectSourcePrivate::pixmap(Qt::CoordinateSystem system, QP
 
     return pixmap;
 }
+#endif //QT_NO_GRAPHICSEFFECT
 
 #ifndef QT_NO_DEBUG_STREAM
 QDebug operator<<(QDebug debug, QGraphicsItem *item)
@@ -10940,6 +11023,9 @@ QDebug operator<<(QDebug debug, QGraphicsItem::GraphicsItemChange change)
     case QGraphicsItem::ItemOpacityHasChanged:
         str = "ItemOpacityHasChanged";
         break;
+    case QGraphicsItem::ItemScenePositionHasChanged:
+        str = "ItemScenePositionHasChanged";
+        break;
     }
     debug << str;
     return debug;
@@ -10997,6 +11083,9 @@ QDebug operator<<(QDebug debug, QGraphicsItem::GraphicsItemFlag flag)
     case QGraphicsItem::ItemIsFocusScope:
         str = "ItemIsFocusScope";
         break;
+    case QGraphicsItem::ItemSendsScenePositionChanges:
+        str = "ItemSendsScenePositionChanges";
+        break;
     }
     debug << str;
     return debug;
diff --git a/src/gui/graphicsview/qgraphicsitem.h b/src/gui/graphicsview/qgraphicsitem.h
index f091e34..8bbe9f1 100644
--- a/src/gui/graphicsview/qgraphicsitem.h
+++ b/src/gui/graphicsview/qgraphicsitem.h
@@ -105,7 +105,8 @@ public:
         ItemAcceptsInputMethod = 0x1000,
         ItemNegativeZStacksBehindParent = 0x2000,
         ItemIsPanel = 0x4000,
-        ItemIsFocusScope = 0x8000 // internal
+        ItemIsFocusScope = 0x8000, // internal
+        ItemSendsScenePositionChanges = 0x10000
         // NB! Don't forget to increase the d_ptr->flags bit field by 1 when adding a new flag.
     };
     Q_DECLARE_FLAGS(GraphicsItemFlags, GraphicsItemFlag)
@@ -137,7 +138,8 @@ public:
         ItemZValueChange,
         ItemZValueHasChanged,
         ItemOpacityChange,
-        ItemOpacityHasChanged
+        ItemOpacityHasChanged,
+        ItemScenePositionHasChanged
     };
 
     enum CacheMode {
@@ -225,9 +227,11 @@ public:
     qreal effectiveOpacity() const;
     void setOpacity(qreal opacity);
 
+#ifndef QT_NO_GRAPHICSEFFECT
     // Effect
     QGraphicsEffect *graphicsEffect() const;
     void setGraphicsEffect(QGraphicsEffect *effect);
+#endif //QT_NO_GRAPHICSEFFECT
 
     Qt::MouseButtons acceptedMouseButtons() const;
     void setAcceptedMouseButtons(Qt::MouseButtons buttons);
diff --git a/src/gui/graphicsview/qgraphicsitem_p.h b/src/gui/graphicsview/qgraphicsitem_p.h
index 51d2ffd..afc2198 100644
--- a/src/gui/graphicsview/qgraphicsitem_p.h
+++ b/src/gui/graphicsview/qgraphicsitem_p.h
@@ -179,6 +179,7 @@ public:
         holesInSiblingIndex(0),
         sequentialOrdering(1),
         updateDueToGraphicsEffect(0),
+        scenePosDescendants(0),
         globalStackingOrder(-1),
         q_ptr(0)
     {
@@ -223,7 +224,9 @@ public:
     bool discardUpdateRequest(bool ignoreClipping = false, bool ignoreVisibleBit = false,
                               bool ignoreDirtyBit = false, bool ignoreOpacity = false) const;
     int depth() const;
+#ifndef QT_NO_GRAPHICSEFFECT
     void invalidateGraphicsEffectsRecursively();
+#endif //QT_NO_GRAPHICSEFFECT
     void invalidateDepthRecursively();
     void resolveDepth();
     void addChild(QGraphicsItem *child);
@@ -429,6 +432,8 @@ public:
     inline void ensureSortedChildren();
     static inline bool insertionOrder(QGraphicsItem *a, QGraphicsItem *b);
     void ensureSequentialSiblingIndex();
+    inline void sendScenePosChange();
+    virtual void siblingOrderChange();
 
     QPainterPath cachedClipPath;
     QRectF childrenBoundingRect;
@@ -483,7 +488,7 @@ public:
 
     // Packed 32 bits
     quint32 fullUpdatePending : 1;
-    quint32 flags : 16;
+    quint32 flags : 17;
     quint32 dirtyChildrenBoundingRect : 1;
     quint32 paintedViewBoundingRectsNeedRepaint : 1;
     quint32 dirtySceneTransform : 1;
@@ -498,14 +503,15 @@ public:
     quint32 sceneTransformTranslateOnly : 1;
     quint32 notifyBoundingRectChanged : 1;
     quint32 notifyInvalidated : 1;
-    quint32 mouseSetsFocus : 1;
 
     // New 32 bits
+    quint32 mouseSetsFocus : 1;
     quint32 explicitActivate : 1;
     quint32 wantsActive : 1;
     quint32 holesInSiblingIndex : 1;
     quint32 sequentialOrdering : 1;
     quint32 updateDueToGraphicsEffect : 1;
+    quint32 scenePosDescendants : 1;
 
     // Optional stacking order
     int globalStackingOrder;
@@ -577,6 +583,7 @@ struct QGraphicsItemPaintInfo
     quint32 drawItem : 1;
 };
 
+#ifndef QT_NO_GRAPHICSEFFECT
 class QGraphicsItemEffectSourcePrivate : public QGraphicsEffectSourcePrivate
 {
 public:
@@ -632,7 +639,7 @@ public:
     QGraphicsItemPaintInfo *info;
     QTransform lastEffectTransform;
 };
-
+#endif //QT_NO_GRAPHICSEFFECT
 
 /*!
     Returns true if \a item1 is on top of \a item2.
diff --git a/src/gui/graphicsview/qgraphicsitemanimation.cpp b/src/gui/graphicsview/qgraphicsitemanimation.cpp
index be2f300..1516e46 100644
--- a/src/gui/graphicsview/qgraphicsitemanimation.cpp
+++ b/src/gui/graphicsview/qgraphicsitemanimation.cpp
@@ -165,7 +165,7 @@ qreal QGraphicsItemAnimationPrivate::linearValueForStep(qreal step, QList<Pair>
 
 void QGraphicsItemAnimationPrivate::insertUniquePair(qreal step, qreal value, QList<Pair> *binList, const char* method)
 {
-    if (step < 0.0 || step > 1.0) {
+    if (step < qreal(0.0) || step > qreal(1.0)) {
         qWarning("QGraphicsItemAnimation::%s: invalid step = %f", method, step);
         return;
     }
@@ -255,7 +255,7 @@ void QGraphicsItemAnimation::setTimeLine(QTimeLine *timeLine)
 */
 QPointF QGraphicsItemAnimation::posAt(qreal step) const
 {
-    if (step < 0.0 || step > 1.0)
+    if (step < qreal(0.0) || step > qreal(1.0))
         qWarning("QGraphicsItemAnimation::posAt: invalid step = %f", step);
 
     return QPointF(d->linearValueForStep(step, &d->xPosition, d->startPos.x()),
@@ -294,7 +294,7 @@ QList<QPair<qreal, QPointF> > QGraphicsItemAnimation::posList() const
 */
 QMatrix QGraphicsItemAnimation::matrixAt(qreal step) const
 {
-    if (step < 0.0 || step > 1.0)
+    if (step < qreal(0.0) || step > qreal(1.0))
         qWarning("QGraphicsItemAnimation::matrixAt: invalid step = %f", step);
 
     QMatrix matrix;
@@ -316,7 +316,7 @@ QMatrix QGraphicsItemAnimation::matrixAt(qreal step) const
 */
 qreal QGraphicsItemAnimation::rotationAt(qreal step) const
 {
-    if (step < 0.0 || step > 1.0)
+    if (step < qreal(0.0) || step > qreal(1.0))
         qWarning("QGraphicsItemAnimation::rotationAt: invalid step = %f", step);
 
     return d->linearValueForStep(step, &d->rotation);
@@ -405,7 +405,7 @@ QList<QPair<qreal, QPointF> > QGraphicsItemAnimation::translationList() const
 */
 qreal QGraphicsItemAnimation::verticalScaleAt(qreal step) const
 {
-    if (step < 0.0 || step > 1.0)
+    if (step < qreal(0.0) || step > qreal(1.0))
         qWarning("QGraphicsItemAnimation::verticalScaleAt: invalid step = %f", step);
 
     return d->linearValueForStep(step, &d->verticalScale, 1);
@@ -418,7 +418,7 @@ qreal QGraphicsItemAnimation::verticalScaleAt(qreal step) const
 */
 qreal QGraphicsItemAnimation::horizontalScaleAt(qreal step) const
 {
-    if (step < 0.0 || step > 1.0)
+    if (step < qreal(0.0) || step > qreal(1.0))
         qWarning("QGraphicsItemAnimation::horizontalScaleAt: invalid step = %f", step);
 
     return d->linearValueForStep(step, &d->horizontalScale, 1);
@@ -457,7 +457,7 @@ QList<QPair<qreal, QPointF> > QGraphicsItemAnimation::scaleList() const
 */
 qreal QGraphicsItemAnimation::verticalShearAt(qreal step) const
 {
-    if (step < 0.0 || step > 1.0)
+    if (step < qreal(0.0) || step > qreal(1.0))
         qWarning("QGraphicsItemAnimation::verticalShearAt: invalid step = %f", step);
 
     return d->linearValueForStep(step, &d->verticalShear, 0);
@@ -470,7 +470,7 @@ qreal QGraphicsItemAnimation::verticalShearAt(qreal step) const
 */
 qreal QGraphicsItemAnimation::horizontalShearAt(qreal step) const
 {
-    if (step < 0.0 || step > 1.0)
+    if (step < qreal(0.0) || step > qreal(1.0))
         qWarning("QGraphicsItemAnimation::horizontalShearAt: invalid step = %f", step);
 
     return d->linearValueForStep(step, &d->horizontalShear, 0);
@@ -527,7 +527,7 @@ void QGraphicsItemAnimation::clear()
 */
 void QGraphicsItemAnimation::setStep(qreal x)
 {
-    if (x < 0.0 || x > 1.0) {
+    if (x < qreal(0.0) || x > qreal(1.0)) {
         qWarning("QGraphicsItemAnimation::setStep: invalid step = %f", x);
         return;
     }
diff --git a/src/gui/graphicsview/qgraphicslinearlayout.cpp b/src/gui/graphicsview/qgraphicslinearlayout.cpp
index 5684f0e..cb68741 100644
--- a/src/gui/graphicsview/qgraphicslinearlayout.cpp
+++ b/src/gui/graphicsview/qgraphicslinearlayout.cpp
@@ -542,6 +542,9 @@ void QGraphicsLinearLayout::invalidate()
     QGraphicsLayout::invalidate();
 }
 
+/*!
+    \internal
+*/
 void QGraphicsLinearLayout::dump(int indent) const
 {
 #ifdef QT_DEBUG
diff --git a/src/gui/graphicsview/qgraphicsscene.cpp b/src/gui/graphicsview/qgraphicsscene.cpp
index dc036f8..01f0e97 100644
--- a/src/gui/graphicsview/qgraphicsscene.cpp
+++ b/src/gui/graphicsview/qgraphicsscene.cpp
@@ -294,6 +294,7 @@ QGraphicsScenePrivate::QGraphicsScenePrivate()
       needSortTopLevelItems(true),
       holesInTopLevelSiblingIndex(false),
       topLevelSequentialOrdering(true),
+      scenePosDescendantsUpdatePending(false),
       stickyFocus(false),
       hasFocus(false),
       focusItem(0),
@@ -488,6 +489,55 @@ void QGraphicsScenePrivate::_q_processDirtyItems()
 
 /*!
     \internal
+*/
+void QGraphicsScenePrivate::setScenePosItemEnabled(QGraphicsItem *item, bool enabled)
+{
+    QGraphicsItem *p = item->d_ptr->parent;
+    while (p) {
+        p->d_ptr->scenePosDescendants = enabled;
+        p = p->d_ptr->parent;
+    }
+    if (!enabled && !scenePosDescendantsUpdatePending) {
+        scenePosDescendantsUpdatePending = true;
+        QMetaObject::invokeMethod(q_func(), "_q_updateScenePosDescendants", Qt::QueuedConnection);
+    }
+}
+
+/*!
+    \internal
+*/
+void QGraphicsScenePrivate::registerScenePosItem(QGraphicsItem *item)
+{
+    scenePosItems.insert(item);
+    setScenePosItemEnabled(item, true);
+}
+
+/*!
+    \internal
+*/
+void QGraphicsScenePrivate::unregisterScenePosItem(QGraphicsItem *item)
+{
+    scenePosItems.remove(item);
+    setScenePosItemEnabled(item, false);
+}
+
+/*!
+    \internal
+*/
+void QGraphicsScenePrivate::_q_updateScenePosDescendants()
+{
+    foreach (QGraphicsItem *item, scenePosItems) {
+        QGraphicsItem *p = item->d_ptr->parent;
+        while (p) {
+            p->d_ptr->scenePosDescendants = 1;
+            p = p->d_ptr->parent;
+        }
+    }
+    scenePosDescendantsUpdatePending = false;
+}
+
+/*!
+    \internal
 
     Schedules an item for removal. This function leaves some stale indexes
     around in the BSP tree if called from the item's destructor; these will
@@ -523,6 +573,9 @@ void QGraphicsScenePrivate::removeItemHelper(QGraphicsItem *item)
         widget->d_func()->fixFocusChainBeforeReparenting(0, 0);
     }
 
+    if (item->flags() & QGraphicsItem::ItemSendsScenePositionChanges)
+        unregisterScenePosItem(item);
+
     item->d_func()->scene = 0;
 
     //We need to remove all children first because they might use their parent
@@ -2293,8 +2346,9 @@ void QGraphicsScene::clear()
     // NB! We have to clear the index before deleting items; otherwise the
     // index might try to access dangling item pointers.
     d->index->clear();
-    const QList<QGraphicsItem *> items = d->topLevelItems;
-    qDeleteAll(items);
+    // NB! QGraphicsScenePrivate::unregisterTopLevelItem() removes items
+    while (!d->topLevelItems.isEmpty())
+        delete d->topLevelItems.first();
     Q_ASSERT(d->topLevelItems.isEmpty());
     d->lastItemCount = 0;
     d->allItemsIgnoreHoverEvents = true;
@@ -2540,6 +2594,9 @@ void QGraphicsScene::addItem(QGraphicsItem *item)
         }
     }
 
+    if (item->flags() & QGraphicsItem::ItemSendsScenePositionChanges)
+        d->registerScenePosItem(item);
+
     // Ensure that newly added items that have subfocus set, gain
     // focus automatically if there isn't a focus item already.
     if (!d->focusItem && item != d->lastFocusItem && item->focusItem() == item)
@@ -2826,18 +2883,20 @@ void QGraphicsScene::removeItem(QGraphicsItem *item)
 }
 
 /*!
-    Returns the scene's current focus item, or 0 if no item currently has
-    focus.
+    When the scene is active, this functions returns the scene's current focus
+    item, or 0 if no item currently has focus. When the scene is inactive, this
+    functions returns the item that will gain input focus when the scene becomes
+    active.
 
     The focus item receives keyboard input when the scene receives a
     key event.
 
-    \sa setFocusItem(), QGraphicsItem::hasFocus()
+    \sa setFocusItem(), QGraphicsItem::hasFocus(), isActive()
 */
 QGraphicsItem *QGraphicsScene::focusItem() const
 {
     Q_D(const QGraphicsScene);
-    return d->focusItem;
+    return isActive() ? d->focusItem : d->lastFocusItem;
 }
 
 /*!
@@ -4109,13 +4168,13 @@ static void _q_paintItem(QGraphicsItem *item, QPainter *painter,
     QGraphicsWidget *widgetItem = static_cast<QGraphicsWidget *>(item);
     QGraphicsProxyWidget *proxy = qobject_cast<QGraphicsProxyWidget *>(widgetItem);
     const qreal windowOpacity = (proxy && proxy->widget() && useWindowOpacity)
-                                ? proxy->widget()->windowOpacity() : 1.0;
+                                ? proxy->widget()->windowOpacity() : qreal(1.0);
     const qreal oldPainterOpacity = painter->opacity();
 
     if (qFuzzyIsNull(windowOpacity))
         return;
     // Set new painter opacity.
-    if (windowOpacity < 1.0)
+    if (windowOpacity < qreal(1.0))
         painter->setOpacity(oldPainterOpacity * windowOpacity);
 
     // set layoutdirection on the painter
@@ -4209,7 +4268,7 @@ void QGraphicsScenePrivate::drawItemHelper(QGraphicsItem *item, QPainter *painte
     QGraphicsProxyWidget *proxy = item->isWidget() ? qobject_cast<QGraphicsProxyWidget *>(static_cast<QGraphicsWidget *>(item)) : 0;
     if (proxy && proxy->widget()) {
         const qreal windowOpacity = proxy->widget()->windowOpacity();
-        if (windowOpacity < 1.0)
+        if (windowOpacity < qreal(1.0))
             newPainterOpacity *= windowOpacity;
     }
 
@@ -4577,6 +4636,7 @@ void QGraphicsScenePrivate::drawSubtreeRecursive(QGraphicsItem *item, QPainter *
     if (itemHasChildren && itemClipsChildrenToShape)
         ENSURE_TRANSFORM_PTR;
 
+#ifndef QT_NO_GRAPHICSEFFECT
     if (item->d_ptr->graphicsEffect && item->d_ptr->graphicsEffect->isEnabled()) {
         ENSURE_TRANSFORM_PTR;
         QGraphicsItemPaintInfo info(viewTransform, transformPtr, effectTransform, exposedRegion, widget, &styleOptionTmp,
@@ -4599,7 +4659,9 @@ void QGraphicsScenePrivate::drawSubtreeRecursive(QGraphicsItem *item, QPainter *
         item->d_ptr->graphicsEffect->draw(painter, source);
         painter->setWorldTransform(restoreTransform);
         sourced->info = 0;
-    } else {
+    } else
+#endif //QT_NO_GRAPHICSEFFECT
+    {
         draw(item, painter, viewTransform, transformPtr, exposedRegion, widget, opacity,
              effectTransform, wasDirtyParentSceneTransform, drawItem);
     }
@@ -4768,10 +4830,12 @@ void QGraphicsScenePrivate::markDirty(QGraphicsItem *item, const QRectF &rect, b
     QGraphicsItem *p = item->d_ptr->parent;
     while (p) {
         p->d_ptr->dirtyChildren = 1;
+#ifndef QT_NO_GRAPHICSEFFECT
         if (p->d_ptr->graphicsEffect && p->d_ptr->graphicsEffect->isEnabled()) {
             p->d_ptr->dirty = 1;
             p->d_ptr->fullUpdatePending = 1;
         }
+#endif //QT_NO_GRAPHICSEFFECT
         p = p->d_ptr->parent;
     }
 }
diff --git a/src/gui/graphicsview/qgraphicsscene.h b/src/gui/graphicsview/qgraphicsscene.h
index d6d48d7..a47574e 100644
--- a/src/gui/graphicsview/qgraphicsscene.h
+++ b/src/gui/graphicsview/qgraphicsscene.h
@@ -299,6 +299,7 @@ private:
     Q_PRIVATE_SLOT(d_func(), void _q_emitUpdated())
     Q_PRIVATE_SLOT(d_func(), void _q_polishItems())
     Q_PRIVATE_SLOT(d_func(), void _q_processDirtyItems())
+    Q_PRIVATE_SLOT(d_func(), void _q_updateScenePosDescendants())
     friend class QGraphicsItem;
     friend class QGraphicsItemPrivate;
     friend class QGraphicsView;
diff --git a/src/gui/graphicsview/qgraphicsscene_p.h b/src/gui/graphicsview/qgraphicsscene_p.h
index f8db084..fdec466 100644
--- a/src/gui/graphicsview/qgraphicsscene_p.h
+++ b/src/gui/graphicsview/qgraphicsscene_p.h
@@ -122,6 +122,13 @@ public:
 
     void _q_processDirtyItems();
 
+    QSet<QGraphicsItem *> scenePosItems;
+    bool scenePosDescendantsUpdatePending;
+    void setScenePosItemEnabled(QGraphicsItem *item, bool enabled);
+    void registerScenePosItem(QGraphicsItem *item);
+    void unregisterScenePosItem(QGraphicsItem *item);
+    void _q_updateScenePosDescendants();
+
     void removeItemHelper(QGraphicsItem *item);
 
     QBrush backgroundBrush;
@@ -234,6 +241,7 @@ public:
         item->d_ptr->fullUpdatePending = 0;
         item->d_ptr->ignoreVisible = 0;
         item->d_ptr->ignoreOpacity = 0;
+#ifndef QT_NO_GRAPHICSEFFECT
         QGraphicsEffect::ChangeFlags flags;
         if (item->d_ptr->notifyBoundingRectChanged) {
             flags |= QGraphicsEffect::SourceBoundingRectChanged;
@@ -243,12 +251,15 @@ public:
             flags |= QGraphicsEffect::SourceInvalidated;
             item->d_ptr->notifyInvalidated = 0;
         }
+#endif //QT_NO_GRAPHICSEFFECT
         if (recursive) {
             for (int i = 0; i < item->d_ptr->children.size(); ++i)
                 resetDirtyItem(item->d_ptr->children.at(i), recursive);
         }
+#ifndef QT_NO_GRAPHICSEFFECT
         if (flags && item->d_ptr->graphicsEffect)
             item->d_ptr->graphicsEffect->sourceChanged(flags);
+#endif //QT_NO_GRAPHICSEFFECT
     }
 
     inline void ensureSortedTopLevelItems()
diff --git a/src/gui/graphicsview/qgraphicsview.cpp b/src/gui/graphicsview/qgraphicsview.cpp
index c88f678..26efe58 100644
--- a/src/gui/graphicsview/qgraphicsview.cpp
+++ b/src/gui/graphicsview/qgraphicsview.cpp
@@ -297,7 +297,7 @@ inline int q_round_bound(qreal d) //### (int)(qreal) INT_MAX != INT_MAX for sing
         return INT_MIN;
     else if (d >= (qreal) INT_MAX)
         return INT_MAX;
-    return d >= 0.0 ? int(d + 0.5) : int(d - int(d-1) + 0.5) + int(d-1);
+    return d >= qreal(0.0) ? int(d + qreal(0.5)) : int(d - int(d-1) + qreal(0.5)) + int(d-1);
 }
 
 void QGraphicsViewPrivate::translateTouchEvent(QGraphicsViewPrivate *d, QTouchEvent *touchEvent)
@@ -1512,6 +1512,11 @@ void QGraphicsView::setScene(QGraphicsScene *scene)
                    this, SLOT(updateSceneRect(QRectF)));
         d->scene->d_func()->removeView(this);
         d->connectedToScene = false;
+
+        if (isActiveWindow() && isVisible()) {
+            QEvent windowDeactivate(QEvent::WindowDeactivate);
+            QApplication::sendEvent(d->scene, &windowDeactivate);
+        }
     }
 
     // Assign the new scene and update the contents (scrollbars, etc.)).
@@ -1533,6 +1538,11 @@ void QGraphicsView::setScene(QGraphicsScene *scene)
         // enable touch events if any items is interested in them
         if (!d->scene->d_func()->allItemsIgnoreTouchEvents)
             d->viewport->setAttribute(Qt::WA_AcceptTouchEvents);
+
+        if (isActiveWindow() && isVisible()) {
+            QEvent windowActivate(QEvent::WindowActivate);
+            QApplication::sendEvent(d->scene, &windowActivate);
+        }
     } else {
         d->recalculateContentSize();
     }
@@ -2638,6 +2648,19 @@ bool QGraphicsView::viewportEvent(QEvent *event)
             d->scene->d_func()->removePopup(d->scene->d_func()->popupWidgets.first());
         QApplication::sendEvent(d->scene, event);
         break;
+    case QEvent::Show:
+        if (d->scene && isActiveWindow()) {
+            QEvent windowActivate(QEvent::WindowActivate);
+            QApplication::sendEvent(d->scene, &windowActivate);
+        }
+        break;
+    case QEvent::Hide:
+        // spontaneous event will generate a WindowDeactivate.
+        if (!event->spontaneous() && d->scene && isActiveWindow()) {
+            QEvent windowDeactivate(QEvent::WindowDeactivate);
+            QApplication::sendEvent(d->scene, &windowDeactivate);
+        }
+        break;
     case QEvent::Leave:
         // ### This is a temporary fix for until we get proper mouse grab
         // events. activeMouseGrabberItem should be set to 0 if we lose the
@@ -3252,10 +3275,13 @@ void QGraphicsView::paintEvent(QPaintEvent *event)
 
     // Determine the exposed region
     d->exposedRegion = event->region();
+    if (d->exposedRegion.isEmpty())
+        d->exposedRegion = viewport()->rect();
     QRectF exposedSceneRect = mapToScene(d->exposedRegion.boundingRect()).boundingRect();
 
     // Set up the painter
     QPainter painter(viewport());
+    painter.setClipRect(event->rect(), Qt::IntersectClip);
 #ifndef QT_NO_RUBBERBAND
     if (d->rubberBanding && !d->rubberBandRect.isEmpty())
         painter.save();
diff --git a/src/gui/graphicsview/qgraphicswidget.cpp b/src/gui/graphicsview/qgraphicswidget.cpp
index d70a281..d9c65bb 100644
--- a/src/gui/graphicsview/qgraphicswidget.cpp
+++ b/src/gui/graphicsview/qgraphicswidget.cpp
@@ -318,6 +318,12 @@ void QGraphicsWidget::resize(const QSizeF &size)
 */
 
 /*!
+    \property QGraphicsWidget::sizePolicy
+    \brief the size policy for the widget
+    \sa sizePolicy(), setSizePolicy(), QWidget::sizePolicy()
+*/
+
+/*!
     \property QGraphicsWidget::geometry
     \brief the geometry of the widget
 
@@ -410,6 +416,27 @@ void QGraphicsWidget::setGeometry(const QRectF &rect)
 */
 
 /*!
+    \property QGraphicsWidget::minimumSize
+    \brief the minimum size of the widget
+
+    \sa setMinimumSize(), minimumSize(), preferredSize, maximumSize
+*/
+
+/*!
+    \property QGraphicsWidget::preferredSize
+    \brief the preferred size of the widget
+
+    \sa setPreferredSize(), preferredSize(), minimumSize, maximumSize
+*/
+
+/*!
+    \property QGraphicsWidget::maximumSize
+    \brief the maximum size of the widget
+
+    \sa setMaximumSize(), maximumSize(), minimumSize, preferredSize
+*/
+
+/*!
     Sets the widget's contents margins to \a left, \a top, \a right and \a
     bottom.
 
diff --git a/src/gui/graphicsview/qgraphicswidget.h b/src/gui/graphicsview/qgraphicswidget.h
index 9c71140..05d3a49 100644
--- a/src/gui/graphicsview/qgraphicswidget.h
+++ b/src/gui/graphicsview/qgraphicswidget.h
@@ -74,6 +74,10 @@ class Q_GUI_EXPORT QGraphicsWidget : public QGraphicsObject, public QGraphicsLay
     Q_PROPERTY(QFont font READ font WRITE setFont)
     Q_PROPERTY(Qt::LayoutDirection layoutDirection READ layoutDirection WRITE setLayoutDirection RESET unsetLayoutDirection)
     Q_PROPERTY(QSizeF size READ size WRITE resize)
+    Q_PROPERTY(QSizeF minimumSize READ minimumSize WRITE setMinimumSize)
+    Q_PROPERTY(QSizeF preferredSize READ preferredSize WRITE setPreferredSize)
+    Q_PROPERTY(QSizeF maximumSize READ maximumSize WRITE setMaximumSize)
+    Q_PROPERTY(QSizePolicy sizePolicy READ sizePolicy WRITE setSizePolicy)
     Q_PROPERTY(Qt::FocusPolicy focusPolicy READ focusPolicy WRITE setFocusPolicy)
     Q_PROPERTY(Qt::WindowFlags windowFlags READ windowFlags WRITE setWindowFlags)
     Q_PROPERTY(QString windowTitle READ windowTitle WRITE setWindowTitle)
diff --git a/src/gui/graphicsview/qgraphicswidget_p.cpp b/src/gui/graphicsview/qgraphicswidget_p.cpp
index b747a30..7847635 100644
--- a/src/gui/graphicsview/qgraphicswidget_p.cpp
+++ b/src/gui/graphicsview/qgraphicswidget_p.cpp
@@ -457,13 +457,13 @@ static QSizeF closestAcceptableSize(const QSizeF &proposed,
     min_hfw = minimumHeightForWidth(maxw, minh, maxh, widget);
 
     do {
-        if (maxw - minw < 0.1) {
+        if (maxw - minw < qreal(0.1)) {
             // we still havent found anything, cut off binary search
             minw = maxw;
             minh = maxh;
         }
-        middlew = minw + (maxw - minw)/2.0;
-        middleh = minh + (maxh - minh)/2.0;
+        middlew = minw + (maxw - minw) * qreal(0.5);
+        middleh = minh + (maxh - minh) * qreal(0.5);
 
         min_hfw = minimumHeightForWidth(middlew, minh, maxh, widget);
 
diff --git a/src/gui/graphicsview/qgridlayoutengine.cpp b/src/gui/graphicsview/qgridlayoutengine.cpp
index f61360a..f6fa16b 100644
--- a/src/gui/graphicsview/qgridlayoutengine.cpp
+++ b/src/gui/graphicsview/qgridlayoutengine.cpp
@@ -69,21 +69,22 @@ static void insertOrRemoveItems(QVector<T> &items, int index, int delta)
 
 static qreal growthFactorBelowPreferredSize(qreal desired, qreal sumAvailable, qreal sumDesired)
 {
-    Q_ASSERT(sumDesired != 0.0);
-    return desired * ::pow(sumAvailable / sumDesired, desired / sumDesired);
+    Q_ASSERT(sumDesired != qreal(0.0));
+    const qreal inv_sumDesired = 1 / sumDesired;
+    return desired * ::pow(sumAvailable * inv_sumDesired, desired * inv_sumDesired);
 }
 
 static qreal fixedDescent(qreal descent, qreal ascent, qreal targetSize)
 {
-    if (descent < 0.0)
-        return -1.0;
+    if (descent < qreal(0.0))
+        return qreal(-1.0);
 
-    Q_ASSERT(descent >= 0.0);
-    Q_ASSERT(ascent >= 0.0);
+    Q_ASSERT(descent >= qreal(0.0));
+    Q_ASSERT(ascent >= qreal(0.0));
     Q_ASSERT(targetSize >= ascent + descent);
 
     qreal extra = targetSize - (ascent + descent);
-    return descent + (extra / 2.0);
+    return descent + (extra * qreal(0.5));
 }
 
 static qreal compare(const QGridLayoutBox &box1, const QGridLayoutBox &box2, int which)
@@ -100,7 +101,7 @@ static qreal compare(const QGridLayoutBox &box1, const QGridLayoutBox &box2, int
 
 void QGridLayoutBox::add(const QGridLayoutBox &other, int stretch, qreal spacing)
 {
-    Q_ASSERT(q_minimumDescent < 0.0);
+    Q_ASSERT(q_minimumDescent < qreal(0.0));
 
     q_minimumSize += other.q_minimumSize + spacing;
     q_preferredSize += other.q_preferredSize + spacing;
@@ -134,7 +135,7 @@ void QGridLayoutBox::normalize()
     q_preferredSize = qBound(q_minimumSize, q_preferredSize, q_maximumSize);
     q_minimumDescent = qMin(q_minimumDescent, q_minimumSize);
 
-    Q_ASSERT((q_minimumDescent < 0.0) == (q_minimumAscent < 0.0));
+    Q_ASSERT((q_minimumDescent < qreal(0.0)) == (q_minimumAscent < qreal(0.0)));
 }
 
 #ifdef QT_DEBUG
@@ -161,7 +162,7 @@ void QGridLayoutRowData::reset(int count)
     boxes.fill(QGridLayoutBox(), count);
     multiCellMap.clear();
     stretches.fill(0, count);
-    spacings.fill(0.0, count);
+    spacings.fill(qreal(0.0), count);
     hasIgnoreFlag = false;
 }
 
@@ -182,7 +183,7 @@ void QGridLayoutRowData::distributeMultiCells()
 
         for (int j = 0; j < NSizes; ++j) {
             qreal extra = compare(totalBox, box, j);
-            if (extra > 0.0) {
+            if (extra > qreal(0.0)) {
                 calculateGeometries(start, end, totalBox.q_sizes(j), dummy.data(), newSizes.data(),
                                     0, totalBox);
 
@@ -210,7 +211,7 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz
     int n = end - start;
     QVarLengthArray<qreal> newSizes(n);
     QVarLengthArray<qreal> factors(n);
-    qreal sumFactors = 0.0;
+    qreal sumFactors = qreal(0.0);
     int sumStretches = 0;
     qreal sumAvailable;
 
@@ -223,24 +224,25 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz
         stealBox(start, end, MinimumSize, positions, sizes);
 
         sumAvailable = targetSize - totalBox.q_minimumSize;
-        if (sumAvailable > 0.0) {
-            qreal sumDesired = totalBox.q_preferredSize - totalBox.q_minimumSize;
+        if (sumAvailable > qreal(0.0)) {
+            const qreal sumDesired = totalBox.q_preferredSize - totalBox.q_minimumSize;
 
             for (int i = 0; i < n; ++i) {
                 if (ignore.testBit(start + i)) {
-                    factors[i] = 0.0;
+                    factors[i] = qreal(0.0);
                     continue;
                 }
 
                 const QGridLayoutBox &box = boxes.at(start + i);
-                qreal desired = box.q_preferredSize - box.q_minimumSize;
+                const qreal desired = box.q_preferredSize - box.q_minimumSize;
                 factors[i] = growthFactorBelowPreferredSize(desired, sumAvailable, sumDesired);
                 sumFactors += factors[i];
             }
 
+            const qreal inv_sumFactors = 1 / sumFactors;
             for (int i = 0; i < n; ++i) {
-                Q_ASSERT(sumFactors > 0.0);
-                qreal delta = sumAvailable * factors[i] / sumFactors;
+                Q_ASSERT(sumFactors > qreal(0.0));
+                const qreal delta = sumAvailable * factors[i] * inv_sumFactors;
                 newSizes[i] = sizes[i] + delta;
             }
         }
@@ -248,46 +250,46 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz
         stealBox(start, end, PreferredSize, positions, sizes);
 
         sumAvailable = targetSize - totalBox.q_preferredSize;
-        if (sumAvailable > 0.0) {
+        if (sumAvailable > qreal(0.0)) {
             bool somethingHasAMaximumSize = false;
 
-            qreal sumPreferredSizes = 0.0;
+            qreal sumPreferredSizes = qreal(0.0);
             for (int i = 0; i < n; ++i)
                 sumPreferredSizes += sizes[i];
 
             for (int i = 0; i < n; ++i) {
                 if (ignore.testBit(start + i)) {
-                    newSizes[i] = 0.0;
-                    factors[i] = 0.0;
+                    newSizes[i] = qreal(0.0);
+                    factors[i] = qreal(0.0);
                     continue;
                 }
 
                 const QGridLayoutBox &box = boxes.at(start + i);
-                qreal desired = box.q_maximumSize - box.q_preferredSize;
-                if (desired == 0.0) {
+                const qreal desired = box.q_maximumSize - box.q_preferredSize;
+                if (desired == qreal(0.0)) {
                     newSizes[i] = sizes[i];
-                    factors[i] = 0.0;
+                    factors[i] = qreal(0.0);
                 } else {
-                    Q_ASSERT(desired > 0.0);
+                    Q_ASSERT(desired > qreal(0.0));
 
                     int stretch = stretches[start + i];
                     if (sumStretches == 0) {
                         if (hasIgnoreFlag) {
-                            factors[i] = (stretch < 0) ? 1.0 : 0.0;
+                            factors[i] = (stretch < 0) ? qreal(1.0) : qreal(0.0);
                         } else {
-                            factors[i] = (stretch < 0) ? sizes[i] : 0.0;
+                            factors[i] = (stretch < 0) ? sizes[i] : qreal(0.0);
                         }
                     } else if (stretch == sumStretches) {
-                        factors[i] = 1.0;
+                        factors[i] = qreal(1.0);
                     } else if (stretch <= 0) {
-                        factors[i] = 0.0;
+                        factors[i] = qreal(0.0);
                     } else {
                         qreal ultimatePreferredSize;
                         qreal ultimateSumPreferredSizes;
                         qreal x = ((stretch * sumPreferredSizes)
                                    - (sumStretches * box.q_preferredSize))
                                   / (sumStretches - stretch);
-                        if (x >= 0.0) {
+                        if (x >= qreal(0.0)) {
                             ultimatePreferredSize = box.q_preferredSize + x;
                             ultimateSumPreferredSizes = sumPreferredSizes + x;
                         } else {
@@ -301,8 +303,8 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz
                             (at the expense of the stretch factors, which are not fully respected
                             during the transition).
                         */
-                        ultimatePreferredSize = ultimatePreferredSize * 3 / 2;
-                        ultimateSumPreferredSizes = ultimateSumPreferredSizes * 3 / 2;
+                        ultimatePreferredSize = ultimatePreferredSize * qreal(1.5);
+                        ultimateSumPreferredSizes = ultimateSumPreferredSizes * qreal(1.5);
 
                         qreal ultimateFactor = (stretch * ultimateSumPreferredSizes
                                                 / sumStretches)
@@ -323,7 +325,7 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz
                     if (desired < sumAvailable)
                         somethingHasAMaximumSize = true;
 
-                    newSizes[i] = -1.0;
+                    newSizes[i] = qreal(-1.0);
                 }
             }
 
@@ -332,7 +334,7 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz
                 keepGoing = false;
 
                 for (int i = 0; i < n; ++i) {
-                    if (newSizes[i] >= 0.0)
+                    if (newSizes[i] >= qreal(0.0))
                         continue;
 
                     const QGridLayoutBox &box = boxes.at(start + i);
@@ -341,7 +343,7 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz
                         newSizes[i] = box.q_maximumSize;
                         sumAvailable -= box.q_maximumSize - sizes[i];
                         sumFactors -= factors[i];
-                        keepGoing = (sumAvailable > 0.0);
+                        keepGoing = (sumAvailable > qreal(0.0));
                         if (!keepGoing)
                             break;
                     }
@@ -349,8 +351,8 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz
             }
 
             for (int i = 0; i < n; ++i) {
-                if (newSizes[i] < 0.0) {
-                    qreal delta = (sumFactors == 0.0) ? 0.0
+                if (newSizes[i] < qreal(0.0)) {
+                    qreal delta = (sumFactors == qreal(0.0)) ? qreal(0.0)
                                                       : sumAvailable * factors[i] / sumFactors;
                     newSizes[i] = sizes[i] + delta;
                 }
@@ -406,8 +408,8 @@ QGridLayoutBox QGridLayoutRowData::totalBox(int start, int end) const
 {
     QGridLayoutBox result;
     if (start < end) {
-        result.q_maximumSize = 0.0;
-        qreal nextSpacing = 0.0;
+        result.q_maximumSize = qreal(0.0);
+        qreal nextSpacing = qreal(0.0);
         for (int i = start; i < end; ++i) {
             result.add(boxes.at(i), stretches.at(i), nextSpacing);
             nextSpacing = spacings.at(i);
@@ -418,11 +420,11 @@ QGridLayoutBox QGridLayoutRowData::totalBox(int start, int end) const
 
 void QGridLayoutRowData::stealBox(int start, int end, int which, qreal *positions, qreal *sizes)
 {
-    qreal offset = 0.0;
-    qreal nextSpacing = 0.0;
+    qreal offset = qreal(0.0);
+    qreal nextSpacing = qreal(0.0);
 
     for (int i = start; i < end; ++i) {
-        qreal avail = 0.0;
+        qreal avail = qreal(0.0);
 
         if (!ignore.testBit(i)) {
             const QGridLayoutBox &box = boxes.at(i);
diff --git a/src/gui/graphicsview/qsimplex_p.cpp b/src/gui/graphicsview/qsimplex_p.cpp
index 86b10b4..1b3eaf9 100644
--- a/src/gui/graphicsview/qsimplex_p.cpp
+++ b/src/gui/graphicsview/qsimplex_p.cpp
@@ -288,7 +288,7 @@ bool QSimplex::setConstraints(const QList<QSimplexConstraint *> newConstraints)
     // original problem.
     // Otherwise, we clean up our structures and report there is
     // no feasible solution.
-    if (valueAt(0, columns - 1) != 0.0) {
+    if ((valueAt(0, columns - 1) != 0.0) && (qAbs(valueAt(0, columns - 1)) > 0.00001)) {
         qWarning() << "QSimplex: No feasible solution!";
         clearDataStructures();
         return false;
@@ -485,8 +485,8 @@ bool QSimplex::iterate()
 
     // Normalize Pivot Row
     qreal pivot = valueAt(pivotRow, pivotColumn);
-    if (pivot != 1.0)
-        combineRows(pivotRow, pivotRow, (1.0 - pivot) / pivot);
+    if (pivot != qreal(1.0))
+        combineRows(pivotRow, pivotRow, (qreal(1.0) - pivot) / pivot);
 
     // Update other rows
     for (int row=0; row < rows; ++row) {
diff --git a/src/gui/graphicsview/qsimplex_p.h b/src/gui/graphicsview/qsimplex_p.h
index 084ad7f..a5816d1 100644
--- a/src/gui/graphicsview/qsimplex_p.h
+++ b/src/gui/graphicsview/qsimplex_p.h
@@ -107,7 +107,7 @@ struct QSimplexConstraint
 
         Q_ASSERT(constant > 0 || qFuzzyCompare(1, 1 + constant));
 
-        if ((leftHandSide == constant) || qFuzzyCompare(1000 + leftHandSide, 1000 + constant))
+        if ((leftHandSide == constant) || qAbs(leftHandSide - constant) < 0.00000001)
             return true;
 
         switch (ratio) {
diff --git a/src/gui/image/qbitmap.cpp b/src/gui/image/qbitmap.cpp
index e081735..4b8d4b8 100644
--- a/src/gui/image/qbitmap.cpp
+++ b/src/gui/image/qbitmap.cpp
@@ -86,7 +86,7 @@ QT_BEGIN_NAMESPACE
     object.
 
     Just like the QPixmap class, QBitmap is optimized by the use of
-    implicit data sharing. For more information, see the {Implicit
+    implicit data sharing. For more information, see the \l {Implicit
     Data Sharing} documentation.
 
     \sa  QPixmap, QImage, QImageReader, QImageWriter
diff --git a/src/gui/image/qimage.cpp b/src/gui/image/qimage.cpp
index 571ef9d..2cf8597 100644
--- a/src/gui/image/qimage.cpp
+++ b/src/gui/image/qimage.cpp
@@ -4083,7 +4083,8 @@ QImage QImage::createAlphaMask(Qt::ImageConversionFlags flags) const
     }
 
     QImage mask(d->width, d->height, Format_MonoLSB);
-    dither_to_Mono(mask.d, d, flags, true);
+    if (!mask.isNull())
+        dither_to_Mono(mask.d, d, flags, true);
     return mask;
 }
 
@@ -5312,19 +5313,19 @@ int QImage::metric(PaintDeviceMetric metric) const
         break;
 
     case PdmDpiX:
-        return qRound(d->dpmx * 0.0254);
+        return qRound(d->dpmx * qreal(0.0254));
         break;
 
     case PdmDpiY:
-        return qRound(d->dpmy * 0.0254);
+        return qRound(d->dpmy * qreal(0.0254));
         break;
 
     case PdmPhysicalDpiX:
-        return qRound(d->dpmx * 0.0254);
+        return qRound(d->dpmx * qreal(0.0254));
         break;
 
     case PdmPhysicalDpiY:
-        return qRound(d->dpmy * 0.0254);
+        return qRound(d->dpmy * qreal(0.0254));
         break;
 
     default:
@@ -5390,12 +5391,12 @@ bool qt_xForm_helper(const QTransform &trueMat, int xoffset, int type, int depth
                      uchar *dptr, int dbpl, int p_inc, int dHeight,
                      const uchar *sptr, int sbpl, int sWidth, int sHeight)
 {
-    int m11 = int(trueMat.m11()*4096.0);
-    int m12 = int(trueMat.m12()*4096.0);
-    int m21 = int(trueMat.m21()*4096.0);
-    int m22 = int(trueMat.m22()*4096.0);
-    int dx  = qRound(trueMat.dx()*4096.0);
-    int dy  = qRound(trueMat.dy()*4096.0);
+    int m11 = int(trueMat.m11()*qreal(4096.0));
+    int m12 = int(trueMat.m12()*qreal(4096.0));
+    int m21 = int(trueMat.m21()*qreal(4096.0));
+    int m22 = int(trueMat.m22()*qreal(4096.0));
+    int dx  = qRound(trueMat.dx()*qreal(4096.0));
+    int dy  = qRound(trueMat.dy()*qreal(4096.0));
 
     int m21ydx = dx + (xoffset<<16) + (m11 + m21) / 2;
     int m22ydy = dy + (m12 + m22) / 2;
@@ -5979,22 +5980,22 @@ QImage QImage::transformed(const QTransform &matrix, Qt::TransformationMode mode
     if (mat.type() <= QTransform::TxScale) {
         if (mat.type() == QTransform::TxNone) // identity matrix
             return *this;
-        else if (mat.m11() == -1. && mat.m22() == -1.)
+        else if (mat.m11() == qreal(-1.) && mat.m22() == qreal(-1.))
             return rotated180(*this);
 
         if (mode == Qt::FastTransformation) {
             hd = qRound(qAbs(mat.m22()) * hs);
             wd = qRound(qAbs(mat.m11()) * ws);
         } else {
-            hd = int(qAbs(mat.m22()) * hs + 0.9999);
-            wd = int(qAbs(mat.m11()) * ws + 0.9999);
+            hd = int(qAbs(mat.m22()) * hs + qreal(0.9999));
+            wd = int(qAbs(mat.m11()) * ws + qreal(0.9999));
         }
         scale_xform = true;
     } else {
         if (mat.type() <= QTransform::TxRotate && mat.m11() == 0 && mat.m22() == 0) {
-            if (mat.m12() == 1. && mat.m21() == -1.)
+            if (mat.m12() == qreal(1.) && mat.m21() == qreal(-1.))
                 return rotated90(*this);
-            else if (mat.m12() == -1. && mat.m21() == 1.)
+            else if (mat.m12() == qreal(-1.) && mat.m21() == qreal(1.))
                 return rotated270(*this);
         }
 
diff --git a/src/gui/image/qpaintengine_pic.cpp b/src/gui/image/qpaintengine_pic.cpp
index 80b16cf..b6fea8b 100644
--- a/src/gui/image/qpaintengine_pic.cpp
+++ b/src/gui/image/qpaintengine_pic.cpp
@@ -342,7 +342,7 @@ void QPicturePaintEngine::writeCmdLength(int pos, const QRectF &r, bool corr)
     }
     d->pic_d->pictb.seek(newpos);                  // set to new position
 
-    if (br.width() > 0.0 || br.height() > 0.0) {
+    if (br.width() > qreal(0.0) || br.height() > qreal(0.0)) {
         if (corr) {                             // widen bounding rect
             int w2 = painter()->pen().width() / 2;
             br.setCoords(br.left() - w2, br.top() - w2,
@@ -354,7 +354,7 @@ void QPicturePaintEngine::writeCmdLength(int pos, const QRectF &r, bool corr)
             br &= cr;
         }
 
-        if (br.width() > 0.0 || br.height() > 0.0) {
+        if (br.width() > qreal(0.0) || br.height() > qreal(0.0)) {
             int minx = qFloor(br.left());
             int miny = qFloor(br.top());
             int maxx = qCeil(br.right());
diff --git a/src/gui/image/qpicture.cpp b/src/gui/image/qpicture.cpp
index f502827..39a4fcc 100644
--- a/src/gui/image/qpicture.cpp
+++ b/src/gui/image/qpicture.cpp
@@ -967,10 +967,10 @@ int QPicture::metric(PaintDeviceMetric m) const
             val = brect.height();
             break;
         case PdmWidthMM:
-            val = int(25.4/qt_defaultDpiX()*brect.width());
+            val = int(qreal(25.4)/qt_defaultDpiX()*brect.width());
             break;
         case PdmHeightMM:
-            val = int(25.4/qt_defaultDpiY()*brect.height());
+            val = int(qreal(25.4)/qt_defaultDpiY()*brect.height());
             break;
         case PdmDpiX:
         case PdmPhysicalDpiX:
diff --git a/src/gui/image/qpixmap.cpp b/src/gui/image/qpixmap.cpp
index c452b9a..dfeea76 100644
--- a/src/gui/image/qpixmap.cpp
+++ b/src/gui/image/qpixmap.cpp
@@ -639,13 +639,13 @@ void QPixmap::resize_helper(const QSize &s)
     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.data()) : 0;
+    QX11PixmapData *x11Data = data && data->classId() == QPixmapData::X11Class ? static_cast<QX11PixmapData*>(data.data()) : 0;
     if (x11Data) {
         pm.x11SetScreen(x11Data->xinfo.screen());
         uninit = x11Data->flags & QX11PixmapData::Uninitialized;
     }
 #elif defined(Q_WS_MAC)
-    QMacPixmapData *macData = data->classId() == QPixmapData::MacClass ? static_cast<QMacPixmapData*>(data.data()) : 0;
+    QMacPixmapData *macData = data && data->classId() == QPixmapData::MacClass ? static_cast<QMacPixmapData*>(data.data()) : 0;
     if (macData)
         uninit = macData->uninit;
 #endif
diff --git a/src/gui/image/qpixmap_raster.cpp b/src/gui/image/qpixmap_raster.cpp
index fc76dc3..8560e5d 100644
--- a/src/gui/image/qpixmap_raster.cpp
+++ b/src/gui/image/qpixmap_raster.cpp
@@ -373,9 +373,9 @@ int QRasterPixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const
     case QPaintDevice::PdmHeight:
         return h;
     case QPaintDevice::PdmWidthMM:
-        return qRound(d->width * 25.4 / qt_defaultDpiX());
+        return qRound(d->width * qreal(25.4) / qt_defaultDpiX());
     case QPaintDevice::PdmHeightMM:
-        return qRound(d->width * 25.4 / qt_defaultDpiY());
+        return qRound(d->width * qreal(25.4) / qt_defaultDpiY());
     case QPaintDevice::PdmNumColors:
         return d->colortable.size();
     case QPaintDevice::PdmDepth:
diff --git a/src/gui/image/qpixmap_s60.cpp b/src/gui/image/qpixmap_s60.cpp
index cd8a4d4..6a999b4 100644
--- a/src/gui/image/qpixmap_s60.cpp
+++ b/src/gui/image/qpixmap_s60.cpp
@@ -568,6 +568,7 @@ int QS60PixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const
     if (!cfbsBitmap)
         return 0;
 
+    qreal div_by_KTwipsPerInch = 1 / (qreal)KTwipsPerInch;
     switch (metric) {
     case QPaintDevice::PdmWidth:
         return cfbsBitmap->SizeInPixels().iWidth;
@@ -575,23 +576,23 @@ int QS60PixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const
         return cfbsBitmap->SizeInPixels().iHeight;
     case QPaintDevice::PdmWidthMM: {
         TInt twips = cfbsBitmap->SizeInTwips().iWidth;
-        return (int)(twips * (25.4/KTwipsPerInch));
+        return (int)(twips * (qreal(25.4) * div_by_KTwipsPerInch));
     }
     case QPaintDevice::PdmHeightMM: {
         TInt twips = cfbsBitmap->SizeInTwips().iHeight;
-        return (int)(twips * (25.4/KTwipsPerInch));
+        return (int)(twips * (qreal(25.4) * div_by_KTwipsPerInch));
     }
     case QPaintDevice::PdmNumColors:
         return TDisplayModeUtils::NumDisplayModeColors(cfbsBitmap->DisplayMode());
     case QPaintDevice::PdmDpiX:
     case QPaintDevice::PdmPhysicalDpiX: {
-        TReal inches = cfbsBitmap->SizeInTwips().iWidth / (TReal)KTwipsPerInch;
+        qreal inches = cfbsBitmap->SizeInTwips().iWidth * div_by_KTwipsPerInch;
         TInt pixels = cfbsBitmap->SizeInPixels().iWidth;
         return pixels / inches;
     }
     case QPaintDevice::PdmDpiY:
     case QPaintDevice::PdmPhysicalDpiY: {
-        TReal inches = cfbsBitmap->SizeInTwips().iHeight / (TReal)KTwipsPerInch;
+        qreal inches = cfbsBitmap->SizeInTwips().iHeight * div_by_KTwipsPerInch;
         TInt pixels = cfbsBitmap->SizeInPixels().iHeight;
         return pixels / inches;
     }
diff --git a/src/gui/image/qpixmap_x11.cpp b/src/gui/image/qpixmap_x11.cpp
index 8a0120a..c735031 100644
--- a/src/gui/image/qpixmap_x11.cpp
+++ b/src/gui/image/qpixmap_x11.cpp
@@ -1916,8 +1916,8 @@ QPixmap QX11PixmapData::transformed(const QTransform &transform,
         free(dptr);
         return bm;
     } else {                                        // color pixmap
-        QPixmap pm;
-        QX11PixmapData *x11Data = static_cast<QX11PixmapData*>(pm.data.data());
+        QX11PixmapData *x11Data = new QX11PixmapData(QPixmapData::PixmapType);
+        QPixmap pm(x11Data);
         x11Data->flags &= ~QX11PixmapData::Uninitialized;
         x11Data->xinfo = xinfo;
         x11Data->d = d;
diff --git a/src/gui/image/qpixmapfilter.cpp b/src/gui/image/qpixmapfilter.cpp
index e50cc8b..d83ef2c 100644
--- a/src/gui/image/qpixmapfilter.cpp
+++ b/src/gui/image/qpixmapfilter.cpp
@@ -53,6 +53,7 @@
 #include "private/qpaintengineex_p.h"
 #include "private/qpaintengine_raster_p.h"
 
+#ifndef QT_NO_GRAPHICSEFFECT
 QT_BEGIN_NAMESPACE
 
 class QPixmapFilterPrivate : public QObjectPrivate
@@ -1107,3 +1108,5 @@ void QPixmapDropShadowFilter::draw(QPainter *p,
 }
 
 QT_END_NAMESPACE
+
+#endif //QT_NO_GRAPHICSEFFECT
diff --git a/src/gui/image/qpixmapfilter_p.h b/src/gui/image/qpixmapfilter_p.h
index 6a96676..2573fc7 100644
--- a/src/gui/image/qpixmapfilter_p.h
+++ b/src/gui/image/qpixmapfilter_p.h
@@ -57,6 +57,7 @@
 #include <QtGui/qpixmap.h>
 #include <QtGui/qgraphicseffect.h>
 
+#ifndef QT_NO_GRAPHICSEFFECT
 QT_BEGIN_HEADER
 
 QT_BEGIN_NAMESPACE
@@ -191,4 +192,5 @@ QT_END_NAMESPACE
 
 QT_END_HEADER
 
+#endif //QT_NO_GRAPHICSEFFECT
 #endif // QPIXMAPFILTER_H
diff --git a/src/gui/image/qpnghandler.cpp b/src/gui/image/qpnghandler.cpp
index 44d689d..e520c63 100644
--- a/src/gui/image/qpnghandler.cpp
+++ b/src/gui/image/qpnghandler.cpp
@@ -732,8 +732,8 @@ bool Q_INTERNAL_WIN_NO_THROW QPNGImageWriter::writeImage(const QImage& image_in,
         png_set_compression_level(png_ptr, quality);
     }
 
-    if (gamma != 0.0) {
-        png_set_gAMA(png_ptr, info_ptr, 1.0/gamma);
+    if (gamma != qreal(0.0)) {
+        png_set_gAMA(png_ptr, info_ptr, qreal(1.0)/gamma);
     }
 
     png_set_write_fn(png_ptr, (void*)this, qpiw_write_fn, qpiw_flush_fn);
diff --git a/src/gui/itemviews/qlistview.cpp b/src/gui/itemviews/qlistview.cpp
index d680af8..15db9a6 100644
--- a/src/gui/itemviews/qlistview.cpp
+++ b/src/gui/itemviews/qlistview.cpp
@@ -357,7 +357,7 @@ QListView::LayoutMode QListView::layoutMode() const
 
 /*!
     \property QListView::spacing
-    \brief the space between items in the layout
+    \brief the space around the items in the layout
 
     This property is the size of the empty space that is padded around
     an item in the layout.
@@ -972,9 +972,9 @@ void QListView::paintEvent(QPaintEvent *e)
         option.rect = visualRect(*it);
 
         if (flow() == TopToBottom)
-            option.rect.setWidth(qMin(viewport()->size().width(), option.rect.width()));
+            option.rect.setWidth(qMin(viewport()->size().width() - 2 * d->spacing(), option.rect.width()));
         else
-            option.rect.setHeight(qMin(viewport()->size().height(), option.rect.height()));
+            option.rect.setHeight(qMin(viewport()->size().height() - 2 * d->spacing(), option.rect.height()));
 
         option.state = state;
         if (selections && selections->isSelected(*it))
@@ -1837,14 +1837,14 @@ void QCommonListViewBase::updateHorizontalScrollBar(const QSize &step)
 {
     horizontalScrollBar()->setSingleStep(step.width() + spacing());
     horizontalScrollBar()->setPageStep(viewport()->width());
-    horizontalScrollBar()->setRange(0, contentsSize.width() - viewport()->width());
+    horizontalScrollBar()->setRange(0, contentsSize.width() - viewport()->width() - 2 * spacing());
 }
 
 void QCommonListViewBase::updateVerticalScrollBar(const QSize &step)
 {
     verticalScrollBar()->setSingleStep(step.height() + spacing());
     verticalScrollBar()->setPageStep(viewport()->height());
-    verticalScrollBar()->setRange(0, contentsSize.height() - viewport()->height());
+    verticalScrollBar()->setRange(0, contentsSize.height() - viewport()->height() - 2 * spacing());
 }
 
 void QCommonListViewBase::scrollContentsBy(int dx, int dy, bool /*scrollElasticBand*/)
diff --git a/src/gui/itemviews/qtreeview.cpp b/src/gui/itemviews/qtreeview.cpp
index 3856293..a3cbc0d 100644
--- a/src/gui/itemviews/qtreeview.cpp
+++ b/src/gui/itemviews/qtreeview.cpp
@@ -2113,6 +2113,12 @@ QModelIndex QTreeView::moveCursor(CursorAction cursorAction, Qt::KeyboardModifie
     if (vi < 0)
         vi = qMax(0, d->viewIndex(current));
 
+    if (isRightToLeft()) {
+        if (cursorAction == MoveRight)
+            cursorAction = MoveLeft;
+        else if (cursorAction == MoveLeft)
+            cursorAction = MoveRight;
+    }
     switch (cursorAction) {
     case MoveNext:
     case MoveDown:
diff --git a/src/gui/itemviews/qtreeview_p.h b/src/gui/itemviews/qtreeview_p.h
index aad5837..d58dea3 100644
--- a/src/gui/itemviews/qtreeview_p.h
+++ b/src/gui/itemviews/qtreeview_p.h
@@ -105,7 +105,7 @@ public:
         int top() const { return startValue().toInt(); }
         QRect rect() const { QRect rect = viewport->rect(); rect.moveTop(top()); return rect; }
         void updateCurrentValue(const QVariant &) { viewport->update(rect()); }
-        void updateState(State, State state) { if (state == Stopped) before = after = QPixmap(); }
+        void updateState(State state, State) { if (state == Stopped) before = after = QPixmap(); }
     } animatedOperation;
     void prepareAnimatedOperation(int item, QVariantAnimation::Direction d);
     void beginAnimatedOperation();
diff --git a/src/gui/kernel/qapplication_mac.mm b/src/gui/kernel/qapplication_mac.mm
index 84e0d50..84da56e 100644
--- a/src/gui/kernel/qapplication_mac.mm
+++ b/src/gui/kernel/qapplication_mac.mm
@@ -104,6 +104,7 @@
 #include "qdir.h"
 #include "qdebug.h"
 #include "qtimer.h"
+#include "qurl.h"
 #include "private/qmacinputcontext_p.h"
 #include "private/qpaintengine_mac_p.h"
 #include "private/qcursor_p.h"
@@ -966,7 +967,8 @@ struct QMacAppleEventTypeSpec {
     AEEventID mac_id;
 } app_apple_events[] = {
     { kCoreEventClass, kAEQuitApplication },
-    { kCoreEventClass, kAEOpenDocuments }
+    { kCoreEventClass, kAEOpenDocuments },
+    { kInternetEventClass, kAEGetURL },
 };
 
 #ifndef QT_MAC_USE_COCOA
@@ -1201,7 +1203,7 @@ void qt_init(QApplicationPrivate *priv, int)
             app_proc_ae_handlerUPP = AEEventHandlerUPP(QApplicationPrivate::globalAppleEventProcessor);
             for(uint i = 0; i < sizeof(app_apple_events) / sizeof(QMacAppleEventTypeSpec); ++i)
                 AEInstallEventHandler(app_apple_events[i].mac_class, app_apple_events[i].mac_id,
-                        app_proc_ae_handlerUPP, SRefCon(qApp), true);
+                        app_proc_ae_handlerUPP, SRefCon(qApp), false);
         }
 
         if (QApplicationPrivate::app_style) {
@@ -1237,6 +1239,10 @@ void qt_init(QApplicationPrivate *priv, int)
         [cocoaApp setMenu:[qtMenuLoader menu]];
         [newDelegate setMenuLoader:qtMenuLoader];
         [qtMenuLoader release];
+
+        NSAppleEventManager *eventManager = [NSAppleEventManager sharedAppleEventManager];
+        [eventManager setEventHandler:newDelegate andSelector:@selector(getUrl:withReplyEvent:)
+          forEventClass:kInternetEventClass andEventID:kAEGetURL];
     }
 #endif
     // Register for Carbon tablet proximity events on the event monitor target.
@@ -2477,6 +2483,22 @@ OSStatus QApplicationPrivate::globalAppleEventProcessor(const AppleEvent *ae, Ap
         default:
             break;
         }
+    } else if (aeClass == kInternetEventClass) {
+        switch (aeID) {
+        case kAEGetURL: {
+            char urlData[1024];
+            Size actualSize;
+            if (AEGetParamPtr(ae, keyDirectObject, typeChar, 0, urlData,
+                    sizeof(urlData) - 1, &actualSize) == noErr) {
+                urlData[actualSize] = 0;
+                QFileOpenEvent ev(QUrl(QString::fromUtf8(urlData)));
+                QApplication::sendSpontaneousEvent(app, &ev);
+            }
+            break;
+        }
+        default:
+            break;
+        }
     }
 #ifdef DEBUG_EVENTS
     qDebug("Qt: internal: %shandled Apple event! %c%c%c%c %c%c%c%c", handled_event ? "(*)" : "",
diff --git a/src/gui/kernel/qcocoaapplicationdelegate_mac.mm b/src/gui/kernel/qcocoaapplicationdelegate_mac.mm
index d103cbd..37dcc67 100644
--- a/src/gui/kernel/qcocoaapplicationdelegate_mac.mm
+++ b/src/gui/kernel/qcocoaapplicationdelegate_mac.mm
@@ -83,6 +83,7 @@
 #include <private/qt_cocoa_helpers_mac_p.h>
 #include <private/qdesktopwidget_mac_p.h>
 #include <qevent.h>
+#include <qurl.h>
 #include <qapplication.h>
 
 QT_BEGIN_NAMESPACE
@@ -303,5 +304,15 @@ static void cleanupCocoaApplicationDelegate()
         [self doesNotRecognizeSelector:invocationSelector];
 }
 
+- (void)getUrl:(NSAppleEventDescriptor *)event withReplyEvent:(NSAppleEventDescriptor *)replyEvent
+{
+    Q_UNUSED(replyEvent);
+
+    NSString *urlString = [[event paramDescriptorForKeyword:keyDirectObject] stringValue];
+    QUrl url(qt_mac_NSStringToQString(urlString));
+    QFileOpenEvent qtEvent(url);
+    qt_sendSpontaneousEvent(qAppInstance(), &qtEvent);
+}
+
 @end
 #endif
diff --git a/src/gui/kernel/qcocoaapplicationdelegate_mac_p.h b/src/gui/kernel/qcocoaapplicationdelegate_mac_p.h
index 80df645..a137744 100644
--- a/src/gui/kernel/qcocoaapplicationdelegate_mac_p.h
+++ b/src/gui/kernel/qcocoaapplicationdelegate_mac_p.h
@@ -123,5 +123,6 @@ QT_FORWARD_DECLARE_CLASS(QApplicationPrivate);
 - (void)setMenuLoader:(QT_MANGLE_NAMESPACE(QCocoaMenuLoader)*)menuLoader;
 - (QT_MANGLE_NAMESPACE(QCocoaMenuLoader) *)menuLoader;
 - (void)setReflectionDelegate:(NSObject <NSApplicationDelegate> *)oldDelegate;
+- (void)getUrl:(NSAppleEventDescriptor *)event withReplyEvent:(NSAppleEventDescriptor *)replyEvent;
 @end
 #endif
diff --git a/src/gui/kernel/qcocoawindowdelegate_mac.mm b/src/gui/kernel/qcocoawindowdelegate_mac.mm
index 803a1b1..9fb674e 100644
--- a/src/gui/kernel/qcocoawindowdelegate_mac.mm
+++ b/src/gui/kernel/qcocoawindowdelegate_mac.mm
@@ -307,6 +307,18 @@ static void cleanupCocoaWindowDelegate()
     return m_windowHash->value(window);
 }
 
+- (BOOL)windowShouldZoom:(NSWindow *)window toFrame:(NSRect)newFrame
+{
+    Q_UNUSED(newFrame);
+    // saving the current window geometry before the window is maximized
+    QWidget *qwidget = m_windowHash->value(window);
+    if (qwidget->isWindow() && !(qwidget->windowState() & Qt::WindowMaximized)) {
+        QWidgetPrivate *widgetPrivate = qt_widget_private(qwidget);
+        widgetPrivate->topData()->normalGeometry = qwidget->geometry();
+    }
+    return YES;
+}
+
 - (NSRect)windowWillUseStandardFrame:(NSWindow *)window defaultFrame:(NSRect)defaultFrame
 {
     NSRect frameToReturn = defaultFrame;
diff --git a/src/gui/kernel/qcocoawindowdelegate_mac_p.h b/src/gui/kernel/qcocoawindowdelegate_mac_p.h
index 3728002..243ba03 100644
--- a/src/gui/kernel/qcocoawindowdelegate_mac_p.h
+++ b/src/gui/kernel/qcocoawindowdelegate_mac_p.h
@@ -78,6 +78,7 @@ QT_FORWARD_DECLARE_CLASS(QWidgetData)
 - (void)windowDidResignKey:(NSNotification*)notification;
 - (BOOL)window:(NSWindow *)window shouldPopUpDocumentPathMenu:(NSMenu *)menu;
 - (BOOL)window:(NSWindow *)window shouldDragDocumentWithEvent:(NSEvent *)event from:(NSPoint)dragImageLocation withPasteboard:(NSPasteboard *)pasteboard;
+- (BOOL)windowShouldZoom:(NSWindow *)window toFrame:(NSRect)newFrame;
 @end
 
 @protocol NSDrawerDelegate <NSObject>
diff --git a/src/gui/kernel/qdesktopwidget_mac.mm b/src/gui/kernel/qdesktopwidget_mac.mm
index 88dc173..c2d05d7 100644
--- a/src/gui/kernel/qdesktopwidget_mac.mm
+++ b/src/gui/kernel/qdesktopwidget_mac.mm
@@ -136,16 +136,19 @@ void QDesktopWidgetImplementation::onResize()
     screenRects.clear(); 
     availableRects.clear(); 
     NSRect primaryRect = [[displays objectAtIndex:0] frame]; 
-    for (int i = 0; i<screenCount; i++) { 
-        NSRect r = [[displays objectAtIndex:i] frame]; 
-        const int flippedY = - r.origin.y +            // account for position offset and 
+    for (int i = 0; i<screenCount; i++) {
+        NSRect r = [[displays objectAtIndex:i] frame];
+        int flippedY = - r.origin.y +                  // account for position offset and
               primaryRect.size.height - r.size.height; // height difference. 
         screenRects.append(QRectF(r.origin.x, flippedY, 
             r.size.width, r.size.height)); 
-        r = [[displays objectAtIndex:i] visibleFrame]; 
+
+        r = [[displays objectAtIndex:i] visibleFrame];
+        flippedY = - r.origin.y +                      // account for position offset and
+              primaryRect.size.height - r.size.height; // height difference. 
         availableRects.append(QRectF(r.origin.x, flippedY, 
                 r.size.width, r.size.height)); 
-    } 
+    }
 }
 
 
diff --git a/src/gui/kernel/qevent.cpp b/src/gui/kernel/qevent.cpp
index bcebe06..ff97405 100644
--- a/src/gui/kernel/qevent.cpp
+++ b/src/gui/kernel/qevent.cpp
@@ -2976,13 +2976,13 @@ QShowEvent::~QShowEvent()
 /*!
     \class QFileOpenEvent
     \brief The QFileOpenEvent class provides an event that will be
-    sent when there is a request to open a file.
+    sent when there is a request to open a file or a URL.
 
     \ingroup events
 
     File open events will be sent to the QApplication::instance()
-    when the operating system requests that a file be opened. This is
-    a high-level event that can be caused by different user actions
+    when the operating system requests that a file or URL should be opened.
+    This is a high-level event that can be caused by different user actions
     depending on the user's desktop environment; for example, double
     clicking on an file icon in the Finder on Mac OS X.
 
@@ -2999,12 +2999,27 @@ QShowEvent::~QShowEvent()
 */
 QFileOpenEvent::QFileOpenEvent(const QString &file)
     : QEvent(FileOpen), f(file)
-{}
+{
+    d = reinterpret_cast<QEventPrivate *>(new QFileOpenEventPrivate(QUrl::fromLocalFile(file)));
+}
+
+/*!
+    \internal
+
+    Constructs a file open event for the given \a url.
+*/
+QFileOpenEvent::QFileOpenEvent(const QUrl &url)
+    : QEvent(FileOpen)
+{
+    d = reinterpret_cast<QEventPrivate *>(new QFileOpenEventPrivate(url));
+    f = url.toLocalFile();
+}
 
 /*! \internal
 */
 QFileOpenEvent::~QFileOpenEvent()
 {
+    delete reinterpret_cast<QFileOpenEventPrivate *>(d);
 }
 
 /*!
@@ -3013,6 +3028,16 @@ QFileOpenEvent::~QFileOpenEvent()
     Returns the file that is being opened.
 */
 
+/*!
+    \fn QUrl QFileOpenEvent::url() const
+
+    Returns the url that is being opened.
+*/
+QUrl QFileOpenEvent::url() const
+{
+    return reinterpret_cast<const QFileOpenEventPrivate *>(d)->url;
+}
+
 #ifndef QT_NO_TOOLBAR
 /*!
     \internal
@@ -4345,9 +4370,9 @@ bool QGestureEvent::isAccepted(QGesture *gesture) const
     Sets the accept flag of the given \a gestureType object to the specified
     \a value.
 
-    Setting the accept flag indicates that the event receiver wants the gesture
-    of type \a gestureType. Unwanted gestures may be propagated to the parent
-    widget.
+    Setting the accept flag indicates that the event receiver wants to receive
+    gestures of the specified type, \a gestureType. Unwanted gestures may be
+    propagated to the parent widget.
 
     By default, gestures in events of type QEvent::Gesture are accepted, and
     gestures in QEvent::GestureOverride events are ignored.
diff --git a/src/gui/kernel/qevent.h b/src/gui/kernel/qevent.h
index b9512fa..9839269 100644
--- a/src/gui/kernel/qevent.h
+++ b/src/gui/kernel/qevent.h
@@ -638,9 +638,11 @@ class Q_GUI_EXPORT QFileOpenEvent : public QEvent
 {
 public:
     QFileOpenEvent(const QString &file);
+    QFileOpenEvent(const QUrl &url);
     ~QFileOpenEvent();
 
     inline QString file() const { return f; }
+    QUrl url() const;
 private:
     QString f;
 };
diff --git a/src/gui/kernel/qevent_p.h b/src/gui/kernel/qevent_p.h
index 6e6ab01..4aaaa8b 100644
--- a/src/gui/kernel/qevent_p.h
+++ b/src/gui/kernel/qevent_p.h
@@ -43,6 +43,7 @@
 #define QEVENT_P_H
 
 #include <QtCore/qglobal.h>
+#include <QtCore/qurl.h>
 #include <QtGui/qevent.h>
 
 QT_BEGIN_NAMESPACE
@@ -164,6 +165,18 @@ public:
     QMap<Qt::GestureType, QWidget *> targetWidgets;
 };
 
+
+class QFileOpenEventPrivate
+{
+public:
+    inline QFileOpenEventPrivate(const QUrl &url)
+        : url(url)
+    {
+    }
+
+    QUrl url;
+};
+
 QT_END_NAMESPACE
 
 #endif // QEVENT_P_H
diff --git a/src/gui/kernel/qgesture.cpp b/src/gui/kernel/qgesture.cpp
index e322af2..e8c2f8a 100644
--- a/src/gui/kernel/qgesture.cpp
+++ b/src/gui/kernel/qgesture.cpp
@@ -174,6 +174,16 @@ void QGesture::unsetHotSpot()
 }
 
 /*!
+    \property QGesture::gestureCancelPolicy
+    \brief the policy for deciding what happens on accepting a gesture
+
+    On accepting one gesture Qt can automatically cancel other gestures
+    that belong to other targets. The policy is normally set to not cancel
+    any other gestures and can be set to cancel all active gestures in the
+    context. For example for all child widgets.
+*/
+
+/*!
     \enum QGesture::GestureCancelPolicy
 
     This enum describes how accepting a gesture can cancel other gestures
@@ -210,16 +220,6 @@ QGesture::GestureCancelPolicy QGesture::gestureCancelPolicy() const
 */
 
 /*!
-    \property QGesture::gestureCancelPolicy
-    \brief the policy for deciding what happens on accepting a gesture
-
-    On accepting one gesture Qt can automatically cancel other gestures
-    that belong to other targets. The policy is normally set to not cancel
-    any other gestures and can be set to cancel all active gestures in the
-    context. For example for all child widgets.
-*/
-
-/*!
     \property QPanGesture::lastOffset
     \brief the last offset recorded for this gesture
 
@@ -658,4 +658,70 @@ void QSwipeGesture::setSwipeAngle(qreal value)
     d_func()->swipeAngle = value;
 }
 
+/*!
+    \class QTapGesture
+    \since 4.6
+    \brief The QTapGesture class describes a tap gesture made by the user.
+    \ingroup gestures
+
+    \sa {Gestures Programming}, QPanGesture, QPinchGesture
+*/
+
+/*!
+    \property QTapGesture::position
+    \brief the position of the tap
+*/
+
+/*!
+    \internal
+*/
+QTapGesture::QTapGesture(QObject *parent)
+    : QGesture(*new QTapGesturePrivate, parent)
+{
+    d_func()->gestureType = Qt::TapGesture;
+}
+
+QPointF QTapGesture::position() const
+{
+    return d_func()->position;
+}
+
+void QTapGesture::setPosition(const QPointF &value)
+{
+    d_func()->position = value;
+}
+/*!
+    \class QTapAndHoldGesture
+    \since 4.6
+    \brief The QTapAndHoldGesture class describes a tap-and-hold (aka LongTap)
+    gesture made by the user.
+    \ingroup gestures
+
+    \sa {Gestures Programming}, QPanGesture, QPinchGesture
+*/
+
+/*!
+    \property QTapAndHoldGesture::position
+    \brief the position of the tap
+*/
+
+/*!
+    \internal
+*/
+QTapAndHoldGesture::QTapAndHoldGesture(QObject *parent)
+    : QGesture(*new QTapAndHoldGesturePrivate, parent)
+{
+    d_func()->gestureType = Qt::TapAndHoldGesture;
+}
+
+QPointF QTapAndHoldGesture::position() const
+{
+    return d_func()->position;
+}
+
+void QTapAndHoldGesture::setPosition(const QPointF &value)
+{
+    d_func()->position = value;
+}
+
 QT_END_NAMESPACE
diff --git a/src/gui/kernel/qgesture.h b/src/gui/kernel/qgesture.h
index dd322ad..f995d7b 100644
--- a/src/gui/kernel/qgesture.h
+++ b/src/gui/kernel/qgesture.h
@@ -219,6 +219,40 @@ public:
     friend class QSwipeGestureRecognizer;
 };
 
+class QTapGesturePrivate;
+class Q_GUI_EXPORT QTapGesture : public QGesture
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QTapGesture)
+
+    Q_PROPERTY(QPointF position READ position WRITE setPosition)
+
+public:
+    QTapGesture(QObject *parent = 0);
+
+    QPointF position() const;
+    void setPosition(const QPointF &pos);
+
+    friend class QTapGestureRecognizer;
+};
+
+class QTapAndHoldGesturePrivate;
+class Q_GUI_EXPORT QTapAndHoldGesture : public QGesture
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QTapAndHoldGesture)
+
+    Q_PROPERTY(QPointF position READ position WRITE setPosition)
+
+public:
+    QTapAndHoldGesture(QObject *parent = 0);
+
+    QPointF position() const;
+    void setPosition(const QPointF &pos);
+
+    friend class QTapAndHoldGestureRecognizer;
+};
+
 QT_END_NAMESPACE
 
 Q_DECLARE_METATYPE(QGesture::GestureCancelPolicy)
diff --git a/src/gui/kernel/qgesture_p.h b/src/gui/kernel/qgesture_p.h
index ae2e287..2537f47 100644
--- a/src/gui/kernel/qgesture_p.h
+++ b/src/gui/kernel/qgesture_p.h
@@ -136,13 +136,45 @@ public:
     QSwipeGesturePrivate()
         : horizontalDirection(QSwipeGesture::NoDirection),
           verticalDirection(QSwipeGesture::NoDirection),
-          swipeAngle(0)
+          swipeAngle(0),
+          started(false), speed(0)
     {
     }
 
     QSwipeGesture::SwipeDirection horizontalDirection;
     QSwipeGesture::SwipeDirection verticalDirection;
     qreal swipeAngle;
+
+    QPoint lastPositions[3];
+    bool started;
+    qreal speed;
+    QTime time;
+};
+
+class QTapGesturePrivate : public QGesturePrivate
+{
+    Q_DECLARE_PUBLIC(QTapGesture)
+
+public:
+    QTapGesturePrivate()
+    {
+    }
+
+    QPointF position;
+};
+
+class QTapAndHoldGesturePrivate : public QGesturePrivate
+{
+    Q_DECLARE_PUBLIC(QTapAndHoldGesture)
+
+public:
+    QTapAndHoldGesturePrivate()
+        : timerId(0)
+    {
+    }
+
+    QPointF position;
+    int timerId;
 };
 
 QT_END_NAMESPACE
diff --git a/src/gui/kernel/qgesturemanager.cpp b/src/gui/kernel/qgesturemanager.cpp
index 628892d..abd2128 100644
--- a/src/gui/kernel/qgesturemanager.cpp
+++ b/src/gui/kernel/qgesturemanager.cpp
@@ -90,9 +90,13 @@ QGestureManager::QGestureManager(QObject *parent)
 #else
     registerGestureRecognizer(new QPanGestureRecognizer);
     registerGestureRecognizer(new QPinchGestureRecognizer);
+    registerGestureRecognizer(new QSwipeGestureRecognizer);
+    registerGestureRecognizer(new QTapGestureRecognizer);
+#endif
 #if defined(Q_OS_WIN)
     registerGestureRecognizer(new QWinNativePanGestureRecognizer);
-#endif
+#else
+    registerGestureRecognizer(new QTapAndHoldGestureRecognizer);
 #endif
 }
 
@@ -175,8 +179,10 @@ QGesture *QGestureManager::getState(QObject *object, QGestureRecognizer *recogni
             return 0;
     } else if (QGesture *g = qobject_cast<QGesture *>(object)) {
         return g;
+#ifndef QT_NO_GRAPHICSVIEW
     } else {
         Q_ASSERT(qobject_cast<QGraphicsObject *>(object));
+#endif
     }
 
     QList<QGesture *> states =
diff --git a/src/gui/kernel/qmacgesturerecognizer_mac.mm b/src/gui/kernel/qmacgesturerecognizer_mac.mm
index d842322..f142d71 100644
--- a/src/gui/kernel/qmacgesturerecognizer_mac.mm
+++ b/src/gui/kernel/qmacgesturerecognizer_mac.mm
@@ -120,7 +120,7 @@ QMacPinchGestureRecognizer::recognize(QGesture *gesture, QObject *obj, QEvent *e
         case QNativeGestureEvent::Zoom:
             g->setLastScaleFactor(g->scaleFactor());
             g->setLastRotationAngle(g->rotationAngle());
-            g->setScaleFactor(g->scaleFactor() + ev->percentage);
+            g->setScaleFactor(g->scaleFactor() * (1 + ev->percentage));
             g->setChangeFlags(QPinchGesture::ScaleFactorChanged);
             g->setTotalChangeFlags(g->totalChangeFlags() | g->changeFlags());
             return QGestureRecognizer::TriggerGesture | QGestureRecognizer::ConsumeEventHint;
diff --git a/src/gui/kernel/qsoftkeymanager.cpp b/src/gui/kernel/qsoftkeymanager.cpp
index a914220..ecad72f 100644
--- a/src/gui/kernel/qsoftkeymanager.cpp
+++ b/src/gui/kernel/qsoftkeymanager.cpp
@@ -137,12 +137,14 @@ QAction *QSoftKeyManager::createAction(StandardSoftKey standardKey, QWidget *act
 */
 QAction *QSoftKeyManager::createKeyedAction(StandardSoftKey standardKey, Qt::Key key, QWidget *actionWidget)
 {
+#ifndef QT_NO_ACTION
     QScopedPointer<QAction> action(createAction(standardKey, actionWidget));
 
     connect(action.data(), SIGNAL(triggered()), QSoftKeyManager::instance(), SLOT(sendKeyEvent()));
     connect(action.data(), SIGNAL(destroyed(QObject*)), QSoftKeyManager::instance(), SLOT(cleanupHash(QObject*)));
     QSoftKeyManager::instance()->d_func()->keyedActions.insert(action.data(), key);
     return action.take();
+#endif //QT_NO_ACTION
 }
 
 void QSoftKeyManager::cleanupHash(QObject* obj)
@@ -175,6 +177,7 @@ void QSoftKeyManager::updateSoftKeys()
 
 bool QSoftKeyManager::event(QEvent *e)
 {
+#ifndef QT_NO_ACTION
     if (e->type() == QEvent::UpdateSoftKeys) {
         QList<QAction*> softKeys;
         QWidget *source = QApplication::focusWidget();
@@ -200,6 +203,7 @@ bool QSoftKeyManager::event(QEvent *e)
         QSoftKeyManagerPrivate::updateSoftKeys_sys(softKeys);
         return true;
     }
+#endif //QT_NO_ACTION
     return false;
 }
 
diff --git a/src/gui/kernel/qstandardgestures.cpp b/src/gui/kernel/qstandardgestures.cpp
index dfd49eb..0ea4764 100644
--- a/src/gui/kernel/qstandardgestures.cpp
+++ b/src/gui/kernel/qstandardgestures.cpp
@@ -45,6 +45,7 @@
 #include "qevent.h"
 #include "qwidget.h"
 #include "qabstractscrollarea.h"
+#include "qdebug.h"
 
 QT_BEGIN_NAMESPACE
 
@@ -66,7 +67,9 @@ QGesture *QPanGestureRecognizer::create(QObject *target)
     return new QPanGesture;
 }
 
-QGestureRecognizer::Result QPanGestureRecognizer::recognize(QGesture *state, QObject *, QEvent *event)
+QGestureRecognizer::Result QPanGestureRecognizer::recognize(QGesture *state,
+                                                            QObject *,
+                                                            QEvent *event)
 {
     QPanGesture *q = static_cast<QPanGesture *>(state);
     QPanGesturePrivate *d = q->d_func();
@@ -155,7 +158,9 @@ QGesture *QPinchGestureRecognizer::create(QObject *target)
     return new QPinchGesture;
 }
 
-QGestureRecognizer::Result QPinchGestureRecognizer::recognize(QGesture *state, QObject *, QEvent *event)
+QGestureRecognizer::Result QPinchGestureRecognizer::recognize(QGesture *state,
+                                                              QObject *,
+                                                              QEvent *event)
 {
     QPinchGesture *q = static_cast<QPinchGesture *>(state);
     QPinchGesturePrivate *d = q->d_func();
@@ -199,8 +204,9 @@ QGestureRecognizer::Result QPinchGestureRecognizer::recognize(QGesture *state, Q
             d->centerPoint = centerPoint;
             d->changeFlags |= QPinchGesture::CenterPointChanged;
 
-            const qreal scaleFactor = QLineF(p1.pos(), p2.pos()).length()
-                                      / QLineF(d->startPosition[0],  d->startPosition[1]).length();
+            const qreal scaleFactor =
+                    QLineF(p1.screenPos(), p2.screenPos()).length()
+                    / QLineF(d->startPosition[0],  d->startPosition[1]).length();
             if (d->isNewSequence) {
                 d->lastScaleFactor = scaleFactor;
             } else {
@@ -210,7 +216,13 @@ QGestureRecognizer::Result QPinchGestureRecognizer::recognize(QGesture *state, Q
             d->totalScaleFactor += d->scaleFactor - d->lastScaleFactor;
             d->changeFlags |= QPinchGesture::ScaleFactorChanged;
 
-            const qreal rotationAngle = -line.angle();
+            qreal angle = QLineF(p1.screenPos(), p2.screenPos()).angle();
+            if (angle > 180)
+                angle -= 360;
+            qreal startAngle = QLineF(p1.startScreenPos(), p2.startScreenPos()).angle();
+            if (startAngle > 180)
+                startAngle -= 360;
+            const qreal rotationAngle = startAngle - angle;
             if (d->isNewSequence)
                 d->lastRotationAngle = rotationAngle;
             else
@@ -224,7 +236,10 @@ QGestureRecognizer::Result QPinchGestureRecognizer::recognize(QGesture *state, Q
             result = QGestureRecognizer::TriggerGesture;
         } else {
             d->isNewSequence = true;
-            result = QGestureRecognizer::MayBeGesture;
+            if (q->state() == Qt::NoGesture)
+                result = QGestureRecognizer::Ignore;
+            else
+                result = QGestureRecognizer::FinishGesture;
         }
         break;
     }
@@ -252,6 +267,299 @@ void QPinchGestureRecognizer::reset(QGesture *state)
     d->totalRotationAngle = d->lastRotationAngle = d->rotationAngle = 0;
 
     d->isNewSequence = true;
+    d->startPosition[0] = d->startPosition[1] = QPointF();
+
+    QGestureRecognizer::reset(state);
+}
+
+//
+// QSwipeGestureRecognizer
+//
+
+QSwipeGestureRecognizer::QSwipeGestureRecognizer()
+{
+}
+
+QGesture *QSwipeGestureRecognizer::create(QObject *target)
+{
+    if (target && target->isWidgetType()) {
+        static_cast<QWidget *>(target)->setAttribute(Qt::WA_AcceptTouchEvents);
+    }
+    return new QSwipeGesture;
+}
+
+QGestureRecognizer::Result QSwipeGestureRecognizer::recognize(QGesture *state,
+                                                              QObject *,
+                                                              QEvent *event)
+{
+    QSwipeGesture *q = static_cast<QSwipeGesture *>(state);
+    QSwipeGesturePrivate *d = q->d_func();
+
+    const QTouchEvent *ev = static_cast<const QTouchEvent *>(event);
+
+    QGestureRecognizer::Result result;
+
+    switch (event->type()) {
+    case QEvent::TouchBegin: {
+        d->speed = 1;
+        d->time = QTime::currentTime();
+        d->started = true;
+        result = QGestureRecognizer::MayBeGesture;
+        break;
+    }
+    case QEvent::TouchEnd: {
+        if (q->state() != Qt::NoGesture) {
+            result = QGestureRecognizer::FinishGesture;
+        } else {
+            result = QGestureRecognizer::CancelGesture;
+        }
+        break;
+    }
+    case QEvent::TouchUpdate: {
+        if (!d->started)
+            result = QGestureRecognizer::CancelGesture;
+        else if (ev->touchPoints().size() == 3) {
+            QTouchEvent::TouchPoint p1 = ev->touchPoints().at(0);
+            QTouchEvent::TouchPoint p2 = ev->touchPoints().at(1);
+            QTouchEvent::TouchPoint p3 = ev->touchPoints().at(2);
+
+            if (d->lastPositions[0].isNull()) {
+                d->lastPositions[0] = p1.startScreenPos().toPoint();
+                d->lastPositions[1] = p2.startScreenPos().toPoint();
+                d->lastPositions[2] = p3.startScreenPos().toPoint();
+            }
+            d->hotSpot = p1.screenPos();
+            d->isHotSpotSet = true;
+
+            int xDistance = (p1.screenPos().x() - d->lastPositions[0].x() +
+                             p2.screenPos().x() - d->lastPositions[1].x() +
+                             p3.screenPos().x() - d->lastPositions[2].x()) / 3;
+            int yDistance = (p1.screenPos().y() - d->lastPositions[0].y() +
+                             p2.screenPos().y() - d->lastPositions[1].y() +
+                             p3.screenPos().y() - d->lastPositions[2].y()) / 3;
+
+            const int distance = xDistance >= yDistance ? xDistance : yDistance;
+            int elapsedTime = d->time.msecsTo(QTime::currentTime());
+            if (!elapsedTime)
+                elapsedTime = 1;
+            d->speed = 0.9 * d->speed + distance / elapsedTime;
+            d->time = QTime::currentTime();
+            d->swipeAngle = QLineF(p1.startScreenPos(), p1.screenPos()).angle();
+
+            static const int MoveThreshold = 50;
+            if (xDistance > MoveThreshold || yDistance > MoveThreshold) {
+                // measure the distance to check if the direction changed
+                d->lastPositions[0] = p1.screenPos().toPoint();
+                d->lastPositions[1] = p2.screenPos().toPoint();
+                d->lastPositions[2] = p3.screenPos().toPoint();
+                QSwipeGesture::SwipeDirection horizontal =
+                        xDistance > 0 ? QSwipeGesture::Right : QSwipeGesture::Left;
+                QSwipeGesture::SwipeDirection vertical =
+                        yDistance > 0 ? QSwipeGesture::Down : QSwipeGesture::Up;
+                if (d->verticalDirection == QSwipeGesture::NoDirection)
+                    d->verticalDirection = vertical;
+                if (d->horizontalDirection == QSwipeGesture::NoDirection)
+                    d->horizontalDirection = horizontal;
+                if (d->verticalDirection != vertical || d->horizontalDirection != horizontal) {
+                    // the user has changed the direction!
+                    result = QGestureRecognizer::CancelGesture;
+                }
+                result = QGestureRecognizer::TriggerGesture;
+            } else {
+                if (q->state() != Qt::NoGesture)
+                    result = QGestureRecognizer::TriggerGesture;
+                else
+                    result = QGestureRecognizer::MayBeGesture;
+            }
+        } else if (ev->touchPoints().size() > 3) {
+            result = QGestureRecognizer::CancelGesture;
+        } else { // less than 3 touch points
+            if (d->started && (ev->touchPointStates() & Qt::TouchPointPressed))
+                result = QGestureRecognizer::CancelGesture;
+            else if (d->started)
+                result = QGestureRecognizer::Ignore;
+            else
+                result = QGestureRecognizer::MayBeGesture;
+        }
+        break;
+    }
+    case QEvent::MouseButtonPress:
+    case QEvent::MouseMove:
+    case QEvent::MouseButtonRelease:
+        result = QGestureRecognizer::Ignore;
+        break;
+    default:
+        result = QGestureRecognizer::Ignore;
+        break;
+    }
+    return result;
+}
+
+void QSwipeGestureRecognizer::reset(QGesture *state)
+{
+    QSwipeGesture *q = static_cast<QSwipeGesture *>(state);
+    QSwipeGesturePrivate *d = q->d_func();
+
+    d->verticalDirection = d->horizontalDirection = QSwipeGesture::NoDirection;
+    d->swipeAngle = 0;
+
+    d->lastPositions[0] = d->lastPositions[1] = d->lastPositions[2] = QPoint();
+    d->started = false;
+    d->speed = 0;
+    d->time = QTime();
+
+    QGestureRecognizer::reset(state);
+}
+
+//
+// QTapGestureRecognizer
+//
+
+QTapGestureRecognizer::QTapGestureRecognizer()
+{
+}
+
+QGesture *QTapGestureRecognizer::create(QObject *target)
+{
+    if (target && target->isWidgetType()) {
+        static_cast<QWidget *>(target)->setAttribute(Qt::WA_AcceptTouchEvents);
+    }
+    return new QTapGesture;
+}
+
+QGestureRecognizer::Result QTapGestureRecognizer::recognize(QGesture *state,
+                                                            QObject *,
+                                                            QEvent *event)
+{
+    QTapGesture *q = static_cast<QTapGesture *>(state);
+    QTapGesturePrivate *d = q->d_func();
+
+    const QTouchEvent *ev = static_cast<const QTouchEvent *>(event);
+
+    QGestureRecognizer::Result result = QGestureRecognizer::CancelGesture;
+
+    switch (event->type()) {
+    case QEvent::TouchBegin: {
+        d->position = ev->touchPoints().at(0).pos();
+        result = QGestureRecognizer::TriggerGesture;
+        break;
+    }
+    case QEvent::TouchUpdate:
+    case QEvent::TouchEnd: {
+        if (q->state() != Qt::NoGesture && ev->touchPoints().size() == 1) {
+            QTouchEvent::TouchPoint p = ev->touchPoints().at(0);
+            QPoint delta = p.pos().toPoint() - p.startPos().toPoint();
+            enum { TapRadius = 40 };
+            if (delta.manhattanLength() <= TapRadius) {
+                if (event->type() == QEvent::TouchEnd)
+                    result = QGestureRecognizer::FinishGesture;
+                else
+                    result = QGestureRecognizer::TriggerGesture;
+            }
+        }
+        break;
+    }
+    case QEvent::MouseButtonPress:
+    case QEvent::MouseMove:
+    case QEvent::MouseButtonRelease:
+        result = QGestureRecognizer::Ignore;
+        break;
+    default:
+        result = QGestureRecognizer::Ignore;
+        break;
+    }
+    return result;
+}
+
+void QTapGestureRecognizer::reset(QGesture *state)
+{
+    QTapGesture *q = static_cast<QTapGesture *>(state);
+    QTapGesturePrivate *d = q->d_func();
+
+    d->position = QPointF();
+
+    QGestureRecognizer::reset(state);
+}
+
+//
+// QTapAndHoldGestureRecognizer
+//
+
+QTapAndHoldGestureRecognizer::QTapAndHoldGestureRecognizer()
+{
+}
+
+QGesture *QTapAndHoldGestureRecognizer::create(QObject *target)
+{
+    if (target && target->isWidgetType()) {
+        static_cast<QWidget *>(target)->setAttribute(Qt::WA_AcceptTouchEvents);
+    }
+    return new QTapAndHoldGesture;
+}
+
+QGestureRecognizer::Result
+QTapAndHoldGestureRecognizer::recognize(QGesture *state, QObject *object,
+                                        QEvent *event)
+{
+    QTapAndHoldGesture *q = static_cast<QTapAndHoldGesture *>(state);
+    QTapAndHoldGesturePrivate *d = q->d_func();
+
+    if (object == state && event->type() == QEvent::Timer) {
+        q->killTimer(d->timerId);
+        d->timerId = 0;
+        return QGestureRecognizer::Ignore | QGestureRecognizer::ConsumeEventHint;
+    }
+
+    const QTouchEvent *ev = static_cast<const QTouchEvent *>(event);
+
+    QGestureRecognizer::Result result = QGestureRecognizer::CancelGesture;
+
+    enum { TimerInterval = 2000 };
+    enum { TapRadius = 40 };
+
+    switch (event->type()) {
+    case QEvent::TouchBegin:
+        d->position = ev->touchPoints().at(0).pos();
+        if (d->timerId)
+            q->killTimer(d->timerId);
+        d->timerId = q->startTimer(TimerInterval);
+        result = QGestureRecognizer::TriggerGesture;
+        break;
+    case QEvent::TouchEnd:
+        if (d->timerId)
+            result = QGestureRecognizer::CancelGesture;
+        else
+            result = QGestureRecognizer::FinishGesture;
+        break;
+    case QEvent::TouchUpdate:
+        if (q->state() != Qt::NoGesture && ev->touchPoints().size() == 1) {
+            QTouchEvent::TouchPoint p = ev->touchPoints().at(0);
+            QPoint delta = p.pos().toPoint() - p.startPos().toPoint();
+            if (delta.manhattanLength() <= TapRadius)
+                result = QGestureRecognizer::TriggerGesture;
+        }
+        break;
+    case QEvent::MouseButtonPress:
+    case QEvent::MouseMove:
+    case QEvent::MouseButtonRelease:
+        result = QGestureRecognizer::Ignore;
+        break;
+    default:
+        result = QGestureRecognizer::Ignore;
+        break;
+    }
+    return result;
+}
+
+void QTapAndHoldGestureRecognizer::reset(QGesture *state)
+{
+    QTapAndHoldGesture *q = static_cast<QTapAndHoldGesture *>(state);
+    QTapAndHoldGesturePrivate *d = q->d_func();
+
+    d->position = QPointF();
+    if (d->timerId)
+        q->killTimer(d->timerId);
+    d->timerId = 0;
 
     QGestureRecognizer::reset(state);
 }
diff --git a/src/gui/kernel/qstandardgestures_p.h b/src/gui/kernel/qstandardgestures_p.h
index e6f346c..8fea2bc 100644
--- a/src/gui/kernel/qstandardgestures_p.h
+++ b/src/gui/kernel/qstandardgestures_p.h
@@ -74,7 +74,36 @@ public:
     QPinchGestureRecognizer();
 
     QGesture *create(QObject *target);
+    QGestureRecognizer::Result recognize(QGesture *state, QObject *watched, QEvent *event);
+    void reset(QGesture *state);
+};
+
+class QSwipeGestureRecognizer : public QGestureRecognizer
+{
+public:
+    QSwipeGestureRecognizer();
 
+    QGesture *create(QObject *target);
+    QGestureRecognizer::Result recognize(QGesture *state, QObject *watched, QEvent *event);
+    void reset(QGesture *state);
+};
+
+class QTapGestureRecognizer : public QGestureRecognizer
+{
+public:
+    QTapGestureRecognizer();
+
+    QGesture *create(QObject *target);
+    QGestureRecognizer::Result recognize(QGesture *state, QObject *watched, QEvent *event);
+    void reset(QGesture *state);
+};
+
+class QTapAndHoldGestureRecognizer : public QGestureRecognizer
+{
+public:
+    QTapAndHoldGestureRecognizer();
+
+    QGesture *create(QObject *target);
     QGestureRecognizer::Result recognize(QGesture *state, QObject *watched, QEvent *event);
     void reset(QGesture *state);
 };
diff --git a/src/gui/kernel/qwidget.cpp b/src/gui/kernel/qwidget.cpp
index 6a72cfa..271b939 100644
--- a/src/gui/kernel/qwidget.cpp
+++ b/src/gui/kernel/qwidget.cpp
@@ -230,7 +230,9 @@ QWidgetPrivate::~QWidgetPrivate()
     if (extra)
         deleteExtra();
 
+#ifndef QT_NO_GRAPHICSEFFECT
     delete graphicsEffect;
+#endif //QT_NO_GRAPHICSEFFECT
 }
 
 QWindowSurface *QWidgetPrivate::createDefaultWindowSurface()
@@ -1793,6 +1795,7 @@ QRegion QWidgetPrivate::clipRegion() const
     return r;
 }
 
+#ifndef QT_NO_GRAPHICSEFFECT
 void QWidgetPrivate::invalidateGraphicsEffectsRecursively()
 {
     Q_Q(QWidget);
@@ -1807,6 +1810,7 @@ void QWidgetPrivate::invalidateGraphicsEffectsRecursively()
         w = w->parentWidget();
     } while (w);
 }
+#endif //QT_NO_GRAPHICSEFFECT
 
 void QWidgetPrivate::setDirtyOpaqueRegion()
 {
@@ -1814,7 +1818,9 @@ void QWidgetPrivate::setDirtyOpaqueRegion()
 
     dirtyOpaqueChildren = true;
 
+#ifndef QT_NO_GRAPHICSEFFECT
     invalidateGraphicsEffectsRecursively();
+#endif //QT_NO_GRAPHICSEFFECT
 
     if (q->isWindow())
         return;
@@ -1963,10 +1969,12 @@ void QWidgetPrivate::clipToEffectiveMask(QRegion &region) const
     const QWidget *w = q;
     QPoint offset;
 
+#ifndef QT_NO_GRAPHICSEFFECT
     if (graphicsEffect) {
         w = q->parentWidget();
         offset -= data.crect.topLeft();
     }
+#endif //QT_NO_GRAPHICSEFFECT
 
     while (w) {
         const QWidgetPrivate *wd = w->d_func();
@@ -2001,11 +2009,13 @@ void QWidgetPrivate::updateIsOpaque()
     // hw: todo: only needed if opacity actually changed
     setDirtyOpaqueRegion();
 
+#ifndef QT_NO_GRAPHICSEFFECT
     if (graphicsEffect) {
         // ### We should probably add QGraphicsEffect::isOpaque at some point.
         setOpaque(false);
         return;
     }
+#endif //QT_NO_GRAPHICSEFFECT
 
     Q_Q(QWidget);
 #ifdef Q_WS_X11
@@ -5013,11 +5023,13 @@ void QWidget::render(QPainter *painter, const QPoint &targetOffset,
 
     \sa setGraphicsEffect()
 */
+#ifndef QT_NO_GRAPHICSEFFECT
 QGraphicsEffect *QWidget::graphicsEffect() const
 {
     Q_D(const QWidget);
     return d->graphicsEffect;
 }
+#endif //QT_NO_GRAPHICSEFFECT
 
 /*!
 
@@ -5036,6 +5048,7 @@ QGraphicsEffect *QWidget::graphicsEffect() const
 
     \sa graphicsEffect()
 */
+#ifndef QT_NO_GRAPHICSEFFECT
 void QWidget::setGraphicsEffect(QGraphicsEffect *effect)
 {
     Q_D(QWidget);
@@ -5065,6 +5078,7 @@ void QWidget::setGraphicsEffect(QGraphicsEffect *effect)
     d->updateIsOpaque();
     update();
 }
+#endif //QT_NO_GRAPHICSEFFECT
 
 bool QWidgetPrivate::isAboutToShow() const
 {
@@ -5157,8 +5171,7 @@ void QWidgetPrivate::render_helper(QPainter *painter, const QPoint &targetOffset
             return;
 
         QPixmap pixmap(size);
-        if (!(renderFlags & QWidget::DrawWindowBackground)
-            || !q->palette().brush(q->backgroundRole()).isOpaque())
+        if (!(renderFlags & QWidget::DrawWindowBackground) || !isOpaque)
             pixmap.fill(Qt::transparent);
         q->render(&pixmap, QPoint(), toBePainted, renderFlags);
 
@@ -5211,6 +5224,7 @@ void QWidgetPrivate::drawWidget(QPaintDevice *pdev, const QRegion &rgn, const QP
         return;
 
     Q_Q(QWidget);
+#ifndef QT_NO_GRAPHICSEFFECT
     if (graphicsEffect && graphicsEffect->isEnabled()) {
         QGraphicsEffectSource *source = graphicsEffect->d_func()->source;
         QWidgetEffectSourcePrivate *sourced = static_cast<QWidgetEffectSourcePrivate *>
@@ -5241,6 +5255,7 @@ void QWidgetPrivate::drawWidget(QPaintDevice *pdev, const QRegion &rgn, const QP
             return;
         }
     }
+#endif //QT_NO_GRAFFICSEFFECT
 
     const bool asRoot = flags & DrawAsRoot;
     const bool alsoOnScreen = flags & DrawPaintOnScreen;
@@ -5395,7 +5410,6 @@ void QWidgetPrivate::paintSiblingsRecursive(QPaintDevice *pdev, const QObjectLis
     QWidgetPrivate *wd = w->d_func();
     const QPoint widgetPos(w->data->crect.topLeft());
     const bool hasMask = wd->extra && wd->extra->hasMask && !wd->graphicsEffect;
-
     if (index > 0) {
         QRegion wr(rgn);
         if (wd->isOpaque)
@@ -5421,6 +5435,7 @@ void QWidgetPrivate::paintSiblingsRecursive(QPaintDevice *pdev, const QObjectLis
     }
 }
 
+#ifndef QT_NO_GRAPHICSEFFECT
 QRectF QWidgetEffectSourcePrivate::boundingRect(Qt::CoordinateSystem system) const
 {
     if (system != Qt::DeviceCoordinates)
@@ -5521,6 +5536,7 @@ QPixmap QWidgetEffectSourcePrivate::pixmap(Qt::CoordinateSystem system, QPoint *
     m_widget->render(&pixmap, pixmapOffset);
     return pixmap;
 }
+#endif //QT_NO_GRAPHICSEFFECT
 
 #ifndef QT_NO_GRAPHICSVIEW
 /*!
diff --git a/src/gui/kernel/qwidget.h b/src/gui/kernel/qwidget.h
index 05f0069..b7c55f9 100644
--- a/src/gui/kernel/qwidget.h
+++ b/src/gui/kernel/qwidget.h
@@ -351,8 +351,10 @@ public:
                 const QRegion &sourceRegion = QRegion(),
                 RenderFlags renderFlags = RenderFlags(DrawWindowBackground | DrawChildren));
 
+#ifndef QT_NO_GRAPHICSEFFECT
     QGraphicsEffect *graphicsEffect() const;
     void setGraphicsEffect(QGraphicsEffect *effect);
+#endif //QT_NO_GRAPHICSEFFECT
 
     void grabGesture(Qt::GestureType type, Qt::GestureFlags flags = Qt::GestureFlags());
     void ungrabGesture(Qt::GestureType type);
diff --git a/src/gui/kernel/qwidget_mac.mm b/src/gui/kernel/qwidget_mac.mm
index 9270220..75f9a59 100644
--- a/src/gui/kernel/qwidget_mac.mm
+++ b/src/gui/kernel/qwidget_mac.mm
@@ -730,6 +730,7 @@ static EventTypeSpec window_events[] = {
     { kEventClassWindow, kEventWindowClose },
     { kEventClassWindow, kEventWindowExpanded },
     { kEventClassWindow, kEventWindowHidden },
+    { kEventClassWindow, kEventWindowZoom },
     { kEventClassWindow, kEventWindowZoomed },
     { kEventClassWindow, kEventWindowCollapsed },
     { kEventClassWindow, kEventWindowToolbarSwitchMode },
@@ -812,6 +813,9 @@ OSStatus QWidgetPrivate::qt_window_event(EventHandlerCallRef er, EventRef event,
 
             QShowEvent qse;
             QApplication::sendSpontaneousEvent(widget, &qse);
+        } else if(ekind == kEventWindowZoom) {
+            widget->d_func()->topData()->normalGeometry = widget->geometry();
+            handled_event = false;
         } else if(ekind == kEventWindowZoomed) {
             WindowPartCode windowPart;
             GetEventParameter(event, kEventParamWindowPartCode,
@@ -3487,10 +3491,10 @@ void QWidget::setWindowState(Qt::WindowStates newstate)
                     qt_mac_set_fullscreen_mode(true);
             } else {
                 needShow = isVisible();
-                setParent(parentWidget(), d->topData()->savedFlags);
-                setGeometry(d->topData()->normalGeometry);
                 if(!qApp->desktop()->screenNumber(this))
                     qt_mac_set_fullscreen_mode(false);
+                setParent(parentWidget(), d->topData()->savedFlags);
+                setGeometry(d->topData()->normalGeometry);
                 d->topData()->normalGeometry.setRect(0, 0, -1, -1);
             }
         }
@@ -3592,7 +3596,7 @@ void QWidget::setWindowState(Qt::WindowStates newstate)
                 [window zoom:window];
 #endif
                 needSendStateChange = oldstate == windowState(); // Zoom didn't change flags.
-            } else if(oldstate & Qt::WindowMaximized) {
+            } else if(oldstate & Qt::WindowMaximized && !(oldstate & Qt::WindowFullScreen)) {
 #ifndef QT_MAC_USE_COCOA
                 Point idealSize;
                 ZoomWindowIdeal(window, inZoomIn, &idealSize);
@@ -3787,7 +3791,7 @@ void QWidgetPrivate::stackUnder_sys(QWidget *w)
 /*
     Modifies the bounds for a widgets backing HIView during moves and resizes. Also updates the
     widget, either by scrolling its contents or repainting, depending on the WA_StaticContents
-    and QWidgetPrivate::isOpaque flags.
+    flag
 */
 static void qt_mac_update_widget_posisiton(QWidget *q, QRect oldRect, QRect newRect)
 {
@@ -3804,8 +3808,8 @@ static void qt_mac_update_widget_posisiton(QWidget *q, QRect oldRect, QRect newR
 
     // Perform a normal (complete repaint) update in some cases:
     if (
-        // move-by-scroll requires QWidgetPrivate::isOpaque set
-        (isMove && q->testAttribute(Qt::WA_OpaquePaintEvent) == false) ||
+        // always repaint on move.
+        (isMove) ||
 
         // limited update on resize requires WA_StaticContents.
         (isResize && q->testAttribute(Qt::WA_StaticContents) == false) ||
diff --git a/src/gui/kernel/qwidget_p.h b/src/gui/kernel/qwidget_p.h
index 8b03a85..151b90a 100644
--- a/src/gui/kernel/qwidget_p.h
+++ b/src/gui/kernel/qwidget_p.h
@@ -384,7 +384,9 @@ public:
     void setOpaque(bool opaque);
     void updateIsTranslucent();
     bool paintOnScreen() const;
+#ifndef QT_NO_GRAPHICSEFFECT
     void invalidateGraphicsEffectsRecursively();
+#endif //QT_NO_GRAPHICSEFFECT
 
     const QRegion &getOpaqueChildren() const;
     void setDirtyOpaqueRegion();
@@ -530,8 +532,10 @@ public:
 
     inline QRect effectiveRectFor(const QRect &rect) const
     {
+#ifndef QT_NO_GRAPHICSEFFECT
         if (graphicsEffect && graphicsEffect->isEnabled())
             return graphicsEffect->boundingRectFor(rect).toAlignedRect();
+#endif //QT_NO_GRAPHICSEFFECT
         return rect;
     }
 
@@ -774,6 +778,7 @@ struct QWidgetPaintContext
     QPainter *painter;
 };
 
+#ifndef QT_NO_GRAPHICSEFFECT
 class QWidgetEffectSourcePrivate : public QGraphicsEffectSourcePrivate
 {
 public:
@@ -826,6 +831,7 @@ public:
     QTransform lastEffectTransform;
     bool updateDueToGraphicsEffect;
 };
+#endif //QT_NO_GRAPHICSEFFECT
 
 inline QWExtra *QWidgetPrivate::extraData() const
 {
diff --git a/src/gui/kernel/qwidget_win.cpp b/src/gui/kernel/qwidget_win.cpp
index 22a94b9..b7ba273 100644
--- a/src/gui/kernel/qwidget_win.cpp
+++ b/src/gui/kernel/qwidget_win.cpp
@@ -677,7 +677,11 @@ QPoint QWidget::mapToGlobal(const QPoint &pos) const
     QWidget *parentWindow = window();
     QWExtra *extra = parentWindow->d_func()->extra;
     if (!isVisible() || parentWindow->isMinimized() || !testAttribute(Qt::WA_WState_Created) || !internalWinId()
-        || (extra && extra->proxyWidget)) {
+        || (extra
+#ifndef QT_NO_GRAPHICSVIEW
+            && extra->proxyWidget
+#endif //QT_NO_GRAPHICSVIEW
+            )) {
         if (extra && extra->topextra && extra->topextra->embedded) {
             QPoint pt = mapTo(parentWindow, pos);
             POINT p = {pt.x(), pt.y()};
@@ -704,7 +708,11 @@ QPoint QWidget::mapFromGlobal(const QPoint &pos) const
     QWidget *parentWindow = window();
     QWExtra *extra = parentWindow->d_func()->extra;
     if (!isVisible() || parentWindow->isMinimized() || !testAttribute(Qt::WA_WState_Created) || !internalWinId()
-        || (extra && extra->proxyWidget)) {
+        || (extra
+#ifndef QT_NO_GRAPHICSVIEW
+            && extra->proxyWidget
+#endif //QT_NO_GRAPHICSVIEW
+            )) {
         if (extra && extra->topextra && extra->topextra->embedded) {
             POINT p = {pos.x(), pos.y()};
             ScreenToClient(parentWindow->effectiveWinId(), &p);
@@ -1331,8 +1339,15 @@ void QWidgetPrivate::setGeometry_sys(int x, int y, int w, int h, bool isMove)
     if (isResize && !q->testAttribute(Qt::WA_StaticContents) && q->internalWinId())
         ValidateRgn(q->internalWinId(), 0);
 
+#ifdef Q_WS_WINCE
+    // On Windows CE we can't just fiddle around with the window state.
+    // Too much magic in setWindowState.
+    if (isResize && q->isMaximized())
+        q->setWindowState(q->windowState() & ~Qt::WindowMaximized);
+#else
     if (isResize)
         data.window_state &= ~Qt::WindowMaximized;
+#endif
 
     if (data.window_state & Qt::WindowFullScreen) {
         QTLWExtra *top = topData();
@@ -2042,6 +2057,7 @@ void QWidgetPrivate::winSetupGestures()
     bool needv = false;
     bool singleFingerPanEnabled = false;
 
+#ifndef QT_NO_SCROLLAREA
     if (QAbstractScrollArea *asa = qobject_cast<QAbstractScrollArea*>(q->parent())) {
         QScrollBar *hbar = asa->horizontalScrollBar();
         QScrollBar *vbar = asa->verticalScrollBar();
@@ -2055,6 +2071,7 @@ void QWidgetPrivate::winSetupGestures()
         if (!winid)
             winid = q->winId(); // enforces the native winid on the viewport
     }
+#endif //QT_NO_SCROLLAREA
     if (winid && qAppPriv->SetGestureConfig) {
         GESTURECONFIG gc[1];
         memset(gc, 0, sizeof(gc));
diff --git a/src/gui/math3d/qmatrix4x4.cpp b/src/gui/math3d/qmatrix4x4.cpp
index 2c3d616..031c5ef 100644
--- a/src/gui/math3d/qmatrix4x4.cpp
+++ b/src/gui/math3d/qmatrix4x4.cpp
@@ -40,6 +40,7 @@
 ****************************************************************************/
 
 #include "qmatrix4x4.h"
+#include <private/qnumeric_p.h>
 #include <QtCore/qmath.h>
 #include <QtCore/qvariant.h>
 #include <QtGui/qmatrix.h>
@@ -58,7 +59,7 @@ QT_BEGIN_NAMESPACE
     \sa QVector3D, QGenericMatrix
 */
 
-static const qreal inv_dist_to_plane = 1. / 1024.;
+static const qreal inv_dist_to_plane = qreal(1.) / qreal(1024.);
 
 /*!
     \fn QMatrix4x4::QMatrix4x4()
@@ -506,22 +507,23 @@ QMatrix4x4 QMatrix4x4::transposed() const
 */
 QMatrix4x4& QMatrix4x4::operator/=(qreal divisor)
 {
-    m[0][0] /= divisor;
-    m[0][1] /= divisor;
-    m[0][2] /= divisor;
-    m[0][3] /= divisor;
-    m[1][0] /= divisor;
-    m[1][1] /= divisor;
-    m[1][2] /= divisor;
-    m[1][3] /= divisor;
-    m[2][0] /= divisor;
-    m[2][1] /= divisor;
-    m[2][2] /= divisor;
-    m[2][3] /= divisor;
-    m[3][0] /= divisor;
-    m[3][1] /= divisor;
-    m[3][2] /= divisor;
-    m[3][3] /= divisor;
+    const qreal inv_divisor = (1 / divisor); 
+    m[0][0] *= inv_divisor;
+    m[0][1] *= inv_divisor;
+    m[0][2] *= inv_divisor;
+    m[0][3] *= inv_divisor;
+    m[1][0] *= inv_divisor;
+    m[1][1] *= inv_divisor;
+    m[1][2] *= inv_divisor;
+    m[1][3] *= inv_divisor;
+    m[2][0] *= inv_divisor;
+    m[2][1] *= inv_divisor;
+    m[2][2] *= inv_divisor;
+    m[2][3] *= inv_divisor;
+    m[3][0] *= inv_divisor;
+    m[3][1] *= inv_divisor;
+    m[3][2] *= inv_divisor;
+    m[3][3] *= inv_divisor;
     flagBits = General;
     return *this;
 }
@@ -662,23 +664,24 @@ QMatrix4x4& QMatrix4x4::operator/=(qreal divisor)
 */
 QMatrix4x4 operator/(const QMatrix4x4& matrix, qreal divisor)
 {
+    const qreal inv_divisor = (1 / divisor);
     QMatrix4x4 m(1); // The "1" says to not load the identity.
-    m.m[0][0] = matrix.m[0][0] / divisor;
-    m.m[0][1] = matrix.m[0][1] / divisor;
-    m.m[0][2] = matrix.m[0][2] / divisor;
-    m.m[0][3] = matrix.m[0][3] / divisor;
-    m.m[1][0] = matrix.m[1][0] / divisor;
-    m.m[1][1] = matrix.m[1][1] / divisor;
-    m.m[1][2] = matrix.m[1][2] / divisor;
-    m.m[1][3] = matrix.m[1][3] / divisor;
-    m.m[2][0] = matrix.m[2][0] / divisor;
-    m.m[2][1] = matrix.m[2][1] / divisor;
-    m.m[2][2] = matrix.m[2][2] / divisor;
-    m.m[2][3] = matrix.m[2][3] / divisor;
-    m.m[3][0] = matrix.m[3][0] / divisor;
-    m.m[3][1] = matrix.m[3][1] / divisor;
-    m.m[3][2] = matrix.m[3][2] / divisor;
-    m.m[3][3] = matrix.m[3][3] / divisor;
+    m.m[0][0] = matrix.m[0][0] * inv_divisor;
+    m.m[0][1] = matrix.m[0][1] * inv_divisor;
+    m.m[0][2] = matrix.m[0][2] * inv_divisor;
+    m.m[0][3] = matrix.m[0][3] * inv_divisor;
+    m.m[1][0] = matrix.m[1][0] * inv_divisor;
+    m.m[1][1] = matrix.m[1][1] * inv_divisor;
+    m.m[1][2] = matrix.m[1][2] * inv_divisor;
+    m.m[1][3] = matrix.m[1][3] * inv_divisor;
+    m.m[2][0] = matrix.m[2][0] * inv_divisor;
+    m.m[2][1] = matrix.m[2][1] * inv_divisor;
+    m.m[2][2] = matrix.m[2][2] * inv_divisor;
+    m.m[2][3] = matrix.m[2][3] * inv_divisor;
+    m.m[3][0] = matrix.m[3][0] * inv_divisor;
+    m.m[3][1] = matrix.m[3][1] * inv_divisor;
+    m.m[3][2] = matrix.m[3][2] * inv_divisor;
+    m.m[3][3] = matrix.m[3][3] * inv_divisor;
     return m;
 }
 
@@ -1011,7 +1014,7 @@ void QMatrix4x4::rotate(qreal angle, qreal x, qreal y, qreal z)
         s = 0.0f;
         c = -1.0f;
     } else {
-        qreal a = angle * M_PI / 180.0f;
+        qreal a = angle * Q_PI180;
         c = qCos(a);
         s = qSin(a);
     }
@@ -1066,10 +1069,11 @@ void QMatrix4x4::rotate(qreal angle, qreal x, qreal y, qreal z)
     if (!quick) {
         qreal len = x * x + y * y + z * z;
         if (!qFuzzyIsNull(len - 1.0f) && !qFuzzyIsNull(len)) {
+            const qreal inv_len = 1 / len;
             len = qSqrt(len);
-            x /= len;
-            y /= len;
-            z /= len;
+            x *= inv_len;
+            y *= inv_len;
+            z *= inv_len;
         }
         ic = 1.0f - c;
         m.m[0][0] = x * x * ic + c;
@@ -1118,7 +1122,7 @@ void QMatrix4x4::projectedRotate(qreal angle, qreal x, qreal y, qreal z)
         s = 0.0f;
         c = -1.0f;
     } else {
-        qreal a = angle * M_PI / 180.0f;
+        qreal a = angle * Q_PI180;
         c = qCos(a);
         s = qSin(a);
     }
@@ -1169,10 +1173,11 @@ void QMatrix4x4::projectedRotate(qreal angle, qreal x, qreal y, qreal z)
     if (!quick) {
         qreal len = x * x + y * y + z * z;
         if (!qFuzzyIsNull(len - 1.0f) && !qFuzzyIsNull(len)) {
+            const qreal inv_len = 1 / len;
             len = qSqrt(len);
-            x /= len;
-            y /= len;
-            z /= len;
+            x *= inv_len;
+            y *= inv_len;
+            z *= inv_len;
         }
         ic = 1.0f - c;
         m.m[0][0] = x * x * ic + c;
@@ -1299,35 +1304,39 @@ void QMatrix4x4::ortho(qreal left, qreal right, qreal bottom, qreal top, qreal n
     qreal width = right - left;
     qreal invheight = top - bottom;
     qreal clip = farPlane - nearPlane;
+    qreal inv_width = 1 / width;
+    qreal inv_invheight = 1 / invheight;
+    qreal inv_clip = 1 / clip;
 #ifndef QT_NO_VECTOR3D
     if (clip == 2.0f && (nearPlane + farPlane) == 0.0f) {
         // We can express this projection as a translate and scale
         // which will be more efficient to modify with further
         // transformations than producing a "General" matrix.
+
         translate(QVector3D
-            (-(left + right) / width,
-             -(top + bottom) / invheight,
+            (-(left + right) * inv_width,
+             -(top + bottom) * inv_invheight,
              0.0f));
         scale(QVector3D
-            (2.0f / width,
-             2.0f / invheight,
+            (2.0f * inv_width,
+             2.0f * inv_invheight,
              -1.0f));
         return;
     }
 #endif
     QMatrix4x4 m(1);
-    m.m[0][0] = 2.0f / width;
+    m.m[0][0] = 2.0f * inv_width;
     m.m[1][0] = 0.0f;
     m.m[2][0] = 0.0f;
-    m.m[3][0] = -(left + right) / width;
+    m.m[3][0] = -(left + right) * inv_width;
     m.m[0][1] = 0.0f;
-    m.m[1][1] = 2.0f / invheight;
+    m.m[1][1] = 2.0f * inv_invheight;
     m.m[2][1] = 0.0f;
-    m.m[3][1] = -(top + bottom) / invheight;
+    m.m[3][1] = -(top + bottom) * inv_invheight;
     m.m[0][2] = 0.0f;
     m.m[1][2] = 0.0f;
-    m.m[2][2] = -2.0f / clip;
-    m.m[3][2] = -(nearPlane + farPlane) / clip;
+    m.m[2][2] = -2.0f * inv_clip;
+    m.m[3][2] = -(nearPlane + farPlane) * inv_clip;
     m.m[0][3] = 0.0f;
     m.m[1][3] = 0.0f;
     m.m[2][3] = 0.0f;
@@ -1354,21 +1363,24 @@ void QMatrix4x4::frustum(qreal left, qreal right, qreal bottom, qreal top, qreal
 
     // Construct the projection.
     QMatrix4x4 m(1);
-    qreal width = right - left;
-    qreal invheight = top - bottom;
-    qreal clip = farPlane - nearPlane;
-    m.m[0][0] = 2.0f * nearPlane / width;
+    const qreal width = right - left;
+    const qreal invheight = top - bottom;
+    const qreal clip = farPlane - nearPlane;
+    const qreal inv_width = 1 / width;
+    const qreal inv_invheight = 1 / invheight;
+    const qreal inv_clip = 1 / clip;
+    m.m[0][0] = 2.0f * nearPlane * inv_width;
     m.m[1][0] = 0.0f;
-    m.m[2][0] = (left + right) / width;
+    m.m[2][0] = (left + right) * inv_width;
     m.m[3][0] = 0.0f;
     m.m[0][1] = 0.0f;
-    m.m[1][1] = 2.0f * nearPlane / invheight;
-    m.m[2][1] = (top + bottom) / invheight;
+    m.m[1][1] = 2.0f * nearPlane * inv_invheight;
+    m.m[2][1] = (top + bottom) * inv_invheight;
     m.m[3][1] = 0.0f;
     m.m[0][2] = 0.0f;
     m.m[1][2] = 0.0f;
-    m.m[2][2] = -(nearPlane + farPlane) / clip;
-    m.m[3][2] = -2.0f * nearPlane * farPlane / clip;
+    m.m[2][2] = -(nearPlane + farPlane) * inv_clip;
+    m.m[3][2] = -2.0f * nearPlane * farPlane * inv_clip;
     m.m[0][3] = 0.0f;
     m.m[1][3] = 0.0f;
     m.m[2][3] = -1.0f;
@@ -1394,12 +1406,13 @@ void QMatrix4x4::perspective(qreal angle, qreal aspect, qreal nearPlane, qreal f
 
     // Construct the projection.
     QMatrix4x4 m(1);
-    qreal radians = (angle / 2.0f) * M_PI / 180.0f;
-    qreal sine = qSin(radians);
+    const qreal radians = (angle * 0.5f) * Q_PI180;
+    const qreal sine = qSin(radians);
     if (sine == 0.0f)
         return;
-    qreal cotan = qCos(radians) / sine;
-    qreal clip = farPlane - nearPlane;
+    const qreal cotan = qCos(radians) / sine;
+    const qreal clip = farPlane - nearPlane;
+    const qreal inv_clip = 1 / clip;
     m.m[0][0] = cotan / aspect;
     m.m[1][0] = 0.0f;
     m.m[2][0] = 0.0f;
@@ -1410,8 +1423,8 @@ void QMatrix4x4::perspective(qreal angle, qreal aspect, qreal nearPlane, qreal f
     m.m[3][1] = 0.0f;
     m.m[0][2] = 0.0f;
     m.m[1][2] = 0.0f;
-    m.m[2][2] = -(nearPlane + farPlane) / clip;
-    m.m[3][2] = -(2.0f * nearPlane * farPlane) / clip;
+    m.m[2][2] = -(nearPlane + farPlane) * inv_clip;
+    m.m[3][2] = -(2.0f * nearPlane * farPlane) * inv_clip;
     m.m[0][3] = 0.0f;
     m.m[1][3] = 0.0f;
     m.m[2][3] = -1.0f;
diff --git a/src/gui/math3d/qquaternion.cpp b/src/gui/math3d/qquaternion.cpp
index 626cb3c..da629e6 100644
--- a/src/gui/math3d/qquaternion.cpp
+++ b/src/gui/math3d/qquaternion.cpp
@@ -269,11 +269,12 @@ void QQuaternion::normalize()
         return;
 
     len = qSqrt(len);
+    const double inv_len = 1 / len;
 
-    xp /= len;
-    yp /= len;
-    zp /= len;
-    wp /= len;
+    xp *= inv_len;
+    yp *= inv_len;
+    zp *= inv_len;
+    wp *= inv_len;
 }
 
 /*!
@@ -357,7 +358,7 @@ QQuaternion QQuaternion::fromAxisAndAngle(const QVector3D& axis, qreal angle)
     // http://www.j3d.org/matrix_faq/matrfaq_latest.html#Q56
     // We normalize the result just in case the values are close
     // to zero, as suggested in the above FAQ.
-    qreal a = (angle / 2.0f) * M_PI / 180.0f;
+    qreal a = (angle * 0.5f) * Q_PI180;
     qreal s = qSin(a);
     qreal c = qCos(a);
     QVector3D ax = axis.normalized();
@@ -375,11 +376,12 @@ QQuaternion QQuaternion::fromAxisAndAngle
 {
     qreal length = qSqrt(x * x + y * y + z * z);
     if (!qFuzzyIsNull(length - 1.0f) && !qFuzzyIsNull(length)) {
-        x /= length;
-        y /= length;
-        z /= length;
+        const qreal inv_length = 1 / length;
+        x *= inv_length;
+        y *= inv_length;
+        z *= inv_length;
     }
-    qreal a = (angle / 2.0f) * M_PI / 180.0f;
+    qreal a = (angle * 0.5f) * Q_PI180;
     qreal s = qSin(a);
     qreal c = qCos(a);
     return QQuaternion(c, x * s, y * s, z * s).normalized();
@@ -516,12 +518,13 @@ QQuaternion QQuaternion::slerp
     // then revert to simple linear interpolation.
     qreal factor1 = 1.0f - t;
     qreal factor2 = t;
-    if ((1.0f - dot) > 0.0000001) {
+    if ((1.0f - dot) > qreal(0.0000001)) {
         qreal angle = qreal(qAcos(dot));
         qreal sinOfAngle = qreal(qSin(angle));
-        if (sinOfAngle > 0.0000001) {
-            factor1 = qreal(qSin((1.0f - t) * angle)) / sinOfAngle;
-            factor2 = qreal(qSin(t * angle)) / sinOfAngle;
+        if (sinOfAngle > qreal(0.0000001)) {
+            const qreal inv_sinOfAngle = 1 / sinOfAngle;
+            factor1 = qreal(qSin((1.0f - t) * angle)) * inv_sinOfAngle;
+            factor2 = qreal(qSin(t * angle)) * inv_sinOfAngle;
         }
     }
 
diff --git a/src/gui/math3d/qvector2d.cpp b/src/gui/math3d/qvector2d.cpp
index 2555a6f..a959979 100644
--- a/src/gui/math3d/qvector2d.cpp
+++ b/src/gui/math3d/qvector2d.cpp
@@ -216,9 +216,9 @@ void QVector2D::normalize()
         return;
 
     len = qSqrt(len);
-
-    xp /= len;
-    yp /= len;
+    const double inv_len = 1 / len;
+    xp *= inv_len;
+    yp *= inv_len;
 }
 
 /*!
diff --git a/src/gui/math3d/qvector3d.cpp b/src/gui/math3d/qvector3d.cpp
index 9552e3a..a8cc807 100644
--- a/src/gui/math3d/qvector3d.cpp
+++ b/src/gui/math3d/qvector3d.cpp
@@ -233,10 +233,10 @@ void QVector3D::normalize()
         return;
 
     len = qSqrt(len);
-
-    xp /= len;
-    yp /= len;
-    zp /= len;
+    const double inv_len = 1 / len;
+    xp *= inv_len;
+    yp *= inv_len;
+    zp *= inv_len;
 }
 
 /*!
diff --git a/src/gui/math3d/qvector4d.cpp b/src/gui/math3d/qvector4d.cpp
index 1691a6d..e4b2b82 100644
--- a/src/gui/math3d/qvector4d.cpp
+++ b/src/gui/math3d/qvector4d.cpp
@@ -285,11 +285,11 @@ void QVector4D::normalize()
         return;
 
     len = qSqrt(len);
-
-    xp /= len;
-    yp /= len;
-    zp /= len;
-    wp /= len;
+    const double inv_len = 1 / len;
+    xp *= inv_len;
+    yp *= inv_len;
+    zp *= inv_len;
+    wp *= inv_len;
 }
 
 /*!
@@ -459,7 +459,8 @@ QVector2D QVector4D::toVector2DAffine() const
 {
     if (qIsNull(wp))
         return QVector2D();
-    return QVector2D(xp / wp, yp / wp, 1);
+    const qreal inv_wp = 1 / wp;
+    return QVector2D(xp * inv_wp, yp * inv_wp, 1);
 }
 
 #endif
@@ -486,7 +487,8 @@ QVector3D QVector4D::toVector3DAffine() const
 {
     if (qIsNull(wp))
         return QVector3D();
-    return QVector3D(xp / wp, yp / wp, zp / wp, 1);
+    const qreal inv_wp = 1 / wp;
+    return QVector3D(xp * inv_wp, yp * inv_wp, zp * inv_wp, 1);
 }
 
 #endif
diff --git a/src/gui/painting/painting.pri b/src/gui/painting/painting.pri
index c35c33a..628a109 100644
--- a/src/gui/painting/painting.pri
+++ b/src/gui/painting/painting.pri
@@ -370,7 +370,6 @@ symbian {
         SOURCES += painting/qwindowsurface_s60.cpp
         armccIfdefBlock = \
         "$${LITERAL_HASH}if defined(ARMV6)" \
-        "MACRO QT_HAVE_ARMV6" \
         "SOURCEPATH 	painting" \
         "SOURCE			qblendfunctions_armv6_rvct.s" \
         "SOURCE			qdrawhelper_armv6_rvct.s" \
diff --git a/src/gui/painting/qbackingstore.cpp b/src/gui/painting/qbackingstore.cpp
index f36470a..8226797 100644
--- a/src/gui/painting/qbackingstore.cpp
+++ b/src/gui/painting/qbackingstore.cpp
@@ -529,7 +529,9 @@ void QWidgetBackingStore::markDirty(const QRegion &rgn, QWidget *widget, bool up
     Q_ASSERT(widget->window() == tlw);
     Q_ASSERT(!rgn.isEmpty());
 
+#ifndef QT_NO_GRAPHICSEFFECT
     widget->d_func()->invalidateGraphicsEffectsRecursively();
+#endif //QT_NO_GRAPHICSEFFECT
 
     if (widget->d_func()->paintOnScreen()) {
         if (widget->d_func()->dirty.isEmpty()) {
@@ -559,9 +561,11 @@ void QWidgetBackingStore::markDirty(const QRegion &rgn, QWidget *widget, bool up
 
     if (invalidateBuffer) {
         const bool eventAlreadyPosted = !dirty.isEmpty();
+#ifndef QT_NO_GRAPHICSEFFECT
         if (widget->d_func()->graphicsEffect)
             dirty += widget->d_func()->effectiveRectFor(rgn.boundingRect()).translated(offset);
         else
+#endif //QT_NO_GRAPHICSEFFECT
             dirty += rgn.translated(offset);
         if (!eventAlreadyPosted || updateImmediately)
             sendUpdateRequest(tlw, updateImmediately);
@@ -576,9 +580,11 @@ void QWidgetBackingStore::markDirty(const QRegion &rgn, QWidget *widget, bool up
 
     if (widget->d_func()->inDirtyList) {
         if (!qt_region_strictContains(widget->d_func()->dirty, widgetRect)) {
+#ifndef QT_NO_GRAPHICSEFFECT
             if (widget->d_func()->graphicsEffect)
                 widget->d_func()->dirty += widget->d_func()->effectiveRectFor(rgn.boundingRect());
             else
+#endif //QT_NO_GRAPHICSEFFECT
                 widget->d_func()->dirty += rgn;
         }
     } else {
@@ -606,7 +612,9 @@ void QWidgetBackingStore::markDirty(const QRect &rect, QWidget *widget, bool upd
     Q_ASSERT(widget->window() == tlw);
     Q_ASSERT(!rect.isEmpty());
 
+#ifndef QT_NO_GRAPHICSEFFECT
     widget->d_func()->invalidateGraphicsEffectsRecursively();
+#endif //QT_NO_GRAPHICSEFFECT
 
     if (widget->d_func()->paintOnScreen()) {
         if (widget->d_func()->dirty.isEmpty()) {
diff --git a/src/gui/painting/qbackingstore_p.h b/src/gui/painting/qbackingstore_p.h
index 3288dae..fbef980 100644
--- a/src/gui/painting/qbackingstore_p.h
+++ b/src/gui/painting/qbackingstore_p.h
@@ -146,9 +146,11 @@ private:
     {
         if (widget && !widget->d_func()->inDirtyList && !widget->data->in_destructor) {
             QWidgetPrivate *widgetPrivate = widget->d_func();
+#ifndef QT_NO_GRAPHICSEFFECT
             if (widgetPrivate->graphicsEffect)
                 widgetPrivate->dirty = widgetPrivate->effectiveRectFor(rgn.boundingRect());
             else
+#endif //QT_NO_GRAPHICSEFFECT
                 widgetPrivate->dirty = rgn;
             dirtyWidgets.append(widget);
             widgetPrivate->inDirtyList = true;
diff --git a/src/gui/painting/qbezier.cpp b/src/gui/painting/qbezier.cpp
index a6b4cef..c49086b 100644
--- a/src/gui/painting/qbezier.cpp
+++ b/src/gui/painting/qbezier.cpp
@@ -62,10 +62,10 @@ QT_BEGIN_NAMESPACE
 #endif
 
 #ifndef M_SQRT2
-#define M_SQRT2	1.41421356237309504880
+#define M_SQRT2	qreal(1.41421356237309504880)
 #endif
 
-#define log2(x) (qLn(x)/qLn(2.))
+#define log2(x) (qLn(qreal(x))/qLn(qreal(2.)))
 
 static inline qreal log4(qreal x)
 {
@@ -132,7 +132,7 @@ static inline void flattenBezierWithoutInflections(QBezier &bez,
 
         qreal d = qAbs(dx * (bez.y3 - bez.y2) - dy * (bez.x3 - bez.x2));
 
-        qreal t = qSqrt(4. / 3. * normalized * flatness / d);
+        qreal t = qSqrt(qreal(4.) / qreal(3.) * normalized * flatness / d);
         if (t > 1 || qFuzzyIsNull(t - (qreal)1.))
             break;
         bez.parameterSplitLeft(t, &left);
@@ -267,7 +267,7 @@ void QBezier::addToPolygonMixed(QPolygonF *polygon) const
                     qAbs(b->x1 - b->x3) + qAbs(b->y1 - b->y3);
                 l = 1.;
             }
-            if (d < .5*l || b == beziers + 31) {
+            if (d < qreal(.5)*l || b == beziers + 31) {
                 // good enough, we pop it off and add the endpoint
                 polygon->append(QPointF(b->x4, b->y4));
                 --b;
@@ -327,8 +327,8 @@ static ShiftResult good_offset(const QBezier *b1, const QBezier *b2, qreal offse
     const qreal o2 = offset*offset;
     const qreal max_dist_line = threshold*offset*offset;
     const qreal max_dist_normal = threshold*offset;
-    const qreal spacing = 0.25;
-    for (qreal i = spacing; i < 0.99; i += spacing) {
+    const qreal spacing = qreal(0.25);
+    for (qreal i = spacing; i < qreal(0.99); i += spacing) {
         QPointF p1 = b1->pointAt(i);
         QPointF p2 = b2->pointAt(i);
         qreal d = (p1.x() - p2.x())*(p1.x() - p2.x()) + (p1.y() - p2.y())*(p1.y() - p2.y());
@@ -337,7 +337,7 @@ static ShiftResult good_offset(const QBezier *b1, const QBezier *b2, qreal offse
 
         QPointF normalPoint = b1->normalVector(i);
         qreal l = qAbs(normalPoint.x()) + qAbs(normalPoint.y());
-        if (l != 0.) {
+        if (l != qreal(0.)) {
             d = qAbs( normalPoint.x()*(p1.y() - p2.y()) - normalPoint.y()*(p1.x() - p2.x()) ) / l;
             if (d > max_dist_normal)
                 return Split;
@@ -418,14 +418,14 @@ static ShiftResult shift(const QBezier *orig, QBezier *shifted, qreal offset, qr
     }
 
     QRectF b = orig->bounds();
-    if (np == 4 && b.width() < .1*offset && b.height() < .1*offset) {
+    if (np == 4 && b.width() < qreal(.1)*offset && b.height() < qreal(.1)*offset) {
         qreal l = (orig->x1 - orig->x2)*(orig->x1 - orig->x2) +
                   (orig->y1 - orig->y2)*(orig->y1 - orig->y1) *
                   (orig->x3 - orig->x4)*(orig->x3 - orig->x4) +
                   (orig->y3 - orig->y4)*(orig->y3 - orig->y4);
         qreal dot = (orig->x1 - orig->x2)*(orig->x3 - orig->x4) +
                     (orig->y1 - orig->y2)*(orig->y3 - orig->y4);
-        if (dot < 0 && dot*dot < 0.8*l)
+        if (dot < 0 && dot*dot < qreal(0.8)*l)
             // the points are close and reverse dirction. Approximate the whole
             // thing by a semi circle
             return Circle;
@@ -444,7 +444,7 @@ static ShiftResult shift(const QBezier *orig, QBezier *shifted, qreal offset, qr
 
         QPointF normal_sum = prev_normal + next_normal;
 
-        qreal r = 1.0 + prev_normal.x() * next_normal.x()
+        qreal r = qreal(1.0) + prev_normal.x() * next_normal.x()
                   + prev_normal.y() * next_normal.y();
 
         if (qFuzzyIsNull(r)) {
@@ -468,7 +468,7 @@ static ShiftResult shift(const QBezier *orig, QBezier *shifted, qreal offset, qr
 // This value is used to determine the length of control point vectors
 // when approximating arc segments as curves. The factor is multiplied
 // with the radius of the circle.
-#define KAPPA 0.5522847498
+#define KAPPA qreal(0.5522847498)
 
 
 static bool addCircle(const QBezier *b, qreal offset, QBezier *o)
@@ -490,32 +490,32 @@ static bool addCircle(const QBezier *b, qreal offset, QBezier *o)
     normals[1] /= -1*qSqrt(normals[1].x()*normals[1].x() + normals[1].y()*normals[1].y());
 
     qreal angles[2];
-    qreal sign = 1.;
+    qreal sign = qreal(1.);
     for (int i = 0; i < 2; ++i) {
         qreal cos_a = normals[i].x()*normals[i+1].x() + normals[i].y()*normals[i+1].y();
-        if (cos_a > 1.)
-            cos_a = 1.;
-        if (cos_a < -1.)
+        if (cos_a > qreal(1.))
+            cos_a = qreal(1.);
+        if (cos_a < qreal(-1.))
             cos_a = -1;
-        angles[i] = acos(cos_a)/Q_PI;
+        angles[i] = qAcos(cos_a)/Q_PI;
     }
 
-    if (angles[0] + angles[1] > 1.) {
+    if (angles[0] + angles[1] > qreal(1.)) {
         // more than 180 degrees
         normals[1] = -normals[1];
-        angles[0] = 1. - angles[0];
-        angles[1] = 1. - angles[1];
-        sign = -1.;
+        angles[0] = qreal(1.) - angles[0];
+        angles[1] = qreal(1.) - angles[1];
+        sign = qreal(-1.);
 
     }
 
     QPointF circle[3];
     circle[0] = QPointF(b->x1, b->y1) + normals[0]*offset;
-    circle[1] = QPointF(0.5*(b->x1 + b->x4), 0.5*(b->y1 + b->y4)) + normals[1]*offset;
+    circle[1] = QPointF(qreal(0.5)*(b->x1 + b->x4), qreal(0.5)*(b->y1 + b->y4)) + normals[1]*offset;
     circle[2] = QPointF(b->x4, b->y4) + normals[2]*offset;
 
     for (int i = 0; i < 2; ++i) {
-        qreal kappa = 2.*KAPPA * sign * offset * angles[i];
+        qreal kappa = qreal(2.)*KAPPA * sign * offset * angles[i];
 
         o->x1 = circle[i].x();
         o->y1 = circle[i].y();
@@ -695,7 +695,7 @@ static bool RecursivelyIntersect(const QBezier &a, qreal t0, qreal t1, int depth
     if (deptha > 0) {
 	QBezier A[2];
         a.split(&A[0], &A[1]);
-	qreal tmid = (t0+t1)*0.5;
+	qreal tmid = (t0+t1)*qreal(0.5);
         //qDebug()<<"\t1)"<<A[0];
         //qDebug()<<"\t2)"<<A[1];
 	deptha--;
@@ -704,7 +704,7 @@ static bool RecursivelyIntersect(const QBezier &a, qreal t0, qreal t1, int depth
             b.split(&B[0], &B[1]);
             //qDebug()<<"\t3)"<<B[0];
             //qDebug()<<"\t4)"<<B[1];
-	    qreal umid = (u0+u1)*0.5;
+	    qreal umid = (u0+u1)*qreal(0.5);
 	    depthb--;
 	    if (IntersectBB(A[0], B[0])) {
                 //fprintf(stderr, "\t 1 from %d\n", currentD);
@@ -756,7 +756,7 @@ static bool RecursivelyIntersect(const QBezier &a, qreal t0, qreal t1, int depth
 	if (depthb > 0) {
 	    QBezier B[2];
             b.split(&B[0], &B[1]);
-	    qreal umid = (u0 + u1)*0.5;
+	    qreal umid = (u0 + u1)*qreal(0.5);
 	    depthb--;
 	    if (IntersectBB(a, B[0])) {
                 //fprintf(stderr, "\t 7 from %d\n", currentD);
@@ -783,13 +783,13 @@ static bool RecursivelyIntersect(const QBezier &a, qreal t0, qreal t1, int depth
 	    qreal xmk = b.x1 - a.x1;
 	    qreal ymk = b.y1 - a.y1;
 	    qreal det = xnm * ylk - ynm * xlk;
-	    if (1.0 + det == 1.0) {
+	    if (qreal(1.0) + det == qreal(1.0)) {
 		return false;
             } else {
                 qreal detinv = 1.0 / det;
                 qreal rs = (xnm * ymk - ynm *xmk) * detinv;
                 qreal rt = (xlk * ymk - ylk * xmk) * detinv;
-                if ((rs < 0.0) || (rs > 1.0) || (rt < 0.0) || (rt > 1.0))
+                if ((rs < qreal(0.0)) || (rs > qreal(1.0)) || (rt < qreal(0.0)) || (rt > qreal(1.0)))
                     return false;
 
                 if (t) {
@@ -816,17 +816,17 @@ bool QBezier::findIntersections(const QBezier &a, const QBezier &b,
                                 QVector<QPair<qreal, qreal> > *t)
 {
     if (IntersectBB(a, b)) {
-        QPointF la1(fabs((a.x3 - a.x2) - (a.x2 - a.x1)),
-                    fabs((a.y3 - a.y2) - (a.y2 - a.y1)));
-	QPointF la2(fabs((a.x4 - a.x3) - (a.x3 - a.x2)),
-                    fabs((a.y4 - a.y3) - (a.y3 - a.y2)));
+        QPointF la1(qFabs((a.x3 - a.x2) - (a.x2 - a.x1)),
+                    qFabs((a.y3 - a.y2) - (a.y2 - a.y1)));
+	QPointF la2(qFabs((a.x4 - a.x3) - (a.x3 - a.x2)),
+                    qFabs((a.y4 - a.y3) - (a.y3 - a.y2)));
 	QPointF la;
 	if (la1.x() > la2.x()) la.setX(la1.x()); else la.setX(la2.x());
 	if (la1.y() > la2.y()) la.setY(la1.y()); else la.setY(la2.y());
-	QPointF lb1(fabs((b.x3 - b.x2) - (b.x2 - b.x1)),
-                    fabs((b.y3 - b.y2) - (b.y2 - b.y1)));
-	QPointF lb2(fabs((b.x4 - b.x3) - (b.x3 - b.x2)),
-                    fabs((b.y4 - b.y3) - (b.y3 - b.y2)));
+	QPointF lb1(qFabs((b.x3 - b.x2) - (b.x2 - b.x1)),
+                    qFabs((b.y3 - b.y2) - (b.y2 - b.y1)));
+	QPointF lb2(qFabs((b.x4 - b.x3) - (b.x3 - b.x2)),
+                    qFabs((b.y4 - b.y3) - (b.y3 - b.y2)));
 	QPointF lb;
 	if (lb1.x() > lb2.x()) lb.setX(lb1.x()); else lb.setX(lb2.x());
 	if (lb1.y() > lb2.y()) lb.setY(lb1.y()); else lb.setY(lb2.y());
@@ -836,27 +836,27 @@ bool QBezier::findIntersections(const QBezier &a, const QBezier &b,
 	else
 	    l0 = la.y();
 	int ra;
-	if (l0 * 0.75 * M_SQRT2 + 1.0 == 1.0)
+	if (l0 * qreal(0.75) * M_SQRT2 + qreal(1.0) == qreal(1.0))
 	    ra = 0;
 	else
-	    ra = qCeil(log4(M_SQRT2 * 6.0 / 8.0 * INV_EPS * l0));
+	    ra = qCeil(log4(M_SQRT2 * qreal(6.0) / qreal(8.0) * INV_EPS * l0));
 	if (lb.x() > lb.y())
 	    l0 = lb.x();
 	else
 	    l0 = lb.y();
 	int rb;
-	if (l0 * 0.75 * M_SQRT2 + 1.0 == 1.0)
+	if (l0 * qreal(0.75) * M_SQRT2 + qreal(1.0) == qreal(1.0))
 	    rb = 0;
 	else
-	    rb = qCeil(log4(M_SQRT2 * 6.0 / 8.0 * INV_EPS * l0));
+	    rb = qCeil(log4(M_SQRT2 * qreal(6.0) / qreal(8.0) * INV_EPS * l0));
 
         // if qreal is float then halve the number of subdivisions
         if (sizeof(qreal) == 4) {
-            ra /= 2;
-            rb /= 2;
+            ra *= qreal(0.5);
+            rb *= qreal(0.5);
         }
 
-	return RecursivelyIntersect(a, 0., 1., ra, b, 0., 1., rb, t);
+	return RecursivelyIntersect(a, qreal(0.), qreal(1.), ra, b, qreal(0.), qreal(1.), rb, t);
     }
 
     //Don't sort here because it breaks the orders of corresponding
@@ -934,7 +934,7 @@ QVector< QList<QBezier> > QBezier::splitAtIntersections(QBezier &b)
 
 qreal QBezier::length(qreal error) const
 {
-    qreal length = 0.0;
+    qreal length = qreal(0.0);
 
     addIfClose(&length, error);
 
@@ -945,7 +945,7 @@ void QBezier::addIfClose(qreal *length, qreal error) const
 {
     QBezier left, right;     /* bez poly splits */
 
-    qreal len = 0.0;        /* arc length */
+    qreal len = qreal(0.0);        /* arc length */
     qreal chord;            /* chord length */
 
     len = len + QLineF(QPointF(x1, y1),QPointF(x2, y2)).length();
@@ -988,7 +988,7 @@ qreal QBezier::tForY(qreal t0, qreal t1, qreal y) const
     qreal lt = t0;
     qreal dt;
     do {
-        qreal t = 0.5 * (t0 + t1);
+        qreal t = qreal(0.5) * (t0 + t1);
 
         qreal a, b, c, d;
         QBezier::coefficients(t, a, b, c, d);
@@ -1054,15 +1054,15 @@ int QBezier::stationaryYPoints(qreal &t0, qreal &t1) const
 qreal QBezier::tAtLength(qreal l) const
 {
     qreal len = length();
-    qreal t   = 1.0;
-    const qreal error = (qreal)0.01;
+    qreal t   = qreal(1.0);
+    const qreal error = qreal(0.01);
     if (l > len || qFuzzyCompare(l, len))
         return t;
 
-    t *= 0.5;
+    t *= qreal(0.5);
     //int iters = 0;
     //qDebug()<<"LEN is "<<l<<len;
-    qreal lastBigger = 1.;
+    qreal lastBigger = qreal(1.);
     while (1) {
         //qDebug()<<"\tt is "<<t;
         QBezier right = *this;
@@ -1073,10 +1073,10 @@ qreal QBezier::tAtLength(qreal l) const
             break;
 
         if (lLen < l) {
-            t += (lastBigger - t)*.5;
+            t += (lastBigger - t)*qreal(.5);
         } else {
             lastBigger = t;
-            t -= t*.5;
+            t -= t*qreal(.5);
         }
         //++iters;
     }
@@ -1120,7 +1120,7 @@ static inline void bindInflectionPoint(const QBezier &bez, const qreal t,
     qreal ey = 3 * (right.y2 - right.y3);
 
     qreal s4 = qAbs(6 * (ey * ax - ex * ay) / qSqrt(ex * ex + ey * ey)) + 0.00001f;
-    qreal tf = pow(qreal(9 * flatness / s4), qreal(1./3.));
+    qreal tf = qPow(qreal(9 * flatness / s4), qreal(1.)/qreal(3.));
     *tMinus = t - (1 - t) * tf;
     *tPlus  = t + (1 - t) * tf;
 }
diff --git a/src/gui/painting/qbezier_p.h b/src/gui/painting/qbezier_p.h
index 7dbd0c2..4cdb0c8 100644
--- a/src/gui/painting/qbezier_p.h
+++ b/src/gui/painting/qbezier_p.h
@@ -83,7 +83,7 @@ public:
     void addToPolygonIterative(QPolygonF *p) const;
     void addToPolygonMixed(QPolygonF *p) const;
     QRectF bounds() const;
-    qreal length(qreal error = 0.01) const;
+    qreal length(qreal error = qreal(0.01)) const;
     void addIfClose(qreal *length, qreal error) const;
 
     qreal tAtLength(qreal len) const;
@@ -122,13 +122,14 @@ public:
 
 inline QPointF QBezier::midPoint() const
 {
-    return QPointF((x1 + x4 + 3*(x2 + x3))/8., (y1 + y4 + 3*(y2 + y3))/8.);
+    const qreal inv_8 = 1 / qreal(8.);
+    return QPointF((x1 + x4 + 3*(x2 + x3))*inv_8, (y1 + y4 + 3*(y2 + y3))*inv_8);
 }
 
 inline QLineF QBezier::midTangent() const
 {
     QPointF mid = midPoint();
-    QLineF dir(QLineF(x1, y1, x2, y2).pointAt(0.5), QLineF(x3, y3, x4, y4).pointAt(0.5));
+    QLineF dir(QLineF(x1, y1, x2, y2).pointAt(qreal(0.5)), QLineF(x3, y3, x4, y4).pointAt(qreal(0.5)));
     return QLineF(mid.x() - dir.dx(), mid.y() - dir.dy(),
                   mid.x() + dir.dx(), mid.y() + dir.dy());
 }
@@ -155,13 +156,13 @@ inline QLineF QBezier::endTangent() const
 
 inline void QBezier::coefficients(qreal t, qreal &a, qreal &b, qreal &c, qreal &d)
 {
-    qreal m_t = 1. - t;
+    qreal m_t = qreal(1.) - t;
     b = m_t * m_t;
     c = t * t;
     d = c * t;
     a = b * m_t;
-    b *= 3. * t;
-    c *= 3. * m_t;
+    b *= qreal(3.) * t;
+    c *= qreal(3.) * m_t;
 }
 
 inline QPointF QBezier::pointAt(qreal t) const
@@ -174,7 +175,7 @@ inline QPointF QBezier::pointAt(qreal t) const
     return QPointF(a*x1 + b*x2 + c*x3 + d*x4, a*y1 + b*y2 + c*y3 + d*y4);
 #else
     // numerically more stable:
-    qreal m_t = 1. - t;
+    qreal m_t = qreal(1.) - t;
     qreal a = x1*m_t + x2*t;
     qreal b = x2*m_t + x3*t;
     qreal c = x3*m_t + x4*t;
@@ -193,7 +194,7 @@ inline QPointF QBezier::pointAt(qreal t) const
 
 inline QPointF QBezier::normalVector(qreal t) const
 {
-    qreal m_t = 1. - t;
+    qreal m_t = qreal(1.) - t;
     qreal a = m_t * m_t;
     qreal b = t * m_t;
     qreal c = t * t;
@@ -205,7 +206,7 @@ inline QPointF QBezier::derivedAt(qreal t) const
 {
     // p'(t) = 3 * (-(1-2t+t^2) * p0 + (1 - 4 * t + 3 * t^2) * p1 + (2 * t - 3 * t^2) * p2 + t^2 * p3)
 
-    qreal m_t = 1. - t;
+    qreal m_t = qreal(1.) - t;
 
     qreal d = t * t;
     qreal a = -m_t * m_t;
@@ -218,7 +219,7 @@ inline QPointF QBezier::derivedAt(qreal t) const
 
 inline QPointF QBezier::secondDerivedAt(qreal t) const
 {
-    qreal a = 2. - 2. * t;
+    qreal a = qreal(2.) - qreal(2.) * t;
     qreal b = -4 + 6 * t;
     qreal c = 2 - 6 * t;
     qreal d = 2 * t;
@@ -232,23 +233,23 @@ inline void QBezier::split(QBezier *firstHalf, QBezier *secondHalf) const
     Q_ASSERT(firstHalf);
     Q_ASSERT(secondHalf);
 
-    qreal c = (x2 + x3)*.5;
-    firstHalf->x2 = (x1 + x2)*.5;
-    secondHalf->x3 = (x3 + x4)*.5;
+    qreal c = (x2 + x3)*qreal(.5);
+    firstHalf->x2 = (x1 + x2)*qreal(.5);
+    secondHalf->x3 = (x3 + x4)*qreal(.5);
     firstHalf->x1 = x1;
     secondHalf->x4 = x4;
-    firstHalf->x3 = (firstHalf->x2 + c)*.5;
-    secondHalf->x2 = (secondHalf->x3 + c)*.5;
-    firstHalf->x4 = secondHalf->x1 = (firstHalf->x3 + secondHalf->x2)*.5;
+    firstHalf->x3 = (firstHalf->x2 + c)*qreal(.5);
+    secondHalf->x2 = (secondHalf->x3 + c)*qreal(.5);
+    firstHalf->x4 = secondHalf->x1 = (firstHalf->x3 + secondHalf->x2)*qreal(.5);
 
-    c = (y2 + y3)/2;
-    firstHalf->y2 = (y1 + y2)*.5;
-    secondHalf->y3 = (y3 + y4)*.5;
+    c = (y2 + y3)*qreal(.5);
+    firstHalf->y2 = (y1 + y2)*qreal(.5);
+    secondHalf->y3 = (y3 + y4)*qreal(.5);
     firstHalf->y1 = y1;
     secondHalf->y4 = y4;
-    firstHalf->y3 = (firstHalf->y2 + c)*.5;
-    secondHalf->y2 = (secondHalf->y3 + c)*.5;
-    firstHalf->y4 = secondHalf->y1 = (firstHalf->y3 + secondHalf->y2)*.5;
+    firstHalf->y3 = (firstHalf->y2 + c)*qreal(.5);
+    secondHalf->y2 = (secondHalf->y3 + c)*qreal(.5);
+    firstHalf->y4 = secondHalf->y1 = (firstHalf->y3 + secondHalf->y2)*qreal(.5);
 }
 
 inline void QBezier::parameterSplitLeft(qreal t, QBezier *left)
diff --git a/src/gui/painting/qblendfunctions.cpp b/src/gui/painting/qblendfunctions.cpp
index f8dd424..2d434d3 100644
--- a/src/gui/painting/qblendfunctions.cpp
+++ b/src/gui/painting/qblendfunctions.cpp
@@ -223,11 +223,23 @@ void qt_scale_image_16bit(uchar *destPixels, int dbpl,
     int h = ty2 - ty1;
     int w = tx2 - tx1;
 
-    const int dstx = qCeil((tx1 + 0.5 - qMin(targetRect.left(), targetRect.right())) * ix) - 1;
-    const int dsty = qCeil((ty1 + 0.5 - qMin(targetRect.top(), targetRect.bottom())) * iy) - 1;
+    quint32 basex;
+    quint32 srcy;
 
-    quint32 basex = quint32((sx < 0 ? srcRect.right() : srcRect.left()) * 65536) + dstx;
-    quint32 srcy = quint32((sy < 0 ? srcRect.bottom() : srcRect.top()) * 65536) + dsty;
+    if (sx < 0) {
+        int dstx = qFloor((tx1 + qreal(0.5) - targetRect.right()) * ix) + 1;
+        basex = quint32(srcRect.right() * 65536) + dstx;
+    } else {
+        int dstx = qCeil((tx1 + qreal(0.5) - targetRect.left()) * ix) - 1;
+        basex = quint32(srcRect.left() * 65536) + dstx;
+    }
+    if (sy < 0) {
+        int dsty = qFloor((ty1 + qreal(0.5) - targetRect.bottom()) * iy) + 1;
+        srcy = quint32(srcRect.bottom() * 65536) + dsty;
+    } else {
+        int dsty = qCeil((ty1 + qreal(0.5) - targetRect.top()) * iy) - 1;
+        srcy = quint32(srcRect.top() * 65536) + dsty;
+    }
 
     quint16 *dst = ((quint16 *) (destPixels + ty1 * dbpl)) + tx1;
 
@@ -723,11 +735,23 @@ template <typename T> void qt_scale_image_32bit(uchar *destPixels, int dbpl,
     int h = ty2 - ty1;
     int w = tx2 - tx1;
 
-    const int dstx = qCeil((tx1 + 0.5 - qMin(targetRect.left(), targetRect.right())) * ix) - 1;
-    const int dsty = qCeil((ty1 + 0.5 - qMin(targetRect.top(), targetRect.bottom())) * iy) - 1;
+    quint32 basex;
+    quint32 srcy;
 
-    quint32 basex = quint32((sx < 0 ? srcRect.right() : srcRect.left()) * 65536) + dstx;
-    quint32 srcy = quint32((sy < 0 ? srcRect.bottom() : srcRect.top()) * 65536) + dsty;
+    if (sx < 0) {
+        int dstx = qFloor((tx1 + qreal(0.5) - targetRect.right()) * ix) + 1;
+        basex = quint32(srcRect.right() * 65536) + dstx;
+    } else {
+        int dstx = qCeil((tx1 + qreal(0.5) - targetRect.left()) * ix) - 1;
+        basex = quint32(srcRect.left() * 65536) + dstx;
+    }
+    if (sy < 0) {
+        int dsty = qFloor((ty1 + qreal(0.5) - targetRect.bottom()) * iy) + 1;
+        srcy = quint32(srcRect.bottom() * 65536) + dsty;
+    } else {
+        int dsty = qCeil((ty1 + qreal(0.5) - targetRect.top()) * iy) - 1;
+        srcy = quint32(srcRect.top() * 65536) + dsty;
+    }
 
     quint32 *dst = ((quint32 *) (destPixels + ty1 * dbpl)) + tx1;
 
@@ -818,8 +842,8 @@ void qt_transform_image_rasterize(DestT *destPixels, int dbpl,
     qreal rightSlope = (bottomRight.x - topRight.x) / (bottomRight.y - topRight.y);
     int dx_l = int(leftSlope * 0x10000);
     int dx_r = int(rightSlope * 0x10000);
-    int x_l = int((topLeft.x + (0.5 + fromY - topLeft.y) * leftSlope + 0.5) * 0x10000);
-    int x_r = int((topRight.x + (0.5 + fromY - topRight.y) * rightSlope + 0.5) * 0x10000);
+    int x_l = int((topLeft.x + (qreal(0.5) + fromY - topLeft.y) * leftSlope + qreal(0.5)) * 0x10000);
+    int x_r = int((topRight.x + (qreal(0.5) + fromY - topRight.y) * rightSlope + qreal(0.5)) * 0x10000);
 
     int fromX, toX, x1, x2, u, v, i, ii;
     DestT *line;
@@ -996,7 +1020,7 @@ void qt_transform_image(DestT *destPixels, int dbpl,
     if (det == 0)
         return;
 
-    qreal invDet = 1.0 / det;
+    qreal invDet = qreal(1.0) / det;
     qreal m11, m12, m21, m22, mdx, mdy;
 
     m11 = (u.u * w.y - u.y * w.u) * invDet;
@@ -1010,8 +1034,8 @@ void qt_transform_image(DestT *destPixels, int dbpl,
     int dvdx = int(m21 * 0x10000);
     int dudy = int(m12 * 0x10000);
     int dvdy = int(m22 * 0x10000);
-    int u0 = qCeil((0.5 * m11 + 0.5 * m12 + mdx) * 0x10000) - 1;
-    int v0 = qCeil((0.5 * m21 + 0.5 * m22 + mdy) * 0x10000) - 1;
+    int u0 = qCeil((qreal(0.5) * m11 + qreal(0.5) * m12 + mdx) * 0x10000) - 1;
+    int v0 = qCeil((qreal(0.5) * m21 + qreal(0.5) * m22 + mdy) * 0x10000) - 1;
 
     int x1 = qFloor(sourceRect.left());
     int y1 = qFloor(sourceRect.top());
diff --git a/src/gui/painting/qbrush.cpp b/src/gui/painting/qbrush.cpp
index cbfbba6..ecbb290 100644
--- a/src/gui/painting/qbrush.cpp
+++ b/src/gui/painting/qbrush.cpp
@@ -970,7 +970,29 @@ bool QBrush::operator==(const QBrush &b) const
 QDebug operator<<(QDebug dbg, const QBrush &b)
 {
 #ifndef Q_BROKEN_DEBUG_STREAM
-    dbg.nospace() << "QBrush(" << b.color() << ',' << b.style() << ')';
+    char *BRUSH_STYLES[] = {
+     "NoBrush",
+     "SolidPattern",
+     "Dense1Pattern",
+     "Dense2Pattern",
+     "Dense3Pattern",
+     "Dense4Pattern",
+     "Dense5Pattern",
+     "Dense6Pattern",
+     "Dense7Pattern",
+     "HorPattern",
+     "VerPattern",
+     "CrossPattern",
+     "BDiagPattern",
+     "FDiagPattern",
+     "DiagCrossPattern",
+     "LinearGradientPattern",
+     "RadialGradientPattern",
+     "ConicalGradientPattern",
+     "TexturePattern"
+    };
+
+    dbg.nospace() << "QBrush(" << b.color() << ',' << BRUSH_STYLES[b.style()] << ')';
     return dbg.space();
 #else
     qWarning("This compiler doesn't support streaming QBrush to QDebug");
@@ -1752,7 +1774,7 @@ static QPointF qt_radial_gradient_adapt_focal_point(const QPointF &center,
     // We have a one pixel buffer zone to avoid numerical instability on the
     // circle border
     //### this is hacky because technically we should adjust based on current matrix
-    const qreal compensated_radius = radius - radius * 0.001;
+    const qreal compensated_radius = radius - radius * qreal(0.001);
     QLineF line(center, focalPoint);
     if (line.length() > (compensated_radius))
         line.setLength(compensated_radius);
diff --git a/src/gui/painting/qcolor.cpp b/src/gui/painting/qcolor.cpp
index 4da993b..acbad3e 100644
--- a/src/gui/painting/qcolor.cpp
+++ b/src/gui/painting/qcolor.cpp
@@ -604,12 +604,13 @@ void QColor::getHsvF(qreal *h, qreal *s, qreal *v, qreal *a) const
         return;
     }
 
-    *h = ct.ahsv.hue == USHRT_MAX ? -1.0 : ct.ahsv.hue / 36000.0;
-    *s = ct.ahsv.saturation / qreal(USHRT_MAX);
-    *v = ct.ahsv.value / qreal(USHRT_MAX);
+    const qreal inv_USHRT_MAX = 1 / qreal(USHRT_MAX);
+    *h = ct.ahsv.hue == USHRT_MAX ? qreal(-1.0) : ct.ahsv.hue / qreal(36000.0);
+    *s = ct.ahsv.saturation * inv_USHRT_MAX;
+    *v = ct.ahsv.value * inv_USHRT_MAX;
 
     if (a)
-        *a = ct.ahsv.alpha / qreal(USHRT_MAX);
+        *a = ct.ahsv.alpha * inv_USHRT_MAX;
 }
 
 /*!
@@ -715,12 +716,13 @@ void QColor::getHslF(qreal *h, qreal *s, qreal *l, qreal *a) const
         return;
     }
 
-    *h = ct.ahsl.hue == USHRT_MAX ? -1.0 : ct.ahsl.hue / 36000.0;
-    *s = ct.ahsl.saturation / qreal(USHRT_MAX);
-    *l = ct.ahsl.lightness / qreal(USHRT_MAX);
+    const qreal inv_USHRT_MAX = 1 / qreal(USHRT_MAX);
+    *h = ct.ahsl.hue == USHRT_MAX ? qreal(-1.0) : ct.ahsl.hue / qreal(36000.0);
+    *s = ct.ahsl.saturation * inv_USHRT_MAX;
+    *l = ct.ahsl.lightness * inv_USHRT_MAX;
 
     if (a)
-        *a = ct.ahsl.alpha / qreal(USHRT_MAX);
+        *a = ct.ahsl.alpha * inv_USHRT_MAX;
 }
 
 /*!
@@ -1300,7 +1302,7 @@ qreal QColor::hsvHueF() const
 {
     if (cspec != Invalid && cspec != Hsv)
         return toHsv().hueF();
-    return ct.ahsv.hue == USHRT_MAX ? -1.0 : ct.ahsv.hue / 36000.0;
+    return ct.ahsv.hue == USHRT_MAX ? qreal(-1.0) : ct.ahsv.hue / qreal(36000.0);
 }
 
 /*!
@@ -1396,7 +1398,7 @@ qreal QColor::hslHueF() const
 {
     if (cspec != Invalid && cspec != Hsl)
         return toHsl().hslHueF();
-    return ct.ahsl.hue == USHRT_MAX ? -1.0 : ct.ahsl.hue / 36000.0;
+    return ct.ahsl.hue == USHRT_MAX ? qreal(-1.0) : ct.ahsl.hue / qreal(36000.0);
 }
 
 /*!
@@ -1547,6 +1549,8 @@ QColor QColor::toRgb() const
     color.ct.argb.alpha = ct.argb.alpha;
     color.ct.argb.pad = 0;
 
+    const qreal inv_USHRT_MAX = 1 / qreal(USHRT_MAX);
+
     switch (cspec) {
     case Hsv:
         {
@@ -1557,15 +1561,15 @@ QColor QColor::toRgb() const
             }
 
             // chromatic case
-            const qreal h = ct.ahsv.hue == 36000 ? 0 : ct.ahsv.hue / 6000.;
-            const qreal s = ct.ahsv.saturation / qreal(USHRT_MAX);
-            const qreal v = ct.ahsv.value / qreal(USHRT_MAX);
+            const qreal h = ct.ahsv.hue == 36000 ? 0 : ct.ahsv.hue / qreal(6000.);
+            const qreal s = ct.ahsv.saturation * inv_USHRT_MAX;
+            const qreal v = ct.ahsv.value * inv_USHRT_MAX;
             const int i = int(h);
             const qreal f = h - i;
-            const qreal p = v * (1.0 - s);
+            const qreal p = v * (qreal(1.0) - s);
 
             if (i & 1) {
-                const qreal q = v * (1.0 - (s * f));
+                const qreal q = v * (qreal(1.0) - (s * f));
 
                 switch (i) {
                 case 1:
@@ -1585,7 +1589,7 @@ QColor QColor::toRgb() const
                     break;
                 }
             } else {
-                const qreal t = v * (1.0 - (s * (1.0 - f)));
+                const qreal t = v * (qreal(1.0) - (s * (qreal(1.0) - f)));
 
                 switch (i) {
                 case 0:
@@ -1617,9 +1621,9 @@ QColor QColor::toRgb() const
                 color.ct.argb.red = color.ct.argb.green = color.ct.argb.blue = 0;
             } else {
                 // chromatic case
-                const qreal h = ct.ahsl.hue == 36000 ? 0 : ct.ahsl.hue / 36000.;
-                const qreal s = ct.ahsl.saturation / qreal(USHRT_MAX);
-                const qreal l = ct.ahsl.lightness / qreal(USHRT_MAX);
+                const qreal h = ct.ahsl.hue == 36000 ? 0 : ct.ahsl.hue / qreal(36000.);
+                const qreal s = ct.ahsl.saturation * inv_USHRT_MAX;
+                const qreal l = ct.ahsl.lightness * inv_USHRT_MAX;
 
                 qreal temp2;
                 if (l < qreal(0.5))
@@ -1656,14 +1660,14 @@ QColor QColor::toRgb() const
         }
     case Cmyk:
         {
-            const qreal c = ct.acmyk.cyan / qreal(USHRT_MAX);
-            const qreal m = ct.acmyk.magenta / qreal(USHRT_MAX);
-            const qreal y = ct.acmyk.yellow / qreal(USHRT_MAX);
-            const qreal k = ct.acmyk.black / qreal(USHRT_MAX);
-
-            color.ct.argb.red   = qRound((1.0 - (c * (1.0 - k) + k)) * USHRT_MAX);
-            color.ct.argb.green = qRound((1.0 - (m * (1.0 - k) + k)) * USHRT_MAX);
-            color.ct.argb.blue  = qRound((1.0 - (y * (1.0 - k) + k)) * USHRT_MAX);
+            const qreal c = ct.acmyk.cyan * inv_USHRT_MAX;
+            const qreal m = ct.acmyk.magenta * inv_USHRT_MAX;
+            const qreal y = ct.acmyk.yellow * inv_USHRT_MAX;
+            const qreal k = ct.acmyk.black * inv_USHRT_MAX;
+
+            color.ct.argb.red   = qRound((qreal(1.0) - (c * (qreal(1.0) - k) + k)) * USHRT_MAX);
+            color.ct.argb.green = qRound((qreal(1.0) - (m * (qreal(1.0) - k) + k)) * USHRT_MAX);
+            color.ct.argb.blue  = qRound((qreal(1.0) - (y * (qreal(1.0) - k) + k)) * USHRT_MAX);
             break;
         }
     default:
@@ -1697,9 +1701,10 @@ QColor QColor::toHsv() const
     color.ct.ahsv.alpha = ct.argb.alpha;
     color.ct.ahsv.pad = 0;
 
-    const qreal r = ct.argb.red   / qreal(USHRT_MAX);
-    const qreal g = ct.argb.green / qreal(USHRT_MAX);
-    const qreal b = ct.argb.blue  / qreal(USHRT_MAX);
+    const qreal inv_USHRT_MAX = 1 / qreal(USHRT_MAX);
+    const qreal r = ct.argb.red   * inv_USHRT_MAX;
+    const qreal g = ct.argb.green * inv_USHRT_MAX;
+    const qreal b = ct.argb.blue  * inv_USHRT_MAX;
     const qreal max = Q_MAX_3(r, g, b);
     const qreal min = Q_MIN_3(r, g, b);
     const qreal delta = max - min;
@@ -1715,15 +1720,15 @@ QColor QColor::toHsv() const
         if (qFuzzyCompare(r, max)) {
             hue = ((g - b) /delta);
         } else if (qFuzzyCompare(g, max)) {
-            hue = (2.0 + (b - r) / delta);
+            hue = (qreal(2.0) + (b - r) / delta);
         } else if (qFuzzyCompare(b, max)) {
-            hue = (4.0 + (r - g) / delta);
+            hue = (qreal(4.0) + (r - g) / delta);
         } else {
             Q_ASSERT_X(false, "QColor::toHsv", "internal error");
         }
-        hue *= 60.0;
-        if (hue < 0.0)
-            hue += 360.0;
+        hue *= qreal(60.0);
+        if (hue < qreal(0.0))
+            hue += qreal(360.0);
         color.ct.ahsv.hue = qRound(hue * 100);
     }
 
@@ -1804,9 +1809,10 @@ QColor QColor::toCmyk() const
     color.ct.acmyk.alpha = ct.argb.alpha;
 
     // rgb -> cmy
-    const qreal r = ct.argb.red   / qreal(USHRT_MAX);
-    const qreal g = ct.argb.green / qreal(USHRT_MAX);
-    const qreal b = ct.argb.blue  / qreal(USHRT_MAX);
+    const qreal inv_USHRT_MAX = 1 / qreal(USHRT_MAX);
+    const qreal r = ct.argb.red   * inv_USHRT_MAX;
+    const qreal g = ct.argb.green * inv_USHRT_MAX;
+    const qreal b = ct.argb.blue  * inv_USHRT_MAX;
     qreal c = 1.0 - r;
     qreal m = 1.0 - g;
     qreal y = 1.0 - b;
@@ -1815,9 +1821,10 @@ QColor QColor::toCmyk() const
     const qreal k = qMin(c, qMin(m, y));
 
     if (!qFuzzyIsNull(k - 1)) {
-        c = (c - k) / (1.0 - k);
-        m = (m - k) / (1.0 - k);
-        y = (y - k) / (1.0 - k);
+        const qreal div_by_one_minus_k = 1 / (qreal(1.0) - k); 
+        c = (c - k) * div_by_one_minus_k;
+        m = (m - k) * div_by_one_minus_k;
+        y = (y - k) * div_by_one_minus_k;
     }
 
     color.ct.acmyk.cyan    = qRound(c * USHRT_MAX);
diff --git a/src/gui/painting/qdrawhelper.cpp b/src/gui/painting/qdrawhelper.cpp
index 41602a1..8d7a15d 100644
--- a/src/gui/painting/qdrawhelper.cpp
+++ b/src/gui/painting/qdrawhelper.cpp
@@ -565,8 +565,8 @@ const uint * QT_FASTCALL fetchTransformed(uint *buffer, const Operator *, const
     int image_width = data->texture.width;
     int image_height = data->texture.height;
 
-    const qreal cx = x + 0.5;
-    const qreal cy = y + 0.5;
+    const qreal cx = x + qreal(0.5);
+    const qreal cy = y + qreal(0.5);
 
     const uint *end = buffer + length;
     uint *b = buffer;
@@ -670,8 +670,8 @@ const uint * QT_FASTCALL fetchTransformedBilinear(uint *buffer, const Operator *
     int image_width = data->texture.width;
     int image_height = data->texture.height;
 
-    const qreal cx = x + 0.5;
-    const qreal cy = y + 0.5;
+    const qreal cx = x + qreal(0.5);
+    const qreal cy = y + qreal(0.5);
 
     const uint *end = buffer + length;
     uint *b = buffer;
@@ -747,8 +747,8 @@ const uint * QT_FASTCALL fetchTransformedBilinear(uint *buffer, const Operator *
 
         while (b < end) {
             const qreal iw = fw == 0 ? 1 : 1 / fw;
-            const qreal px = fx * iw - 0.5;
-            const qreal py = fy * iw - 0.5;
+            const qreal px = fx * iw - qreal(0.5);
+            const qreal py = fy * iw - qreal(0.5);
 
             int x1 = int(px) - (px < 0);
             int x2 = x1 + 1;
@@ -927,7 +927,7 @@ static const SourceFetchProc sourceFetch[NBlendTypes][QImage::NImageFormats] = {
 
 static inline uint qt_gradient_pixel(const QGradientData *data, qreal pos)
 {
-    int ipos = int(pos * (GRADIENT_STOPTABLE_SIZE - 1) + 0.5);
+    int ipos = int(pos * (GRADIENT_STOPTABLE_SIZE - 1) + qreal(0.5));
 
   // calculate the actual offset.
     if (ipos < 0 || ipos >= GRADIENT_STOPTABLE_SIZE) {
@@ -1008,8 +1008,8 @@ static const uint * QT_FASTCALL fetchLinearGradient(uint *buffer, const Operator
     if (op->linear.l == 0) {
         t = inc = 0;
     } else {
-        rx = data->m21 * (y + 0.5) + data->m11 * (x + 0.5) + data->dx;
-        ry = data->m22 * (y + 0.5) + data->m12 * (x + 0.5) + data->dy;
+        rx = data->m21 * (y + qreal(0.5)) + data->m11 * (x + qreal(0.5)) + data->dx;
+        ry = data->m22 * (y + qreal(0.5)) + data->m12 * (x + qreal(0.5)) + data->dy;
         t = op->linear.dx*rx + op->linear.dy*ry + op->linear.off;
         inc = op->linear.dx * data->m11 + op->linear.dy * data->m12;
         affine = !data->m13 && !data->m23;
@@ -1045,7 +1045,7 @@ static const uint * QT_FASTCALL fetchLinearGradient(uint *buffer, const Operator
             }
         }
     } else { // fall back to float math here as well
-        qreal rw = data->m23 * (y + 0.5) + data->m13 * (x + 0.5) + data->m33;
+        qreal rw = data->m23 * (y + qreal(0.5)) + data->m13 * (x + qreal(0.5)) + data->m33;
         while (buffer < end) {
             qreal x = rx/rw;
             qreal y = ry/rw;
@@ -1092,10 +1092,10 @@ static const uint * QT_FASTCALL fetchRadialGradient(uint *buffer, const Operator
                                                     int y, int x, int length)
 {
     const uint *b = buffer;
-    qreal rx = data->m21 * (y + 0.5)
-               + data->dx + data->m11 * (x + 0.5);
-    qreal ry = data->m22 * (y + 0.5)
-               + data->dy + data->m12 * (x + 0.5);
+    qreal rx = data->m21 * (y + qreal(0.5))
+               + data->dx + data->m11 * (x + qreal(0.5));
+    qreal ry = data->m22 * (y + qreal(0.5))
+               + data->dy + data->m12 * (x + qreal(0.5));
     bool affine = !data->m13 && !data->m23;
     //qreal r  = data->gradient.radial.radius;
 
@@ -1141,8 +1141,8 @@ static const uint * QT_FASTCALL fetchRadialGradient(uint *buffer, const Operator
             ++buffer;
         }
     } else {
-        qreal rw = data->m23 * (y + 0.5)
-                   + data->m33 + data->m13 * (x + 0.5);
+        qreal rw = data->m23 * (y + qreal(0.5))
+                   + data->m33 + data->m13 * (x + qreal(0.5));
         if (!rw)
             rw = 1;
         while (buffer < end) {
@@ -1171,10 +1171,10 @@ static const uint * QT_FASTCALL fetchConicalGradient(uint *buffer, const Operato
                                                      int y, int x, int length)
 {
     const uint *b = buffer;
-    qreal rx = data->m21 * (y + 0.5)
-               + data->dx + data->m11 * (x + 0.5);
-    qreal ry = data->m22 * (y + 0.5)
-               + data->dy + data->m12 * (x + 0.5);
+    qreal rx = data->m21 * (y + qreal(0.5))
+               + data->dx + data->m11 * (x + qreal(0.5));
+    qreal ry = data->m22 * (y + qreal(0.5))
+               + data->dy + data->m12 * (x + qreal(0.5));
     bool affine = !data->m13 && !data->m23;
 
     const uint *end = buffer + length;
@@ -1182,25 +1182,25 @@ static const uint * QT_FASTCALL fetchConicalGradient(uint *buffer, const Operato
         rx -= data->gradient.conical.center.x;
         ry -= data->gradient.conical.center.y;
         while (buffer < end) {
-            qreal angle = atan2(ry, rx) + data->gradient.conical.angle;
+            qreal angle = qAtan2(ry, rx) + data->gradient.conical.angle;
 
-            *buffer = qt_gradient_pixel(&data->gradient, 1 - angle / (2*Q_PI));
+            *buffer = qt_gradient_pixel(&data->gradient, 1 - angle / Q_2PI);
 
             rx += data->m11;
             ry += data->m12;
             ++buffer;
         }
     } else {
-        qreal rw = data->m23 * (y + 0.5)
-                   + data->m33 + data->m13 * (x + 0.5);
+        qreal rw = data->m23 * (y + qreal(0.5))
+                   + data->m33 + data->m13 * (x + qreal(0.5));
         if (!rw)
             rw = 1;
         while (buffer < end) {
-            qreal angle = atan2(ry/rw - data->gradient.conical.center.x,
+            qreal angle = qAtan2(ry/rw - data->gradient.conical.center.x,
                                 rx/rw - data->gradient.conical.center.y)
                           + data->gradient.conical.angle;
 
-            *buffer = qt_gradient_pixel(&data->gradient, 1. - angle / (2*Q_PI));
+            *buffer = qt_gradient_pixel(&data->gradient, qreal(1.) - angle / Q_2PI);
 
             rx += data->m11;
             ry += data->m12;
@@ -2386,12 +2386,12 @@ static void QT_FASTCALL comp_func_HardLight(uint *dest, const uint *src, int len
 }
 
 /*
-   if 2.Sca < Sa
-       Dca' = Dca.(Sa - (1 - Dca/Da).(2.Sca - Sa)) + Sca.(1 - Da) + Dca.(1 - Sa)
-   otherwise if 8.Dca <= Da
-       Dca' = Dca.(Sa - (1 - Dca/Da).(2.Sca - Sa).(3 - 8.Dca/Da)) + Sca.(1 - Da) + Dca.(1 - Sa)
-   otherwise
-       Dca' = (Dca.Sa + ((Dca/Da)^(0.5).Da - Dca).(2.Sca - Sa)) + Sca.(1 - Da) + Dca.(1 - Sa)
+    if 2.Sca <= Sa
+        Dca' = Dca.(Sa + (2.Sca - Sa).(1 - Dca/Da)) + Sca.(1 - Da) + Dca.(1 - Sa)
+    otherwise if 2.Sca > Sa and 4.Dca <= Da
+        Dca' = Dca.Sa + Da.(2.Sca - Sa).(4.Dca/Da.(4.Dca/Da + 1).(Dca/Da - 1) + 7.Dca/Da) + Sca.(1 - Da) + Dca.(1 - Sa)
+    otherwise if 2.Sca > Sa and 4.Dca > Da
+        Dca' = Dca.Sa + Da.(2.Sca - Sa).((Dca/Da)^0.5 - Dca/Da) + Sca.(1 - Da) + Dca.(1 - Sa)
 */
 static inline int soft_light_op(int dst, int src, int da, int sa)
 {
@@ -2400,13 +2400,11 @@ static inline int soft_light_op(int dst, int src, int da, int sa)
     const int temp = (src * (255 - da) + dst * (255 - sa)) * 255;
 
     if (src2 < sa)
-        return (dst * ((sa * 255) - (255 - dst_np) * (src2 - sa)) + temp) / 65025;
-    else if (8 * dst <= da)
-        return (dst * ((sa * 255) - ((255 - dst_np) * (src2 - sa) * ((3 * 255) - 8 * dst_np)) / 255) + temp) / 65025;
+        return (dst * (sa * 255 + (src2 - sa) * (255 - dst_np)) + temp) / 65025;
+    else if (4 * dst <= da)
+        return (dst * sa * 255 + da * (src2 - sa) * ((((16 * dst_np - 12 * 255) * dst_np + 3 * 65025) * dst_np) / 65025) + temp) / 65025;
     else {
-        // sqrt is too expensive to do three times per pixel, so skipping it for now
-        // a future possibility is to use a LUT
-        return ((dst * sa * 255) + (int(dst_np) * da - (dst * 255)) * (src2 - sa) + temp) / 65025;
+        return (dst * sa * 255 + da * (src2 - sa) * (int(sqrt(qreal(dst_np * 255))) - dst_np) + temp) / 65025;
     }
 }
 
@@ -5168,8 +5166,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_argb(int count, const
             uint *target = ((uint *)t) + spans->x;
             uint *image_bits = (uint *)data->texture.imageData;
 
-            const qreal cx = spans->x + 0.5;
-            const qreal cy = spans->y + 0.5;
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
 
             int x = int((data->m21 * cy
                          + data->m11 * cx + data->dx) * fixed_scale) - half_point;
@@ -5243,8 +5241,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_argb(int count, const
             uint *target = ((uint *)t) + spans->x;
             uint *image_bits = (uint *)data->texture.imageData;
 
-            const qreal cx = spans->x + 0.5;
-            const qreal cy = spans->y + 0.5;
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
 
             qreal x = data->m21 * cy + data->m11 * cx + data->dx;
             qreal y = data->m22 * cy + data->m12 * cx + data->dy;
@@ -5258,8 +5256,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_argb(int count, const
                 uint *b = buffer;
                 while (b < end) {
                     const qreal iw = w == 0 ? 1 : 1 / w;
-                    const qreal px = x * iw - 0.5;
-                    const qreal py = y * iw - 0.5;
+                    const qreal px = x * iw - qreal(0.5);
+                    const qreal py = y * iw - qreal(0.5);
 
                     int x1 = int(px) - (px < 0);
                     int x2 = x1 + 1;
@@ -5670,8 +5668,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_tiled_argb(int count,
             uint *target = ((uint *)t) + spans->x;
             uint *image_bits = (uint *)data->texture.imageData;
 
-            const qreal cx = spans->x + 0.5;
-            const qreal cy = spans->y + 0.5;
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
 
             int x = int((data->m21 * cy
                          + data->m11 * cx + data->dx) * fixed_scale) - half_point;
@@ -5753,8 +5751,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_tiled_argb(int count,
             uint *target = ((uint *)t) + spans->x;
             uint *image_bits = (uint *)data->texture.imageData;
 
-            const qreal cx = spans->x + 0.5;
-            const qreal cy = spans->y + 0.5;
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
 
             qreal x = data->m21 * cy + data->m11 * cx + data->dx;
             qreal y = data->m22 * cy + data->m12 * cx + data->dy;
@@ -5768,8 +5766,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_tiled_argb(int count,
                 uint *b = buffer;
                 while (b < end) {
                     const qreal iw = w == 0 ? 1 : 1 / w;
-                    const qreal px = x * iw - 0.5;
-                    const qreal py = y * iw - 0.5;
+                    const qreal px = x * iw - qreal(0.5);
+                    const qreal py = y * iw - qreal(0.5);
 
                     int x1 = int(px) - (px < 0);
                     int x2 = x1 + 1;
@@ -5861,8 +5859,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_argb(int count, const QSpan *s
             uint *target = ((uint *)t) + spans->x;
             uint *image_bits = (uint *)data->texture.imageData;
 
-            const qreal cx = spans->x + 0.5;
-            const qreal cy = spans->y + 0.5;
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
 
             int x = int((data->m21 * cy
                          + data->m11 * cx + data->dx) * fixed_scale);
@@ -5909,8 +5907,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_argb(int count, const QSpan *s
             uint *target = ((uint *)t) + spans->x;
             uint *image_bits = (uint *)data->texture.imageData;
 
-            const qreal cx = spans->x + 0.5;
-            const qreal cy = spans->y + 0.5;
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
 
             qreal x = data->m21 * cy + data->m11 * cx + data->dx;
             qreal y = data->m22 * cy + data->m12 * cx + data->dy;
@@ -6261,8 +6259,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_tiled_argb(int count, const QS
             uint *target = ((uint *)t) + spans->x;
             uint *image_bits = (uint *)data->texture.imageData;
 
-            const qreal cx = spans->x + 0.5;
-            const qreal cy = spans->y + 0.5;
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
 
             int x = int((data->m21 * cy
                          + data->m11 * cx + data->dx) * fixed_scale);
@@ -6313,8 +6311,8 @@ Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_tiled_argb(int count, const QS
             uint *target = ((uint *)t) + spans->x;
             uint *image_bits = (uint *)data->texture.imageData;
 
-            const qreal cx = spans->x + 0.5;
-            const qreal cy = spans->y + 0.5;
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
 
             qreal x = data->m21 * cy + data->m11 * cx + data->dx;
             qreal y = data->m22 * cy + data->m12 * cx + data->dy;
@@ -6998,7 +6996,7 @@ static void qt_gradient_quint32(int count, const QSpan *spans, void *userData)
          */
         const int gss = GRADIENT_STOPTABLE_SIZE - 1;
         int yinc = int((linear.dy * data->m22 * gss) * FIXPT_SIZE);
-        int off = int((((linear.dy * (data->m22 * 0.5 + data->dy) + linear.off) * gss) * FIXPT_SIZE));
+        int off = int((((linear.dy * (data->m22 * qreal(0.5) + data->dy) + linear.off) * gss) * FIXPT_SIZE));
 
         while (count--) {
             int y = spans->y;
@@ -7046,7 +7044,7 @@ static void qt_gradient_quint16(int count, const QSpan *spans, void *userData)
          */
         const int gss = GRADIENT_STOPTABLE_SIZE - 1;
         int yinc = int((linear.dy * data->m22 * gss) * FIXPT_SIZE);
-        int off = int((((linear.dy * (data->m22 * 0.5 + data->dy) + linear.off) * gss) * FIXPT_SIZE));
+        int off = int((((linear.dy * (data->m22 * qreal(0.5) + data->dy) + linear.off) * gss) * FIXPT_SIZE));
 
         uint oldColor = data->solid.color;
         while (count--) {
@@ -7125,13 +7123,13 @@ void qt_build_pow_tables() {
 #ifdef Q_WS_MAC
     // decided by testing a few things on an iMac, should probably get this from the
     // system...
-    smoothing = 2.0;
+    smoothing = qreal(2.0);
 #endif
 
 #ifdef Q_WS_WIN
     int winSmooth;
     if (SystemParametersInfo(0x200C /* SPI_GETFONTSMOOTHINGCONTRAST */, 0, &winSmooth, 0))
-        smoothing = winSmooth / 1000.0;
+        smoothing = winSmooth / qreal(1000.0);
 #endif
 
 #ifdef Q_WS_X11
@@ -7141,18 +7139,19 @@ void qt_build_pow_tables() {
         qt_pow_rgb_invgamma[i] = uchar(i);
     }
 #else
+    const qreal inv_255 = 1 / qreal(255.0);
     for (int i=0; i<256; ++i) {
-        qt_pow_rgb_gamma[i] = uchar(qRound(pow(i / qreal(255.0), smoothing) * 255));
-        qt_pow_rgb_invgamma[i] = uchar(qRound(pow(i / qreal(255.), 1 / smoothing) * 255));
+        qt_pow_rgb_gamma[i] = uchar(qRound(qPow(i * inv_255, smoothing) * 255));
+        qt_pow_rgb_invgamma[i] = uchar(qRound(qPow(i * inv_255, 1 / smoothing) * 255));
     }
 #endif
 
 #if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
-    const qreal gray_gamma = 2.31;
+    const qreal gray_gamma = qreal(2.31);
     for (int i=0; i<256; ++i)
-        qt_pow_gamma[i] = uint(qRound(pow(i / qreal(255.), gray_gamma) * 2047));
+        qt_pow_gamma[i] = uint(qRound(qPow(i / qreal(255.), gray_gamma) * 2047));
     for (int i=0; i<2048; ++i)
-        qt_pow_invgamma[i] = uchar(qRound(pow(i / 2047.0, 1 / gray_gamma) * 255));
+        qt_pow_invgamma[i] = uchar(qRound(qPow(i / qreal(2047.0), 1 / gray_gamma) * 255));
 #endif
 }
 
diff --git a/src/gui/painting/qdrawutil.cpp b/src/gui/painting/qdrawutil.cpp
index 1182b9a..be9061f 100644
--- a/src/gui/painting/qdrawutil.cpp
+++ b/src/gui/painting/qdrawutil.cpp
@@ -1180,46 +1180,48 @@ void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargin
     for (int i = 2; i < rows - 1; ++i)
         yTarget[i] = yTarget[i - 1] + dy;
 
+    const qreal inv_d_source_width = 1 / (qreal)d.source.width();
+	const qreal inv_d_source_height = 1 / (qreal)d.source.height();
     // corners
     if (targetMargins.top() > 0 && targetMargins.left() > 0 && sourceMargins.top() > 0 && sourceMargins.left() > 0) { // top left
         d.point.setX(0.5 * (xTarget[1] + xTarget[0]));
         d.point.setY(0.5 * (yTarget[1] + yTarget[0]));
         d.source = QRectF(sourceRect.left(), sourceRect.top(), sourceMargins.left(), sourceMargins.top());
-        d.scaleX = qreal(xTarget[1] - xTarget[0]) / d.source.width();
-        d.scaleY = qreal(yTarget[1] - yTarget[0]) / d.source.height();
+        d.scaleX = qreal(xTarget[1] - xTarget[0]) * inv_d_source_width;
+        d.scaleY = qreal(yTarget[1] - yTarget[0]) * inv_d_source_height;
         if (hints & QDrawBorderPixmap::OpaqueTopLeft)
             opaqueData.append(d);
         else
             translucentData.append(d);
     }
     if (targetMargins.top() > 0 && targetMargins.right() > 0 && sourceMargins.top() > 0 && sourceMargins.right() > 0) { // top right
-        d.point.setX(0.5 * (xTarget[columns] + xTarget[columns - 1]));
-        d.point.setY(0.5 * (yTarget[1] + yTarget[0]));
+        d.point.setX(qreal(0.5) * (xTarget[columns] + xTarget[columns - 1]));
+        d.point.setY(qreal(0.5) * (yTarget[1] + yTarget[0]));
         d.source = QRectF(sourceCenterRight, sourceRect.top(), sourceMargins.right(), sourceMargins.top());
-        d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) / d.source.width();
-        d.scaleY = qreal(yTarget[1] - yTarget[0]) / d.source.height();
+        d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) * inv_d_source_width;
+        d.scaleY = qreal(yTarget[1] - yTarget[0]) * inv_d_source_height;
         if (hints & QDrawBorderPixmap::OpaqueTopRight)
             opaqueData.append(d);
         else
             translucentData.append(d);
     }
     if (targetMargins.bottom() > 0 && targetMargins.left() > 0 && sourceMargins.bottom() > 0 && sourceMargins.left() > 0) { // bottom left
-        d.point.setX(0.5 * (xTarget[1] + xTarget[0]));
-        d.point.setY(0.5 * (yTarget[rows] + yTarget[rows - 1]));
+        d.point.setX(qreal(0.5) * (xTarget[1] + xTarget[0]));
+        d.point.setY(qreal(0.5) * (yTarget[rows] + yTarget[rows - 1]));
         d.source = QRectF(sourceRect.left(), sourceCenterBottom, sourceMargins.left(), sourceMargins.bottom());
-        d.scaleX = qreal(xTarget[1] - xTarget[0]) / d.source.width();
-        d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) / d.source.height();
+        d.scaleX = qreal(xTarget[1] - xTarget[0]) * inv_d_source_width;
+        d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) * inv_d_source_height;
         if (hints & QDrawBorderPixmap::OpaqueBottomLeft)
             opaqueData.append(d);
         else
             translucentData.append(d);
     }
     if (targetMargins.bottom() > 0 && targetMargins.right() > 0 && sourceMargins.bottom() > 0 && sourceMargins.right() > 0) { // bottom right
-        d.point.setX(0.5 * (xTarget[columns] + xTarget[columns - 1]));
-        d.point.setY(0.5 * (yTarget[rows] + yTarget[rows - 1]));
+        d.point.setX(qreal(0.5) * (xTarget[columns] + xTarget[columns - 1]));
+        d.point.setY(qreal(0.5) * (yTarget[rows] + yTarget[rows - 1]));
         d.source = QRectF(sourceCenterRight, sourceCenterBottom, sourceMargins.right(), sourceMargins.bottom());
-        d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) / d.source.width();
-        d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) / d.source.height();
+        d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) * inv_d_source_width;
+        d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) * inv_d_source_height;
         if (hints & QDrawBorderPixmap::OpaqueBottomRight)
             opaqueData.append(d);
         else
@@ -1231,11 +1233,11 @@ void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargin
         if (targetMargins.top() > 0 && sourceMargins.top() > 0) { // top
             QDrawPixmapsDataArray &data = hints & QDrawBorderPixmap::OpaqueTop ? opaqueData : translucentData;
             d.source = QRectF(sourceCenterLeft, sourceRect.top(), sourceCenterWidth, sourceMargins.top());
-            d.point.setY(0.5 * (yTarget[1] + yTarget[0]));
-            d.scaleX = dx / d.source.width();
-            d.scaleY = qreal(yTarget[1] - yTarget[0]) / d.source.height();
+            d.point.setY(qreal(0.5) * (yTarget[1] + yTarget[0]));
+            d.scaleX = dx * inv_d_source_width;
+            d.scaleY = qreal(yTarget[1] - yTarget[0]) * inv_d_source_height;
             for (int i = 1; i < columns - 1; ++i) {
-                d.point.setX(0.5 * (xTarget[i + 1] + xTarget[i]));
+                d.point.setX(qreal(0.5) * (xTarget[i + 1] + xTarget[i]));
                 data.append(d);
             }
             if (rules.horizontal == Qt::RepeatTile)
@@ -1244,11 +1246,11 @@ void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargin
         if (targetMargins.bottom() > 0 && sourceMargins.bottom() > 0) { // bottom
             QDrawPixmapsDataArray &data = hints & QDrawBorderPixmap::OpaqueBottom ? opaqueData : translucentData;
             d.source = QRectF(sourceCenterLeft, sourceCenterBottom, sourceCenterWidth, sourceMargins.bottom());;
-            d.point.setY(0.5 * (yTarget[rows] + yTarget[rows - 1]));
-            d.scaleX = dx / d.source.width();
-            d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) / d.source.height();
+            d.point.setY(qreal(0.5) * (yTarget[rows] + yTarget[rows - 1]));
+            d.scaleX = dx * inv_d_source_width;
+            d.scaleY = qreal(yTarget[rows] - yTarget[rows - 1]) * inv_d_source_height;
             for (int i = 1; i < columns - 1; ++i) {
-                d.point.setX(0.5 * (xTarget[i + 1] + xTarget[i]));
+                d.point.setX(qreal(0.5) * (xTarget[i + 1] + xTarget[i]));
                 data.append(d);
             }
             if (rules.horizontal == Qt::RepeatTile)
@@ -1261,11 +1263,11 @@ void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargin
         if (targetMargins.left() > 0 && sourceMargins.left() > 0) { // left
             QDrawPixmapsDataArray &data = hints & QDrawBorderPixmap::OpaqueLeft ? opaqueData : translucentData;
             d.source = QRectF(sourceRect.left(), sourceCenterTop, sourceMargins.left(), sourceCenterHeight);
-            d.point.setX(0.5 * (xTarget[1] + xTarget[0]));
-            d.scaleX = qreal(xTarget[1] - xTarget[0]) / d.source.width();
-            d.scaleY = dy / d.source.height();
+            d.point.setX(qreal(0.5) * (xTarget[1] + xTarget[0]));
+            d.scaleX = qreal(xTarget[1] - xTarget[0]) * inv_d_source_width;
+            d.scaleY = dy * inv_d_source_height;
             for (int i = 1; i < rows - 1; ++i) {
-                d.point.setY(0.5 * (yTarget[i + 1] + yTarget[i]));
+                d.point.setY(qreal(0.5) * (yTarget[i + 1] + yTarget[i]));
                 data.append(d);
             }
             if (rules.vertical == Qt::RepeatTile)
@@ -1274,11 +1276,11 @@ void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargin
         if (targetMargins.right() > 0 && sourceMargins.right() > 0) { // right
             QDrawPixmapsDataArray &data = hints & QDrawBorderPixmap::OpaqueRight ? opaqueData : translucentData;
             d.source = QRectF(sourceCenterRight, sourceCenterTop, sourceMargins.right(), sourceCenterHeight);
-            d.point.setX(0.5 * (xTarget[columns] + xTarget[columns - 1]));
-            d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) / d.source.width();
-            d.scaleY = dy / d.source.height();
+            d.point.setX(qreal(0.5) * (xTarget[columns] + xTarget[columns - 1]));
+            d.scaleX = qreal(xTarget[columns] - xTarget[columns - 1]) * inv_d_source_width;
+            d.scaleY = dy * inv_d_source_height;
             for (int i = 1; i < rows - 1; ++i) {
-                d.point.setY(0.5 * (yTarget[i + 1] + yTarget[i]));
+                d.point.setY(qreal(0.5) * (yTarget[i + 1] + yTarget[i]));
                 data.append(d);
             }
             if (rules.vertical == Qt::RepeatTile)
@@ -1290,16 +1292,16 @@ void qDrawBorderPixmap(QPainter *painter, const QRect &targetRect, const QMargin
     if (targetCenterWidth > 0 && targetCenterHeight > 0 && sourceCenterWidth > 0 && sourceCenterHeight > 0) {
         QDrawPixmapsDataArray &data = hints & QDrawBorderPixmap::OpaqueCenter ? opaqueData : translucentData;
         d.source = QRectF(sourceCenterLeft, sourceCenterTop, sourceCenterWidth, sourceCenterHeight);
-        d.scaleX = dx / d.source.width();
-        d.scaleY = dy / d.source.height();
+        d.scaleX = dx * inv_d_source_width;
+        d.scaleY = dy * inv_d_source_height;
 
         qreal repeatWidth = (xTarget[columns - 1] - xTarget[columns - 2]) / d.scaleX;
         qreal repeatHeight = (yTarget[rows - 1] - yTarget[rows - 2]) / d.scaleY;
 
         for (int j = 1; j < rows - 1; ++j) {
-            d.point.setY(0.5 * (yTarget[j + 1] + yTarget[j]));
+            d.point.setY(qreal(0.5) * (yTarget[j + 1] + yTarget[j]));
             for (int i = 1; i < columns - 1; ++i) {
-                d.point.setX(0.5 * (xTarget[i + 1] + xTarget[i]));
+                d.point.setX(qreal(0.5) * (xTarget[i + 1] + xTarget[i]));
                 data.append(d);
             }
             if (rules.horizontal == Qt::RepeatTile)
diff --git a/src/gui/painting/qmath_p.h b/src/gui/painting/qmath_p.h
index f4a3982..53ed8ab 100644
--- a/src/gui/painting/qmath_p.h
+++ b/src/gui/painting/qmath_p.h
@@ -54,13 +54,10 @@
 //
 
 #include <math.h>
+#include <private/qnumeric_p.h>
 
 QT_BEGIN_NAMESPACE
 
-static const qreal Q_PI   = qreal(3.14159265358979323846);   // pi
-static const qreal Q_2PI  = qreal(6.28318530717958647693);   // 2*pi
-static const qreal Q_PI2  = qreal(1.57079632679489661923);   // pi/2
-
 QT_END_NAMESPACE
 
 #endif // QMATH_P_H
diff --git a/src/gui/painting/qpaintbuffer.cpp b/src/gui/painting/qpaintbuffer.cpp
index 6b9d77c..fc6726e 100644
--- a/src/gui/painting/qpaintbuffer.cpp
+++ b/src/gui/painting/qpaintbuffer.cpp
@@ -48,7 +48,7 @@
 
 #include <QDebug>
 
-//#define QPAINTBUFFER_DEBUG_DRAW
+// #define QPAINTBUFFER_DEBUG_DRAW
 
 QT_BEGIN_NAMESPACE
 
@@ -247,23 +247,24 @@ void QPaintBuffer::draw(QPainter *painter, int frame) const
 #ifdef QPAINTBUFFER_DEBUG_DRAW
     qDebug() << "QPaintBuffer::draw() --------------------------------";
 
-//     printf("Float buffer:");
-//     for (int i=0; i<d->floats.size(); i++) {
-//         if ((i % 10) == 0) {
-//             printf("\n%4d-%4d: ", i, i+9);
-//         }
-//         printf("%4.2f  ", d->floats[i]);
-//     }
-//     printf("\n");
-
-//     printf("Int Buffer:");
-//     for (int i=0; i<d->ints.size(); i++) {
-//         if ((i % 10) == 0) {
-//             printf("\n%4d-%4d: ", i, i+10);
-//         }
-//         printf("%5d", d->ints[i]);
-//     }
-//     printf("\n");
+    Q_D(const QPaintBuffer);
+    printf("Float buffer:");
+    for (int i=0; i<d->floats.size(); i++) {
+        if ((i % 10) == 0) {
+            printf("\n%4d-%4d: ", i, i+9);
+        }
+        printf("%4.2f  ", d->floats[i]);
+    }
+    printf("\n");
+
+    printf("Int Buffer:");
+    for (int i=0; i<d->ints.size(); i++) {
+        if ((i % 10) == 0) {
+            printf("\n%4d-%4d: ", i, i+10);
+        }
+        printf("%5d", d->ints[i]);
+    }
+    printf("\n");
 #endif
 
     if (painter && !painter->isActive())
@@ -406,16 +407,17 @@ void QPaintBufferEngine::clipEnabledChanged()
 
 void QPaintBufferEngine::penChanged()
 {
-#ifdef QPAINTBUFFER_DEBUG_DRAW
-    qDebug() << "QPaintBufferEngine:" << state()->pen;
-#endif
     const QPen &pen = state()->pen;
 
     if (!buffer->commands.isEmpty()
         && buffer->commands.last().id == QPaintBufferPrivate::Cmd_SetPen) {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: penChanged (compressed)" << state()->pen;
+#endif
         buffer->variants[buffer->commands.last().offset] = pen;
         return;
     }
+
     if (buffer->calculateBoundingRect) {
         if (pen.style() == Qt::NoPen) {
             buffer->penWidthAdjustment = 0;
@@ -424,25 +426,31 @@ void QPaintBufferEngine::penChanged()
             QPointF transformedWidth(penWidth, penWidth);
             if (!pen.isCosmetic())
                 transformedWidth = painter()->transform().map(transformedWidth);
-            buffer->penWidthAdjustment = transformedWidth.x() / 2.0;
+            buffer->penWidthAdjustment = transformedWidth.x() * qreal(0.5);
         }
     }
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: penChanged" << state()->pen;
+#endif
     buffer->addCommand(QPaintBufferPrivate::Cmd_SetPen, pen);
 }
 
 void QPaintBufferEngine::brushChanged()
 {
-#ifdef QPAINTBUFFER_DEBUG_DRAW
-    qDebug() << "QPaintBufferEngine:" << state()->brush;
-#endif
     const QBrush &brush = state()->brush;
 
     if (!buffer->commands.isEmpty()
         && buffer->commands.last().id == QPaintBufferPrivate::Cmd_SetBrush) {
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << "QPaintBufferEngine: brushChanged (compressed)" << state()->brush;
+#endif
         buffer->variants[buffer->commands.last().offset] = brush;
         return;
     }
 
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    qDebug() << "QPaintBufferEngine: brushChanged" << state()->brush;
+#endif
     buffer->addCommand(QPaintBufferPrivate::Cmd_SetBrush, brush);
 }
 
@@ -488,14 +496,14 @@ void QPaintBufferEngine::transformChanged()
     if (!buffer->commands.isEmpty()
         && buffer->commands.last().id == QPaintBufferPrivate::Cmd_SetTransform) {
 #ifdef QPAINTBUFFER_DEBUG_DRAW
-        qDebug() << "QPaintBufferEngine: compressing " << state()->matrix;
+        qDebug() << "QPaintBufferEngine: transformChanged (compressing) " << state()->matrix;
 #endif
         buffer->variants[buffer->commands.last().offset] = state()->matrix;
         return;
     }
 
 #ifdef QPAINTBUFFER_DEBUG_DRAW
-        qDebug() << "QPaintBufferEngine: " << state()->matrix;
+        qDebug() << "QPaintBufferEngine: transformChanged:" << state()->matrix;
 #endif
     buffer->addCommand(QPaintBufferPrivate::Cmd_SetTransform, state()->matrix);
 }
@@ -514,7 +522,18 @@ void QPaintBufferEngine::draw(const QVectorPath &path)
 #ifdef QPAINTBUFFER_DEBUG_DRAW
     qDebug() << "QPaintBufferEngine: draw vpath:" << path.elementCount();
 #endif
-    buffer->addCommand(QPaintBufferPrivate::Cmd_DrawVectorPath, path);
+
+    bool hasBrush = qbrush_style(state()->brush) != Qt::NoBrush;
+    bool hasPen = qpen_style(state()->pen) != Qt::NoPen
+                  && qbrush_style(qpen_brush(state()->pen)) != Qt::NoBrush;
+
+    if (hasPen || hasBrush)
+        buffer->addCommand(QPaintBufferPrivate::Cmd_DrawVectorPath, path);
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+    else
+        qDebug() << " - no pen or brush active, discarded...\n";
+#endif
+
 //     if (buffer->calculateBoundingRect) {
 //         QRealRect r = path.controlPointRect();
 //         buffer->updateBoundingRect(QRectF(r.x1, r.y1, r.x2 - r.x1, r.y2 - r.y1));
@@ -745,15 +764,15 @@ void QPaintBufferEngine::drawEllipse(const QRect &r)
 
 void QPaintBufferEngine::drawPath(const QPainterPath &path)
 {
-#ifdef QPAINTBUFFER_DEBUG_DRAW
-    qDebug() << "QPaintBufferEngine: drawPath: element count:" << path.elementCount();
-#endif
-    // ### Path -> QVariant
-    // buffer->addCommand(QPaintBufferPrivate::Cmd_DrawPath, QVariant(path));
+// #ifdef QPAINTBUFFER_DEBUG_DRAW
+//     qDebug() << "QPaintBufferEngine: drawPath: element count:" << path.elementCount();
+// #endif
+//     // ### Path -> QVariant
+//     // buffer->addCommand(QPaintBufferPrivate::Cmd_DrawPath, QVariant(path));
     QPaintEngineEx::drawPath(path);
 
-    if (buffer->calculateBoundingRect)
-        buffer->updateBoundingRect(path.boundingRect());
+//     if (buffer->calculateBoundingRect)
+//         buffer->updateBoundingRect(path.boundingRect());
 }
 
 void QPaintBufferEngine::drawPoints(const QPoint *points, int pointCount)
@@ -1424,10 +1443,6 @@ void QPainterReplayer::process(const QPaintBufferCommand &cmd)
         QTextItemInt &ti = (*tiCopy)();
         QString text(ti.text());
 
-#ifdef QPAINTBUFFER_DEBUG_DRAW
-        qDebug() << " -> Cmd_DrawTextItem:" << pos << " " << text << " " << scaleFactor;
-#endif
-
         QFont font(ti.font());
         font.setUnderline(false);
         font.setStrikeOut(false);
@@ -1439,6 +1454,10 @@ void QPainterReplayer::process(const QPaintBufferCommand &cmd)
             justificationWidth = si.width.toReal();
         qreal scaleFactor = font.d->dpi/qreal(qt_defaultDpiY());
 
+#ifdef QPAINTBUFFER_DEBUG_DRAW
+        qDebug() << " -> Cmd_DrawTextItem:" << pos << " " << text << " " << scaleFactor;
+#endif
+
         if (scaleFactor != 1.0) {
             QFont fnt(font);
             QFakeDevice fake;
diff --git a/src/gui/painting/qpaintbuffer_p.h b/src/gui/painting/qpaintbuffer_p.h
index 6a7ac73..adf0564 100644
--- a/src/gui/painting/qpaintbuffer_p.h
+++ b/src/gui/painting/qpaintbuffer_p.h
@@ -66,6 +66,7 @@ class QPaintBufferPlayback;
 
 class Q_GUI_EXPORT QPaintBuffer : public QPaintDevice
 {
+    Q_DECLARE_PRIVATE(QPaintBuffer);
 public:
     QPaintBuffer();
     QPaintBuffer(const QPaintBuffer &other);
@@ -311,7 +312,7 @@ public:
     virtual ~QPainterReplayer() { }
 
     void setupTransform(QPainter *painter);
-    void process(const QPaintBufferCommand &cmd);
+    virtual void process(const QPaintBufferCommand &cmd);
     void draw(const QPaintBuffer &buffer, QPainter *painter, int frame);
 
 protected:
@@ -326,7 +327,7 @@ class Q_GUI_EXPORT QPaintEngineExReplayer : public QPainterReplayer
 public:
     QPaintEngineExReplayer() { }
 
-    void process(const QPaintBufferCommand &cmd);
+    virtual void process(const QPaintBufferCommand &cmd);
 };
 
 class QPaintBufferEnginePrivate;
diff --git a/src/gui/painting/qpaintengine_raster.cpp b/src/gui/painting/qpaintengine_raster.cpp
index 8d0b961..e3c4fe5 100644
--- a/src/gui/painting/qpaintengine_raster.cpp
+++ b/src/gui/painting/qpaintengine_raster.cpp
@@ -126,7 +126,7 @@ void dumpClip(int width, int height, const QClipData *clip);
 #define int_dim(pos, dim) (int(pos+dim) - int(pos))
 
 // use the same rounding as in qrasterizer.cpp (6 bit fixed point)
-static const qreal aliasedCoordinateDelta = 0.5 - 0.015625;
+static const qreal aliasedCoordinateDelta = qreal(0.5) - qreal(0.015625);
 
 #ifdef Q_WS_WIN
 extern bool qt_cleartype_enabled;
@@ -1743,8 +1743,8 @@ void QRasterPaintEngine::stroke(const QVectorPath &path, const QPen &pen)
             if (lines[i].p1() == lines[i].p2()) {
                 if (s->lastPen.capStyle() != Qt::FlatCap) {
                     QPointF p = lines[i].p1();
-                    QLineF line = s->matrix.map(QLineF(QPointF(p.x() - width*0.5, p.y()),
-                                                       QPointF(p.x() + width*0.5, p.y())));
+                    QLineF line = s->matrix.map(QLineF(QPointF(p.x() - width*qreal(0.5), p.y()),
+                                                       QPointF(p.x() + width*qreal(0.5), p.y())));
                     d->rasterizer->rasterizeLine(line.p1(), line.p2(), 1);
                 }
                 continue;
@@ -1958,8 +1958,9 @@ static bool splitPolygon(const QPointF *points, int pointCount, QVector<QPointF>
     QVector<const QPointF *> sorted;
     sorted.reserve(pointCount);
 
-    upper->reserve(pointCount * 3 / 4);
-    lower->reserve(pointCount * 3 / 4);
+    const qreal three_quarters = qreal(3) / qreal(4);
+    upper->reserve(pointCount * three_quarters);
+    lower->reserve(pointCount * three_quarters);
 
     for (int i = 0; i < pointCount; ++i)
         sorted << points + i;
@@ -2336,13 +2337,13 @@ void QRasterPaintEngine::strokePolygonCosmetic(const QPoint *points, int pointCo
 
         int x1 = points[pointCount-1].x() * m11 + dx;
         int y1 = points[pointCount-1].y() * m22 + dy;
-        qreal w = m13*points[pointCount-1].x() + m23*points[pointCount-1].y() + 1.;
+        qreal w = m13*points[pointCount-1].x() + m23*points[pointCount-1].y() + qreal(1.);
         w = 1/w;
         x1 = int(x1*w);
         y1 = int(y1*w);
         int x2 = points[0].x() * m11 + dx;
         int y2 = points[0].y() * m22 + dy;
-        w = m13*points[0].x() + m23*points[0].y() + 1.;
+        w = m13*points[0].x() + m23*points[0].y() + qreal(1.);
         w = 1/w;
         x2 = int(x2 * w);
         y2 = int(y2 * w);
@@ -4867,7 +4868,7 @@ void QGradientCache::generateGradientColorTable(const QGradient& gradient, uint
     uint next_color;
 
     qreal incr = 1 / qreal(size); // the double increment.
-    qreal dpos = 1.5 * incr; // current position in gradient stop list (0 to 1)
+    qreal dpos = qreal(1.5) * incr; // current position in gradient stop list (0 to 1)
 
      // Up to first point
     colorTable[pos++] = PREMUL(current_color);
@@ -5041,7 +5042,7 @@ void QSpanData::setup(const QBrush &brush, int alpha, QPainter::CompositionMode
             QPointF center = g->center();
             conicalData.center.x = center.x();
             conicalData.center.y = center.y();
-            conicalData.angle = g->angle() * 2 * Q_PI / 360.0;
+            conicalData.angle = g->angle() * Q_2PI / qreal(360.0);
         }
         break;
 
@@ -5140,7 +5141,8 @@ void QSpanData::setupMatrix(const QTransform &matrix, int bilin)
 {
     QTransform delta;
     // make sure we round off correctly in qdrawhelper.cpp
-    delta.translate(1.0 / 65536, 1.0 / 65536);
+    const qreal inv_65536 = qreal(1.0) / 65536;
+    delta.translate(inv_65536, inv_65536);
 
     QTransform inv = (delta * matrix).inverted();
     m11 = inv.m11();
@@ -6049,9 +6051,9 @@ static void drawEllipse_midpoint_i(const QRect &rect, const QRect &clip,
     const QFixed b = QFixed(rect.height()) >> 1;
     QFixed d = b*b - (a*a*b) + ((a*a) >> 2);
 #else
-    const qreal a = qreal(rect.width()) / 2;
-    const qreal b = qreal(rect.height()) / 2;
-    qreal d = b*b - (a*a*b) + 0.25*a*a;
+    const qreal a = qreal(rect.width()) * qreal(0.5);
+    const qreal b = qreal(rect.height()) * qreal(0.5);
+    qreal d = b*b - (a*a*b) + qreal(0.25)*a*a;
 #endif
 
     int x = 0;
@@ -6079,7 +6081,7 @@ static void drawEllipse_midpoint_i(const QRect &rect, const QRect &clip,
     d = b*b*(x + (QFixed(1) >> 1))*(x + (QFixed(1) >> 1))
         + a*a*((y - 1)*(y - 1) - b*b);
 #else
-    d = b*b*(x + 0.5)*(x + 0.5) + a*a*((y - 1)*(y - 1) - b*b);
+    d = b*b*(x + qreal(0.5))*(x + qreal(0.5)) + a*a*(qreal(y - 1)*qreal(y - 1) - b*b);
 #endif
     const int miny = rect.height() & 0x1;
     while (y > miny) {
@@ -6150,4 +6152,4 @@ void dumpClip(int width, int height, const QClipData *clip)
 #endif
 
 
-QT_END_NAMESPACE
+QT_END_NAMESPACE
\ No newline at end of file
diff --git a/src/gui/painting/qpaintengineex.cpp b/src/gui/painting/qpaintengineex.cpp
index 9e21182..62b16ab 100644
--- a/src/gui/painting/qpaintengineex.cpp
+++ b/src/gui/painting/qpaintengineex.cpp
@@ -431,6 +431,10 @@ void QPaintEngineEx::stroke(const QVectorPath &path, const QPen &pen)
 
     // Some engines might decide to optimize for the non-shape hint later on...
     uint flags = QVectorPath::WindingFill;
+
+    if (path.elementCount() > 2)
+        flags |= QVectorPath::NonConvexShapeMask;
+
     if (d->stroker.capStyle() == Qt::RoundCap || d->stroker.joinStyle() == Qt::RoundJoin)
         flags |= QVectorPath::CurvedShapeMask;
 
@@ -727,8 +731,9 @@ void QPaintEngineEx::drawRoundedRect(const QRectF &rect, qreal xRadius, qreal yR
     qreal y2 = rect.bottom();
 
     if (mode == Qt::RelativeSize) {
-        xRadius = xRadius * rect.width() / 200.;
-        yRadius = yRadius * rect.height() / 200.;
+        const qreal inv_200 = 1 / qreal(200.);
+        xRadius = xRadius * rect.width() * inv_200;
+        yRadius = yRadius * rect.height() * inv_200;
     }
 
     xRadius = qMin(xRadius, rect.width() / 2);
@@ -842,7 +847,7 @@ void QPaintEngineEx::drawPoints(const QPointF *points, int pointCount)
             for (int i=0; i<count; ++i) {
                 pts[++oset] = points[i].x();
                 pts[++oset] = points[i].y();
-                pts[++oset] = points[i].x() + 0.001;
+                pts[++oset] = points[i].x() + qreal(0.001);
                 pts[++oset] = points[i].y();
             }
             QVectorPath path(pts, count * 2, qpaintengineex_line_types_16, QVectorPath::LinesHint);
@@ -852,7 +857,7 @@ void QPaintEngineEx::drawPoints(const QPointF *points, int pointCount)
         }
     } else {
         for (int i=0; i<pointCount; ++i) {
-            qreal pts[] = { points[i].x(), points[i].y(), points[i].x() + 0.001, points[i].y() };
+            qreal pts[] = { points[i].x(), points[i].y(), points[i].x() + qreal(0.001), points[i].y() };
             QVectorPath path(pts, 2, 0);
             stroke(path, pen);
         }
@@ -873,7 +878,7 @@ void QPaintEngineEx::drawPoints(const QPoint *points, int pointCount)
             for (int i=0; i<count; ++i) {
                 pts[++oset] = points[i].x();
                 pts[++oset] = points[i].y();
-                pts[++oset] = points[i].x() + 0.001;
+                pts[++oset] = points[i].x() + qreal(0.001);
                 pts[++oset] = points[i].y();
             }
             QVectorPath path(pts, count * 2, qpaintengineex_line_types_16, QVectorPath::LinesHint);
@@ -883,7 +888,7 @@ void QPaintEngineEx::drawPoints(const QPoint *points, int pointCount)
         }
     } else {
         for (int i=0; i<pointCount; ++i) {
-            qreal pts[] = { points[i].x(), points[i].y(), points[i].x() + 0.001, points[i].y() };
+            qreal pts[] = { points[i].x(), points[i].y(), points[i].x() + qreal(0.001), points[i].y() };
             QVectorPath path(pts, 2, 0);
             stroke(path, pen);
         }
diff --git a/src/gui/painting/qpainter.cpp b/src/gui/painting/qpainter.cpp
index 09a4563..da5b7ac 100644
--- a/src/gui/painting/qpainter.cpp
+++ b/src/gui/painting/qpainter.cpp
@@ -383,8 +383,8 @@ void QPainterPrivate::draw_helper(const QPainterPath &originalPath, DrawOperatio
                 QPainterPath stroke = stroker.createStroke(originalPath);
                 strokeBounds = (stroke * state->matrix).boundingRect();
             } else {
-                strokeOffsetX = qAbs(penWidth * state->matrix.m11() / 2.0);
-                strokeOffsetY = qAbs(penWidth * state->matrix.m22() / 2.0);
+                strokeOffsetX = qAbs(penWidth * state->matrix.m11() * qreal(0.5));
+                strokeOffsetY = qAbs(penWidth * state->matrix.m22() * qreal(0.5));
             }
         }
     }
@@ -467,7 +467,7 @@ void QPainterPrivate::draw_helper(const QPainterPath &originalPath, DrawOperatio
         pt.end();
         p.resetTransform();
         p.setCompositionMode(QPainter::CompositionMode_SourceAtop);
-        p.setOpacity(0.5);
+        p.setOpacity(qreal(0.5));
         p.fillRect(0, 0, image.width(), image.height(), QBrush(block));
     }
 #endif
@@ -3565,7 +3565,7 @@ void QPainter::drawPoints(const QPointF *points, int pointCount)
         QPainterPath path;
         for (int i=0; i<pointCount; ++i) {
             path.moveTo(points[i].x(), points[i].y());
-            path.lineTo(points[i].x() + 0.0001, points[i].y());
+            path.lineTo(points[i].x() + qreal(0.0001), points[i].y());
         }
         d->draw_helper(path, QPainterPrivate::StrokeDraw);
         if (flat_pen)
@@ -3627,7 +3627,7 @@ void QPainter::drawPoints(const QPoint *points, int pointCount)
         QPainterPath path;
         for (int i=0; i<pointCount; ++i) {
             path.moveTo(points[i].x(), points[i].y());
-            path.lineTo(points[i].x() + 0.0001, points[i].y());
+            path.lineTo(points[i].x() + qreal(0.0001), points[i].y());
         }
         d->draw_helper(path, QPainterPrivate::StrokeDraw);
         if (flat_pen)
@@ -3787,27 +3787,14 @@ void QPainter::setPen(const QPen &pen)
     if (d->state->pen == pen)
         return;
 
+    d->state->pen = pen;
+
     if (d->extended) {
-        d->state->pen = pen;
         d->checkEmulation();
         d->extended->penChanged();
         return;
     }
 
-    // Do some checks to see if we are the same pen.
-    Qt::PenStyle currentStyle = d->state->pen.style();
-    if (currentStyle == pen.style() && currentStyle != Qt::CustomDashLine) {
-        if (currentStyle == Qt::NoPen ||
-            (d->state->pen.isSolid() && pen.isSolid()
-             && d->state->pen.color() == pen.color()
-             && d->state->pen.widthF() == pen.widthF()
-             && d->state->pen.capStyle() == pen.capStyle()
-             && d->state->pen.joinStyle() == pen.joinStyle()
-             && d->state->pen.isCosmetic() == pen.isCosmetic()))
-            return;
-    }
-
-    d->state->pen = pen;
     d->state->dirtyFlags |= QPaintEngine::DirtyPen;
 }
 
@@ -3890,14 +3877,6 @@ void QPainter::setBrush(const QBrush &brush)
         return;
     }
 
-    Qt::BrushStyle currentStyle = d->state->brush.style();
-    if (currentStyle == brush.style()) {
-        if (currentStyle == Qt::NoBrush
-            || (currentStyle == Qt::SolidPattern
-                && d->state->brush.color() == brush.color()))
-            return;
-    }
-
     d->state->brush = brush;
     d->state->dirtyFlags |= QPaintEngine::DirtyBrush;
 }
@@ -4291,8 +4270,9 @@ void QPainter::drawArc(const QRectF &r, int a, int alen)
     QRectF rect = r.normalized();
 
     QPainterPath path;
-    path.arcMoveTo(rect, a/16.0);
-    path.arcTo(rect, a/16.0, alen/16.0);
+    const qreal inv_16 = 1 / qreal(16.0);
+    path.arcMoveTo(rect, a * inv_16);
+    path.arcTo(rect, a * inv_16, alen * inv_16);
     strokePath(path, d->state->pen);
 }
 
@@ -4361,8 +4341,9 @@ void QPainter::drawPie(const QRectF &r, int a, int alen)
     QRectF rect = r.normalized();
 
     QPainterPath path;
+    const qreal inv_16 = 1 / qreal(16.0);
     path.moveTo(rect.center());
-    path.arcTo(rect.x(), rect.y(), rect.width(), rect.height(), a/16.0, alen/16.0);
+    path.arcTo(rect.x(), rect.y(), rect.width(), rect.height(), a * inv_16, alen * inv_16);
     path.closeSubpath();
     drawPath(path);
 
@@ -4423,8 +4404,9 @@ void QPainter::drawChord(const QRectF &r, int a, int alen)
     QRectF rect = r.normalized();
 
     QPainterPath path;
-    path.arcMoveTo(rect, a/16.0);
-    path.arcTo(rect, a/16.0, alen/16.0);
+    const qreal inv_16 = 1 / qreal(16.0);
+    path.arcMoveTo(rect, a * inv_16);
+    path.arcTo(rect, a * inv_16, alen * inv_16);
     path.closeSubpath();
     drawPath(path);
 }
@@ -5926,7 +5908,7 @@ static QPainterPath generateWavyPath(qreal minWidth, qreal maxRadius, QPaintDevi
     QPainterPath path;
 
     bool up = true;
-    const qreal radius = qMax(qreal(.5), qMin(qreal(1.25 * device->logicalDpiY() / qt_defaultDpi()), maxRadius));
+    const qreal radius = qMax(qreal(.5), qMin(qreal(1.25) * device->logicalDpiY() / qt_defaultDpi(), maxRadius));
     qreal xs, ys;
     int i = 0;
     path.moveTo(0, radius);
@@ -6006,7 +5988,7 @@ static void drawTextItemDecoration(QPainter *painter, const QPointF &pos, const
 
     if (ti.flags & QTextItem::StrikeOut) {
         QLineF strikeOutLine = line;
-        strikeOutLine.translate(0., - fe->ascent().toReal() / 3.);
+        strikeOutLine.translate(qreal(0.), - fe->ascent().toReal() / qreal(3.));
         painter->setPen(pen);
         painter->drawLine(strikeOutLine);
     }
diff --git a/src/gui/painting/qpainterpath.cpp b/src/gui/painting/qpainterpath.cpp
index 8133793..0f31cca 100644
--- a/src/gui/painting/qpainterpath.cpp
+++ b/src/gui/painting/qpainterpath.cpp
@@ -799,8 +799,9 @@ void QPainterPath::quadTo(const QPointF &c, const QPointF &e)
     if (prev == c && c == e)
         return;
 
-    QPointF c1((prev.x() + 2*c.x()) / 3, (prev.y() + 2*c.y()) / 3);
-    QPointF c2((e.x() + 2*c.x()) / 3, (e.y() + 2*c.y()) / 3);
+    const qreal inv_3 = 1 / qreal(3);
+    QPointF c1((prev.x() + 2*c.x()) * inv_3, (prev.y() + 2*c.y()) * inv_3);
+    QPointF c2((e.x() + 2*c.x()) * inv_3, (e.y() + 2*c.y()) * inv_3);
     cubicTo(c1, c2, e);
 }
 
@@ -1804,22 +1805,24 @@ static bool qt_painterpath_isect_line_rect(qreal x1, qreal y1, qreal x2, qreal y
         return false;
 
     if (p1 | p2) {
-        qreal dx = x2 - x1;
-        qreal dy = y2 - y1;
+        const qreal dx = x2 - x1;
+        const qreal dy = y2 - y1;
+        const qreal dx_dy_ratio = dx / dy;
+        const qreal dy_dx_ratio = dy / dx;
 
         // clip x coordinates
         if (x1 < left) {
-            y1 += dy/dx * (left - x1);
+            y1 += dy_dx_ratio * (left - x1);
             x1 = left;
         } else if (x1 > right) {
-            y1 -= dy/dx * (x1 - right);
+            y1 -= dy_dx_ratio * (x1 - right);
             x1 = right;
         }
         if (x2 < left) {
-            y2 += dy/dx * (left - x2);
+            y2 += dy_dx_ratio * (left - x2);
             x2 = left;
         } else if (x2 > right) {
-            y2 -= dy/dx * (x2 - right);
+            y2 -= dy_dx_ratio * (x2 - right);
             x2 = right;
         }
 
@@ -1833,17 +1836,17 @@ static bool qt_painterpath_isect_line_rect(qreal x1, qreal y1, qreal x2, qreal y
 
         // clip y coordinates
         if (y1 < top) {
-            x1 += dx/dy * (top - y1);
+            x1 += dx_dy_ratio * (top - y1);
             y1 = top;
         } else if (y1 > bottom) {
-            x1 -= dx/dy * (y1 - bottom);
+            x1 -= dx_dy_ratio * (y1 - bottom);
             y1 = bottom;
         }
         if (y2 < top) {
-            x2 += dx/dy * (top - y2);
+            x2 += dx_dy_ratio * (top - y2);
             y2 = top;
         } else if (y2 > bottom) {
-            x2 -= dx/dy * (y2 - bottom);
+            x2 -= dx_dy_ratio * (y2 - bottom);
             y2 = bottom;
         }
 
diff --git a/src/gui/painting/qpainterpath_p.h b/src/gui/painting/qpainterpath_p.h
index 54b9392..a2bc905 100644
--- a/src/gui/painting/qpainterpath_p.h
+++ b/src/gui/painting/qpainterpath_p.h
@@ -258,7 +258,7 @@ inline void QPainterPathData::maybeMoveTo()
     }
 }
 
-#define KAPPA 0.5522847498
+#define KAPPA qreal(0.5522847498)
 
 
 QT_END_NAMESPACE
diff --git a/src/gui/painting/qpathclipper.cpp b/src/gui/painting/qpathclipper.cpp
index ab2dc33..1568ad8 100644
--- a/src/gui/painting/qpathclipper.cpp
+++ b/src/gui/painting/qpathclipper.cpp
@@ -321,11 +321,11 @@ void QIntersectionFinder::intersectLines(const QLineF &a, const QLineF &b, QData
     if (p1_equals_q1 || p1_equals_q2 || p2_equals_q1 || p2_equals_q2)
         return;
 
-
+    const qreal inv_par = 1 / qreal(par);
     const qreal tp = (qDelta.y() * (q1.x() - p1.x()) -
-                      qDelta.x() * (q1.y() - p1.y())) / par;
+                      qDelta.x() * (q1.y() - p1.y())) * inv_par;
     const qreal tq = (pDelta.y() * (q1.x() - p1.x()) -
-                      pDelta.x() * (q1.y() - p1.y())) / par;
+                      pDelta.x() * (q1.y() - p1.y())) * inv_par;
 
     if (tp<0 || tp>1 || tq<0 || tq>1)
         return;
@@ -1192,24 +1192,24 @@ static qreal computeAngle(const QPointF &v)
 {
 #if 1
     if (v.x() == 0) {
-        return v.y() <= 0 ? 0 : 64.;
+        return v.y() <= 0 ? 0 : qreal(64.);
     } else if (v.y() == 0) {
-        return v.x() <= 0 ? 32. : 96.;
+        return v.x() <= 0 ? qreal(32.) : qreal(96.);
     }
 
     QPointF nv = normalize(v);
     if (nv.y() < 0) {
         if (nv.x() < 0) { // 0 - 32
-            return -32. * nv.x();
+            return qreal(-32.) * nv.x();
         } else { // 96 - 128
-            return 128. - 32. * nv.x();
+            return qreal(128.) - qreal(32.) * nv.x();
         }
     } else { // 32 - 96
-        return 64. + 32 * nv.x();
+        return qreal(64.) + 32 * nv.x();
     }
 #else
     // doesn't seem to be robust enough
-    return atan2(v.x(), v.y()) + Q_PI;
+    return qAtan2(v.x(), v.y()) + Q_PI;
 #endif
 }
 
diff --git a/src/gui/painting/qpen.cpp b/src/gui/painting/qpen.cpp
index 41efc80..77aa748 100644
--- a/src/gui/painting/qpen.cpp
+++ b/src/gui/painting/qpen.cpp
@@ -835,16 +835,17 @@ bool QPen::operator==(const QPen &p) const
 {
     QPenData *dd = static_cast<QPenData *>(d);
     QPenData *pdd = static_cast<QPenData *>(p.d);
-    return (p.d == d) || (p.d->style == d->style
-                          && p.d->capStyle == d->capStyle
-                          && p.d->joinStyle == d->joinStyle
-                          && p.d->width == d->width
-                          && pdd->miterLimit == dd->miterLimit
-                          && (d->style != Qt::CustomDashLine
-                              || (qFuzzyCompare(pdd->dashOffset, dd->dashOffset) &&
-                                  pdd->dashPattern == dd->dashPattern))
-                          && p.d->brush == d->brush
-                          && pdd->cosmetic == dd->cosmetic);
+    return (p.d == d)
+        || (p.d->style == d->style
+            && p.d->capStyle == d->capStyle
+            && p.d->joinStyle == d->joinStyle
+            && p.d->width == d->width
+            && pdd->miterLimit == dd->miterLimit
+            && (d->style != Qt::CustomDashLine
+                || (qFuzzyCompare(pdd->dashOffset, dd->dashOffset) &&
+                    pdd->dashPattern == dd->dashPattern))
+            && p.d->brush == d->brush
+            && pdd->cosmetic == dd->cosmetic);
 }
 
 
@@ -983,8 +984,18 @@ QDataStream &operator>>(QDataStream &s, QPen &p)
 QDebug operator<<(QDebug dbg, const QPen &p)
 {
 #ifndef Q_BROKEN_DEBUG_STREAM
+    const char *PEN_STYLES[] = {
+        "NoPen",
+        "SolidLine",
+        "DashLine",
+        "DotLine",
+        "DashDotLine",
+        "DashDotDotLine",
+        "CustomDashLine"
+    };
+
     dbg.nospace() << "QPen(" << p.width() << ',' << p.brush()
-                  << ',' << int(p.style()) << ',' << int(p.capStyle())
+                  << ',' << PEN_STYLES[p.style()] << ',' << int(p.capStyle())
                   << ',' << int(p.joinStyle()) << ',' << p.dashPattern()
                   << ',' << p.dashOffset()
                   << ',' << p.miterLimit() << ')';
diff --git a/src/gui/painting/qrasterizer.cpp b/src/gui/painting/qrasterizer.cpp
index b602690..ba5eda6 100644
--- a/src/gui/painting/qrasterizer.cpp
+++ b/src/gui/painting/qrasterizer.cpp
@@ -44,6 +44,7 @@
 #include <QPoint>
 #include <QRect>
 
+#include <qmath.h>
 #include <private/qmath_p.h>
 #include <private/qdatabuffer_p.h>
 #include <private/qdrawhelper_p.h>
@@ -51,8 +52,8 @@
 QT_BEGIN_NAMESPACE
 
 typedef int Q16Dot16;
-#define Q16Dot16ToFloat(i) ((i)/65536.)
-#define FloatToQ16Dot16(i) (int)((i) * 65536.)
+#define Q16Dot16ToFloat(i) ((i)/qreal(65536.))
+#define FloatToQ16Dot16(i) (int)((i) * qreal(65536.))
 #define IntToQ16Dot16(i) ((i) << 16)
 #define Q16Dot16ToInt(i) ((i) >> 16)
 #define Q16Dot16Factor 65536
@@ -707,12 +708,12 @@ void QRasterizer::rasterizeLine(const QPointF &a, const QPointF &b, qreal width,
     if (a == b || width == 0 || d->clipRect.isEmpty())
         return;
 
-    Q_ASSERT(width > 0.0);
+    Q_ASSERT(width > qreal(0.0));
 
     QPointF pa = a;
     QPointF pb = b;
 
-    QPointF offs = QPointF(qAbs(b.y() - a.y()), qAbs(b.x() - a.x())) * width * 0.5;    
+    QPointF offs = QPointF(qAbs(b.y() - a.y()), qAbs(b.x() - a.x())) * width * qreal(0.5);
     if (squareCap)
         offs += QPointF(offs.y(), offs.x());
     const QRectF clip(d->clipRect.topLeft() - offs, d->clipRect.bottomRight() + QPoint(1, 1) + offs);
@@ -750,10 +751,12 @@ void QRasterizer::rasterizeLine(const QPointF &a, const QPointF &b, qreal width,
     }
 
     if (!d->antialiased) {
-        pa.rx() += (COORD_OFFSET - COORD_ROUNDING)/64.;
-        pa.ry() += (COORD_OFFSET - COORD_ROUNDING)/64.;
-        pb.rx() += (COORD_OFFSET - COORD_ROUNDING)/64.;
-        pb.ry() += (COORD_OFFSET - COORD_ROUNDING)/64.;
+        const qreal inv_64 =  1 / qreal(64.);
+        const qreal delta = (COORD_OFFSET - COORD_ROUNDING) * inv_64;
+        pa.rx() += delta;
+        pa.ry() += delta;
+        pb.rx() += delta;
+        pb.ry() += delta;
     }
 
     {
@@ -778,7 +781,7 @@ void QRasterizer::rasterizeLine(const QPointF &a, const QPointF &b, qreal width,
             return;
 
         // adjust width which is given relative to |b - a|
-        width *= sqrt(w0 / w);
+        width *= qSqrt(w0 / w);
     }
 
     QSpanBuffer buffer(d->blend, d->data, d->clipRect);
@@ -793,10 +796,11 @@ void QRasterizer::rasterizeLine(const QPointF &a, const QPointF &b, qreal width,
         pa = QPointF(x, y - dy);
         pb = QPointF(x, y + dy);
 
+        const qreal inv_width = 1 / width;
         if (squareCap)
-            width = 1 / width + 1.0f;
+            width = inv_width + 1.0f;
         else
-            width = 1 / width;
+            width = inv_width;
 
         squareCap = false;
     }
@@ -1192,8 +1196,10 @@ void QRasterizer::rasterize(const QPainterPath &path, Qt::FillRule fillRule)
 
     QRectF bounds = path.controlPointRect();
 
-    int iTopBound = qMax(d->clipRect.top(), int(bounds.top() + 0.5 + (COORD_OFFSET - COORD_ROUNDING)/64.));
-    int iBottomBound = qMin(d->clipRect.bottom(), int(bounds.bottom() - 0.5 + (COORD_OFFSET - COORD_ROUNDING)/64.));
+    const qreal inv_64 = 1 / qreal(64.);
+    const qreal delta = (COORD_OFFSET - COORD_ROUNDING) * inv_64 ;
+    int iTopBound = qMax(d->clipRect.top(), int(bounds.top() + qreal(0.5) + delta));
+    int iBottomBound = qMin(d->clipRect.bottom(), int(bounds.bottom() - qreal(0.5) + delta));
 
     if (iTopBound > iBottomBound)
         return;
diff --git a/src/gui/painting/qstroker.cpp b/src/gui/painting/qstroker.cpp
index 228a6b1..b33d86b 100644
--- a/src/gui/painting/qstroker.cpp
+++ b/src/gui/painting/qstroker.cpp
@@ -788,12 +788,12 @@ qreal qt_t_for_arc_angle(qreal angle)
     if (qFuzzyCompare(angle, qreal(90)))
         return 1;
 
-    qreal radians = Q_PI * angle / 180;
+    qreal radians = Q_PI180 * angle;
     qreal cosAngle = qCos(radians);
     qreal sinAngle = qSin(radians);
 
     // initial guess
-    qreal tc = angle / 90;
+    qreal tc = angle / qreal(90);
     // do some iterations of newton's method to approximate cosAngle
     // finds the zero of the function b.pointAt(tc).x() - cosAngle
     tc -= ((((2-3*QT_PATH_KAPPA) * tc + 3*(QT_PATH_KAPPA-1)) * tc) * tc + 1 - cosAngle) // value
@@ -812,7 +812,7 @@ qreal qt_t_for_arc_angle(qreal angle)
 
     // use the average of the t that best approximates cosAngle
     // and the t that best approximates sinAngle
-    qreal t = 0.5 * (tc + ts);
+    qreal t = qreal(0.5) * (tc + ts);
 
 #if 0
     printf("angle: %f, t: %f\n", angle, t);
@@ -861,11 +861,11 @@ QPointF qt_curves_for_arc(const QRectF &rect, qreal startAngle, qreal sweepLengt
     qreal y = rect.y();
 
     qreal w = rect.width();
-    qreal w2 = rect.width() / 2;
+    qreal w2 = rect.width() * qreal(0.5);
     qreal w2k = w2 * QT_PATH_KAPPA;
 
     qreal h = rect.height();
-    qreal h2 = rect.height() / 2;
+    qreal h2 = rect.height() * qreal(0.5);
     qreal h2k = h2 * QT_PATH_KAPPA;
 
     QPointF points[16] =
@@ -898,23 +898,24 @@ QPointF qt_curves_for_arc(const QRectF &rect, qreal startAngle, qreal sweepLengt
     else if (sweepLength < -360) sweepLength = -360;
 
     // Special case fast paths
-    if (startAngle == 0.0) {
-        if (sweepLength == 360.0) {
+    if (startAngle == qreal(0.0)) {
+        if (sweepLength == qreal(360.0)) {
             for (int i = 11; i >= 0; --i)
                 curves[(*point_count)++] = points[i];
             return points[12];
-        } else if (sweepLength == -360.0) {
+        } else if (sweepLength == qreal(-360.0)) {
             for (int i = 1; i <= 12; ++i)
                 curves[(*point_count)++] = points[i];
             return points[0];
         }
     }
 
-    int startSegment = int(floor(startAngle / 90));
-    int endSegment = int(floor((startAngle + sweepLength) / 90));
+    qreal inv_90 = qreal(1) / qreal(90);
+    int startSegment = int(floor(startAngle * inv_90));
+    int endSegment = int(floor((startAngle + sweepLength) * inv_90));
 
-    qreal startT = (startAngle - startSegment * 90) / 90;
-    qreal endT = (startAngle + sweepLength - endSegment * 90) / 90;
+    qreal startT = (startAngle - startSegment * 90) * inv_90;
+    qreal endT = (startAngle + sweepLength - endSegment * 90) * inv_90;
 
     int delta = sweepLength > 0 ? 1 : -1;
     if (delta < 0) {
diff --git a/src/gui/painting/qstroker_p.h b/src/gui/painting/qstroker_p.h
index a10ebd9..5ff9d87 100644
--- a/src/gui/painting/qstroker_p.h
+++ b/src/gui/painting/qstroker_p.h
@@ -110,7 +110,7 @@ struct qfixed2d
 };
 #endif
 
-#define QT_PATH_KAPPA 0.5522847498
+#define QT_PATH_KAPPA qreal(0.5522847498)
 
 QPointF qt_curves_for_arc(const QRectF &rect, qreal startAngle, qreal sweepLength,
                           QPointF *controlPoints, int *point_count);
diff --git a/src/gui/painting/qtransform.cpp b/src/gui/painting/qtransform.cpp
index 8118450..622ceda 100644
--- a/src/gui/painting/qtransform.cpp
+++ b/src/gui/painting/qtransform.cpp
@@ -52,7 +52,7 @@
 
 QT_BEGIN_NAMESPACE
 
-#define Q_NEAR_CLIP (sizeof(qreal) == sizeof(double) ? 0.000001 : 0.0001)
+#define Q_NEAR_CLIP (sizeof(qreal) == sizeof(double) ? qreal(0.000001) : qreal(0.0001))
 
 #ifdef MAP
 #  undef MAP
@@ -82,7 +82,7 @@ QT_BEGIN_NAMESPACE
             if (t == TxProject) {                                       \
                 qreal w = (m_13 * FX_ + m_23 * FY_ + m_33);              \
                 if (w < qreal(Q_NEAR_CLIP)) w = qreal(Q_NEAR_CLIP);     \
-                w = 1./w;                                               \
+                w = qreal(1.)/w;                                               \
                 nx *= w;                                                \
                 ny *= w;                                                \
             }                                                           \
@@ -369,8 +369,8 @@ QTransform QTransform::inverted(bool *invertible) const
         inv = !qFuzzyIsNull(affine._m11);
         inv &= !qFuzzyIsNull(affine._m22);
         if (inv) {
-            invert.affine._m11 = 1. / affine._m11;
-            invert.affine._m22 = 1. / affine._m22;
+            invert.affine._m11 = qreal(1.) / affine._m11;
+            invert.affine._m22 = qreal(1.) / affine._m22;
             invert.affine._dx = -affine._dx * invert.affine._m11;
             invert.affine._dy = -affine._dy * invert.affine._m22;
         }
@@ -1087,7 +1087,7 @@ QPoint QTransform::map(const QPoint &p) const
         x = affine._m11 * fx + affine._m21 * fy + affine._dx;
         y = affine._m12 * fx + affine._m22 * fy + affine._dy;
         if (t == TxProject) {
-            qreal w = 1./(m_13 * fx + m_23 * fy + m_33);
+            qreal w = qreal(1.)/(m_13 * fx + m_23 * fy + m_33);
             x *= w;
             y *= w;
         }
@@ -1138,7 +1138,7 @@ QPointF QTransform::map(const QPointF &p) const
         x = affine._m11 * fx + affine._m21 * fy + affine._dx;
         y = affine._m12 * fx + affine._m22 * fy + affine._dy;
         if (t == TxProject) {
-            qreal w = 1./(m_13 * fx + m_23 * fy + m_33);
+            qreal w = qreal(1.)/(m_13 * fx + m_23 * fy + m_33);
             x *= w;
             y *= w;
         }
@@ -1217,10 +1217,10 @@ QLine QTransform::map(const QLine &l) const
         x2 = affine._m11 * fx2 + affine._m21 * fy2 + affine._dx;
         y2 = affine._m12 * fx2 + affine._m22 * fy2 + affine._dy;
         if (t == TxProject) {
-            qreal w = 1./(m_13 * fx1 + m_23 * fy1 + m_33);
+            qreal w = qreal(1.)/(m_13 * fx1 + m_23 * fy1 + m_33);
             x1 *= w;
             y1 *= w;
-            w = 1./(m_13 * fx2 + m_23 * fy2 + m_33);
+            w = qreal(1.)/(m_13 * fx2 + m_23 * fy2 + m_33);
             x2 *= w;
             y2 *= w;
         }
@@ -1276,10 +1276,10 @@ QLineF QTransform::map(const QLineF &l) const
         x2 = affine._m11 * fx2 + affine._m21 * fy2 + affine._dx;
         y2 = affine._m12 * fx2 + affine._m22 * fy2 + affine._dy;
         if (t == TxProject) {
-            qreal w = 1./(m_13 * fx1 + m_23 * fy1 + m_33);
+            qreal w = qreal(1.)/(m_13 * fx1 + m_23 * fy1 + m_33);
             x1 *= w;
             y1 *= w;
-            w = 1./(m_13 * fx2 + m_23 * fy2 + m_33);
+            w = qreal(1.)/(m_13 * fx2 + m_23 * fy2 + m_33);
             x2 *= w;
             y2 *= w;
         }
@@ -1438,7 +1438,7 @@ struct QHomogeneousCoordinate
     QHomogeneousCoordinate(qreal x_, qreal y_, qreal w_) : x(x_), y(y_), w(w_) {}
 
     const QPointF toPoint() const {
-        qreal iw = 1. / w;
+        qreal iw = qreal(1.) / w;
         return QPointF(x * iw, y * iw);
     }
 };
@@ -1695,8 +1695,9 @@ bool QTransform::squareToQuad(const QPolygonF &quad, QTransform &trans)
         if (!bottom)
             return false;
 
-        g = gtop/bottom;
-        h = htop/bottom;
+        double inv_bottom = 1 / bottom;
+        g = gtop * inv_bottom;
+        h = htop * inv_bottom;
 
         a = dx1 - dx0 + g * dx1;
         b = dx3 - dx0 + h * dx3;
@@ -2214,12 +2215,14 @@ bool qt_scaleForTransform(const QTransform &transform, qreal *scale)
 {
     const QTransform::TransformationType type = transform.type();
     if (type <= QTransform::TxTranslate) {
-        *scale = 1;
+        if (scale)
+            *scale = 1;
         return true;
     } else if (type == QTransform::TxScale) {
         const qreal xScale = qAbs(transform.m11());
         const qreal yScale = qAbs(transform.m22());
-        *scale = qMax(xScale, yScale);
+        if (scale)
+            *scale = qMax(xScale, yScale);
         return qFuzzyCompare(xScale, yScale);
     }
 
@@ -2227,7 +2230,8 @@ bool qt_scaleForTransform(const QTransform &transform, qreal *scale)
                          + transform.m21() * transform.m21();
     const qreal yScale = transform.m12() * transform.m12()
                          + transform.m22() * transform.m22();
-    *scale = qSqrt(qMax(xScale, yScale));
+    if (scale)
+        *scale = qSqrt(qMax(xScale, yScale));
     return type == QTransform::TxRotate && qFuzzyCompare(xScale, yScale);
 }
 
diff --git a/src/gui/statemachine/qguistatemachine.cpp b/src/gui/statemachine/qguistatemachine.cpp
index 1de5ffa..4f7806f 100644
--- a/src/gui/statemachine/qguistatemachine.cpp
+++ b/src/gui/statemachine/qguistatemachine.cpp
@@ -106,8 +106,10 @@ static QEvent *cloneEvent(QEvent *e)
         return new QEvent(*e);
     case QEvent::HideToParent:
         return new QEvent(*e);
+#ifndef QT_NO_WHEELEVENT
     case QEvent::Wheel:
         return new QWheelEvent(*static_cast<QWheelEvent*>(e));
+#endif //QT_NO_WHEELEVENT
     case QEvent::WindowTitleChange:
         return new QEvent(*e);
     case QEvent::WindowIconChange:
@@ -190,8 +192,10 @@ static QEvent *cloneEvent(QEvent *e)
         return new QInputMethodEvent(*static_cast<QInputMethodEvent*>(e));
     case QEvent::AccessibilityPrepare:
         return new QEvent(*e);
+#ifndef QT_NO_TABLETEVENT
     case QEvent::TabletMove:
         return new QTabletEvent(*static_cast<QTabletEvent*>(e));
+#endif //QT_NO_TABLETEVENT
     case QEvent::LocaleChange:
         return new QEvent(*e);
     case QEvent::LanguageChange:
@@ -200,10 +204,12 @@ static QEvent *cloneEvent(QEvent *e)
         return new QEvent(*e);
     case QEvent::Style:
         return new QEvent(*e);
+#ifndef QT_NO_TABLETEVENT
     case QEvent::TabletPress:
         return new QTabletEvent(*static_cast<QTabletEvent*>(e));
     case QEvent::TabletRelease:
         return new QTabletEvent(*static_cast<QTabletEvent*>(e));
+#endif //QT_NO_TABLETEVENT
     case QEvent::OkRequest:
         return new QEvent(*e);
     case QEvent::HelpRequest:
@@ -238,8 +244,10 @@ static QEvent *cloneEvent(QEvent *e)
         return new QHelpEvent(*static_cast<QHelpEvent*>(e));
     case QEvent::WhatsThis:
         return new QHelpEvent(*static_cast<QHelpEvent*>(e));
+#ifndef QT_NO_STATUSTIP
     case QEvent::StatusTip:
         return new QStatusTipEvent(*static_cast<QStatusTipEvent*>(e));
+#endif //QT_NO_STATUSTIP
 #ifndef QT_NO_ACTION
     case QEvent::ActionChanged:
     case QEvent::ActionAdded:
@@ -249,8 +257,10 @@ static QEvent *cloneEvent(QEvent *e)
     case QEvent::FileOpen:
         return new QFileOpenEvent(*static_cast<QFileOpenEvent*>(e));
 
+#ifndef QT_NO_SHORTCUT
     case QEvent::Shortcut:
         return new QShortcutEvent(*static_cast<QShortcutEvent*>(e));
+#endif //QT_NO_SHORTCUT
     case QEvent::ShortcutOverride:
         return new QKeyEvent(*static_cast<QKeyEvent*>(e));
 
@@ -263,11 +273,15 @@ static QEvent *cloneEvent(QEvent *e)
         break;
 #endif
 
+#ifndef QT_NO_WHATSTHIS
     case QEvent::WhatsThisClicked:
         return new QWhatsThisClickedEvent(*static_cast<QWhatsThisClickedEvent*>(e));
+#endif //QT_NO_WHATSTHIS
 
+#ifndef QT_NO_TOOLBAR
     case QEvent::ToolBarChange:
         return new QToolBarChangeEvent(*static_cast<QToolBarChangeEvent*>(e));
+#endif //QT_NO_TOOLBAR
 
     case QEvent::ApplicationActivate:
         return new QEvent(*e);
@@ -397,9 +411,11 @@ static QEvent *cloneEvent(QEvent *e)
     case QEvent::DynamicPropertyChange:
         return new QDynamicPropertyChangeEvent(*static_cast<QDynamicPropertyChangeEvent*>(e));
 
+#ifndef QT_NO_TABLETEVENT
     case QEvent::TabletEnterProximity:
     case QEvent::TabletLeaveProximity:
         return new QTabletEvent(*static_cast<QTabletEvent*>(e));
+#endif //QT_NO_TABLETEVENT
 
     case QEvent::NonClientAreaMouseMove:
     case QEvent::NonClientAreaMouseButtonPress:
diff --git a/src/gui/styles/qcommonstyle.cpp b/src/gui/styles/qcommonstyle.cpp
index 4c9541b..4d3272c 100644
--- a/src/gui/styles/qcommonstyle.cpp
+++ b/src/gui/styles/qcommonstyle.cpp
@@ -3070,9 +3070,9 @@ static QPolygonF calcArrow(const QStyleOptionSlider *dial, qreal &a)
     int currentSliderPosition = dial->upsideDown ? dial->sliderPosition : (dial->maximum - dial->sliderPosition);
 
     if (dial->maximum == dial->minimum)
-        a = Q_PI / 2;
+        a = Q_PI2;
     else if (dial->dialWrapping)
-        a = Q_PI * 3 / 2 - (currentSliderPosition - dial->minimum) * 2 * Q_PI
+        a = Q_PI2 * 3 - (currentSliderPosition - dial->minimum) * Q_2PI
             / (dial->maximum - dial->minimum);
     else
         a = (Q_PI * 8 - (currentSliderPosition - dial->minimum) * 10 * Q_PI
@@ -3087,12 +3087,13 @@ static QPolygonF calcArrow(const QStyleOptionSlider *dial, qreal &a)
     int back = len / 2;
 
     QPolygonF arrow(3);
-    arrow[0] = QPointF(0.5 + xc + len * qCos(a),
-                       0.5 + yc - len * qSin(a));
-    arrow[1] = QPointF(0.5 + xc + back * qCos(a + Q_PI * 5 / 6),
-                       0.5 + yc - back * qSin(a + Q_PI * 5 / 6));
-    arrow[2] = QPointF(0.5 + xc + back * qCos(a - Q_PI * 5 / 6),
-                       0.5 + yc - back * qSin(a - Q_PI * 5 / 6));
+    const qreal five_div_by_six = 5 / 6;
+    arrow[0] = QPointF(qreal(0.5) + xc + len * qCos(a),
+                       qreal(0.5) + yc - len * qSin(a));
+    arrow[1] = QPointF(qreal(0.5) + xc + back * qCos(a + Q_PI * five_div_by_six),
+                       qreal(0.5) + yc - back * qSin(a + Q_PI * five_div_by_six));
+    arrow[2] = QPointF(qreal(0.5) + xc + back * qCos(a - Q_PI * five_div_by_six),
+                       qreal(0.5) + yc - back * qSin(a - Q_PI * five_div_by_six));
     return arrow;
 }
 
diff --git a/src/gui/styles/qs60style.cpp b/src/gui/styles/qs60style.cpp
index c0a1f76..016b6a7 100644
--- a/src/gui/styles/qs60style.cpp
+++ b/src/gui/styles/qs60style.cpp
@@ -281,7 +281,7 @@ void QS60StylePrivate::drawSkinElement(SkinElements element, QPainter *painter,
         drawFrame(SF_ButtonInactive, painter, rect, flags | SF_PointNorth);
         break;
     case SE_Editor:
-        drawFrame(SF_Editor, painter, rect, flags | SF_PointNorth);
+        drawFrame(SF_FrameLineEdit, painter, rect, flags | SF_PointNorth);
         break;
     default:
         break;
@@ -579,7 +579,7 @@ void QS60StylePrivate::drawRow(QS60StyleEnums::SkinParts start,
 
 #if 0
     painter->save();
-    painter->setOpacity(.3);
+    painter->setOpacity(qreal(.3));
     painter->fillRect(startRect, Qt::red);
     painter->fillRect(middleRect, Qt::green);
     painter->fillRect(endRect, Qt::blue);
@@ -831,6 +831,11 @@ QSize QS60StylePrivate::partSize(QS60StyleEnums::SkinParts part, SkinElementFlag
                 pixelMetric(QStyle::PM_SliderControlThickness), Qt::IgnoreAspectRatio);
             break;
 
+        case QS60StyleEnums::SP_QgnGrafBarFrameSideL:
+        case QS60StyleEnums::SP_QgnGrafBarFrameSideR:
+            result.setWidth(pixelMetric(PM_Custom_FrameCornerWidth));
+            break;
+            
         case QS60StyleEnums::SP_QsnCpScrollHandleBottomPressed:
         case QS60StyleEnums::SP_QsnCpScrollHandleTopPressed:
         case QS60StyleEnums::SP_QsnCpScrollHandleMiddlePressed:
@@ -1619,7 +1624,7 @@ void QS60Style::drawControl(ControlElement element, const QStyleOption *option,
                     QS60StylePrivate::SF_PointNorth : QS60StylePrivate::SF_PointWest;
                 QS60StylePrivate::drawSkinPart(QS60StyleEnums::SP_QgnGrafBarWait, painter, progressRect, flags | orientationFlag);
             } else {
-                const qreal progressFactor = (optionProgressBar->minimum == optionProgressBar->maximum) ? 1.0
+                const qreal progressFactor = (optionProgressBar->minimum == optionProgressBar->maximum) ? qreal(1.0)
                     : (qreal)optionProgressBar->progress / optionProgressBar->maximum;
                 if (optionProgressBar->orientation == Qt::Horizontal) {
                     progressRect.setWidth(int(progressRect.width() * progressFactor));
@@ -1676,18 +1681,18 @@ void QS60Style::drawControl(ControlElement element, const QStyleOption *option,
             if (!styleHint(SH_UnderlineShortcut, menuItem, widget))
                 text_flags |= Qt::TextHideMnemonic;
 
-            QRect iconRect =
-                subElementRect(SE_ItemViewItemDecoration, &optionMenuItem, widget);
-            QRect textRect = subElementRect(SE_ItemViewItemText, &optionMenuItem, widget);
-
             if ((option->state & State_Selected) && (option->state & State_Enabled))
                 QS60StylePrivate::drawSkinElement(QS60StylePrivate::SE_ListHighlight, painter, option->rect, flags);
 
+            QRect iconRect = subElementRect(SE_ItemViewItemDecoration, &optionMenuItem, widget);
+            QRect textRect = subElementRect(SE_ItemViewItemText, &optionMenuItem, widget);
+
             //todo: move the vertical spacing stuff into subElementRect
             const int vSpacing = QS60StylePrivate::pixelMetric(QStyle::PM_LayoutVerticalSpacing);
             if (checkable){
+                const int hSpacing = QS60StylePrivate::pixelMetric(QStyle::PM_LayoutHorizontalSpacing);
                 QStyleOptionMenuItem optionCheckBox;
-                optionCheckBox.QStyleOption::operator=(*menuItem);
+                optionCheckBox.QStyleOptionMenuItem::operator=(*menuItem);
                 optionCheckBox.rect.setWidth(pixelMetric(PM_IndicatorWidth));
                 optionCheckBox.rect.setHeight(pixelMetric(PM_IndicatorHeight));
                 const int moveByX = optionCheckBox.rect.width()+vSpacing;
@@ -1696,6 +1701,7 @@ void QS60Style::drawControl(ControlElement element, const QStyleOption *option,
                     iconRect.translate(moveByX, 0);
                     iconRect.setWidth(iconRect.width()+vSpacing);
                     textRect.setWidth(textRect.width()-moveByX-vSpacing);
+                    optionCheckBox.rect.translate(vSpacing/2, hSpacing/2);
                 } else {
                     textRect.setWidth(textRect.width()-moveByX);
                     iconRect.setWidth(iconRect.width()+vSpacing);
@@ -1906,12 +1912,12 @@ void QS60Style::drawControl(ControlElement element, const QStyleOption *option,
                 if (focusFrame->widget() && focusFrame->widget()->hasEditFocus())
                     editFocus = true;
             }
-            const qreal opacity = editFocus ? 0.65 : 0.45; // Trial and error factors. Feel free to improve.
+            const qreal opacity = editFocus ? qreal(0.65) : qreal(0.45); // Trial and error factors. Feel free to improve.
 #else
-            const qreal opacity = 0.5;
+            const qreal opacity = qreal(0.5);
 #endif
             // Because of Qts coordinate system, we need to tweak the rect by .5 pixels, otherwise it gets blurred.
-            const qreal rectAdjustment = (penWidth % 2) ? -.5 : 0;
+            const qreal rectAdjustment = (penWidth % 2) ? qreal(-.5) : 0;
 
             // Make sure that the pen stroke is inside the rect
             const QRectF adjustedRect =
@@ -1935,7 +1941,7 @@ void QS60Style::drawControl(ControlElement element, const QStyleOption *option,
     case CE_Splitter:
         if (option->state & State_Sunken && option->state & State_Enabled) {
             painter->save();
-            painter->setOpacity(0.5);
+            painter->setOpacity(qreal(0.5));
             painter->setBrush(d->themePalette()->light());
             painter->setRenderHint(QPainter::Antialiasing);
             const qreal roundRectRadius = 4 * goldenRatio;
@@ -2013,8 +2019,8 @@ void QS60Style::drawPrimitive(PrimitiveElement element, const QStyleOption *opti
     case PE_IndicatorRadioButton: {
             QRect buttonRect = option->rect;
             //there is empty (a. 33%) space in svg graphics for radiobutton
-            const qreal reduceWidth = (qreal)buttonRect.width()/3.0;
-            const qreal rectWidth = (qreal)option->rect.width() != 0 ? option->rect.width() : 1.0;
+            const qreal reduceWidth = (qreal)buttonRect.width()/qreal(3.0);
+            const qreal rectWidth = (qreal)option->rect.width() != 0 ? option->rect.width() : qreal(1.0);
             // Try to occupy the full area
             const qreal scaler = 1 + (reduceWidth/rectWidth);
             buttonRect.setWidth((int)((buttonRect.width()-reduceWidth) * scaler));
diff --git a/src/gui/styles/qs60style_p.h b/src/gui/styles/qs60style_p.h
index 54af757..46547bf 100644
--- a/src/gui/styles/qs60style_p.h
+++ b/src/gui/styles/qs60style_p.h
@@ -361,7 +361,6 @@ public:
         SF_ToolBarButtonPressed,
         SF_PanelBackground,
         SF_ButtonInactive,
-        SF_Editor,
     };
 
     enum SkinElementFlag {
diff --git a/src/gui/styles/qs60style_s60.cpp b/src/gui/styles/qs60style_s60.cpp
index 0cd87bd..c2a207c 100644
--- a/src/gui/styles/qs60style_s60.cpp
+++ b/src/gui/styles/qs60style_s60.cpp
@@ -319,16 +319,6 @@ const partMapEntry QS60StyleModeSpecifics::m_partMap[] = {
     /* SP_QsnFrButtonSideRInactive */    {KAknsIIDQsnFrButtonTbSideR,           ENoDraw,     ES60_3_1 | ES60_3_2, EAknsMajorSkin, 0x21b8},
     /* SP_QsnFrButtonCenterInactive */   {KAknsIIDQsnFrButtonTbCenter,          EDrawIcon,   ES60_3_1 | ES60_3_2, EAknsMajorSkin, 0x21b9},
 
-    /* SP_QsnFrNotepadCornerTl */        {KAknsIIDQsnFrNotepadContCornerTl,     ENoDraw,     ES60_AllReleases,    -1,-1},
-    /* SP_QsnFrNotepadCornerTr */        {KAknsIIDQsnFrNotepadContCornerTr,     ENoDraw,     ES60_AllReleases,    -1,-1},
-    /* SP_QsnFrNotepadCornerBl */        {KAknsIIDQsnFrNotepadCornerBl,         ENoDraw,     ES60_AllReleases,    -1,-1},
-    /* SP_QsnFrNotepadCornerBr */        {KAknsIIDQsnFrNotepadCornerBr,         ENoDraw,     ES60_AllReleases,    -1,-1},
-    /* SP_QsnFrNotepadSideT */           {KAknsIIDQsnFrNotepadContSideT,        ENoDraw,     ES60_AllReleases,    -1,-1},
-    /* SP_QsnFrNotepadSideB */           {KAknsIIDQsnFrNotepadSideB,            ENoDraw,     ES60_AllReleases,    -1,-1},
-    /* SP_QsnFrNotepadSideL */           {KAknsIIDQsnFrNotepadSideL,            ENoDraw,     ES60_AllReleases,    -1,-1},
-    /* SP_QsnFrNotepadSideR */           {KAknsIIDQsnFrNotepadSideR,            ENoDraw,     ES60_AllReleases,    -1,-1},
-    /* SP_QsnFrNotepadCenter */          {KAknsIIDQsnFrNotepadCenter,           EDrawIcon,   ES60_AllReleases,    -1,-1},
-
 };
 
 QPixmap QS60StyleModeSpecifics::skinnedGraphics(
@@ -852,10 +842,6 @@ void QS60StyleModeSpecifics::frameIdAndCenterId(QS60StylePrivate::SkinFrameEleme
             centerId.Set(KAknsIIDNone);
             frameId.Set(KAknsIIDQsnFrSetOpt);
             break;
-        case QS60StylePrivate::SF_Editor:
-            centerId.Set(KAknsIIDQsnFrNotepadCenter);
-            frameId.Set(KAknsIIDQsnFrNotepadCont);
-            break;
         default:
             // center should be correct here
             frameId.iMinor = centerId.iMinor - 9;
diff --git a/src/gui/styles/qstyle.cpp b/src/gui/styles/qstyle.cpp
index ec238a9..6733209 100644
--- a/src/gui/styles/qstyle.cpp
+++ b/src/gui/styles/qstyle.cpp
@@ -2132,7 +2132,7 @@ int QStyle::sliderPositionFromValue(int min, int max, int logicalValue, int span
     uint p = upsideDown ? max - logicalValue : logicalValue - min;
 
     if (range > (uint)INT_MAX/4096) {
-        double dpos = (double(p))/(double(range)/span);
+        qreal dpos = (qreal(p))/(qreal(range)/span);
         return int(dpos);
     } else if (range > (uint)span) {
         return (2 * p * span + range) / (2*range);
diff --git a/src/gui/styles/qstylehelper.cpp b/src/gui/styles/qstylehelper.cpp
index af30f15..5b6f72f 100644
--- a/src/gui/styles/qstylehelper.cpp
+++ b/src/gui/styles/qstylehelper.cpp
@@ -117,15 +117,15 @@ static QPointF calcRadialPos(const QStyleOptionSlider *dial, qreal offset)
     const int currentSliderPosition = dial->upsideDown ? dial->sliderPosition : (dial->maximum - dial->sliderPosition);
     qreal a = 0;
     if (dial->maximum == dial->minimum)
-        a = Q_PI / 2;
+        a = Q_PI2;
     else if (dial->dialWrapping)
-        a = Q_PI * 3 / 2 - (currentSliderPosition - dial->minimum) * 2 * Q_PI
+        a = Q_PI2 * 3 - (currentSliderPosition - dial->minimum) * Q_2PI
             / (dial->maximum - dial->minimum);
     else
         a = (Q_PI * 8 - (currentSliderPosition - dial->minimum) * 10 * Q_PI
             / (dial->maximum - dial->minimum)) / 6;
-    qreal xc = width / 2.0;
-    qreal yc = height / 2.0;
+    const qreal xc = width * qreal(0.5);
+    const qreal yc = height * qreal(0.5);
     qreal len = r - QStyleHelper::calcBigLineSize(r) - 3;
     qreal back = offset * len;
     QPointF pos(QPointF(xc + back * qCos(a), yc - back * qSin(a)));
@@ -134,7 +134,7 @@ static QPointF calcRadialPos(const QStyleOptionSlider *dial, qreal offset)
 
 qreal angle(const QPointF &p1, const QPointF &p2)
 {
-    static const qreal rad_factor = 180 / Q_PI;
+    static const qreal rad_factor = Q_PI180;
     qreal _angle = 0;
 
     if (p1.x() == p2.x()) {
@@ -186,7 +186,7 @@ QPolygonF calcLines(const QStyleOptionSlider *dial)
     poly.resize(2 + 2 * notches);
     int smallLineSize = bigLineSize / 2;
     for (int i = 0; i <= notches; ++i) {
-        qreal angle = dial->dialWrapping ? Q_PI * 3 / 2 - i * 2 * Q_PI / notches
+        qreal angle = dial->dialWrapping ? Q_PI2 * 3 - i * Q_2PI / notches
                   : (Q_PI * 8 - i * 10 * Q_PI / notches) / 6;
         qreal s = qSin(angle);
         qreal c = qCos(angle);
@@ -215,7 +215,7 @@ void drawDial(const QStyleOptionSlider *option, QPainter *painter)
     const bool enabled = option->state & QStyle::State_Enabled;
     qreal r = qMin(width, height) / 2;
     r -= r/50;
-    const qreal penSize = r/20.0;
+    const qreal penSize = r/qreal(20.0);
 
     painter->save();
     painter->setRenderHint(QPainter::Antialiasing);
@@ -234,7 +234,7 @@ void drawDial(const QStyleOptionSlider *option, QPainter *painter)
     const qreal dx = option->rect.x() + d_ + (width - 2 * r) / 2 + 1;
     const qreal dy = option->rect.y() + d_ + (height - 2 * r) / 2 + 1;
 
-    QRectF br = QRectF(dx + 0.5, dy + 0.5,
+    QRectF br = QRectF(dx + qreal(0.5), dy + qreal(0.5),
                        int(r * 2 - 2 * d_ - 2),
                        int(r * 2 - 2 * d_ - 2));
     buttonColor.setHsv(buttonColor .hue(),
@@ -244,11 +244,11 @@ void drawDial(const QStyleOptionSlider *option, QPainter *painter)
 
     if (enabled) {
         // Drop shadow
-        qreal shadowSize = qMax(1.0, penSize/2.0);
+        const qreal shadowSize = qMax(qreal(1.0), penSize * qreal(0.5));
         QRectF shadowRect= br.adjusted(-2*shadowSize, -2*shadowSize,
                                        2*shadowSize, 2*shadowSize);
         QRadialGradient shadowGradient(shadowRect.center().x(),
-                                       shadowRect.center().y(), shadowRect.width()/2.0,
+                                       shadowRect.center().y(), shadowRect.width() * qreal(0.5),
                                        shadowRect.center().x(), shadowRect.center().y());
         shadowGradient.setColorAt(qreal(0.91), QColor(0, 0, 0, 40));
         shadowGradient.setColorAt(qreal(1.0), Qt::transparent);
@@ -260,7 +260,7 @@ void drawDial(const QStyleOptionSlider *option, QPainter *painter)
 
         // Main gradient
         QRadialGradient gradient(br.center().x() - br.width()/3, dy,
-                                 br.width()*1.3, br.center().x(),
+                                 br.width()*qreal(1.3), br.center().x(),
                                  br.center().y() - br.height()/2);
         gradient.setColorAt(0, buttonColor.lighter(110));
         gradient.setColorAt(qreal(0.5), buttonColor);
@@ -283,7 +283,7 @@ void drawDial(const QStyleOptionSlider *option, QPainter *painter)
                          qMin(160, highlight.saturation()),
                          qMax(230, highlight.value()));
         highlight.setAlpha(127);
-        p->setPen(QPen(highlight, 2.0));
+        p->setPen(QPen(highlight, qreal(2.0)));
         p->setBrush(Qt::NoBrush);
         p->drawEllipse(br.adjusted(-1, -1, 1, 1));
     }
@@ -302,7 +302,7 @@ void drawDial(const QStyleOptionSlider *option, QPainter *painter)
     dialGradient.setColorAt(1, buttonColor.darker(140));
     dialGradient.setColorAt(qreal(0.4), buttonColor.darker(120));
     dialGradient.setColorAt(0, buttonColor.darker(110));
-    if (penSize > 3.0) {
+    if (penSize > qreal(3.0)) {
         painter->setPen(QPen(QColor(0, 0, 0, 25), penSize));
         painter->drawLine(calcRadialPos(option, qreal(0.90)), calcRadialPos(option, qreal(0.96)));
     }
diff --git a/src/gui/styles/qstyleoption.cpp b/src/gui/styles/qstyleoption.cpp
index f5a2b94..d73a563 100644
--- a/src/gui/styles/qstyleoption.cpp
+++ b/src/gui/styles/qstyleoption.cpp
@@ -4736,8 +4736,9 @@ QStyleOptionTabWidgetFrameV2::QStyleOptionTabWidgetFrameV2(const QStyleOptionTab
     QStyleOptionFrame types.
 
     If the \a{other} style option's version is 1, this style option's
-    \l FrameFeature value is set to \l QStyleOptionFrameV2::None. If
-    its version is 2, its \l FrameFeature value is simply copied to
+    QStyleOptionFrameV2::FrameFeature value is set to
+    QStyleOptionFrameV2::None. If its version is 2, its
+    \l{QStyleOptionFrameV2::}{FrameFeature} value is simply copied to
     this style option.
 */
 QStyleOptionTabWidgetFrameV2 &QStyleOptionTabWidgetFrameV2::operator=(const QStyleOptionTabWidgetFrame &other)
diff --git a/src/gui/styles/qstylesheetstyle.cpp b/src/gui/styles/qstylesheetstyle.cpp
index ae1d33a..1c24a03 100644
--- a/src/gui/styles/qstylesheetstyle.cpp
+++ b/src/gui/styles/qstylesheetstyle.cpp
@@ -1252,20 +1252,20 @@ QPainterPath QRenderRule::borderClip(QRect r)
     const QRectF rect(r);
     const int *borders = border()->borders;
     QPainterPath path;
-    qreal curY = rect.y() + borders[TopEdge]/2.0;
+    qreal curY = rect.y() + borders[TopEdge]*qreal(0.5);
     path.moveTo(rect.x() + tlr.width(), curY);
     path.lineTo(rect.right() - trr.width(), curY);
-    qreal curX = rect.right() - borders[RightEdge]/2.0;
+    qreal curX = rect.right() - borders[RightEdge]*qreal(0.5);
     path.arcTo(curX - 2*trr.width() + borders[RightEdge], curY,
                trr.width()*2 - borders[RightEdge], trr.height()*2 - borders[TopEdge], 90, -90);
 
     path.lineTo(curX, rect.bottom() - brr.height());
-    curY = rect.bottom() - borders[BottomEdge]/2.0;
+    curY = rect.bottom() - borders[BottomEdge]*qreal(0.5);
     path.arcTo(curX - 2*brr.width() + borders[RightEdge], curY - 2*brr.height() + borders[BottomEdge],
                brr.width()*2 - borders[RightEdge], brr.height()*2 - borders[BottomEdge], 0, -90);
 
     path.lineTo(rect.x() + blr.width(), curY);
-    curX = rect.left() + borders[LeftEdge]/2.0;
+    curX = rect.left() + borders[LeftEdge]*qreal(0.5);
     path.arcTo(curX, rect.bottom() - 2*blr.height() + borders[BottomEdge]/2,
                blr.width()*2 - borders[LeftEdge], blr.height()*2 - borders[BottomEdge], 270, -90);
 
@@ -3325,9 +3325,14 @@ void QStyleSheetStyle::drawControl(ControlElement ce, const QStyleOption *opt, Q
         break;
 
     case CE_PushButton:
-        ParentStyle::drawControl(ce, opt, p, w);
-        return;
-
+        if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(opt)) {
+            if (rule.hasDrawable() || rule.hasBox() || rule.hasPosition() || rule.hasPalette() ||
+                    ((btn->features & QStyleOptionButton::HasMenu) && hasStyleRule(w, PseudoElement_PushButtonMenuIndicator))) {
+                ParentStyle::drawControl(ce, opt, p, w);
+                return;
+            }
+        }
+        break;
     case CE_PushButtonBevel:
         if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(opt)) {
             QStyleOptionButton btnOpt(*btn);
@@ -3370,7 +3375,9 @@ void QStyleSheetStyle::drawControl(ControlElement ce, const QStyleOption *opt, Q
             if (rule.hasPosition() && rule.position()->textAlignment != 0) {
                 Qt::Alignment textAlignment = rule.position()->textAlignment;
                 QRect textRect = button->rect;
-                uint tf = Qt::AlignVCenter | Qt::TextShowMnemonic;
+                uint tf = Qt::TextShowMnemonic;
+                const uint verticalAlignMask = Qt::AlignVCenter | Qt::AlignTop | Qt::AlignLeft;
+                tf |= (textAlignment & verticalAlignMask) ? (textAlignment & verticalAlignMask) : Qt::AlignVCenter;
                 if (!styleHint(SH_UnderlineShortcut, button, w))
                     tf |= Qt::TextHideMnemonic;
                 if (!button->icon.isNull()) {
@@ -3599,6 +3606,27 @@ void QStyleSheetStyle::drawControl(ControlElement ce, const QStyleOption *opt, Q
                 }
             } else if (hasStyleRule(w, PseudoElement_MenuCheckMark) || hasStyleRule(w, PseudoElement_MenuRightArrow)) {
                 QWindowsStyle::drawControl(ce, &mi, p, w);
+                if (mi.checkType != QStyleOptionMenuItem::NotCheckable && !mi.checked) {
+                    // We have a style defined, but QWindowsStyle won't draw anything if not checked.
+                    // So we mimick what QWindowsStyle would do.
+                    int checkcol = qMax<int>(mi.maxIconWidth, QWindowsStylePrivate::windowsCheckMarkWidth);
+                    QRect vCheckRect = visualRect(opt->direction, mi.rect, QRect(mi.rect.x(), mi.rect.y(), checkcol, mi.rect.height()));
+                    if (mi.state.testFlag(State_Enabled) && mi.state.testFlag(State_Selected)) {
+                        qDrawShadePanel(p, vCheckRect, mi.palette, true, 1, &mi.palette.brush(QPalette::Button));
+                    } else {
+                        QBrush fill(mi.palette.light().color(), Qt::Dense4Pattern);
+                        qDrawShadePanel(p, vCheckRect, mi.palette, true, 1, &fill);
+                    }
+                    QRenderRule subSubRule = renderRule(w, opt, PseudoElement_MenuCheckMark);
+                    if (subSubRule.hasDrawable()) {
+                        QStyleOptionMenuItem newMi(mi);
+                        newMi.rect = visualRect(opt->direction, mi.rect, QRect(mi.rect.x() + QWindowsStylePrivate::windowsItemFrame,
+                                                                               mi.rect.y() + QWindowsStylePrivate::windowsItemFrame,
+                                                                               checkcol - 2 * QWindowsStylePrivate::windowsItemFrame,
+                                                                               mi.rect.height() - 2 * QWindowsStylePrivate::windowsItemFrame));
+                        drawPrimitive(PE_IndicatorMenuCheckMark, &newMi, p, w);
+                    }
+                }
             } else {
                 if (rule.hasDrawable() && !subRule.hasDrawable() && !(opt->state & QStyle::State_Selected)) {
                     mi.palette.setColor(QPalette::Window, Qt::transparent);
@@ -3668,7 +3696,7 @@ void QStyleSheetStyle::drawControl(ControlElement ce, const QStyleOption *opt, Q
             }
             if (!cb->currentText.isEmpty() && !cb->editable) {
                 drawItemText(p, editRect.adjusted(0, 0, 0, 0), Qt::AlignLeft | Qt::AlignVCenter, cb->palette,
-                             cb->state & State_Enabled, cb->currentText);
+                             cb->state & State_Enabled, cb->currentText, QPalette::Text);
             }
             p->restore();
             return;
@@ -4275,23 +4303,7 @@ void QStyleSheetStyle::drawPrimitive(PrimitiveElement pe, const QStyleOption *op
                     p->fillRect(v2->rect, v2->palette.alternateBase());
                 subRule.drawRule(p, opt->rect);
             } else {
-                QStyleOptionViewItemV2 v2Copy(*v2);
-                if (v2->showDecorationSelected) {
-                    QRenderRule subRule2 = renderRule(w, opt, PseudoElement_ViewItem);
-                    if (v2->state & QStyle::State_Selected) {
-                        subRule2.configurePalette(&v2Copy.palette, QPalette::NoRole, QPalette::Highlight);
-                    } else if (v2->features & QStyleOptionViewItemV2::Alternate) {
-                        subRule2.configurePalette(&v2Copy.palette, QPalette::NoRole, QPalette::AlternateBase);
-                    } else if (subRule2.hasBackground()) {
-                        p->fillRect(v2->rect, subRule2.background()->brush);
-                    }
-                } else if (v2->features & QStyleOptionViewItemV2::Alternate) {
-                    quint64 pc = v2->state & QStyle::State_Enabled ? PseudoClass_Enabled : PseudoClass_Disabled;
-                    pc |= PseudoClass_Alternate;
-                    QRenderRule subRule2 = renderRule(w, PseudoElement_ViewItem, pc);
-                    subRule2.configurePalette(&v2Copy.palette, QPalette::NoRole, QPalette::AlternateBase);
-                }
-                baseStyle()->drawPrimitive(pe, &v2Copy, p, w);
+                baseStyle()->drawPrimitive(pe, v2, p, w);
             }
         }
         return;
@@ -4356,18 +4368,6 @@ void QStyleSheetStyle::drawPrimitive(PrimitiveElement pe, const QStyleOption *op
         break;
 
     case PE_PanelItemViewItem:
-        if (!styleHint(SH_ItemView_ShowDecorationSelected, opt, w)) {
-            rect = subElementRect(QStyle::SE_ItemViewItemText,  opt, w)
-                   | subElementRect(QStyle::SE_ItemViewItemDecoration, opt, w)
-                   | subElementRect(QStyle::SE_ItemViewItemCheckIndicator, opt, w);
-        }
-        pseudoElement = PseudoElement_ViewItem;
-        break;
-
-    case PE_PanelItemViewRow:
-        ParentStyle::drawPrimitive(pe, opt, p, w);
-        if (!styleHint(SH_ItemView_ShowDecorationSelected, opt, w))
-            return;
         pseudoElement = PseudoElement_ViewItem;
         break;
 
diff --git a/src/gui/styles/qstylesheetstyle_default.cpp b/src/gui/styles/qstylesheetstyle_default.cpp
index 406633e..f79f8e0 100644
--- a/src/gui/styles/qstylesheetstyle_default.cpp
+++ b/src/gui/styles/qstylesheetstyle_default.cpp
@@ -203,49 +203,6 @@ StyleSheet QStyleSheetStyle::getDefaultStyleSheet() const
         ADD_STYLE_RULE;
     }
 
-    /*QLineEdit[style="QCleanlooksStyle"] {
-        padding-top: 2px;
-        padding-bottom: 2px;
-    }*/
-    if (baseStyle()->inherits("QCleanlooksStyle"))
-    {
-        SET_ELEMENT_NAME(QLatin1String("QLineEdit"));
-        ADD_BASIC_SELECTOR;
-        ADD_SELECTOR;
-
-
-        SET_PROPERTY(QLatin1String("padding-top"), PaddingTop);
-        ADD_VALUE(Value::Identifier, QString::fromLatin1("2px"));
-        ADD_DECLARATION;
-
-        SET_PROPERTY(QLatin1String("padding-bottom"), PaddingBottom);
-        ADD_VALUE(Value::Identifier, QString::fromLatin1("2px"));
-        ADD_DECLARATION;
-
-        ADD_STYLE_RULE;
-    }
-
-    /*QLineEdit[style="QWindowsXPStyle"],
-      QLineEdit[style="QWindowsVistaStyle"],
-      QLineEdit[style="QGtkStyle"] {
-        padding-top: 1px;
-        padding-bottom: 1px;
-    }*/
-    if (baseStyle()->inherits("QWindowsXPStyle") || baseStyle()->inherits("QGtkStyle"))
-    {
-        SET_ELEMENT_NAME(QLatin1String("QLineEdit"));
-
-        SET_PROPERTY(QLatin1String("padding-top"), PaddingTop);
-        ADD_VALUE(Value::Identifier, QString::fromLatin1("1px"));
-        ADD_DECLARATION;
-
-        SET_PROPERTY(QLatin1String("padding-bottom"), PaddingBottom);
-        ADD_VALUE(Value::Identifier, QString::fromLatin1("1px"));
-        ADD_DECLARATION;
-
-        ADD_STYLE_RULE;
-    }
-
     /*QFrame {
         border: native;
     }*/
diff --git a/src/gui/styles/qwindowsmobilestyle.cpp b/src/gui/styles/qwindowsmobilestyle.cpp
index 7ed187f..86ba947 100644
--- a/src/gui/styles/qwindowsmobilestyle.cpp
+++ b/src/gui/styles/qwindowsmobilestyle.cpp
@@ -4121,6 +4121,7 @@ void QWindowsMobileStylePrivate::setupWindowsMobileStyle65()
 
 void QWindowsMobileStylePrivate::drawTabBarTab(QPainter *painter, const QStyleOptionTab *tab)
 {
+#ifndef QT_NO_TABBAR
 #ifdef Q_WS_WINCE_WM
     if (wm65) {
         tintImagesButton(tab->palette.button().color());
@@ -4207,6 +4208,7 @@ void QWindowsMobileStylePrivate::drawTabBarTab(QPainter *painter, const QStyleOp
         }
     }
     painter->restore();
+#endif //QT_NO_TABBAR
 }
 
 void QWindowsMobileStylePrivate::drawPanelItemViewSelected(QPainter *painter, const QStyleOptionViewItemV4 *option, QRect rect)
@@ -4412,7 +4414,7 @@ void QWindowsMobileStylePrivate::drawScrollbarHandleUp(QPainter *p, QStyleOption
 
 void QWindowsMobileStylePrivate::drawScrollbarHandleDown(QPainter *p, QStyleOptionSlider *opt, bool completeFrame, bool secondScrollBar)
 {
-
+#ifndef QT_NO_SCROLLBAR
 #ifdef Q_WS_WINCE_WM
     if (wm65) {
         tintImagesHigh(opt->palette.highlight().color());
@@ -4469,10 +4471,12 @@ void QWindowsMobileStylePrivate::drawScrollbarHandleDown(QPainter *p, QStyleOpti
             arrowOpt.rect.adjust(1, 0, 1, 0);
         q_func()->proxy()->drawPrimitive(QStyle::PE_IndicatorArrowDown, &arrowOpt, p, 0);
     }
+#endif //QT_NO_SCROLLBAR
 }
 
 void QWindowsMobileStylePrivate::drawScrollbarGroove(QPainter *p,const QStyleOptionSlider *opt)
 {
+#ifndef QT_NO_SCROLLBAR
 #ifdef Q_OS_WINCE_WM
     if (wm65) {
         p->fillRect(opt->rect, QColor(231, 231, 231));
@@ -4498,6 +4502,7 @@ void QWindowsMobileStylePrivate::drawScrollbarGroove(QPainter *p,const QStyleOpt
               fill = opt->palette.light();
             }
             p->fillRect(opt->rect, fill);
+#endif //QT_NO_SCROLLBAR
 }
 
 QWindowsMobileStyle::QWindowsMobileStyle(QWindowsMobileStylePrivate &dd) : QWindowsStyle(dd) {
@@ -6325,16 +6330,20 @@ QSize QWindowsMobileStyle::sizeFromContents(ContentsType type, const QStyleOptio
     switch (type) {
     case CT_PushButton:
        if (const QStyleOptionButton *button = qstyleoption_cast<const QStyleOptionButton *>(option)) {
-            newSize = QWindowsStyle::sizeFromContents(type, option, size, widget);
+            newSize = QCommonStyle::sizeFromContents(type, option, size, widget);
             int w = newSize.width(),
                 h = newSize.height();
             int defwidth = 0;
             if (button->features & QStyleOptionButton::AutoDefaultButton)
                 defwidth = 2 * proxy()->pixelMetric(PM_ButtonDefaultIndicator, button, widget);
-            if (w < 75 + defwidth && button->icon.isNull())
-                w = 75 + defwidth;
-            if (h < 23 + defwidth)
-                h = 23 + defwidth;
+
+            int minwidth = int(QStyleHelper::dpiScaled(55.0f));
+            int minheight = int(QStyleHelper::dpiScaled(19.0f));
+
+            if (w < minwidth + defwidth && button->icon.isNull())
+                w = minwidth + defwidth;
+            if (h < minheight + defwidth)
+                h = minheight + defwidth;
             newSize = QSize(w + 4, h + 4);
         }
         break;
diff --git a/src/gui/styles/qwindowsmobilestyle_p.h b/src/gui/styles/qwindowsmobilestyle_p.h
index 1e8c7ff..139a4ab 100644
--- a/src/gui/styles/qwindowsmobilestyle_p.h
+++ b/src/gui/styles/qwindowsmobilestyle_p.h
@@ -60,6 +60,10 @@ QT_BEGIN_NAMESPACE
 
 #ifndef QT_NO_STYLE_WINDOWSMOBILE
 
+class QStyleOptionTab;
+class QStyleOptionSlider;
+class QStyleOptionViewItemV4;
+
 class QWindowsMobileStylePrivate : public QWindowsStylePrivate
 {
     Q_DECLARE_PUBLIC(QWindowsMobileStyle)
diff --git a/src/gui/styles/qwindowsstyle.cpp b/src/gui/styles/qwindowsstyle.cpp
index 5cf738e..f894b82 100644
--- a/src/gui/styles/qwindowsstyle.cpp
+++ b/src/gui/styles/qwindowsstyle.cpp
@@ -115,14 +115,6 @@ QT_BEGIN_INCLUDE_NAMESPACE
 #include <limits.h>
 QT_END_INCLUDE_NAMESPACE
 
-static const int windowsItemFrame        =  2; // menu item frame width
-static const int windowsSepHeight        =  9; // separator item height
-static const int windowsItemHMargin      =  3; // menu item hor text margin
-static const int windowsItemVMargin      =  2; // menu item ver text margin
-static const int windowsArrowHMargin     =  6; // arrow horizontal margin
-static const int windowsRightBorder      = 15; // right border on windows
-static const int windowsCheckMarkWidth   = 12; // checkmarks width on windows
-
 enum QSliderDirection { SlUp, SlDown, SlLeft, SlRight };
 
 /*
@@ -1847,7 +1839,7 @@ void QWindowsStyle::drawControl(ControlElement ce, const QStyleOption *opt, QPai
             bool act = menuitem->state & State_Selected;
 
             // windows always has a check column, regardless whether we have an icon or not
-            int checkcol = qMax(menuitem->maxIconWidth, windowsCheckMarkWidth);
+            int checkcol = qMax<int>(menuitem->maxIconWidth, QWindowsStylePrivate::windowsCheckMarkWidth);
 
             QBrush fill = menuitem->palette.brush(act ? QPalette::Highlight : QPalette::Button);
             p->fillRect(menuitem->rect.adjusted(0, 0, -1, 0), fill);
@@ -1903,8 +1895,10 @@ void QWindowsStyle::drawControl(ControlElement ce, const QStyleOption *opt, QPai
                     newMi.state |= State_Enabled;
                 if (act)
                     newMi.state |= State_On;
-                newMi.rect = visualRect(opt->direction, menuitem->rect, QRect(menuitem->rect.x() + windowsItemFrame, menuitem->rect.y() + windowsItemFrame,
-                                                                              checkcol - 2 * windowsItemFrame, menuitem->rect.height() - 2*windowsItemFrame));
+                newMi.rect = visualRect(opt->direction, menuitem->rect, QRect(menuitem->rect.x() + QWindowsStylePrivate::windowsItemFrame,
+                                                                              menuitem->rect.y() + QWindowsStylePrivate::windowsItemFrame,
+                                                                              checkcol - 2 * QWindowsStylePrivate::windowsItemFrame,
+                                                                              menuitem->rect.height() - 2 * QWindowsStylePrivate::windowsItemFrame));
                 proxy()->drawPrimitive(PE_IndicatorMenuCheckMark, &newMi, p, widget);
             }
             p->setPen(act ? menuitem->palette.highlightedText().color() : menuitem->palette.buttonText().color());
@@ -1915,9 +1909,10 @@ void QWindowsStyle::drawControl(ControlElement ce, const QStyleOption *opt, QPai
                 p->setPen(discol);
             }
 
-            int xm = windowsItemFrame + checkcol + windowsItemHMargin;
+            int xm = QWindowsStylePrivate::windowsItemFrame + checkcol + QWindowsStylePrivate::windowsItemHMargin;
             int xpos = menuitem->rect.x() + xm;
-            QRect textRect(xpos, y + windowsItemVMargin, w - xm - windowsRightBorder - tab + 1, h - 2 * windowsItemVMargin);
+            QRect textRect(xpos, y + QWindowsStylePrivate::windowsItemVMargin,
+                           w - xm - QWindowsStylePrivate::windowsRightBorder - tab + 1, h - 2 * QWindowsStylePrivate::windowsItemVMargin);
             QRect vTextRect = visualRect(opt->direction, menuitem->rect, textRect);
             QString s = menuitem->text;
             if (!s.isEmpty()) {                     // draw text
@@ -1951,10 +1946,10 @@ void QWindowsStyle::drawControl(ControlElement ce, const QStyleOption *opt, QPai
                 p->restore();
             }
             if (menuitem->menuItemType == QStyleOptionMenuItem::SubMenu) {// draw sub menu arrow
-                int dim = (h - 2 * windowsItemFrame) / 2;
+                int dim = (h - 2 * QWindowsStylePrivate::windowsItemFrame) / 2;
                 PrimitiveElement arrow;
                 arrow = (opt->direction == Qt::RightToLeft) ? PE_IndicatorArrowLeft : PE_IndicatorArrowRight;
-                xpos = x + w - windowsArrowHMargin - windowsItemFrame - dim;
+                xpos = x + w - QWindowsStylePrivate::windowsArrowHMargin - QWindowsStylePrivate::windowsItemFrame - dim;
                 QRect  vSubMenuRect = visualRect(opt->direction, menuitem->rect, QRect(xpos, y + h / 2 - dim / 2, dim, dim));
                 QStyleOptionMenuItem newMI = *menuitem;
                 newMI.rect = vSubMenuRect;
@@ -2994,6 +2989,7 @@ void QWindowsStyle::drawComplexControl(ComplexControl cc, const QStyleOptionComp
 #ifndef QT_NO_COMBOBOX
     case CC_ComboBox:
         if (const QStyleOptionComboBox *cmb = qstyleoption_cast<const QStyleOptionComboBox *>(opt)) {
+            p->save();
             QBrush editBrush = cmb->palette.brush(QPalette::Base);
             if ((cmb->subControls & SC_ComboBoxFrame)) {
                 if (cmb->frame) {
@@ -3063,6 +3059,7 @@ void QWindowsStyle::drawComplexControl(ComplexControl cc, const QStyleOptionComp
                     proxy()->drawPrimitive(PE_FrameFocusRect, &focus, p, widget);
                 }
             }
+            p->restore();
         }
         break;
 #endif // QT_NO_COMBOBOX
@@ -3191,7 +3188,7 @@ QSize QWindowsStyle::sizeFromContents(ContentsType ct, const QStyleOption *opt,
             sz = QCommonStyle::sizeFromContents(ct, opt, csz, widget);
 
             if (mi->menuItemType == QStyleOptionMenuItem::Separator) {
-                sz = QSize(10, windowsSepHeight);
+                sz = QSize(10, QWindowsStylePrivate::windowsSepHeight);
             }
             else if (mi->icon.isNull()) {
                 sz.setHeight(sz.height() - 2);
@@ -3202,14 +3199,14 @@ QSize QWindowsStyle::sizeFromContents(ContentsType ct, const QStyleOption *opt,
                 int iconExtent = proxy()->pixelMetric(PM_SmallIconSize, opt, widget);
                 sz.setHeight(qMax(sz.height(),
                                   mi->icon.actualSize(QSize(iconExtent, iconExtent)).height()
-                                  + 2 * windowsItemFrame));
+                                  + 2 * QWindowsStylePrivate::windowsItemFrame));
             }
             int maxpmw = mi->maxIconWidth;
             int tabSpacing = 20;
             if (mi->text.contains(QLatin1Char('\t')))
                 w += tabSpacing;
             else if (mi->menuItemType == QStyleOptionMenuItem::SubMenu)
-                w += 2 * windowsArrowHMargin;
+                w += 2 * QWindowsStylePrivate::windowsArrowHMargin;
             else if (mi->menuItemType == QStyleOptionMenuItem::DefaultItem) {
                 // adjust the font and add the difference in size.
                 // it would be better if the font could be adjusted in the initStyleOption qmenu func!!
@@ -3220,9 +3217,9 @@ QSize QWindowsStyle::sizeFromContents(ContentsType ct, const QStyleOption *opt,
                 w += fmBold.width(mi->text) - fm.width(mi->text);
             }
 
-            int checkcol = qMax(maxpmw, windowsCheckMarkWidth); // Windows always shows a check column
+            int checkcol = qMax<int>(maxpmw, QWindowsStylePrivate::windowsCheckMarkWidth); // Windows always shows a check column
             w += checkcol;
-            w += windowsRightBorder + 10;
+            w += QWindowsStylePrivate::windowsRightBorder + 10;
             sz.setWidth(w);
         }
         break;
@@ -3230,7 +3227,7 @@ QSize QWindowsStyle::sizeFromContents(ContentsType ct, const QStyleOption *opt,
 #ifndef QT_NO_MENUBAR
     case CT_MenuBarItem:
         if (!sz.isEmpty())
-            sz += QSize(windowsItemHMargin * 4, windowsItemVMargin * 2);
+            sz += QSize(QWindowsStylePrivate::windowsItemHMargin * 4, QWindowsStylePrivate::windowsItemVMargin * 2);
         break;
 #endif
                 // Otherwise, fall through
diff --git a/src/gui/styles/qwindowsstyle_p.h b/src/gui/styles/qwindowsstyle_p.h
index fb84dce..d81c82b 100644
--- a/src/gui/styles/qwindowsstyle_p.h
+++ b/src/gui/styles/qwindowsstyle_p.h
@@ -87,7 +87,17 @@ public:
     QColor activeGradientCaptionColor;
     QColor inactiveCaptionColor;
     QColor inactiveGradientCaptionColor;
+
+    enum {
+        windowsItemFrame        =  2, // menu item frame width
+        windowsSepHeight        =  9, // separator item height
+        windowsItemHMargin      =  3, // menu item hor text margin
+        windowsItemVMargin      =  2, // menu item ver text margin
+        windowsArrowHMargin     =  6, // arrow horizontal margin
+        windowsRightBorder      = 15, // right border on windows
+        windowsCheckMarkWidth   = 12  // checkmarks width on windows
     };
+};
 
 QT_END_NAMESPACE
 
diff --git a/src/gui/text/qcssparser.cpp b/src/gui/text/qcssparser.cpp
index 6db86bd..93b9fc6 100644
--- a/src/gui/text/qcssparser.cpp
+++ b/src/gui/text/qcssparser.cpp
@@ -1129,19 +1129,22 @@ static bool setFontWeightFromValue(const Value &value, QFont *font)
 static bool setFontFamilyFromValues(const QVector<Value> &values, QFont *font, int start = 0)
 {
     QString family;
+    bool shouldAddSpace = false;
     for (int i = start; i < values.count(); ++i) {
         const Value &v = values.at(i);
         if (v.type == Value::TermOperatorComma) {
             family += QLatin1Char(',');
+            shouldAddSpace = false;
             continue;
         }
         const QString str = v.variant.toString();
         if (str.isEmpty())
             break;
+        if (shouldAddSpace)
+            family += QLatin1Char(' ');
         family += str;
-        family += QLatin1Char(' ');
+        shouldAddSpace = true;
     }
-    family = family.simplified();
     if (family.isEmpty())
         return false;
     font->setFamily(family);
diff --git a/src/gui/text/qfont.cpp b/src/gui/text/qfont.cpp
index 447087c..4511709 100644
--- a/src/gui/text/qfont.cpp
+++ b/src/gui/text/qfont.cpp
@@ -309,7 +309,7 @@ QFontPrivate *QFontPrivate::smallCapsFontPrivate() const
     QFont font(const_cast<QFontPrivate *>(this));
     qreal pointSize = font.pointSizeF();
     if (pointSize > 0)
-        font.setPointSizeF(pointSize * .7);
+        font.setPointSizeF(pointSize * qreal(.7));
     else
         font.setPixelSize((font.pixelSize() * 7 + 5) / 10);
     scFont = font.d.data();
@@ -2143,7 +2143,7 @@ QDataStream &operator<<(QDataStream &s, const QFont &font)
 
     if (s.version() >= QDataStream::Qt_4_0) {
         // 4.0
-        double pointSize = font.d->request.pointSize;
+        qreal pointSize = font.d->request.pointSize;
         qint32 pixelSize = font.d->request.pixelSize;
         s << pointSize;
         s << pixelSize;
@@ -2205,7 +2205,7 @@ QDataStream &operator>>(QDataStream &s, QFont &font)
 
     if (s.version() >= QDataStream::Qt_4_0) {
         // 4.0
-        double pointSize;
+        qreal pointSize;
         qint32 pixelSize;
         s >> pointSize;
         s >> pixelSize;
diff --git a/src/gui/text/qfontdatabase.cpp b/src/gui/text/qfontdatabase.cpp
index fb8444e..e8a0068 100644
--- a/src/gui/text/qfontdatabase.cpp
+++ b/src/gui/text/qfontdatabase.cpp
@@ -533,7 +533,13 @@ static int requiredUnicodeBits[QFontDatabase::WritingSystemsCount][2] = {
         // Vietnamese,
     { 0, 127 }, // same as latin1
         // Other,
-    { 126, 127 }
+    { 126, 127 },
+        // Ogham,
+    { 78, 127 },
+        // Runic,
+    { 79, 127 },
+        // Nko,
+    { 14, 127 },
 };
 
 #define SimplifiedChineseCsbBit 18
@@ -873,7 +879,8 @@ static const int scriptForWritingSystem[] = {
     QUnicodeTables::Common, // Braille
     QUnicodeTables::Common, // Symbol
     QUnicodeTables::Ogham,  // Ogham
-    QUnicodeTables::Runic // Runic
+    QUnicodeTables::Runic, // Runic
+    QUnicodeTables::Nko // Nko
 };
 
 
@@ -881,12 +888,12 @@ static const int scriptForWritingSystem[] = {
 static inline bool requiresOpenType(int writingSystem)
 {
     return ((writingSystem >= QFontDatabase::Syriac && writingSystem <= QFontDatabase::Sinhala)
-            || writingSystem == QFontDatabase::Khmer);
+            || writingSystem == QFontDatabase::Khmer || writingSystem == QFontDatabase::Nko);
 }
 static inline bool scriptRequiresOpenType(int script)
 {
     return ((script >= QUnicodeTables::Syriac && script <= QUnicodeTables::Sinhala)
-            || script == QUnicodeTables::Khmer);
+            || script == QUnicodeTables::Khmer || script == QUnicodeTables::Nko);
 }
 #endif
 
@@ -1558,6 +1565,7 @@ QFontDatabase::QFontDatabase()
     \value Other (the same as Symbol)
     \value Ogham
     \value Runic
+    \value Nko
 
     \omitvalue WritingSystemsCount
 */
@@ -1877,11 +1885,12 @@ QList<int> QFontDatabase::pointSizes(const QString &family,
                 smoothScalable = true;
                 goto end;
             }
+            const qreal pointsize_factor = qreal(72.0) / dpi;
             for (int l = 0; l < style->count; l++) {
                 const QtFontSize *size = style->pixelSizes + l;
 
                 if (size->pixelSize != 0 && size->pixelSize != USHRT_MAX) {
-                    const uint pointSize = qRound(size->pixelSize * 72.0 / dpi);
+                    const uint pointSize = qRound(size->pixelSize * pointsize_factor);
                     if (! sizes.contains(pointSize))
                         sizes.append(pointSize);
                 }
@@ -1984,11 +1993,12 @@ QList<int> QFontDatabase::smoothSizes(const QString &family,
                 smoothScalable = true;
                 goto end;
             }
+            const qreal pointsize_factor = qreal(72.0) / dpi;
             for (int l = 0; l < style->count; l++) {
                 const QtFontSize *size = style->pixelSizes + l;
 
                 if (size->pixelSize != 0 && size->pixelSize != USHRT_MAX) {
-                    const uint pointSize = qRound(size->pixelSize * 72.0 / dpi);
+                    const uint pointSize = qRound(size->pixelSize * pointsize_factor);
                     if (! sizes.contains(pointSize))
                         sizes.append(pointSize);
                 }
@@ -2232,6 +2242,9 @@ QString QFontDatabase::writingSystemName(WritingSystem writingSystem)
     case Runic:
         name = QT_TRANSLATE_NOOP("QFontDatabase", "Runic");
         break;
+    case Nko:
+        name = QT_TRANSLATE_NOOP("QFontDatabase", "N'Ko");
+        break;
     default:
         Q_ASSERT_X(false, "QFontDatabase::writingSystemName", "invalid 'writingSystem' parameter");
         break;
@@ -2445,6 +2458,12 @@ QString QFontDatabase::writingSystemSample(WritingSystem writingSystem)
         sample += QChar(0x16a2);
         sample += QChar(0x16a3);
         break;
+    case Nko:
+        sample += QChar(0x7ca);
+        sample += QChar(0x7cb);
+        sample += QChar(0x7cc);
+        sample += QChar(0x7cd);
+        break;
     default:
         break;
     }
diff --git a/src/gui/text/qfontdatabase.h b/src/gui/text/qfontdatabase.h
index e6dcfc9..37b5860 100644
--- a/src/gui/text/qfontdatabase.h
+++ b/src/gui/text/qfontdatabase.h
@@ -108,6 +108,7 @@ public:
 
         Ogham,
         Runic,
+        Nko,
 
         WritingSystemsCount
     };
diff --git a/src/gui/text/qfontdatabase_x11.cpp b/src/gui/text/qfontdatabase_x11.cpp
index f184811..dd575f9 100644
--- a/src/gui/text/qfontdatabase_x11.cpp
+++ b/src/gui/text/qfontdatabase_x11.cpp
@@ -155,187 +155,187 @@ static const char writingSystems_for_xlfd_encoding[sizeof(xlfd_encoding)][QFontD
     { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // iso8859-2
     { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // iso8859-3
     { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // iso8859-4
     { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // iso8859-9
     { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // iso8859-10
     { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // iso8859-13
     { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // iso8859-14
     { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // iso8859-15
     { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // hp-roman8
     { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // iso8859-5
     { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // *-cp1251
     { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // koi8-ru
     { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // koi8-u
     { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // koi8-r
     { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // iso8859-7
     { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // iso8859-8
     { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // gb18030-0
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // gb18030.2000-0
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // gbk-0
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // gb2312.*-0
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // jisx0201*-0
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
-      0 },
+      0, 0 },
     // jisx0208*-0
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
-      0 },
+      0, 0 },
     // ksc5601*-*
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
-      0 },
+      0, 0 },
     // big5hkscs-0
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
-      0 },
+      0, 0 },
     // hkscs-1
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
-      0 },
+      0, 0 },
     // big5*-*
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
-      0 },
+      0, 0 },
     // tscii-*
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // tis620*-*
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // iso8859-11
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // mulelao-1
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // ethiopic-unicode
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      0 },
+      0, 0 },
     // iso10646-1
     { 0, 1, 1, 1, 1, 1, 1, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
       1, 1, 0, 1, 0, 1, 1, 0, 0, 0,
-      0 },
+      0, 0 },
     // unicode-*
     { 0, 1, 1, 1, 1, 1, 1, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
       1, 1, 0, 1, 0, 1, 1, 0, 0, 0,
-      0 },
+      0, 0 },
     // *-symbol
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      1 },
+      1, 0 },
     // *-fontspecific
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      1 },
+      1, 0 },
     // fontspecific-*
     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-      1 }
+      1, 0 }
 
 };
 
@@ -835,7 +835,8 @@ static const char *specialLanguages[] = {
     "ko", // Hangul
     "", // Ogham
     "", // Runic
-    "km" // Khmer
+    "km", // Khmer
+    "" // N'Ko
 };
 enum { SpecialLanguageCount = sizeof(specialLanguages) / sizeof(const char *) };
 
@@ -866,7 +867,8 @@ static const ushort specialChars[] = {
     0, // Hangul
     0x1681, // Ogham
     0x16a0, // Runic
-    0  // Khmer
+    0,  // Khmer
+    0x7ca // N'Ko
 };
 enum { SpecialCharCount = sizeof(specialChars) / sizeof(ushort) };
 
@@ -905,7 +907,8 @@ static const char *languageForWritingSystem[] = {
     "vi",  // Vietnamese
     0, // Symbol
     0, // Ogham
-    0 // Runic
+    0, // Runic
+    0 // N'Ko
 };
 enum { LanguageCount = sizeof(languageForWritingSystem) / sizeof(const char *) };
 
@@ -944,7 +947,8 @@ static const ushort sampleCharForWritingSystem[] = {
     0,  // Vietnamese
     0, // Symbol
     0x1681, // Ogham
-    0x16a0 // Runic
+    0x16a0, // Runic
+    0x7ca // N'Ko
 };
 enum { SampleCharCount = sizeof(sampleCharForWritingSystem) / sizeof(ushort) };
 
@@ -984,7 +988,8 @@ static const char *openType[] = {
     0,  // Vietnamese
     0, // Symbol
     0, // Ogham
-    0 // Runic
+    0, // Runic
+    "nko " // N'Ko
 };
 enum { OpenTypeCount = sizeof(openType) / sizeof(const char *) };
 
@@ -1472,7 +1477,7 @@ void qt_addPatternProps(FcPattern *pattern, int screen, int script, const QFontD
                          !(request.styleStrategy & QFont::NoAntialias));
     }
 
-    if (script != QUnicodeTables::Common) {
+    if (script != QUnicodeTables::Common && *specialLanguages[script] != '\0') {
         Q_ASSERT(script < QUnicodeTables::ScriptCount);
         FcLangSet *ls = FcLangSetCreate();
         FcLangSetAdd(ls, (const FcChar8*)specialLanguages[script]);
@@ -1615,7 +1620,7 @@ static QFontEngine *tryPatternLoad(FcPattern *p, int screen,
                 goto done;
             if (!FcCharSetHasChar(cs, specialChars[script]))
                 goto done;
-        } else {
+        } else if (*specialLanguages[script] != '\0'){
             FcLangSet *langSet = 0;
             if (FcPatternGetLangSet(match, FC_LANG, 0, &langSet) != FcResultMatch)
                 goto done;
diff --git a/src/gui/text/qtextcontrol.cpp b/src/gui/text/qtextcontrol.cpp
index 9497b6f..2bfe33c 100644
--- a/src/gui/text/qtextcontrol.cpp
+++ b/src/gui/text/qtextcontrol.cpp
@@ -911,7 +911,7 @@ void QTextControl::processEvent(QEvent *e, const QMatrix &matrix, QWidget *conte
             break;
         case QEvent::MouseButtonPress: {
             QMouseEvent *ev = static_cast<QMouseEvent *>(e);
-            d->mousePressEvent(ev->button(), matrix.map(ev->pos()), ev->modifiers(),
+            d->mousePressEvent(ev, ev->button(), matrix.map(ev->pos()), ev->modifiers(),
                                ev->buttons(), ev->globalPos());
             break; }
         case QEvent::MouseMove: {
@@ -979,7 +979,7 @@ void QTextControl::processEvent(QEvent *e, const QMatrix &matrix, QWidget *conte
 #ifndef QT_NO_GRAPHICSVIEW
         case QEvent::GraphicsSceneMousePress: {
             QGraphicsSceneMouseEvent *ev = static_cast<QGraphicsSceneMouseEvent *>(e);
-            d->mousePressEvent(ev->button(), matrix.map(ev->pos()), ev->modifiers(), ev->buttons(),
+            d->mousePressEvent(ev, ev->button(), matrix.map(ev->pos()), ev->modifiers(), ev->buttons(),
                                ev->screenPos());
             break; }
         case QEvent::GraphicsSceneMouseMove: {
@@ -1296,7 +1296,9 @@ QVariant QTextControl::loadResource(int type, const QUrl &name)
 void QTextControlPrivate::_q_updateBlock(const QTextBlock &block)
 {
     Q_Q(QTextControl);
-    emit q->updateRequest(q->blockBoundingRect(block));
+    QRectF br = q->blockBoundingRect(block);
+    br.setRight(qreal(INT_MAX)); // the block might have shrunk
+    emit q->updateRequest(br);
 }
 
 QRectF QTextControlPrivate::rectForPosition(int position) const
@@ -1465,7 +1467,7 @@ QRectF QTextControl::selectionRect() const
     return selectionRect(d->cursor);
 }
 
-void QTextControlPrivate::mousePressEvent(Qt::MouseButton button, const QPointF &pos, Qt::KeyboardModifiers modifiers,
+void QTextControlPrivate::mousePressEvent(QEvent *e, Qt::MouseButton button, const QPointF &pos, Qt::KeyboardModifiers modifiers,
                                           Qt::MouseButtons buttons, const QPoint &globalPos)
 {
     Q_Q(QTextControl);
@@ -1479,11 +1481,11 @@ void QTextControlPrivate::mousePressEvent(Qt::MouseButton button, const QPointF
             cursor.clearSelection();
         }
     }
-    if (!(button & Qt::LeftButton))
-        return;
-
-    if (!((interactionFlags & Qt::TextSelectableByMouse) || (interactionFlags & Qt::TextEditable)))
-        return;
+    if (!(button & Qt::LeftButton) ||
+        !((interactionFlags & Qt::TextSelectableByMouse) || (interactionFlags & Qt::TextEditable))) {
+            e->ignore();
+            return;
+    }
 
     cursorIsFocusIndicator = false;
     const QTextCursor oldSelection = cursor;
@@ -1507,8 +1509,10 @@ void QTextControlPrivate::mousePressEvent(Qt::MouseButton button, const QPointF
         trippleClickTimer.stop();
     } else {
         int cursorPos = q->hitTest(pos, Qt::FuzzyHit);
-        if (cursorPos == -1)
+        if (cursorPos == -1) {
+            e->ignore();
             return;
+        }
 
 #if !defined(QT_NO_IM)
         QTextLayout *layout = cursor.block().layout();
@@ -1519,8 +1523,10 @@ void QTextControlPrivate::mousePressEvent(Qt::MouseButton button, const QPointF
                                button, buttons, modifiers);
                 ctx->mouseHandler(cursorPos - cursor.position(), &ev);
             }
-            if (!layout->preeditAreaText().isEmpty())
+            if (!layout->preeditAreaText().isEmpty()) {
+                e->ignore();
                 return;
+            }
         }
 #endif
         if (modifiers == Qt::ShiftModifier) {
diff --git a/src/gui/text/qtextcontrol_p_p.h b/src/gui/text/qtextcontrol_p_p.h
index ca9db9f..66459f6 100644
--- a/src/gui/text/qtextcontrol_p_p.h
+++ b/src/gui/text/qtextcontrol_p_p.h
@@ -131,10 +131,10 @@ public:
     QString anchorForCursor(const QTextCursor &anchor) const;
 
     void keyPressEvent(QKeyEvent *e);
-    void mousePressEvent(Qt::MouseButton button, const QPointF &pos,
+    void mousePressEvent(QEvent *e, Qt::MouseButton button, const QPointF &pos,
                          Qt::KeyboardModifiers modifiers,
                          Qt::MouseButtons buttons,
-                         const QPoint &globalPos = QPoint());
+                         const QPoint &globalPos);
     void mouseMoveEvent(Qt::MouseButtons buttons, const QPointF &pos);
     void mouseReleaseEvent(Qt::MouseButton button, const QPointF &pos);
     void mouseDoubleClickEvent(QEvent *e, Qt::MouseButton button, const QPointF &pos);
diff --git a/src/gui/util/qdesktopservices.cpp b/src/gui/util/qdesktopservices.cpp
index 85b539f..fd84949 100644
--- a/src/gui/util/qdesktopservices.cpp
+++ b/src/gui/util/qdesktopservices.cpp
@@ -293,8 +293,6 @@ void QDesktopServices::unsetUrlHandler(const QString &scheme)
     have desktop concept, DesktopLocation returns same path as DocumentsLocation.
     Rest of the standard locations point to folder on same drive with executable, except
     that if executable is in ROM the folder from C drive is returned.
-
-    \endcode
 */
 
 /*!
diff --git a/src/gui/widgets/qcombobox.cpp b/src/gui/widgets/qcombobox.cpp
index 1879db4..bd1d8ba 100644
--- a/src/gui/widgets/qcombobox.cpp
+++ b/src/gui/widgets/qcombobox.cpp
@@ -1111,6 +1111,32 @@ void QComboBoxPrivate::updateLineEditGeometry()
     lineEdit->setGeometry(editRect);
 }
 
+Qt::MatchFlags QComboBoxPrivate::matchFlags() const
+{
+    // Base how duplicates are determined on the autocompletion case sensitivity
+    Qt::MatchFlags flags = Qt::MatchFixedString;
+#ifndef QT_NO_COMPLETER
+    if (!lineEdit->completer() || lineEdit->completer()->caseSensitivity() == Qt::CaseSensitive)
+#endif
+        flags |= Qt::MatchCaseSensitive;
+    return flags;
+}
+
+
+void QComboBoxPrivate::_q_editingFinished()
+{
+    Q_Q(QComboBox);
+    if (lineEdit && !lineEdit->text().isEmpty()) {
+        //here we just check if the current item was entered
+        const int index = q_func()->findText(lineEdit->text(), matchFlags());
+        if (index != -1 && itemText(currentIndex) != lineEdit->text()) {
+            q->setCurrentIndex(index);
+            emitActivated(currentIndex);
+        }
+    }
+
+}
+
 void QComboBoxPrivate::_q_returnPressed()
 {
     Q_Q(QComboBox);
@@ -1123,13 +1149,7 @@ void QComboBoxPrivate::_q_returnPressed()
         // check for duplicates (if not enabled) and quit
         int index = -1;
         if (!duplicatesEnabled) {
-            // Base how duplicates are determined on the autocompletion case sensitivity
-            Qt::MatchFlags flags = Qt::MatchFixedString;
-#ifndef QT_NO_COMPLETER
-            if (!lineEdit->completer() || lineEdit->completer()->caseSensitivity() == Qt::CaseSensitive)
-#endif
-                flags |= Qt::MatchCaseSensitive;
-            index = q->findText(text, flags);
+            index = q->findText(text, matchFlags());
             if (index != -1) {
                 q->setCurrentIndex(index);
                 emitActivated(currentIndex);
@@ -1664,6 +1684,7 @@ void QComboBox::setLineEdit(QLineEdit *edit)
     if (d->lineEdit->parent() != this)
         d->lineEdit->setParent(this);
     connect(d->lineEdit, SIGNAL(returnPressed()), this, SLOT(_q_returnPressed()));
+    connect(d->lineEdit, SIGNAL(editingFinished()), this, SLOT(_q_editingFinished()));
     connect(d->lineEdit, SIGNAL(textChanged(QString)), this, SIGNAL(editTextChanged(QString)));
 #ifdef QT3_SUPPORT
     connect(d->lineEdit, SIGNAL(textChanged(QString)), this, SIGNAL(textChanged(QString)));
@@ -1960,7 +1981,7 @@ void QComboBoxPrivate::setCurrentIndex(const QModelIndex &mi)
     if (lineEdit) {
         QString newText = q->itemText(currentIndex.row());
         if (lineEdit->text() != newText)
-            lineEdit->setText(q->itemText(currentIndex.row()));
+            lineEdit->setText(newText);
         updateLineEditGeometry();
     }
     if (indexChanged) {
diff --git a/src/gui/widgets/qcombobox.h b/src/gui/widgets/qcombobox.h
index 0652594..5d5ea21 100644
--- a/src/gui/widgets/qcombobox.h
+++ b/src/gui/widgets/qcombobox.h
@@ -304,6 +304,7 @@ private:
     Q_PRIVATE_SLOT(d_func(), void _q_itemSelected(const QModelIndex &item))
     Q_PRIVATE_SLOT(d_func(), void _q_emitHighlighted(const QModelIndex &))
     Q_PRIVATE_SLOT(d_func(), void _q_emitCurrentIndexChanged(const QModelIndex &index))
+    Q_PRIVATE_SLOT(d_func(), void _q_editingFinished())
     Q_PRIVATE_SLOT(d_func(), void _q_returnPressed())
     Q_PRIVATE_SLOT(d_func(), void _q_resetButton())
     Q_PRIVATE_SLOT(d_func(), void _q_dataChanged(const QModelIndex &, const QModelIndex &))
diff --git a/src/gui/widgets/qcombobox_p.h b/src/gui/widgets/qcombobox_p.h
index fe42c47..f6ba57c 100644
--- a/src/gui/widgets/qcombobox_p.h
+++ b/src/gui/widgets/qcombobox_p.h
@@ -342,6 +342,8 @@ public:
     void init();
     QComboBoxPrivateContainer* viewContainer();
     void updateLineEditGeometry();
+    Qt::MatchFlags matchFlags() const;
+    void _q_editingFinished();
     void _q_returnPressed();
     void _q_complete();
     void _q_itemSelected(const QModelIndex &item);
diff --git a/src/gui/widgets/qlinecontrol.cpp b/src/gui/widgets/qlinecontrol.cpp
index 0fc94c9..2914164 100644
--- a/src/gui/widgets/qlinecontrol.cpp
+++ b/src/gui/widgets/qlinecontrol.cpp
@@ -1511,6 +1511,18 @@ void QLineControl::processKeyEvent(QKeyEvent* event)
     }
 #endif // QT_NO_COMPLETER
 
+    if (event->key() == Qt::Key_Enter || event->key() == Qt::Key_Return) {
+        if (hasAcceptableInput() || fixup()) {
+            emit accepted();
+            emit editingFinished();
+        }
+        if (inlineCompletionAccepted)
+            event->accept();
+        else
+            event->ignore();
+        return;
+    }
+
     if (echoMode() == QLineEdit::PasswordEchoOnEdit
         && !passwordEchoEditing()
         && !isReadOnly()
@@ -1531,17 +1543,6 @@ void QLineControl::processKeyEvent(QKeyEvent* event)
         clear();
     }
 
-    if (event->key() == Qt::Key_Enter || event->key() == Qt::Key_Return) {
-        if (hasAcceptableInput() || fixup()) {
-            emit accepted();
-            emit editingFinished();
-        }
-        if (inlineCompletionAccepted)
-            event->accept();
-        else
-            event->ignore();
-        return;
-    }
     bool unknown = false;
 
     if (false) {
diff --git a/src/gui/widgets/qmenu.cpp b/src/gui/widgets/qmenu.cpp
index 1b5d1cd..cc39b7f 100644
--- a/src/gui/widgets/qmenu.cpp
+++ b/src/gui/widgets/qmenu.cpp
@@ -273,7 +273,7 @@ void QMenuPrivate::updateActionRects() const
 
     for (int i = 0; i < actions.count(); ++i) {
         QAction *action = actions.at(i);
-        if (action->isSeparator() || !action->isVisible() || widgetItems.at(i))
+        if (action->isSeparator() || !action->isVisible() || widgetItems.contains(action))
             continue;
         //..and some members
         hasCheckableItems |= action->isCheckable();
@@ -301,7 +301,7 @@ void QMenuPrivate::updateActionRects() const
         const QFontMetrics &fm = opt.fontMetrics;
 
         QSize sz;
-        if (QWidget *w = widgetItems.at(i)) {
+        if (QWidget *w = widgetItems.value(action)) {
           sz = w->sizeHint().expandedTo(w->minimumSize()).expandedTo(w->minimumSizeHint()).boundedTo(w->maximumSize());
         } else {
             //calc what I think the size is..
@@ -370,7 +370,7 @@ void QMenuPrivate::updateActionRects() const
         rect.setWidth(max_column_width); //uniform width
 
         //we need to update the widgets geometry
-        if (QWidget *widget = widgetItems.at(i)) {
+        if (QWidget *widget = widgetItems.value(actions.at(i))) {
             widget->setGeometry(rect);
             widget->setVisible(actions.at(i)->isVisible());
         }
@@ -583,8 +583,7 @@ void QMenuPrivate::setCurrentAction(QAction *action, int popup, SelectionReason
             q->update(actionRect(action));
 
             if (reason == SelectedFromKeyboard) {
-                const int actionIndex = actions.indexOf(action);
-                QWidget *widget = widgetItems.at(actionIndex);
+                QWidget *widget = widgetItems.value(action);
                 if (widget) {
                     if (widget->focusPolicy() != Qt::NoFocus)
                         widget->setFocus(Qt::TabFocusReason);
@@ -800,7 +799,7 @@ void QMenuPrivate::scrollMenu(QAction *action, QMenuScroller::ScrollLocation loc
             current.moveTop(current.top() + delta);
 
             //we need to update the widgets geometry
-            if (QWidget *w = widgetItems.at(i))
+            if (QWidget *w = widgetItems.value(actions.at(i)))
                 w->setGeometry(current);
         }
     }
@@ -1392,11 +1391,12 @@ QMenu::QMenu(QMenuPrivate &dd, QWidget *parent)
 QMenu::~QMenu()
 {
     Q_D(QMenu);
-    for (int i = 0; i < d->widgetItems.count(); ++i) {
-        if (QWidget *widget = d->widgetItems.at(i)) {
-            QWidgetAction *action = static_cast<QWidgetAction *>(d->actions.at(i));
+    QHash<QAction *, QWidget *>::iterator it = d->widgetItems.begin();
+    for (; it != d->widgetItems.end(); ++it) {
+        if (QWidget *widget = it.value()) {
+            QWidgetAction *action = static_cast<QWidgetAction *>(it.key());
             action->releaseWidget(widget);
-            d->widgetItems[i] = 0;
+            *it = 0;
         }
     }
 
@@ -1878,9 +1878,11 @@ void QMenu::popup(const QPoint &p, QAction *atAction)
             if(snapToMouse) //position flowing left from the mouse
                 pos.setX(mouse.x()-size.width());
 
+#ifndef QT_NO_MENUBAR
             //if in a menubar, it should be right-aligned
             if (qobject_cast<QMenuBar*>(d->causedPopup.widget))
                 pos.rx() -= size.width();
+#endif //QT_NO_MENUBAR
 
             if (pos.x() < screen.left()+desktopFrame)
                 pos.setX(qMax(p.x(), screen.left()+desktopFrame));
@@ -2151,7 +2153,7 @@ void QMenu::paintEvent(QPaintEvent *e)
         QAction *action = d->actions.at(i);
         QRect adjustedActionRect = d->actionRects.at(i);
         if (!e->rect().intersects(adjustedActionRect)
-            || d->widgetItems.at(i))
+            || d->widgetItems.value(action))
            continue;
         //set the clip region to be extra safe (and adjust for the scrollers)
         QRegion adjustedActionReg(adjustedActionRect);
@@ -2862,25 +2864,20 @@ void QMenu::actionEvent(QActionEvent *e)
             connect(e->action(), SIGNAL(triggered()), this, SLOT(_q_actionTriggered()));
             connect(e->action(), SIGNAL(hovered()), this, SLOT(_q_actionHovered()));
         }
-        QWidget *widget = 0;
-        if (QWidgetAction *wa = qobject_cast<QWidgetAction *>(e->action()))
-            widget = wa->requestWidget(this);
-
-        int index = d->actions.indexOf(e->action());
-        Q_ASSERT(index != -1);
-        d->widgetItems.insert(index, widget);
-
+        if (QWidgetAction *wa = qobject_cast<QWidgetAction *>(e->action())) {
+            QWidget *widget = wa->requestWidget(this);
+            if (widget)
+                d->widgetItems.insert(wa, widget);
+        }
     } else if (e->type() == QEvent::ActionRemoved) {
         e->action()->disconnect(this);
         if (e->action() == d->currentAction)
             d->currentAction = 0;
-        int index = d->actions.indexOf(e->before()) + 1;
         if (QWidgetAction *wa = qobject_cast<QWidgetAction *>(e->action())) {
-            if (QWidget *widget = d->widgetItems.at(index))
+            if (QWidget *widget = d->widgetItems.value(wa))
                 wa->releaseWidget(widget);
         }
-        Q_ASSERT(index != -1);
-        d->widgetItems.removeAt(index);
+        d->widgetItems.remove(e->action());
     }
 
 #ifdef Q_WS_MAC
diff --git a/src/gui/widgets/qmenu_mac.mm b/src/gui/widgets/qmenu_mac.mm
index b238faf..9510cc6 100644
--- a/src/gui/widgets/qmenu_mac.mm
+++ b/src/gui/widgets/qmenu_mac.mm
@@ -1191,7 +1191,7 @@ QMenuPrivate::QMacMenuPrivate::addAction(QMacMenuAction *action, QMacMenuAction
 #endif
         }
 
-        QWidget *widget = qmenu ? qmenu->widgetItems.value(qmenu->actions.indexOf(action->action)) : 0;
+        QWidget *widget = qmenu ? qmenu->widgetItems.value(action->action) : 0;
         if (widget) {
 #ifndef QT_MAC_USE_COCOA
             ChangeMenuAttributes(action->menu, kMenuAttrDoNotCacheImage, 0);
diff --git a/src/gui/widgets/qmenu_p.h b/src/gui/widgets/qmenu_p.h
index 9348f7b..a5bde7c 100644
--- a/src/gui/widgets/qmenu_p.h
+++ b/src/gui/widgets/qmenu_p.h
@@ -190,7 +190,7 @@ public:
     QRect actionRect(QAction *) const;
 
     mutable QVector<QRect> actionRects;
-    mutable QWidgetList widgetItems;
+    mutable QHash<QAction *, QWidget *> widgetItems;
     void updateActionRects() const;
     QRect popupGeometry(const QWidget *widget) const;
     QRect popupGeometry(int screen = -1) const;
diff --git a/src/gui/widgets/qwidgetanimator.cpp b/src/gui/widgets/qwidgetanimator.cpp
index bdd3c75..13ee346 100644
--- a/src/gui/widgets/qwidgetanimator.cpp
+++ b/src/gui/widgets/qwidgetanimator.cpp
@@ -88,8 +88,6 @@ void QWidgetAnimator::animate(QWidget *widget, const QRect &_final_geometry, boo
     const QRect final_geometry = _final_geometry.isValid() || widget->isWindow() ? _final_geometry :
         QRect(QPoint(-500 - widget->width(), -500 - widget->height()), widget->size());
 
-    if (r == final_geometry)
-        return; //the widget is already where it should be
 #ifndef QT_NO_ANIMATION
     AnimationMap::const_iterator it = m_animation_map.constFind(widget);
     if (it != m_animation_map.constEnd() && (*it)->endValue().toRect() == final_geometry)
@@ -116,9 +114,4 @@ bool QWidgetAnimator::animating() const
     return !m_animation_map.isEmpty();
 }
 
-bool QWidgetAnimator::animating(QWidget *widget) const
-{
-    return m_animation_map.contains(widget);
-}
-
 QT_END_NAMESPACE
diff --git a/src/gui/widgets/qwidgetanimator_p.h b/src/gui/widgets/qwidgetanimator_p.h
index 68d9344..095380f 100644
--- a/src/gui/widgets/qwidgetanimator_p.h
+++ b/src/gui/widgets/qwidgetanimator_p.h
@@ -70,7 +70,6 @@ public:
     QWidgetAnimator(QMainWindowLayout *layout);
     void animate(QWidget *widget, const QRect &final_geometry, bool animate);
     bool animating() const;
-    bool animating(QWidget *widget) const;
 
     void abort(QWidget *widget);