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

17 files changed, 276 insertions, 246 deletions

diff --git a/src/gui/graphicsview/qgraphicsitem.cpp b/src/gui/graphicsview/qgraphicsitem.cpp
index b2c04ca..a304027 100644
--- a/src/gui/graphicsview/qgraphicsitem.cpp
+++ b/src/gui/graphicsview/qgraphicsitem.cpp
@@ -797,7 +797,7 @@ QPointF QGraphicsItemPrivate::genericMapFromScene(const QPointF &pos,
 void QGraphicsItemPrivate::combineTransformToParent(QTransform *x, const QTransform *viewTransform) const
 {
     // COMBINE
-    if (itemIsUntransformable() && viewTransform) {
+    if (viewTransform && itemIsUntransformable()) {
         *x = q_ptr->deviceTransform(*viewTransform);
     } else {
         if (transformData)
@@ -819,7 +819,7 @@ void QGraphicsItemPrivate::combineTransformToParent(QTransform *x, const QTransf
 void QGraphicsItemPrivate::combineTransformFromParent(QTransform *x, const QTransform *viewTransform) const
 {
     // COMBINE
-    if (itemIsUntransformable() && viewTransform) {
+    if (viewTransform && itemIsUntransformable()) {
         *x = q_ptr->deviceTransform(*viewTransform);
     } else {
         x->translate(pos.x(), pos.y());
diff --git a/src/gui/graphicsview/qgraphicsscene.cpp b/src/gui/graphicsview/qgraphicsscene.cpp
index 4d4c3b4..6c97886 100644
--- a/src/gui/graphicsview/qgraphicsscene.cpp
+++ b/src/gui/graphicsview/qgraphicsscene.cpp
@@ -1424,6 +1424,63 @@ QGraphicsWidget *QGraphicsScenePrivate::windowForItem(const QGraphicsItem *item)
     return 0;
 }
 
+QList<QGraphicsItem *> QGraphicsScenePrivate::topLevelItemsInStackingOrder(const QTransform *const viewTransform,
+                                                                           QRegion *exposedRegion)
+{
+    if (indexMethod == QGraphicsScene::NoIndex || !exposedRegion) {
+        if (needSortTopLevelItems) {
+            needSortTopLevelItems = false;
+            qStableSort(topLevelItems.begin(), topLevelItems.end(), qt_notclosestLeaf);
+        }
+        return topLevelItems;
+    }
+
+    const QRectF exposedRect = exposedRegion->boundingRect().adjusted(-1, -1, 1, 1);
+    QRectF sceneRect;
+    QTransform invertedViewTransform(Qt::Uninitialized);
+    if (!viewTransform) {
+        sceneRect = exposedRect;
+    } else {
+        invertedViewTransform = viewTransform->inverted();
+        sceneRect = invertedViewTransform.mapRect(exposedRect);
+    }
+    if (!largestUntransformableItem.isEmpty()) {
+        // ### Nuke this when we move the indexing code into a separate
+        // class.  All the largestUntransformableItem code should then go
+        // away, and the estimate function should return untransformable
+        // items as well.
+        QRectF untr = largestUntransformableItem;
+        QRectF ltri = !viewTransform ? untr : invertedViewTransform.mapRect(untr);
+        ltri.adjust(-untr.width(), -untr.height(), untr.width(), untr.height());
+        sceneRect.adjust(-ltri.width(), -ltri.height(), ltri.width(), ltri.height());
+    }
+
+    QList<QGraphicsItem *> tmp = estimateItemsInRect(sceneRect);
+    for (int i = 0; i < tmp.size(); ++i)
+        tmp.at(i)->topLevelItem()->d_ptr->itemDiscovered = 1;
+
+    // Sort if the toplevel list is unsorted.
+    if (needSortTopLevelItems) {
+        needSortTopLevelItems = false;
+        qStableSort(topLevelItems.begin(), topLevelItems.end(), qt_notclosestLeaf);
+    }
+
+    QList<QGraphicsItem *> tli;
+    for (int i = 0; i < topLevelItems.size(); ++i) {
+        // ### Investigate smarter ways. Looping through all top level
+        // items is not optimal. If the BSP tree is to have maximum
+        // effect, it should be possible to sort the subset of items
+        // quickly. We must use this approach for now, as it's the only
+        // current way to keep the stable sorting order (insertion order).
+        QGraphicsItem *item = topLevelItems.at(i);
+        if (item->d_ptr->itemDiscovered) {
+            item->d_ptr->itemDiscovered = 0;
+            tli << item;
+        }
+    }
+    return tli;
+}
+
 void QGraphicsScenePrivate::recursive_items_helper(QGraphicsItem *item, QRectF rect,
                                                    QList<QGraphicsItem *> *items,
                                                    const QTransform &parentTransform,
@@ -5045,165 +5102,118 @@ void QGraphicsScenePrivate::drawItemHelper(QGraphicsItem *item, QPainter *painte
 }
 
 void QGraphicsScenePrivate::drawSubtreeRecursive(QGraphicsItem *item, QPainter *painter,
-                                                 const QTransform &viewTransform,
+                                                 const QTransform *const viewTransform,
                                                  QRegion *exposedRegion, QWidget *widget,
-                                                 QList<QGraphicsItem *> *topLevelItems,
                                                  qreal parentOpacity)
 {
-    // Calculate opacity.
-    qreal opacity;
-    bool invisibleButChildIgnoresParentOpacity = false;
-    if (item) {
-        if (!item->d_ptr->visible)
-            return;
-        opacity = item->d_ptr->combineOpacityFromParent(parentOpacity);
-        if (opacity == 0.0 && !(item->d_ptr->flags & QGraphicsItem::ItemDoesntPropagateOpacityToChildren)) {
-            invisibleButChildIgnoresParentOpacity = !item->d_ptr->childrenCombineOpacity();
-            if (!invisibleButChildIgnoresParentOpacity)
-                return;
-        }
-    } else {
-        opacity = parentOpacity;
-    }
-
-    // Item is invisible.
-    bool hasContents = item && !(item->d_ptr->flags & QGraphicsItem::ItemHasNoContents);
-    bool invisible = !hasContents || invisibleButChildIgnoresParentOpacity;
-
-    // Calculate the full transform for this item.
-    bool wasDirtyParentSceneTransform = false;
-    bool dontDrawItem = true;
-    QTransform transform(Qt::Uninitialized);
-    if (item) {
-        if (item->d_ptr->itemIsUntransformable()) {
-            transform = item->deviceTransform(viewTransform);
-        } else {
-            if (item->d_ptr->dirtySceneTransform) {
-                item->d_ptr->sceneTransform = item->d_ptr->parent ? item->d_ptr->parent->d_ptr->sceneTransform
-                                              : QTransform();
-                item->d_ptr->combineTransformFromParent(&item->d_ptr->sceneTransform);
-                item->d_ptr->dirtySceneTransform = 0;
-                wasDirtyParentSceneTransform = true;
-            }
-            transform = item->d_ptr->sceneTransform;
-            transform *= viewTransform;
-        }
-
-        if (!invisible) {
-            QRectF brect = item->boundingRect();
-            // ### This does not take the clip into account.
-            _q_adjustRect(&brect);
-            QRect viewBoundingRect = transform.mapRect(brect).toRect();
-            item->d_ptr->paintedViewBoundingRects.insert(widget, viewBoundingRect);
-            viewBoundingRect.adjust(-1, -1, 1, 1);
-            if (exposedRegion)
-                dontDrawItem = !exposedRegion->intersects(viewBoundingRect);
-            else
-                dontDrawItem = viewBoundingRect.isEmpty();
-        }
-    }
+    Q_ASSERT(item);
 
-    // Find and sort children.
-    QList<QGraphicsItem *> tmp;
-    QList<QGraphicsItem *> *children = 0;
-    if (item) {
-        children = &item->d_ptr->children;
-    } else if (topLevelItems) {
-        children = topLevelItems;
-    } else if (indexMethod == QGraphicsScene::NoIndex || !exposedRegion) {
-        children = &this->topLevelItems;
-    } else {
-        QRectF sceneRect = viewTransform.inverted().mapRect(QRectF(exposedRegion->boundingRect().adjusted(-1, -1, 1, 1)));
-        if (!largestUntransformableItem.isEmpty()) {
-            // ### Nuke this when we move the indexing code into a separate
-            // class.  All the largestUntransformableItem code should then go
-            // away, and the estimate function should return untransformable
-            // items as well.
-            QRectF untr = largestUntransformableItem;
-            QRectF ltri = viewTransform.inverted().mapRect(untr);
-            ltri.adjust(-untr.width(), -untr.height(), untr.width(), untr.height());
-            sceneRect.adjust(-ltri.width(), -ltri.height(), ltri.width(), ltri.height());
-        }
-        tmp = estimateItemsInRect(sceneRect);
+    if (!item->d_ptr->visible)
+        return;
 
-        QList<QGraphicsItem *> tli;
-        for (int i = 0; i < tmp.size(); ++i)
-            tmp.at(i)->topLevelItem()->d_ptr->itemDiscovered = 1;
+    const bool itemHasContents = !(item->d_ptr->flags & QGraphicsItem::ItemHasNoContents);
+    const bool itemHasChildren = !item->d_ptr->children.isEmpty();
+    if (!itemHasContents && !itemHasChildren)
+        return; // Item has neither contents nor children!(?)
 
-        // Sort if the toplevel list is unsorted.
-        if (needSortTopLevelItems) {
-            needSortTopLevelItems = false;
-            qStableSort(this->topLevelItems.begin(),
-                        this->topLevelItems.end(), qt_notclosestLeaf);
-        }
+    const qreal opacity = item->d_ptr->combineOpacityFromParent(parentOpacity);
+    const bool itemIsFullyTransparent = (opacity < 0.0001);
+    if (itemIsFullyTransparent && (!itemHasChildren || item->d_ptr->childrenCombineOpacity()))
+        return;
 
-        for (int i = 0; i < this->topLevelItems.size(); ++i) {
-            // ### Investigate smarter ways. Looping through all top level
-            // items is not optimal. If the BSP tree is to have maximum
-            // effect, it should be possible to sort the subset of items
-            // quickly. We must use this approach for now, as it's the only
-            // current way to keep the stable sorting order (insertion order).
-            QGraphicsItem *item = this->topLevelItems.at(i);
-            if (item->d_ptr->itemDiscovered) {
-                item->d_ptr->itemDiscovered = 0;
-                tli << item;
+    QTransform transform(Qt::Uninitialized);
+    QTransform *transformPtr = 0;
+#define ENSURE_TRANSFORM_PTR \
+    if (!transformPtr) { \
+        Q_ASSERT(!itemIsUntransformable); \
+        if (viewTransform) { \
+            transform = item->d_ptr->sceneTransform; \
+            transform *= *viewTransform; \
+            transformPtr = &transform; \
+        } else { \
+            transformPtr = &item->d_ptr->sceneTransform; \
+        } \
+    }
+
+    // Update the item's scene transform if the item is transformable;
+    // otherwise calculate the full transform,
+    bool wasDirtyParentSceneTransform = false;
+    const bool itemIsUntransformable = item->d_ptr->itemIsUntransformable();
+    if (itemIsUntransformable) {
+        transform = item->deviceTransform(viewTransform ? *viewTransform : QTransform());
+        transformPtr = &transform;
+    } else if (item->d_ptr->dirtySceneTransform) {
+        item->d_ptr->sceneTransform = item->d_ptr->parent ? item->d_ptr->parent->d_ptr->sceneTransform
+                                                          : QTransform();
+        item->d_ptr->combineTransformFromParent(&item->d_ptr->sceneTransform);
+        item->d_ptr->dirtySceneTransform = 0;
+        wasDirtyParentSceneTransform = true;
+    }
+
+    const bool itemClipsChildrenToShape = (item->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape);
+    bool drawItem = itemHasContents && !itemIsFullyTransparent;
+    if (drawItem) {
+        const QRectF brect = adjustedItemBoundingRect(item);
+        ENSURE_TRANSFORM_PTR
+        QRect viewBoundingRect = transformPtr->mapRect(brect).toRect();
+        item->d_ptr->paintedViewBoundingRects.insert(widget, viewBoundingRect);
+        viewBoundingRect.adjust(-1, -1, 1, 1);
+        drawItem = exposedRegion ? exposedRegion->intersects(viewBoundingRect) : !viewBoundingRect.isEmpty();
+        if (!drawItem) {
+            if (!itemHasChildren)
+                return;
+            if (itemClipsChildrenToShape) {
+                if (wasDirtyParentSceneTransform)
+                    item->d_ptr->invalidateChildrenSceneTransform();
+                return;
             }
         }
+    } // else we know for sure this item has children we must process.
 
-        tmp = tli;
-        children = &tmp;
-    }
-
-    bool childClip = (item && (item->d_ptr->flags & QGraphicsItem::ItemClipsChildrenToShape));
-    bool dontDrawChildren = item && hasContents && dontDrawItem && childClip;
-    childClip &= !dontDrawChildren && !children->isEmpty();
-    if (item && invisible)
-        dontDrawItem = true;
-
-    // Clip children.
-    if (childClip) {
-        painter->save();
-        painter->setWorldTransform(transform);
-        painter->setClipPath(item->shape(), Qt::IntersectClip);
-    }
-    
-    if (!dontDrawChildren) {
-        if (item && item->d_ptr->needSortChildren) {
+    int i = 0;
+    if (itemHasChildren) {
+        if (item->d_ptr->needSortChildren) {
             item->d_ptr->needSortChildren = 0;
-            qStableSort(children->begin(), children->end(), qt_notclosestLeaf);
-        } else if (!item && needSortTopLevelItems && children != &tmp) {
-            needSortTopLevelItems = false;
-            qStableSort(children->begin(), children->end(), qt_notclosestLeaf);
+            qStableSort(item->d_ptr->children.begin(), item->d_ptr->children.end(), qt_notclosestLeaf);
         }
-    }
 
-    // Draw children behind
-    int i = 0;
-    if (!dontDrawChildren) {
-        // ### Don't visit children that don't ignore parent opacity if this
-        // item is invisible.
-        for (i = 0; i < children->size(); ++i) {
-            QGraphicsItem *child = children->at(i);
+        if (itemClipsChildrenToShape) {
+            painter->save();
+            ENSURE_TRANSFORM_PTR
+            painter->setWorldTransform(*transformPtr);
+            painter->setClipPath(item->shape(), Qt::IntersectClip);
+        }
+
+        // Draw children behind
+        for (i = 0; i < item->d_ptr->children.size(); ++i) {
+            QGraphicsItem *child = item->d_ptr->children.at(i);
             if (wasDirtyParentSceneTransform)
                 child->d_ptr->dirtySceneTransform = 1;
             if (!(child->d_ptr->flags & QGraphicsItem::ItemStacksBehindParent))
                 break;
-            drawSubtreeRecursive(child, painter, viewTransform, exposedRegion, widget,
-                                 0, opacity);
+            if (itemIsFullyTransparent && !(child->d_ptr->flags & QGraphicsItem::ItemIgnoresParentOpacity))
+                continue;
+            drawSubtreeRecursive(child, painter, viewTransform, exposedRegion, widget, opacity);
         }
     }
 
     // Draw item
-    if (!dontDrawItem) {
-        item->d_ptr->initStyleOption(&styleOptionTmp, transform, exposedRegion ? *exposedRegion : QRegion(), exposedRegion == 0);
-
-        bool clipsToShape = (item->d_ptr->flags & QGraphicsItem::ItemClipsToShape);
-        bool savePainter = clipsToShape || painterStateProtection;
+    if (drawItem) {
+        Q_ASSERT(!itemIsFullyTransparent);
+        Q_ASSERT(itemHasContents);
+        item->d_ptr->initStyleOption(&styleOptionTmp, transform, exposedRegion
+                                     ? *exposedRegion : QRegion(), exposedRegion == 0);
+
+        const bool itemClipsToShape = item->d_ptr->flags & QGraphicsItem::ItemClipsToShape;
+        const bool savePainter = itemClipsToShape || painterStateProtection;
         if (savePainter)
             painter->save();
-        if (!childClip)
-            painter->setWorldTransform(transform);
-        if (clipsToShape)
+
+        if (!itemHasChildren || !itemClipsChildrenToShape) {
+            ENSURE_TRANSFORM_PTR
+            painter->setWorldTransform(*transformPtr);
+        }
+        if (itemClipsToShape)
             painter->setClipPath(item->shape(), Qt::IntersectClip);
         painter->setOpacity(opacity);
 
@@ -5217,22 +5227,19 @@ void QGraphicsScenePrivate::drawSubtreeRecursive(QGraphicsItem *item, QPainter *
     }
 
     // Draw children in front
-    if (!dontDrawChildren) {
-        // ### Don't visit children that don't ignore parent opacity if this
-        // item is invisible.
-        for (; i < children->size(); ++i) {
-            QGraphicsItem *child = children->at(i);
+    if (itemHasChildren) {
+        for (; i < item->d_ptr->children.size(); ++i) {
+            QGraphicsItem *child = item->d_ptr->children.at(i);
             if (wasDirtyParentSceneTransform)
                 child->d_ptr->dirtySceneTransform = 1;
-            drawSubtreeRecursive(child, painter, viewTransform, exposedRegion,
-                                 widget, 0, opacity);
+            if (itemIsFullyTransparent && !(child->d_ptr->flags & QGraphicsItem::ItemIgnoresParentOpacity))
+                continue;
+            drawSubtreeRecursive(child, painter, viewTransform, exposedRegion, widget, opacity);
         }
-    } else if (wasDirtyParentSceneTransform) {
-        item->d_ptr->invalidateChildrenSceneTransform();
     }
 
     // Restore child clip
-    if (childClip)
+    if (itemHasChildren && itemClipsChildrenToShape)
         painter->restore();
 }
 
@@ -5525,7 +5532,7 @@ void QGraphicsScene::drawItems(QPainter *painter,
         if (!item->d_ptr->itemDiscovered) {
             topLevelItems << item;
             item->d_ptr->itemDiscovered = 1;
-            d->drawSubtreeRecursive(item, painter, viewTransform, expose, widget);
+            d->drawSubtreeRecursive(item, painter, &viewTransform, expose, widget);
         }
     }
 
diff --git a/src/gui/graphicsview/qgraphicsscene_p.h b/src/gui/graphicsview/qgraphicsscene_p.h
index a8f6699..2f63e5b 100644
--- a/src/gui/graphicsview/qgraphicsscene_p.h
+++ b/src/gui/graphicsview/qgraphicsscene_p.h
@@ -206,6 +206,7 @@ public:
     void mousePressEventHandler(QGraphicsSceneMouseEvent *mouseEvent);
     QGraphicsWidget *windowForItem(const QGraphicsItem *item) const;
 
+    QList<QGraphicsItem *> topLevelItemsInStackingOrder(const QTransform *const, QRegion *);
     void recursive_items_helper(QGraphicsItem *item, QRectF rect, QList<QGraphicsItem *> *items,
                                 const QTransform &parentTransform, const QTransform &viewTransform,
                                 Qt::ItemSelectionMode mode, Qt::SortOrder order, qreal parentOpacity = 1.0) const;
@@ -259,10 +260,18 @@ public:
     void drawItemHelper(QGraphicsItem *item, QPainter *painter,
                         const QStyleOptionGraphicsItem *option, QWidget *widget,
                         bool painterStateProtection);
-    
-    void drawSubtreeRecursive(QGraphicsItem *item, QPainter *painter, const QTransform &viewTransform,
-                              QRegion *exposedRegion, QWidget *widget,
-                              QList<QGraphicsItem *> *topLevelItems = 0, qreal parentOpacity = qreal(1.0));
+
+    inline void drawItems(QPainter *painter, const QTransform *const viewTransform,
+                          QRegion *exposedRegion, QWidget *widget)
+    {
+        const QList<QGraphicsItem *> tli = topLevelItemsInStackingOrder(viewTransform, exposedRegion);
+        for (int i = 0; i < tli.size(); ++i)
+            drawSubtreeRecursive(tli.at(i), painter, viewTransform, exposedRegion, widget);
+        return;
+    }
+
+    void drawSubtreeRecursive(QGraphicsItem *item, QPainter *painter, const QTransform *const,
+                              QRegion *exposedRegion, QWidget *widget, qreal parentOpacity = qreal(1.0));
     void markDirty(QGraphicsItem *item, const QRectF &rect = QRectF(), bool invalidateChildren = false,
                    bool maybeDirtyClipPath = false, bool force = false, bool ignoreOpacity = false,
                    bool removingItemFromScene = false);
diff --git a/src/gui/graphicsview/qgraphicsview.cpp b/src/gui/graphicsview/qgraphicsview.cpp
index 553d71c..1ba87ec 100644
--- a/src/gui/graphicsview/qgraphicsview.cpp
+++ b/src/gui/graphicsview/qgraphicsview.cpp
@@ -3298,8 +3298,8 @@ void QGraphicsView::paintEvent(QPaintEvent *event)
 
     // Items
     if (!(d->optimizationFlags & IndirectPainting)) {
-        d->scene->d_func()->drawSubtreeRecursive(0, &painter, viewTransform, &d->exposedRegion,
-                                                 viewport(), 0);
+        d->scene->d_func()->drawItems(&painter, viewTransformed ? &viewTransform : 0,
+                                      &d->exposedRegion, viewport());
     } else {
         // Find all exposed items
         bool allItems = false;
diff --git a/src/gui/kernel/qapplication_x11.cpp b/src/gui/kernel/qapplication_x11.cpp
index 942836a..babc5df 100644
--- a/src/gui/kernel/qapplication_x11.cpp
+++ b/src/gui/kernel/qapplication_x11.cpp
@@ -1085,10 +1085,8 @@ static void qt_set_input_encoding()
 }
 
 // Reads a KDE color setting
-static QColor kdeColor(const QString &key)
+static QColor kdeColor(const QString &key, const QSettings &kdeSettings)
 {
-    QSettings kdeSettings(QApplicationPrivate::kdeHome() +
-                          QLatin1String("/share/config/kdeglobals"), QSettings::IniFormat);
     QVariant variant = kdeSettings.value(key);
     if (variant.isValid()) {
         QStringList values = variant.toStringList();
@@ -1307,36 +1305,40 @@ static void qt_set_x11_resources(const char* font = 0, const char* fg = 0,
         }
 
         if (kdeColors) {
+            const QSettings &theKdeSettings =
+                      QSettings(QApplicationPrivate::kdeHome()
+                      + QLatin1String("/share/config/kdeglobals"), QSettings::IniFormat);
+
             // Setup KDE palette
             QColor color;
-            color = kdeColor(QLatin1String("buttonBackground"));
+            color = kdeColor(QLatin1String("buttonBackground"), theKdeSettings);
             if (!color.isValid())
-                color = kdeColor(QLatin1String("Colors:Button/BackgroundNormal"));
+                color = kdeColor(QLatin1String("Colors:Button/BackgroundNormal"), theKdeSettings);
             if (color.isValid())
                 btn = color;
 
-            color = kdeColor(QLatin1String("background"));
+            color = kdeColor(QLatin1String("background"), theKdeSettings);
             if (!color.isValid())
-                color = kdeColor(QLatin1String("Colors:Window/BackgroundNormal"));
+                color = kdeColor(QLatin1String("Colors:Window/BackgroundNormal"), theKdeSettings);
             if (color.isValid())
                 bg = color;
 
-            color = kdeColor(QLatin1String("foreground"));
+            color = kdeColor(QLatin1String("foreground"), theKdeSettings);
             if (!color.isValid())
-                color = kdeColor(QLatin1String("Colors:View/ForegroundNormal"));
+                color = kdeColor(QLatin1String("Colors:View/ForegroundNormal"), theKdeSettings);
             if (color.isValid()) {
                 fg = color;
             }
 
-            color = kdeColor(QLatin1String("windowForeground"));
+            color = kdeColor(QLatin1String("windowForeground"), theKdeSettings);
             if (!color.isValid())
-                color = kdeColor(QLatin1String("Colors:Window/ForegroundNormal"));
+                color = kdeColor(QLatin1String("Colors:Window/ForegroundNormal"), theKdeSettings);
             if (color.isValid())
                 wfg = color;
 
-            color = kdeColor(QLatin1String("windowBackground"));
+            color = kdeColor(QLatin1String("windowBackground"), theKdeSettings);
             if (!color.isValid())
-                color = kdeColor(QLatin1String("Colors:View/BackgroundNormal"));
+                color = kdeColor(QLatin1String("Colors:View/BackgroundNormal"), theKdeSettings);
             if (color.isValid())
                 base = color;
         }
@@ -1355,29 +1357,33 @@ static void qt_set_x11_resources(const char* font = 0, const char* fg = 0,
         }
         // Use KDE3 or KDE4 color settings if present
         if (kdeColors) {
-            QColor color = kdeColor(QLatin1String("selectBackground"));
+            const QSettings &theKdeSettings =
+                      QSettings(QApplicationPrivate::kdeHome()
+                      + QLatin1String("/share/config/kdeglobals"), QSettings::IniFormat);
+
+            QColor color = kdeColor(QLatin1String("selectBackground"), theKdeSettings);
             if (!color.isValid())
-                color = kdeColor(QLatin1String("Colors:Selection/BackgroundNormal"));
+                color = kdeColor(QLatin1String("Colors:Selection/BackgroundNormal"), theKdeSettings);
             if (color.isValid())
                 highlight = color;
 
-            color = kdeColor(QLatin1String("selectForeground"));
+            color = kdeColor(QLatin1String("selectForeground"), theKdeSettings);
             if (!color.isValid())
-                color = kdeColor(QLatin1String("Colors:Selection/ForegroundNormal"));
+                color = kdeColor(QLatin1String("Colors:Selection/ForegroundNormal"), theKdeSettings);
             if (color.isValid())
                 highlightText = color;
 
-            color = kdeColor(QLatin1String("alternateBackground"));
+            color = kdeColor(QLatin1String("alternateBackground"), theKdeSettings);
             if (!color.isValid())
-                color = kdeColor(QLatin1String("Colors:View/BackgroundAlternate"));
+                color = kdeColor(QLatin1String("Colors:View/BackgroundAlternate"), theKdeSettings);
             if (color.isValid())
                 pal.setColor(QPalette::AlternateBase, color);
             else
                 pal.setBrush(QPalette::AlternateBase, pal.base().color().darker(110));
 
-            color = kdeColor(QLatin1String("buttonForeground"));
+            color = kdeColor(QLatin1String("buttonForeground"), theKdeSettings);
             if (!color.isValid())
-                color = kdeColor(QLatin1String("Colors:Button/ForegroundNormal"));
+                color = kdeColor(QLatin1String("Colors:Button/ForegroundNormal"), theKdeSettings);
             if (color.isValid())
                 pal.setColor(QPalette::ButtonText, color);
         }
diff --git a/src/gui/painting/qmatrix.cpp b/src/gui/painting/qmatrix.cpp
index 62addd3..221267f 100644
--- a/src/gui/painting/qmatrix.cpp
+++ b/src/gui/painting/qmatrix.cpp
@@ -198,7 +198,7 @@ QT_BEGIN_NAMESPACE
   QMatrix member functions
  *****************************************************************************/
 /*!
-    \fn QMatrix::QMatrix(Qt::Uninitialized)
+    \fn QMatrix::QMatrix(Qt::Initialization)
     \internal
 */
 
diff --git a/src/gui/painting/qmatrix.h b/src/gui/painting/qmatrix.h
index b2e5d70..aa4177c 100644
--- a/src/gui/painting/qmatrix.h
+++ b/src/gui/painting/qmatrix.h
@@ -61,7 +61,7 @@ class QVariant;
 class Q_GUI_EXPORT QMatrix // 2D transform matrix
 {
 public:
-    inline explicit QMatrix(enum Qt::Uninitialized) {}
+    inline explicit QMatrix(Qt::Initialization) {}
     QMatrix();
     QMatrix(qreal m11, qreal m12, qreal m21, qreal m22,
             qreal dx, qreal dy);
diff --git a/src/gui/painting/qpaintengine_raster.cpp b/src/gui/painting/qpaintengine_raster.cpp
index 78515ac..37f7b6d 100644
--- a/src/gui/painting/qpaintengine_raster.cpp
+++ b/src/gui/painting/qpaintengine_raster.cpp
@@ -1771,10 +1771,10 @@ void QRasterPaintEngine::stroke(const QVectorPath &path, const QPen &pen)
 
 static inline QRect toNormalizedFillRect(const QRectF &rect)
 {
-    int x1 = int(rect.x() + aliasedCoordinateDelta);
-    int y1 = int(rect.y() + aliasedCoordinateDelta);
-    int x2 = int(rect.right() + aliasedCoordinateDelta);
-    int y2 = int(rect.bottom() + aliasedCoordinateDelta);
+    int x1 = qRound(rect.x() + aliasedCoordinateDelta);
+    int y1 = qRound(rect.y() + aliasedCoordinateDelta);
+    int x2 = qRound(rect.right() + aliasedCoordinateDelta);
+    int y2 = qRound(rect.bottom() + aliasedCoordinateDelta);
 
     if (x2 < x1)
         qSwap(x1, x2);
diff --git a/src/gui/painting/qstroker_p.h b/src/gui/painting/qstroker_p.h
index f94c353..30c22b2 100644
--- a/src/gui/painting/qstroker_p.h
+++ b/src/gui/painting/qstroker_p.h
@@ -179,7 +179,7 @@ private:
 
 };
 
-class QStroker : public QStrokerOps
+class Q_GUI_EXPORT QStroker : public QStrokerOps
 {
 public:
 
diff --git a/src/gui/painting/qtransform.cpp b/src/gui/painting/qtransform.cpp
index 85adb27..f0b2351 100644
--- a/src/gui/painting/qtransform.cpp
+++ b/src/gui/painting/qtransform.cpp
@@ -232,7 +232,7 @@ QT_BEGIN_NAMESPACE
 */
 
 /*!
-    \fn QTransform::QTransform(Qt::Uninitialized)
+    \fn QTransform::QTransform(Qt::Initialization)
     \internal
 */
 
diff --git a/src/gui/painting/qtransform.h b/src/gui/painting/qtransform.h
index f99b0e7..291d35c 100644
--- a/src/gui/painting/qtransform.h
+++ b/src/gui/painting/qtransform.h
@@ -71,7 +71,7 @@ public:
         TxProject   = 0x10
     };
 
-    inline explicit QTransform(enum Qt::Uninitialized) : affine(Qt::Uninitialized) {}
+    inline explicit QTransform(Qt::Initialization) : affine(Qt::Uninitialized) {}
     QTransform();
     QTransform(qreal h11, qreal h12, qreal h13,
                qreal h21, qreal h22, qreal h23,
diff --git a/src/gui/widgets/qdockarealayout.cpp b/src/gui/widgets/qdockarealayout.cpp
index 135bcda..3125304 100644
--- a/src/gui/widgets/qdockarealayout.cpp
+++ b/src/gui/widgets/qdockarealayout.cpp
@@ -155,6 +155,11 @@ QSize QDockAreaLayoutItem::maximumSize() const
     return QSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
 }
 
+bool QDockAreaLayoutItem::hasFixedSize(Qt::Orientation o) const
+{
+    return perp(o, minimumSize()) == perp(o, maximumSize());
+}
+
 bool QDockAreaLayoutItem::expansive(Qt::Orientation o) const
 {
     if ((flags & GapItem) || placeHolderItem != 0)
@@ -216,7 +221,7 @@ static quintptr tabId(const QDockAreaLayoutItem &item)
 #endif
 
 QDockAreaLayoutInfo::QDockAreaLayoutInfo()
-    : sep(0), dockPos(QInternal::LeftDock), o(Qt::Horizontal), rect(0, 0, -1, -1), mainWindow(0)
+    : sep(0), dockPos(QInternal::LeftDock), o(Qt::Horizontal), mainWindow(0)
 #ifndef QT_NO_TABBAR
     , tabbed(false), tabBar(0), tabBarShape(QTabBar::RoundedSouth)
 #endif
@@ -226,7 +231,7 @@ QDockAreaLayoutInfo::QDockAreaLayoutInfo()
 QDockAreaLayoutInfo::QDockAreaLayoutInfo(int _sep, QInternal::DockPosition _dockPos,
                                             Qt::Orientation _o, int tbshape,
                                             QMainWindow *window)
-    : sep(_sep), dockPos(_dockPos), o(_o), rect(0, 0, -1, -1), mainWindow(window)
+    : sep(_sep), dockPos(_dockPos), o(_o), mainWindow(window)
 #ifndef QT_NO_TABBAR
     , tabbed(false), tabBar(0), tabBarShape(static_cast<QTabBar::Shape>(tbshape))
 #endif
@@ -244,7 +249,7 @@ QSize QDockAreaLayoutInfo::size() const
 void QDockAreaLayoutInfo::clear()
 {
     item_list.clear();
-    rect = QRect(0, 0, -1, -1);
+    rect = QRect();
 #ifndef QT_NO_TABBAR
     tabbed = false;
     tabBar = 0;
@@ -388,10 +393,9 @@ QSize QDockAreaLayoutInfo::sizeHint() const
         return QSize(0, 0);
 
     int a = 0, b = 0;
-    bool prev_gap = false;
-    bool first = true;
     int min_perp = 0;
     int max_perp = QWIDGETSIZE_MAX;
+    const QDockAreaLayoutItem *previous = 0;
     for (int i = 0; i < item_list.size(); ++i) {
         const QDockAreaLayoutItem &item = item_list.at(i);
         if (item.skip())
@@ -409,14 +413,15 @@ QSize QDockAreaLayoutInfo::sizeHint() const
         } else
 #endif
         {
-            if (!first && !gap && !prev_gap)
+            if (previous && !gap && !(previous->flags &  QDockAreaLayoutItem::GapItem)
+                && !previous->hasFixedSize(o)) {
                 a += sep;
+            }
             a += gap ? item.size : pick(o, size_hint);
         }
         b = qMax(b, perp(o, size_hint));
 
-        prev_gap = gap;
-        first = false;
+        previous = &item;
     }
 
     max_perp = qMax(max_perp, min_perp);
@@ -539,21 +544,20 @@ void QDockAreaLayoutInfo::fitItems()
     int max_size = realMaxSize(*this);
     int last_index = -1;
 
-    bool prev_gap = false;
-    bool first = true;
+    const QDockAreaLayoutItem *previous = 0;
     for (int i = 0; i < item_list.size(); ++i) {
         QDockAreaLayoutItem &item = item_list[i];
         if (item.skip())
             continue;
 
         bool gap = item.flags & QDockAreaLayoutItem::GapItem;
-        if (!first && !gap && !prev_gap) {
-            QLayoutStruct &ls = layout_struct_list[j++];
-            ls.init();
-            ls.minimumSize = sep;
-            ls.maximumSize = sep;
-            ls.sizeHint = sep;
-            ls.empty = false;
+        if (previous && !gap) {
+            if (!(previous->flags & QDockAreaLayoutItem::GapItem)) {
+                QLayoutStruct &ls = layout_struct_list[j++];
+                ls.init();
+                ls.minimumSize = ls.maximumSize = ls.sizeHint = previous->hasFixedSize(o) ? 0 : sep;
+                ls.empty = false;
+            }
         }
 
         if (item.flags & QDockAreaLayoutItem::KeepSize) {
@@ -592,8 +596,7 @@ void QDockAreaLayoutInfo::fitItems()
         }
 
         item.flags &= ~QDockAreaLayoutItem::KeepSize;
-        prev_gap = gap;
-        first = false;
+        previous = &item;
     }
     layout_struct_list.resize(j);
 
@@ -607,8 +610,8 @@ void QDockAreaLayoutInfo::fitItems()
     qGeomCalc(layout_struct_list, 0, j, pick(o, rect.topLeft()), size, 0);
 
     j = 0;
-    prev_gap = false;
-    first = true;
+    bool prev_gap = false;
+    bool first = true;
     for (int i = 0; i < item_list.size(); ++i) {
         QDockAreaLayoutItem &item = item_list[i];
         if (item.skip())
@@ -1408,11 +1411,12 @@ QList<int> QDockAreaLayoutInfo::findSeparator(const QPoint &_pos) const
         if (next == -1 || (item_list.at(next).flags & QDockAreaLayoutItem::GapItem))
             continue;
 
-        int margin = (sep == 1? 2 : 0);
-        if (pos >= item.pos + item.size - margin && item.pos + item.size + sep + margin > pos) {
-            QList<int> result;
-            result.append(i);
-            return result;
+        QRect sepRect = separatorRect(i);
+        if (!sepRect.isNull() && sep == 1)
+            sepRect.adjust(-2, -2, 2, 2);
+        //we also make sure we don't find a separator that's not there
+        if (sepRect.contains(_pos) && !item.hasFixedSize(o)) {
+            return QList<int>() << i;
         }
 
     }
@@ -1478,6 +1482,12 @@ QMainWindowLayout *QDockAreaLayoutInfo::mainWindowLayout() const
     return result;
 }
 
+bool QDockAreaLayoutInfo::hasFixedSize() const
+{
+    return perp(o, minimumSize()) == perp(o, maximumSize());
+}
+
+
 void QDockAreaLayoutInfo::apply(bool animate)
 {
     QWidgetAnimator *widgetAnimator = mainWindowLayout()->widgetAnimator;
@@ -1629,7 +1639,7 @@ void QDockAreaLayoutInfo::paintSeparators(QPainter *p, QWidget *widget,
         if (next == -1)
             break;
         QRect r = separatorRect(i);
-        if (clip.contains(r))
+        if (clip.contains(r) && !item.hasFixedSize(o))
             paintSep(p, widget, r, o, r.contains(mouse));
     }
 }
@@ -2009,10 +2019,8 @@ bool QDockAreaLayoutInfo::restoreState(QDataStream &stream, QList<QDockWidget*>
 
 void QDockAreaLayoutInfo::updateSeparatorWidgets() const
 {
-    QDockAreaLayoutInfo *that = const_cast<QDockAreaLayoutInfo*>(this);
-
     if (tabbed) {
-        that->separatorWidgets.clear();
+        separatorWidgets.clear();
         return;
     }
 
@@ -2040,7 +2048,7 @@ void QDockAreaLayoutInfo::updateSeparatorWidgets() const
             sepWidget = separatorWidgets.at(j);
         } else {
             sepWidget = mainWindowLayout()->getSeparatorWidget();
-            that->separatorWidgets.append(sepWidget);
+            separatorWidgets.append(sepWidget);
         }
         j++;
 
@@ -2053,10 +2061,10 @@ void QDockAreaLayoutInfo::updateSeparatorWidgets() const
         sepWidget->show();
     }
 
-    for (int k = j; k < that->separatorWidgets.size(); ++k) {
-        that->separatorWidgets[k]->hide();
+    for (int k = j; k < separatorWidgets.size(); ++k) {
+        separatorWidgets[k]->hide();
     }
-    that->separatorWidgets.resize(j);
+    separatorWidgets.resize(j);
     Q_ASSERT(separatorWidgets.size() == j);
 }
 
@@ -2271,7 +2279,7 @@ QDockAreaLayout::QDockAreaLayout(QMainWindow *win)
     docks[QInternal::BottomDock]
         = QDockAreaLayoutInfo(sep, QInternal::BottomDock, Qt::Horizontal, tabShape, win);
     centralWidgetItem = 0;
-    centralWidgetRect = QRect(0, 0, -1, -1);
+
 
     corners[Qt::TopLeftCorner] = Qt::TopDockWidgetArea;
     corners[Qt::TopRightCorner] = Qt::TopDockWidgetArea;
@@ -2442,9 +2450,9 @@ QList<int> QDockAreaLayout::findSeparator(const QPoint &pos) const
         if (info.isEmpty())
             continue;
         QRect rect = separatorRect(i);
-        if (sep == 1)
+        if (!rect.isNull() && sep == 1)
             rect.adjust(-2, -2, 2, 2);
-        if (rect.contains(pos)) {
+        if (rect.contains(pos) && !info.hasFixedSize()) {
             result << i;
             break;
         } else if (info.rect.contains(pos)) {
@@ -2504,9 +2512,10 @@ QRect QDockAreaLayout::itemRect(QList<int> path) const
 
 QRect QDockAreaLayout::separatorRect(int index) const
 {
-    if (docks[index].isEmpty())
+    const QDockAreaLayoutInfo &dock = docks[index];
+    if (dock.isEmpty())
         return QRect();
-    QRect r = docks[index].rect;
+    QRect r = dock.rect;
     switch (index) {
         case QInternal::LeftDock:
             return QRect(r.right() + 1, r.top(), sep, r.height());
@@ -2854,8 +2863,8 @@ void QDockAreaLayout::clear()
     for (int i = 0; i < QInternal::DockCount; ++i)
         docks[i].clear();
 
-    rect = QRect(0, 0, -1, -1);
-    centralWidgetRect = QRect(0, 0, -1, -1);
+    rect = QRect();
+    centralWidgetRect = QRect();
 }
 
 QSize QDockAreaLayout::sizeHint() const
@@ -3080,7 +3089,7 @@ void QDockAreaLayout::paintSeparators(QPainter *p, QWidget *widget,
         if (dock.isEmpty())
             continue;
         QRect r = separatorRect(i);
-        if (clip.contains(r)) {
+        if (clip.contains(r) && !dock.hasFixedSize()) {
             Qt::Orientation opposite = dock.o == Qt::Horizontal
                                         ? Qt::Vertical : Qt::Horizontal;
             paintSep(p, widget, r, opposite, r.contains(mouse));
@@ -3154,8 +3163,6 @@ int QDockAreaLayout::separatorMove(QList<int> separator, const QPoint &origin,
 // Allocates new sepearator widgets with getSeparatorWidget
 void QDockAreaLayout::updateSeparatorWidgets() const
 {
-    QDockAreaLayout *that = const_cast<QDockAreaLayout*>(this);
-
     int j = 0;
 
     for (int i = 0; i < QInternal::DockCount; ++i) {
@@ -3168,7 +3175,7 @@ void QDockAreaLayout::updateSeparatorWidgets() const
             sepWidget = separatorWidgets.at(j);
         } else {
             sepWidget = qobject_cast<QMainWindowLayout*>(mainWindow->layout())->getSeparatorWidget();
-            that->separatorWidgets.append(sepWidget);
+            separatorWidgets.append(sepWidget);
         }
         j++;
 
@@ -3183,7 +3190,7 @@ void QDockAreaLayout::updateSeparatorWidgets() const
     for (int i = j; i < separatorWidgets.size(); ++i)
         separatorWidgets.at(i)->hide();
 
-    that->separatorWidgets.resize(j);
+    separatorWidgets.resize(j);
 }
 
 QLayoutItem *QDockAreaLayout::itemAt(int *x, int index) const
diff --git a/src/gui/widgets/qdockarealayout_p.h b/src/gui/widgets/qdockarealayout_p.h
index 0b8d832..137aeba 100644
--- a/src/gui/widgets/qdockarealayout_p.h
+++ b/src/gui/widgets/qdockarealayout_p.h
@@ -103,6 +103,7 @@ struct QDockAreaLayoutItem
     QSize maximumSize() const;
     QSize sizeHint() const;
     bool expansive(Qt::Orientation o) const;
+    bool hasFixedSize(Qt::Orientation o) const;
 
     QLayoutItem *widgetItem;
     QDockAreaLayoutInfo *subinfo;
@@ -167,6 +168,7 @@ public:
 
     void clear();
     bool isEmpty() const;
+    bool hasFixedSize() const;
     QList<int> findSeparator(const QPoint &pos) const;
     int next(int idx) const;
     int prev(int idx) const;
@@ -188,7 +190,7 @@ public:
     QMainWindowLayout *mainWindowLayout() const;
 
     int sep;
-    QVector<QWidget*> separatorWidgets;
+    mutable QVector<QWidget*> separatorWidgets;
     QInternal::DockPosition dockPos;
     Qt::Orientation o;
     QRect rect;
@@ -231,7 +233,7 @@ public:
     QDockAreaLayout(QMainWindow *win);
     QDockAreaLayoutInfo docks[4];
     int sep; // separator extent
-    QVector<QWidget*> separatorWidgets;
+    mutable QVector<QWidget*> separatorWidgets;
 
     bool isValid() const;
 
diff --git a/src/gui/widgets/qmainwindowlayout.cpp b/src/gui/widgets/qmainwindowlayout.cpp
index 308f956..10e07d3 100644
--- a/src/gui/widgets/qmainwindowlayout.cpp
+++ b/src/gui/widgets/qmainwindowlayout.cpp
@@ -490,10 +490,10 @@ void QMainWindowLayoutState::clear()
 #ifndef QT_NO_DOCKWIDGET
     dockAreaLayout.clear();
 #else
-    centralWidgetRect = QRect(0, 0, -1, -1);
+    centralWidgetRect = QRect();
 #endif
 
-    rect = QRect(0, 0, -1, -1);
+    rect = QRect();
 }
 
 bool QMainWindowLayoutState::isValid() const
diff --git a/src/gui/widgets/qmenu.cpp b/src/gui/widgets/qmenu.cpp
index 6bbf4e8..fc55a2c 100644
--- a/src/gui/widgets/qmenu.cpp
+++ b/src/gui/widgets/qmenu.cpp
@@ -1826,7 +1826,7 @@ void QMenu::popup(const QPoint &p, QAction *atAction)
                 if (d->scroll && d->scroll->scrollFlags != QMenuPrivate::QMenuScroller::ScrollNone
                     && !style()->styleHint(QStyle::SH_Menu_FillScreenWithScroll, 0, this)) {
                     int below_height = above_height + d->scroll->scrollOffset;
-                    for(int i2 = i; i2 < (int)d->actionList.count(); i2++)
+                    for(int i2 = i; i2 < d->actionList.count(); i2++)
                         below_height += d->actionRects.value(d->actionList.at(i2)).height();
                     size.setHeight(below_height);
                 }
@@ -2263,7 +2263,7 @@ void QMenu::mouseReleaseEvent(QMouseEvent *e)
                     break;
                 }
             }
-            if (e->button() == Qt::LeftButton || (e->button() == Qt::RightButton && isContextMenu))
+            if (e->button() || isContextMenu)
 #endif
                 d->activateAction(action, QAction::Trigger);
         }
@@ -2746,7 +2746,7 @@ void QMenu::mouseMoveEvent(QMouseEvent *e)
         if (d->hasHadMouse && !rect().contains(e->pos()))
             d->setCurrentAction(0);
         return;
-    } else if(e->buttons() & (Qt::LeftButton | Qt::RightButton)) {
+    } else if(e->buttons()) {
         d->mouseDown = this;
     }
     if (d->sloppyRegion.contains(e->pos())) {
diff --git a/src/gui/widgets/qplaintextedit.cpp b/src/gui/widgets/qplaintextedit.cpp
index efacd00..4977b31 100644
--- a/src/gui/widgets/qplaintextedit.cpp
+++ b/src/gui/widgets/qplaintextedit.cpp
@@ -1029,15 +1029,14 @@ void QPlainTextEditPrivate::ensureViewportLayouted()
 
     \section1 Using QPlainTextEdit as a Display Widget
 
-    The text is set or replaced using setPlainText() which deletes any
-    existing text and replaces it with the text passed in the
-    setPlainText() call.
+    The text is set or replaced using setPlainText() which deletes the
+    existing text and replaces it with the text passed to setPlainText().
 
-    Text itself can be inserted using the QTextCursor class or using
-    the convenience functins insertPlainText(), appendPlainText() or
+    Text can be inserted using the QTextCursor class or using the
+    convenience functions insertPlainText(), appendPlainText() or
     paste().
 
-    By default the text edit wraps words at whitespace to fit within
+    By default, the text edit wraps words at whitespace to fit within
     the text edit widget. The setLineWrapMode() function is used to
     specify the kind of line wrap you want, \l WidgetWidth or \l
     NoWrap if you don't want any wrapping.  If you use word wrap to
diff --git a/src/gui/widgets/qtoolbararealayout.cpp b/src/gui/widgets/qtoolbararealayout.cpp
index aaab885..8a10355 100644
--- a/src/gui/widgets/qtoolbararealayout.cpp
+++ b/src/gui/widgets/qtoolbararealayout.cpp
@@ -567,7 +567,7 @@ bool QToolBarAreaLayoutInfo::insertGap(QList<int> path, QLayoutItem *item)
 void QToolBarAreaLayoutInfo::clear()
 {
     lines.clear();
-    rect = QRect(0, 0, -1, -1);
+    rect = QRect();
 }
 
 QRect QToolBarAreaLayoutInfo::itemRect(QList<int> path) const
@@ -1101,7 +1101,7 @@ void QToolBarAreaLayout::clear()
 {
     for (int i = 0; i < QInternal::DockCount; ++i)
         docks[i].clear();
-    rect = QRect(0, 0, -1, -1);
+    rect = QRect();
 }
 
 QToolBarAreaLayoutItem &QToolBarAreaLayout::item(QList<int> path)