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

* '4.7' of scm.dev.nokia.troll.no:qt/oslo-staging-2: (26 commits)
  Disable the unified toolbar before entering
  QWorkspace: fix hardcoded min size overwriting the real min size
  Fix tst_moduleqt47::accidentalImport
  tst_qcompleter: Fix the QTBUG_14292_filesystem test on X11
  tst_qcompleter.cpp: fix test on mac.
  Fixed autotest that was missing focus on Windows
  QGraphicsLayoutItem - user set sizes should always override, even if there's a constraint
  QGridLayoutEngine - Rework height-for-width support so that row/col spanning works
  Revert "Revert "Fix (implement!) hfw/wfh in QGridLayoutEngine""
  Fixed statement about const_iterator and some whitespace fixes.
  Adjust the parent index for the itemsMoved call.
  Correctly handle both 16bit and 32bit live pixmaps in meego graphics system.
  Correctly remove the egl alpha surface flags in meego graphics system.
  Proper dither & proper alpha checking.
  In meego graphics system, use always 16bit textures.
  QCompleter: do not auto complete when directory is changed.
  tst_qcompleter: Add a test for QFileSystemModel
  Doc: adjusting the search field width
  Doc - remove disclaimer
  Added the default format of QTime::toString().
  ...

12 files changed, 368 insertions, 62 deletions

diff --git a/src/gui/graphicsview/qgraphicslayoutitem.cpp b/src/gui/graphicsview/qgraphicslayoutitem.cpp
index ad4b2b5..e43f7fa 100644
--- a/src/gui/graphicsview/qgraphicslayoutitem.cpp
+++ b/src/gui/graphicsview/qgraphicslayoutitem.cpp
@@ -48,6 +48,7 @@
 #include "qgraphicslayoutitem.h"
 #include "qgraphicslayoutitem_p.h"
 #include "qwidget.h"
+#include "qgraphicswidget.h"
 
 #include <QtDebug>
 
@@ -259,6 +260,52 @@ void QGraphicsLayoutItemPrivate::setSizeComponent(
     q->updateGeometry();
 }
 
+
+bool QGraphicsLayoutItemPrivate::hasHeightForWidth() const
+{
+    Q_Q(const QGraphicsLayoutItem);
+    if (isLayout) {
+        const QGraphicsLayout *l = static_cast<const QGraphicsLayout *>(q);
+        for (int i = l->count() - 1; i >= 0; --i) {
+            if (QGraphicsLayoutItemPrivate::get(l->itemAt(i))->hasHeightForWidth())
+                return true;
+        }
+    } else if (QGraphicsItem *item = q->graphicsItem()) {
+        if (item->isWidget()) {
+            QGraphicsWidget *w = static_cast<QGraphicsWidget *>(item);
+            if (w->layout()) {
+                return QGraphicsLayoutItemPrivate::get(w->layout())->hasHeightForWidth();
+            }
+        }
+    }
+    return q->sizePolicy().hasHeightForWidth();
+}
+
+bool QGraphicsLayoutItemPrivate::hasWidthForHeight() const
+{
+    // enable this code when we add QSizePolicy::hasWidthForHeight() (For 4.8)
+#if 1
+    return false;
+#else
+    Q_Q(const QGraphicsLayoutItem);
+    if (isLayout) {
+        const QGraphicsLayout *l = static_cast<const QGraphicsLayout *>(q);
+        for (int i = l->count() - 1; i >= 0; --i) {
+            if (QGraphicsLayoutItemPrivate::get(l->itemAt(i))->hasWidthForHeight())
+                return true;
+        }
+    } else if (QGraphicsItem *item = q->graphicsItem()) {
+        if (item->isWidget()) {
+            QGraphicsWidget *w = static_cast<QGraphicsWidget *>(item);
+            if (w->layout()) {
+                return QGraphicsLayoutItemPrivate::get(w->layout())->hasWidthForHeight();
+            }
+        }
+    }
+    return q->sizePolicy().hasWidthForHeight();
+#endif
+}
+
 /*!
     \class QGraphicsLayoutItem
     \brief The QGraphicsLayoutItem class can be inherited to allow your custom
diff --git a/src/gui/graphicsview/qgraphicslayoutitem_p.h b/src/gui/graphicsview/qgraphicslayoutitem_p.h
index 15cc7a5..b752e03 100644
--- a/src/gui/graphicsview/qgraphicslayoutitem_p.h
+++ b/src/gui/graphicsview/qgraphicslayoutitem_p.h
@@ -65,6 +65,9 @@ class Q_AUTOTEST_EXPORT QGraphicsLayoutItemPrivate
 public:
     virtual ~QGraphicsLayoutItemPrivate();
     QGraphicsLayoutItemPrivate(QGraphicsLayoutItem *parent, bool isLayout);
+    static QGraphicsLayoutItemPrivate *get(QGraphicsLayoutItem *q) { return q->d_func();}
+    static const QGraphicsLayoutItemPrivate *get(const QGraphicsLayoutItem *q) { return q->d_func();}
+
     void init();
     QSizeF *effectiveSizeHints(const QSizeF &constraint) const;
     QGraphicsItem *parentItem() const;
@@ -73,6 +76,9 @@ public:
     enum SizeComponent { Width, Height };
     void setSizeComponent(Qt::SizeHint which, SizeComponent component, qreal value);
 
+    bool hasHeightForWidth() const;
+    bool hasWidthForHeight() const;
+
     QSizePolicy sizePolicy;
     QGraphicsLayoutItem *parent;
 
diff --git a/src/gui/graphicsview/qgraphicswidget.cpp b/src/gui/graphicsview/qgraphicswidget.cpp
index 1bfe266..4a733be 100644
--- a/src/gui/graphicsview/qgraphicswidget.cpp
+++ b/src/gui/graphicsview/qgraphicswidget.cpp
@@ -750,6 +750,22 @@ QSizeF QGraphicsWidget::sizeHint(Qt::SizeHint which, const QSizeF &constraint) c
 /*!
     \property QGraphicsWidget::layout
     \brief The layout of the widget
+
+    Any existing layout manager is deleted before the new layout is assigned. If
+     \a layout is 0, the widget is left without a layout. Existing subwidgets'
+    geometries will remain unaffected.
+
+    QGraphicsWidget takes ownership of \a layout.
+
+    All widgets that are currently managed by \a layout or all of its
+    sublayouts, are automatically reparented to this item. The layout is then
+    invalidated, and the child widget geometries are adjusted according to
+    this item's geometry() and contentsMargins(). Children who are not
+    explicitly managed by \a layout remain unaffected by the layout after
+    it has been assigned to this widget.
+
+    If no layout is currently managing this widget, layout() will return 0.
+
 */
 
 /*!
diff --git a/src/gui/graphicsview/qgridlayoutengine.cpp b/src/gui/graphicsview/qgridlayoutengine.cpp
index ae5bf90..e486b4d 100644
--- a/src/gui/graphicsview/qgridlayoutengine.cpp
+++ b/src/gui/graphicsview/qgridlayoutengine.cpp
@@ -545,6 +545,24 @@ QSizePolicy::Policy QGridLayoutItem::sizePolicy(Qt::Orientation orientation) con
                                            : sizePolicy.verticalPolicy();
 }
 
+/*
+  returns true if the size policy returns true for either hasHeightForWidth()
+  or hasWidthForHeight()
+ */
+bool QGridLayoutItem::hasDynamicConstraint() const
+{
+    return QGraphicsLayoutItemPrivate::get(q_layoutItem)->hasHeightForWidth()
+        || QGraphicsLayoutItemPrivate::get(q_layoutItem)->hasWidthForHeight();
+}
+
+Qt::Orientation QGridLayoutItem::dynamicConstraintOrientation() const
+{
+    if (QGraphicsLayoutItemPrivate::get(q_layoutItem)->hasHeightForWidth())
+        return Qt::Vertical;
+    else //if (QGraphicsLayoutItemPrivate::get(q_layoutItem)->hasWidthForHeight())
+        return Qt::Horizontal;
+}
+
 QSizePolicy::ControlTypes QGridLayoutItem::controlTypes(LayoutSide /* side */) const
 {
     return q_layoutItem->sizePolicy().controlType();
@@ -613,7 +631,17 @@ QRectF QGridLayoutItem::geometryWithin(qreal x, qreal y, qreal width, qreal heig
         qreal cellWidth = width;
         qreal cellHeight = height;
 
-        QSizeF size = effectiveMaxSize().boundedTo(QSizeF(cellWidth, cellHeight));
+
+        QSizeF size = effectiveMaxSize(QSizeF(-1,-1));
+        if (hasDynamicConstraint()) {
+            if (dynamicConstraintOrientation() == Qt::Vertical) {
+               if (size.width() > cellWidth)
+                   size = effectiveMaxSize(QSizeF(cellWidth, -1));
+            } else if(size.height() > cellHeight) {
+                size = effectiveMaxSize(QSizeF(-1, cellHeight));
+            }
+        }
+        size = size.boundedTo(QSizeF(cellWidth, cellHeight));
         width = size.width();
         height = size.height();
 
@@ -675,13 +703,13 @@ void QGridLayoutItem::insertOrRemoveRows(int row, int delta, Qt::Orientation ori
     Note that effectiveSizeHint does not take sizePolicy into consideration,
     (since it only evaluates the hints, as the name implies)
 */
-QSizeF QGridLayoutItem::effectiveMaxSize() const
+QSizeF QGridLayoutItem::effectiveMaxSize(const QSizeF &constraint) const
 {
-    QSizeF size;
+    QSizeF size = constraint;
     bool vGrow = (sizePolicy(Qt::Vertical) & QSizePolicy::GrowFlag) == QSizePolicy::GrowFlag;
     bool hGrow = (sizePolicy(Qt::Horizontal) & QSizePolicy::GrowFlag) == QSizePolicy::GrowFlag;
     if (!vGrow || !hGrow) {
-        QSizeF pref = layoutItem()->effectiveSizeHint(Qt::PreferredSize);
+        QSizeF pref = layoutItem()->effectiveSizeHint(Qt::PreferredSize, constraint);
         if (!vGrow)
             size.setHeight(pref.height());
         if (!hGrow)
@@ -689,7 +717,7 @@ QSizeF QGridLayoutItem::effectiveMaxSize() const
     }
 
     if (!size.isValid()) {
-        QSizeF maxSize = layoutItem()->effectiveSizeHint(Qt::MaximumSize);
+        QSizeF maxSize = layoutItem()->effectiveSizeHint(Qt::MaximumSize, size);
         if (size.width() == -1)
             size.setWidth(maxSize.width());
         if (size.height() == -1)
@@ -1010,6 +1038,7 @@ void QGridLayoutEngine::invalidate()
     q_cachedEffectiveLastRows[Ver] = -1;
     q_cachedDataForStyleInfo.invalidate();
     q_cachedSize = QSizeF();
+    q_cachedConstraintOrientation = UnknownConstraint;
 }
 
 static void visualRect(QRectF *geom, Qt::LayoutDirection dir, const QRectF &contentsRect)
@@ -1074,19 +1103,78 @@ QRectF QGridLayoutEngine::cellRect(const QLayoutStyleInfo &styleInfo,
 }
 
 QSizeF QGridLayoutEngine::sizeHint(const QLayoutStyleInfo &styleInfo, Qt::SizeHint which,
-                                   const QSizeF & /* constraint */) const
+                                   const QSizeF &constraint) const
 {
-    ensureColumnAndRowData(styleInfo);
+    QGridLayoutBox sizehint_totalBoxes[NOrientations];
+
+    if(rowCount() < 1 || columnCount() < 1 || !hasDynamicConstraint()) {
+        //No items with height for width, so it doesn't matter which order we do these in
+        if(q_cachedDataForStyleInfo != styleInfo) {
+            ensureColumnAndRowData(&q_columnData, &sizehint_totalBoxes[Hor], styleInfo, NULL, NULL, Qt::Horizontal);
+            ensureColumnAndRowData(&q_rowData, &sizehint_totalBoxes[Ver], styleInfo, NULL, NULL, Qt::Vertical);
+        } else {
+            sizehint_totalBoxes[Hor] = q_totalBoxes[Hor];
+            sizehint_totalBoxes[Ver] = q_totalBoxes[Ver];
+        }
+    } else if(constraintOrientation() == Qt::Vertical) {
+        //We have items whose width depends on their height
+        if(q_cachedDataForStyleInfo != styleInfo)
+            ensureColumnAndRowData(&q_columnData, &sizehint_totalBoxes[Hor], styleInfo, NULL, NULL, Qt::Horizontal);
+        else
+            sizehint_totalBoxes[Hor] = q_totalBoxes[Hor];
+        QVector<qreal> sizehint_xx;
+        QVector<qreal> sizehint_widths;
+
+        sizehint_xx.resize(columnCount());
+        sizehint_widths.resize(columnCount());
+        qreal width = constraint.width();
+        if(width < 0) {
+            /* It's not obvious what the behaviour should be. */
+/*            if(which == Qt::MaximumSize)
+                width = sizehint_totalBoxes[Hor].q_maximumSize;
+            else if(which == Qt::MinimumSize)
+                width = sizehint_totalBoxes[Hor].q_minimumSize;
+            else*/
+                width = sizehint_totalBoxes[Hor].q_preferredSize;
+        }
+        //Calculate column widths and positions, and put results in q_xx.data() and q_widths.data() so that we can use this information as
+        //constraints to find the row heights
+        q_columnData.calculateGeometries(0, columnCount(), width, sizehint_xx.data(), sizehint_widths.data(),
+                0, sizehint_totalBoxes[Hor]);
+        ensureColumnAndRowData(&q_rowData, &sizehint_totalBoxes[Ver], styleInfo, sizehint_xx.data(), sizehint_widths.data(), Qt::Vertical);
+    } else {
+        //We have items whose height depends on their width
+        ensureColumnAndRowData(&q_rowData, &sizehint_totalBoxes[Ver], styleInfo, NULL, NULL, Qt::Vertical);
+        QVector<qreal> sizehint_yy;
+        QVector<qreal> sizehint_heights;
+
+        sizehint_yy.resize(rowCount());
+        sizehint_heights.resize(rowCount());
+        qreal height = constraint.height();
+        if(height < 0) {
+/*            if(which == Qt::MaximumSize)
+                height = sizehint_totalBoxes[Ver].q_maximumSize;
+            else if(which == Qt::MinimumSize)
+                height = sizehint_totalBoxes[Ver].q_minimumSize;
+            else*/
+                height = sizehint_totalBoxes[Ver].q_preferredSize;
+        }
+        //Calculate row heights and positions, and put results in q_yy.data() and q_heights.data() so that we can use this information as
+        //constraints to find the column widths
+        q_rowData.calculateGeometries(0, rowCount(), height, sizehint_yy.data(), sizehint_heights.data(),
+                0, sizehint_totalBoxes[Ver]);
+        ensureColumnAndRowData(&q_columnData, &sizehint_totalBoxes[Hor], styleInfo, sizehint_yy.data(), sizehint_heights.data(), Qt::Vertical);
+    }
 
     switch (which) {
     case Qt::MinimumSize:
-        return QSizeF(q_totalBoxes[Hor].q_minimumSize, q_totalBoxes[Ver].q_minimumSize);
+        return QSizeF(sizehint_totalBoxes[Hor].q_minimumSize, sizehint_totalBoxes[Ver].q_minimumSize);
     case Qt::PreferredSize:
-        return QSizeF(q_totalBoxes[Hor].q_preferredSize, q_totalBoxes[Ver].q_preferredSize);
+        return QSizeF(sizehint_totalBoxes[Hor].q_preferredSize, sizehint_totalBoxes[Ver].q_preferredSize);
     case Qt::MaximumSize:
-        return QSizeF(q_totalBoxes[Hor].q_maximumSize, q_totalBoxes[Ver].q_maximumSize);
+        return QSizeF(sizehint_totalBoxes[Hor].q_maximumSize, sizehint_totalBoxes[Ver].q_maximumSize);
     case Qt::MinimumDescent:
-        return QSizeF(-1.0, q_totalBoxes[Hor].q_minimumDescent);    // ### doesn't work
+        return QSizeF(-1.0, sizehint_totalBoxes[Hor].q_minimumDescent);    // ### doesn't work
     default:
         break;
     }
@@ -1262,6 +1350,7 @@ void QGridLayoutEngine::insertOrRemoveRows(int row, int delta, Qt::Orientation o
 }
 
 void QGridLayoutEngine::fillRowData(QGridLayoutRowData *rowData, const QLayoutStyleInfo &styleInfo,
+                                    qreal *colPositions, qreal *colSizes,
                                     Qt::Orientation orientation) const
 {
     const int ButtonMask = QSizePolicy::ButtonBox | QSizePolicy::PushButton;
@@ -1375,7 +1464,21 @@ void QGridLayoutEngine::fillRowData(QGridLayoutRowData *rowData, const QLayoutSt
                         box = &multiCell.q_box;
                         multiCell.q_stretch = itemStretch;
                     }
-                    box->combine(item->box(orientation));
+                    // Items with constraints need to be passed the constraint
+                    if (colSizes && colPositions && item->hasDynamicConstraint() && orientation == item->dynamicConstraintOrientation()) {
+                        /* Get the width of the item by summing up the widths of the columns that it spans.
+                         * We need to have already calculated the widths of the columns by calling
+                         * q_columns->calculateGeometries() before hand and passing the value in the colSizes
+                         * and colPositions parameters.
+                         * The variable name is still colSizes even when it actually has the row sizes
+                         */
+                        qreal length = colSizes[item->lastColumn(orientation)];
+                        if (item->columnSpan(orientation) != 1)
+                            length += colPositions[item->lastColumn(orientation)] - colPositions[item->firstColumn(orientation)];
+                        box->combine(item->box(orientation, length));
+                    } else {
+                        box->combine(item->box(orientation));
+                    }
 
                     if (effectiveRowSpan == 1) {
                         QSizePolicy::ControlTypes controls = item->controlTypes(top);
@@ -1512,44 +1615,99 @@ void QGridLayoutEngine::ensureEffectiveFirstAndLastRows() const
     }
 }
 
-void QGridLayoutEngine::ensureColumnAndRowData(const QLayoutStyleInfo &styleInfo) const
+void QGridLayoutEngine::ensureColumnAndRowData(QGridLayoutRowData *rowData, QGridLayoutBox *totalBox,
+                                            const QLayoutStyleInfo &styleInfo,
+                                            qreal *colPositions, qreal *colSizes,
+                                            Qt::Orientation orientation) const
 {
-    if (q_cachedDataForStyleInfo == styleInfo)
-        return;
-
-    q_columnData.reset(columnCount());
-    q_rowData.reset(rowCount());
-
-    fillRowData(&q_columnData, styleInfo, Qt::Horizontal);
-    fillRowData(&q_rowData, styleInfo, Qt::Vertical);
+    rowData->reset(rowCount(orientation));
+    fillRowData(rowData, styleInfo, colPositions, colSizes, orientation);
+    rowData->distributeMultiCells();
+    *totalBox = rowData->totalBox(0, rowCount(orientation));
+        //We have items whose width depends on their height
+}
 
-    q_columnData.distributeMultiCells();
-    q_rowData.distributeMultiCells();
+/**
+   returns false if the layout has contradicting constraints (i.e. some items with a horizontal
+   constraint and other items with a vertical constraint)
+ */
+bool QGridLayoutEngine::ensureDynamicConstraint() const
+{
+    if (q_cachedConstraintOrientation == UnknownConstraint) {
+        for (int i = q_items.count() - 1; i >= 0; --i) {
+            QGridLayoutItem *item = q_items.at(i);
+            if (item->hasDynamicConstraint()) {
+                Qt::Orientation itemConstraintOrientation = item->dynamicConstraintOrientation();
+                if (q_cachedConstraintOrientation == UnknownConstraint) {
+                    q_cachedConstraintOrientation = itemConstraintOrientation;
+                } else if (q_cachedConstraintOrientation != itemConstraintOrientation) {
+                    q_cachedConstraintOrientation = UnfeasibleConstraint;
+                    qWarning("QGridLayoutEngine: Unfeasible, cannot mix horizontal and"
+                             " vertical constraint in the same layout");
+                    return false;
+                }
+            }
+        }
+        if (q_cachedConstraintOrientation == UnknownConstraint)
+            q_cachedConstraintOrientation = NoConstraint;
+    }
+    return true;
+}
 
-    q_totalBoxes[Hor] = q_columnData.totalBox(0, columnCount());
-    q_totalBoxes[Ver] = q_rowData.totalBox(0, rowCount());
+bool QGridLayoutEngine::hasDynamicConstraint() const
+{
+    if (!ensureDynamicConstraint())
+        return false;
+    return q_cachedConstraintOrientation != NoConstraint;
+}
 
-    q_cachedDataForStyleInfo = styleInfo;
+/*
+ * return value is only valid if hasConstraint() returns true
+ */
+Qt::Orientation QGridLayoutEngine::constraintOrientation() const
+{
+    (void)ensureDynamicConstraint();
+    return (Qt::Orientation)q_cachedConstraintOrientation;
 }
 
 void QGridLayoutEngine::ensureGeometries(const QLayoutStyleInfo &styleInfo,
                                          const QSizeF &size) const
 {
-    ensureColumnAndRowData(styleInfo);
-    if (q_cachedSize == size)
+    if (q_cachedDataForStyleInfo == styleInfo && q_cachedSize == size)
         return;
 
+    q_cachedDataForStyleInfo = styleInfo;
+    q_cachedSize = size;
+
     q_xx.resize(columnCount());
-    q_yy.resize(rowCount());
     q_widths.resize(columnCount());
+    q_yy.resize(rowCount());
     q_heights.resize(rowCount());
     q_descents.resize(rowCount());
-    q_columnData.calculateGeometries(0, columnCount(), size.width(), q_xx.data(), q_widths.data(),
-                                     0, q_totalBoxes[Hor]);
-    q_rowData.calculateGeometries(0, rowCount(), size.height(), q_yy.data(), q_heights.data(),
-                                  q_descents.data(), q_totalBoxes[Ver]);
 
-    q_cachedSize = size;
+    if(constraintOrientation() != Qt::Horizontal) {
+        //We might have items whose width depends on their height
+        ensureColumnAndRowData(&q_columnData, &q_totalBoxes[Hor], styleInfo, NULL, NULL, Qt::Horizontal);
+        //Calculate column widths and positions, and put results in q_xx.data() and q_widths.data() so that we can use this information as
+        //constraints to find the row heights
+        q_columnData.calculateGeometries(0, columnCount(), size.width(), q_xx.data(), q_widths.data(),
+                0, q_totalBoxes[Hor]);
+        ensureColumnAndRowData(&q_rowData, &q_totalBoxes[Ver], styleInfo, q_xx.data(), q_widths.data(), Qt::Vertical);
+        //Calculate row heights and positions, and put results in q_yy.data() and q_heights.data()
+        q_rowData.calculateGeometries(0, rowCount(), size.height(), q_yy.data(), q_heights.data(),
+                q_descents.data(), q_totalBoxes[Ver]);
+    } else {
+        //We have items whose height depends on their width
+        ensureColumnAndRowData(&q_rowData, &q_totalBoxes[Ver], styleInfo, NULL, NULL, Qt::Vertical);
+        //Calculate row heights and positions, and put results in q_yy.data() and q_heights.data() so that we can use this information as
+        //constraints to find the column widths
+        q_rowData.calculateGeometries(0, rowCount(), size.height(), q_yy.data(), q_heights.data(),
+                q_descents.data(), q_totalBoxes[Ver]);
+        ensureColumnAndRowData(&q_columnData, &q_totalBoxes[Hor], styleInfo, q_yy.data(), q_heights.data(), Qt::Horizontal);
+        //Calculate row heights and positions, and put results in q_yy.data() and q_heights.data()
+        q_columnData.calculateGeometries(0, columnCount(), size.width(), q_xx.data(), q_widths.data(),
+                0, q_totalBoxes[Hor]);
+    }
 }
 
 QT_END_NAMESPACE
diff --git a/src/gui/graphicsview/qgridlayoutengine_p.h b/src/gui/graphicsview/qgridlayoutengine_p.h
index 9ac9a8e..02c74b0 100644
--- a/src/gui/graphicsview/qgridlayoutengine_p.h
+++ b/src/gui/graphicsview/qgridlayoutengine_p.h
@@ -91,6 +91,14 @@ enum LayoutSide {
     Bottom
 };
 
+enum {
+    NoConstraint,
+    HorizontalConstraint,   // Width depends on the height
+    VerticalConstraint,     // Height depends on the width
+    UnknownConstraint,      // need to update cache
+    UnfeasibleConstraint    // not feasible, it be has some items with Vertical and others with Horizontal constraints
+};
+
 template <typename T>
 class QLayoutParameter
 {
@@ -270,6 +278,10 @@ public:
     inline void setAlignment(Qt::Alignment alignment) { q_alignment = alignment; }
 
     QSizePolicy::Policy sizePolicy(Qt::Orientation orientation) const;
+
+    bool hasDynamicConstraint() const;
+    Qt::Orientation dynamicConstraintOrientation() const;
+
     QSizePolicy::ControlTypes controlTypes(LayoutSide side) const;
     QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
     QGridLayoutBox box(Qt::Orientation orientation, qreal constraint = -1.0) const;
@@ -280,7 +292,7 @@ public:
     void setGeometry(const QRectF &rect);
     void transpose();
     void insertOrRemoveRows(int row, int delta, Qt::Orientation orientation = Qt::Vertical);
-    QSizeF effectiveMaxSize() const;
+    QSizeF effectiveMaxSize(const QSizeF &constraint) const;
 
 #ifdef QT_DEBUG
     void dump(int indent = 0) const;
@@ -372,6 +384,14 @@ public:
                     int column, int rowSpan, int columnSpan) const;
     QSizeF sizeHint(const QLayoutStyleInfo &styleInfo, Qt::SizeHint which,
                     const QSizeF &constraint) const;
+
+    // heightForWidth / widthForHeight support
+    QSizeF dynamicallyConstrainedSizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
+    bool ensureDynamicConstraint() const;
+    bool hasDynamicConstraint() const;
+    Qt::Orientation constraintOrientation() const;
+
+
     QSizePolicy::ControlTypes controlTypes(LayoutSide side) const;
     void transpose();
     void setVisualDirection(Qt::LayoutDirection direction);
@@ -390,9 +410,14 @@ private:
     void setItemAt(int row, int column, QGridLayoutItem *item);
     void insertOrRemoveRows(int row, int delta, Qt::Orientation orientation = Qt::Vertical);
     void fillRowData(QGridLayoutRowData *rowData, const QLayoutStyleInfo &styleInfo,
-                     Qt::Orientation orientation = Qt::Vertical) const;
+                                    qreal *colPositions, qreal *colSizes,
+                                    Qt::Orientation orientation = Qt::Vertical) const;
     void ensureEffectiveFirstAndLastRows() const;
-    void ensureColumnAndRowData(const QLayoutStyleInfo &styleInfo) const;
+    void ensureColumnAndRowData(QGridLayoutRowData *rowData, QGridLayoutBox *totalBox,
+                                            const QLayoutStyleInfo &styleInfo,
+                                            qreal *colPositions, qreal *colSizes,
+                                            Qt::Orientation orientation) const;
+
     void ensureGeometries(const QLayoutStyleInfo &styleInfo, const QSizeF &size) const;
 
     // User input
@@ -405,6 +430,7 @@ private:
     // Lazily computed from the above user input
     mutable int q_cachedEffectiveFirstRows[NOrientations];
     mutable int q_cachedEffectiveLastRows[NOrientations];
+    mutable quint8 q_cachedConstraintOrientation : 2;
 
     // Layout item input
     mutable QLayoutStyleInfo q_cachedDataForStyleInfo;
diff --git a/src/gui/kernel/qwidget.cpp b/src/gui/kernel/qwidget.cpp
index f7c795e..9b44f15 100644
--- a/src/gui/kernel/qwidget.cpp
+++ b/src/gui/kernel/qwidget.cpp
@@ -68,6 +68,7 @@
 # include "qt_cocoa_helpers_mac_p.h"
 # include "qmainwindow.h"
 # include "qtoolbar.h"
+# include <private/qmainwindowlayout_p.h>
 #endif
 #if defined(Q_WS_QWS)
 # include "qwsdisplay_qws.h"
@@ -3002,6 +3003,15 @@ bool QWidget::isFullScreen() const
 */
 void QWidget::showFullScreen()
 {
+#ifdef Q_WS_MAC
+    // If the unified toolbar is enabled, we have to disable it before going fullscreen.
+    QMainWindow *mainWindow = qobject_cast<QMainWindow*>(this);
+    if (mainWindow && mainWindow->unifiedTitleAndToolBarOnMac()) {
+        mainWindow->setUnifiedTitleAndToolBarOnMac(false);
+        QMainWindowLayout *mainLayout = qobject_cast<QMainWindowLayout*>(mainWindow->layout());
+        mainLayout->activateUnifiedToolbarAfterFullScreen = true;
+    }
+#endif // Q_WS_MAC
     ensurePolished();
 #ifdef QT3_SUPPORT
     if (parent())
@@ -3034,6 +3044,18 @@ void QWidget::showMaximized()
 
     setWindowState((windowState() & ~(Qt::WindowMinimized | Qt::WindowFullScreen))
                    | Qt::WindowMaximized);
+#ifdef Q_WS_MAC
+    // If the unified toolbar was enabled before going fullscreen, we have to enable it back.
+    QMainWindow *mainWindow = qobject_cast<QMainWindow*>(this);
+    if (mainWindow)
+    {
+        QMainWindowLayout *mainLayout = qobject_cast<QMainWindowLayout*>(mainWindow->layout());
+        if (mainLayout->activateUnifiedToolbarAfterFullScreen) {
+            mainWindow->setUnifiedTitleAndToolBarOnMac(true);
+            mainLayout->activateUnifiedToolbarAfterFullScreen = false;
+        }
+    }
+#endif // Q_WS_MAC
     show();
 }
 
@@ -3055,6 +3077,18 @@ void QWidget::showNormal()
     setWindowState(windowState() & ~(Qt::WindowMinimized
                                      | Qt::WindowMaximized
                                      | Qt::WindowFullScreen));
+#ifdef Q_WS_MAC
+    // If the unified toolbar was enabled before going fullscreen, we have to enable it back.
+    QMainWindow *mainWindow = qobject_cast<QMainWindow*>(this);
+    if (mainWindow)
+    {
+        QMainWindowLayout *mainLayout = qobject_cast<QMainWindowLayout*>(mainWindow->layout());
+        if (mainLayout->activateUnifiedToolbarAfterFullScreen) {
+            mainWindow->setUnifiedTitleAndToolBarOnMac(true);
+            mainLayout->activateUnifiedToolbarAfterFullScreen = false;
+        }
+    }
+#endif // Q_WS_MAC
     show();
 }
 
diff --git a/src/gui/util/qcompleter.cpp b/src/gui/util/qcompleter.cpp
index e718212..bcd601b 100644
--- a/src/gui/util/qcompleter.cpp
+++ b/src/gui/util/qcompleter.cpp
@@ -782,7 +782,8 @@ QMatchData QUnsortedModelEngine::filter(const QString& part, const QModelIndex&
 ///////////////////////////////////////////////////////////////////////////////
 QCompleterPrivate::QCompleterPrivate()
 : widget(0), proxy(0), popup(0), cs(Qt::CaseSensitive), role(Qt::EditRole), column(0),
-  maxVisibleItems(7), sorting(QCompleter::UnsortedModel), wrap(true), eatFocusOut(true)
+  maxVisibleItems(7), sorting(QCompleter::UnsortedModel), wrap(true), eatFocusOut(true),
+  hiddenBecauseNoMatch(false)
 {
 }
 
@@ -921,12 +922,14 @@ void QCompleterPrivate::showPopup(const QRect& rect)
 void QCompleterPrivate::_q_fileSystemModelDirectoryLoaded(const QString &path)
 {
     Q_Q(QCompleter);
-#ifndef QT_NO_LINEEDIT
-    QLineEdit *lineEdit = qobject_cast<QLineEdit *>(widget);
-    //the path given by QFileSystemModel does not end with /
-    if (lineEdit && !lineEdit->text().isEmpty() && !q->completionPrefix().isEmpty() && q->completionPrefix() != path + QLatin1Char('/'))
+    // Slot called when QFileSystemModel has finished loading.
+    // If we hide the popup because there was no match because the model was not loaded yet,
+    // we re-start the completion when we get the results
+    if (hiddenBecauseNoMatch
+        && prefix.startsWith(path) && prefix != (path + '/')
+        && widget) {
         q->complete();
-#endif
+    }
 }
 
 /*!
@@ -1200,6 +1203,7 @@ bool QCompleter::eventFilter(QObject *o, QEvent *e)
     Q_D(QCompleter);
 
     if (d->eatFocusOut && o == d->widget && e->type() == QEvent::FocusOut) {
+        d->hiddenBecauseNoMatch = false;
         if (d->popup && d->popup->isVisible())
             return true;
     }
@@ -1378,6 +1382,7 @@ void QCompleter::complete(const QRect& rect)
 {
     Q_D(QCompleter);
     QModelIndex idx = d->proxy->currentIndex(false);
+    d->hiddenBecauseNoMatch = false;
     if (d->mode == QCompleter::InlineCompletion) {
         if (idx.isValid())
             d->_q_complete(idx, true);
@@ -1389,6 +1394,7 @@ void QCompleter::complete(const QRect& rect)
         || (d->mode == QCompleter::UnfilteredPopupCompletion && d->proxy->rowCount() == 0)) {
         if (d->popup)
             d->popup->hide(); // no suggestion, hide
+        d->hiddenBecauseNoMatch = true;
         return;
     }
 
diff --git a/src/gui/util/qcompleter_p.h b/src/gui/util/qcompleter_p.h
index 8f00793..19b76e5 100644
--- a/src/gui/util/qcompleter_p.h
+++ b/src/gui/util/qcompleter_p.h
@@ -93,6 +93,7 @@ public:
 
     bool eatFocusOut;
     QRect popupRect;
+    bool hiddenBecauseNoMatch;
 
     void showPopup(const QRect&);
     void _q_complete(QModelIndex, bool = false);
diff --git a/src/gui/widgets/qmainwindow.cpp b/src/gui/widgets/qmainwindow.cpp
index 1183be6..d971f61 100644
--- a/src/gui/widgets/qmainwindow.cpp
+++ b/src/gui/widgets/qmainwindow.cpp
@@ -78,6 +78,7 @@ public:
         : layout(0), explicitIconSize(false), toolButtonStyle(Qt::ToolButtonIconOnly)
 #ifdef Q_WS_MAC
             , useHIToolBar(false)
+            , activateUnifiedToolbarAfterFullScreen(false)
 #endif
 #if !defined(QT_NO_DOCKWIDGET) && !defined(QT_NO_CURSOR)
             , hasOldCursor(false) , cursorAdjusted(false)
@@ -89,6 +90,7 @@ public:
     Qt::ToolButtonStyle toolButtonStyle;
 #ifdef Q_WS_MAC
     bool useHIToolBar;
+    bool activateUnifiedToolbarAfterFullScreen;
 #endif
     void init();
     QList<int> hoverSeparator;
@@ -1501,8 +1503,6 @@ bool QMainWindow::event(QEvent *event)
     \i Before Qt 4.5, if you called showFullScreen() on the main window, the QToolbar would
         disappear since it is considered to be part of the title bar. Qt 4.5 and up will now work around this by pulling
         the toolbars out and back into the regular toolbar and vice versa when you swap out.
-        However, a good practice would be that turning off the unified toolbar before you call
-        showFullScreen() and restoring it after you call showNormal().
     \endlist
 
     Setting this back to false will remove these restrictions.
diff --git a/src/gui/widgets/qmainwindowlayout_p.h b/src/gui/widgets/qmainwindowlayout_p.h
index e1b981c..3e1a95d 100644
--- a/src/gui/widgets/qmainwindowlayout_p.h
+++ b/src/gui/widgets/qmainwindowlayout_p.h
@@ -335,6 +335,7 @@ public:
     void cleanUpMacToolbarItems();
     void fixSizeInUnifiedToolbar(QToolBar *tb) const;
     bool useHIToolBar;
+    bool activateUnifiedToolbarAfterFullScreen;
     void syncUnifiedToolbarVisibility();
     bool blockVisiblityCheck;
 #endif
diff --git a/src/gui/widgets/qmenubar.cpp b/src/gui/widgets/qmenubar.cpp
index df16f7f..ae56fa5 100644
--- a/src/gui/widgets/qmenubar.cpp
+++ b/src/gui/widgets/qmenubar.cpp
@@ -1628,10 +1628,10 @@ bool QMenuBar::eventFilter(QObject *object, QEvent *event)
 }
 
 /*!
-  \internal
+  Returns the QAction at \a pt. Returns 0 if there is no action at \a pt or if
+the location has a separator.
 
-  Return the item at \a pt, or 0 if there is no item there or if it is
-  a separator item.
+    \sa addAction(), addSeparator()
 */
 QAction *QMenuBar::actionAt(const QPoint &pt) const
 {
@@ -1640,9 +1640,9 @@ QAction *QMenuBar::actionAt(const QPoint &pt) const
 }
 
 /*!
-  \internal
+  Returns the geometry of action \a act as a QRect.
 
-  Returns the geometry of action \a act.
+    \sa actionAt()
 */
 QRect QMenuBar::actionGeometry(QAction *act) const
 {
@@ -1836,10 +1836,17 @@ void QMenuBarPrivate::_q_updateLayout()
 }
 
 /*!
-  \internal
+    \fn void QMenuBar::setCornerWidget(QWidget *widget, Qt::Corner corner)
 
-  This sets widget \a w to be shown directly on the left of the first or
-  the right of the last menu item, depending on \a corner.
+    This sets the given \a widget to be shown directly on the left of the first
+    menu item, or on the right of the last menu item, depending on \a corner.
+
+    The menu bar takes ownership of \a widget, reparenting it into the menu bar.
+    However, if the \a corner already contains a widget, this previous widget
+    will no longer be managed and will still be a visible child of the menu bar.
+
+   \note Using a corner other than Qt::TopRightCorner or Qt::TopLeftCorner
+    will result in a warning.
 */
 void QMenuBar::setCornerWidget(QWidget *w, Qt::Corner corner)
 {
@@ -1869,10 +1876,11 @@ void QMenuBar::setCornerWidget(QWidget *w, Qt::Corner corner)
 }
 
 /*!
-  \internal
+    Returns the widget on the left of the first or on the right of the last menu
+    item, depending on \a corner.
 
-  Returns the widget in the left of the first or the right of the last menu
-  item, depending on \a corner.
+   \note Using a corner other than Qt::TopRightCorner or Qt::TopLeftCorner
+    will result in a warning.
 */
 QWidget *QMenuBar::cornerWidget(Qt::Corner corner) const
 {
diff --git a/src/gui/widgets/qworkspace.cpp b/src/gui/widgets/qworkspace.cpp
index 7180c4d..3a9b30c 100644
--- a/src/gui/widgets/qworkspace.cpp
+++ b/src/gui/widgets/qworkspace.cpp
@@ -2551,7 +2551,6 @@ QWorkspaceChild::QWorkspaceChild(QWidget* window, QWorkspace *parent, Qt::Window
                  this, SLOT(titleBarDoubleClicked()));
     }
 
-    setMinimumSize(128, 0);
     int fw =  style()->pixelMetric(QStyle::PM_MdiSubWindowFrameWidth, 0, this);
     setContentsMargins(fw, fw, fw, fw);
 
@@ -2702,11 +2701,15 @@ QSize QWorkspaceChild::sizeHint() const
 
 QSize QWorkspaceChild::minimumSizeHint() const
 {
-    if (!childWidget)
-        return QWidget::minimumSizeHint() + baseSize();
-    QSize s = childWidget->minimumSize();
-    if (s.isEmpty())
-        s = childWidget->minimumSizeHint();
+    QSize s;
+    if (!childWidget) {
+        s = QWidget::minimumSizeHint();
+    } else {
+        s = childWidget->minimumSize();
+        if (s.isEmpty())
+            s = childWidget->minimumSizeHint();
+    }
+    s = s.expandedTo(QSize(128, 0));
     return s + baseSize();
 }