Change the layout engine of RowLayout and ColumnLayout.

It now uses the gridlayoutengine from graphicsview, which
also gives us a well tested grid layout engine almost for
free.

Change-Id: I939ae4d2b321c8079935ff3374e8e5d10d02384b
Reviewed-by: Jens Bache-Wiig <jens.bache-wiig@digia.com>

25 files changed, 3874 insertions, 971 deletions

diff --git a/src/controls/ApplicationWindow.qml b/src/controls/ApplicationWindow.qml
index d483a075..9fa5c374 100644
--- a/src/controls/ApplicationWindow.qml
+++ b/src/controls/ApplicationWindow.qml
@@ -41,6 +41,8 @@
 import QtQuick 2.0
 import QtQuick.Window 2.0
 import QtQuick.Controls 1.0
+import QtQuick.Layouts 1.0
+import QtQuick.Controls.Private 1.0
 
 /*!
     \qmltype ApplicationWindow
diff --git a/src/controls/SplitView.qml b/src/controls/SplitView.qml
index 3b226ac2..ac858258 100644
--- a/src/controls/SplitView.qml
+++ b/src/controls/SplitView.qml
@@ -40,6 +40,7 @@
 
 import QtQuick 2.0
 import QtQuick.Controls 1.0
+import QtQuick.Layouts 1.0
 import QtQuick.Controls.Private 1.0 as Private
 
 /*!
diff --git a/src/controls/plugin.cpp b/src/controls/plugin.cpp
index b81347c0..20d2f394 100644
--- a/src/controls/plugin.cpp
+++ b/src/controls/plugin.cpp
@@ -44,7 +44,6 @@
 #include "qtexclusivegroup_p.h"
 #include "qtmenu_p.h"
 #include "qtmenubar_p.h"
-#include "qquicklinearlayout_p.h"
 #include "qpagestatus.h"
 
 #include <qimage.h>
@@ -87,11 +86,6 @@ void StylePlugin::registerTypes(const char *uri)
     qmlRegisterUncreatableType<QtMenuBase>(uri, 1, 0, "MenuBase",
                                            QLatin1String("Do not create objects of type MenuBase"));
 
-    qmlRegisterType<QQuickComponentsRowLayout>(uri, 1, 0, "RowLayout");
-    qmlRegisterType<QQuickComponentsColumnLayout>(uri, 1, 0, "ColumnLayout");
-    qmlRegisterUncreatableType<QQuickComponentsLayout>(uri, 1, 0, "Layout",
-                                                       QLatin1String("Do not create objects of type Layout"));
-
     qmlRegisterUncreatableType<QPageStatus>(uri, 1, 0, "PageStatus", QLatin1String("Do not create objects of type PageStatus"));
 }
 
diff --git a/src/controls/plugin.pri b/src/controls/plugin.pri
index 5637e75c..338645e4 100644
--- a/src/controls/plugin.pri
+++ b/src/controls/plugin.pri
@@ -1,7 +1,4 @@
 HEADERS += \
-    $$PWD/qquicklayout_p.h \
-    $$PWD/qquicklayoutengine_p.h \
-    $$PWD/qquicklinearlayout_p.h \
     $$PWD/plugin_p.h \
     $$PWD/qtaction_p.h \
     $$PWD/qtexclusivegroup_p.h \
@@ -12,9 +9,6 @@ HEADERS += \
     $$PWD/qpagestatus.h
 
 SOURCES += \
-    $$PWD/qquicklayout.cpp \
-    $$PWD/qquicklayoutengine.cpp \
-    $$PWD/qquicklinearlayout.cpp \
     $$PWD/plugin.cpp \
     $$PWD/qtaction.cpp \
     $$PWD/qtexclusivegroup.cpp \
diff --git a/src/controls/plugins.qmltypes b/src/controls/plugins.qmltypes
index 1e8d179d..1cfb3477 100644
--- a/src/controls/plugins.qmltypes
+++ b/src/controls/plugins.qmltypes
@@ -21,49 +21,6 @@ Module {
         }
     }
     Component {
-        name: "QQuickComponentsColumnLayout"
-        defaultProperty: "data"
-        prototype: "QQuickComponentsLinearLayout"
-        exports: ["ColumnLayout 1.0"]
-    }
-    Component {
-        name: "QQuickComponentsLayout"
-        defaultProperty: "data"
-        prototype: "QQuickItem"
-        exports: ["Layout 1.0"]
-        attachedType: "QQuickComponentsLayoutAttached"
-        Enum {
-            name: "SizePolicy"
-            values: {
-                "Fixed": 0,
-                "Expanding": 1
-            }
-        }
-    }
-    Component {
-        name: "QQuickComponentsLayoutAttached"
-        prototype: "QObject"
-        Property { name: "minimumWidth"; type: "double" }
-        Property { name: "minimumHeight"; type: "double" }
-        Property { name: "maximumWidth"; type: "double" }
-        Property { name: "maximumHeight"; type: "double" }
-        Property { name: "verticalSizePolicy"; type: "QQuickComponentsLayout::SizePolicy" }
-        Property { name: "horizontalSizePolicy"; type: "QQuickComponentsLayout::SizePolicy" }
-    }
-    Component {
-        name: "QQuickComponentsLinearLayout"
-        defaultProperty: "data"
-        prototype: "QQuickComponentsLayout"
-        Property { name: "spacing"; type: "double" }
-        Signal { name: "orientationChanged" }
-    }
-    Component {
-        name: "QQuickComponentsRowLayout"
-        defaultProperty: "data"
-        prototype: "QQuickComponentsLinearLayout"
-        exports: ["RowLayout 1.0"]
-    }
-    Component {
         name: "QtAction"
         prototype: "QObject"
         exports: ["Action 1.0"]
diff --git a/src/controls/qquicklayout_p.h b/src/controls/qquicklayout_p.h
deleted file mode 100644
index f8f88657..00000000
--- a/src/controls/qquicklayout_p.h
+++ /dev/null
@@ -1,142 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
-** Contact: http://www.qt-project.org/legal
-**
-** This file is part of the Qt Quick Controls module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and Digia.  For licensing terms and
-** conditions see http://qt.digia.com/licensing.  For further information
-** use the contact form at http://qt.digia.com/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Digia gives you certain additional
-** rights.  These rights are described in the Digia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3.0 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU General Public License version 3.0 requirements will be
-** met: http://www.gnu.org/copyleft/gpl.html.
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef QQUICKLAYOUT_P_H
-#define QQUICKLAYOUT_P_H
-
-#include <QPointer>
-#include <QQuickItem>
-
-QT_BEGIN_NAMESPACE
-
-class QQuickComponentsLayoutAttached;
-
-
-class QQuickComponentsLayout : public QQuickItem
-{
-    Q_OBJECT
-    Q_ENUMS(SizePolicy)
-
-public:
-    enum SizePolicy {
-        Fixed,
-        Expanding
-    };
-
-    explicit QQuickComponentsLayout(QQuickItem *parent = 0);
-    ~QQuickComponentsLayout();
-
-    static QQuickComponentsLayoutAttached *qmlAttachedProperties(QObject *object);
-
-protected:
-    void invalidate();
-    bool event(QEvent *e);
-    void reconfigureTopDown();
-    virtual void reconfigureLayout();
-    void setupItemLayout(QQuickItem *item);
-
-private:
-    bool m_dirty;
-
-    friend class QQuickComponentsLayoutAttached;
-};
-
-
-class QQuickComponentsLayoutAttached : public QObject
-{
-    Q_OBJECT
-    Q_PROPERTY(qreal minimumWidth READ minimumWidth WRITE setMinimumWidth NOTIFY minimumWidthChanged)
-    Q_PROPERTY(qreal minimumHeight READ minimumHeight WRITE setMinimumHeight NOTIFY minimumHeightChanged)
-    Q_PROPERTY(qreal maximumWidth READ maximumWidth WRITE setMaximumWidth NOTIFY maximumWidthChanged)
-    Q_PROPERTY(qreal maximumHeight READ maximumHeight WRITE setMaximumHeight NOTIFY maximumHeightChanged)
-    Q_PROPERTY(QQuickComponentsLayout::SizePolicy verticalSizePolicy READ verticalSizePolicy WRITE setVerticalSizePolicy NOTIFY verticalSizePolicyChanged)
-    Q_PROPERTY(QQuickComponentsLayout::SizePolicy horizontalSizePolicy READ horizontalSizePolicy WRITE setHorizontalSizePolicy NOTIFY horizontalSizePolicyChanged)
-
-public:
-    QQuickComponentsLayoutAttached(QObject *object);
-
-    qreal minimumWidth() const { return m_minimumWidth; }
-    void setMinimumWidth(qreal width);
-
-    qreal minimumHeight() const { return m_minimumHeight; }
-    void setMinimumHeight(qreal height);
-
-    qreal maximumWidth() const { return m_maximumWidth; }
-    void setMaximumWidth(qreal width);
-
-    qreal maximumHeight() const { return m_maximumHeight; }
-    void setMaximumHeight(qreal height);
-
-    QQuickComponentsLayout::SizePolicy verticalSizePolicy() const { return m_verticalSizePolicy; }
-    void setVerticalSizePolicy(QQuickComponentsLayout::SizePolicy policy);
-
-    QQuickComponentsLayout::SizePolicy horizontalSizePolicy() const { return m_horizontalSizePolicy; }
-    void setHorizontalSizePolicy(QQuickComponentsLayout::SizePolicy policy);
-
-signals:
-    void minimumWidthChanged();
-    void minimumHeightChanged();
-    void maximumWidthChanged();
-    void maximumHeightChanged();
-    void verticalSizePolicyChanged();
-    void horizontalSizePolicyChanged();
-
-protected:
-    void updateLayout();
-
-private:
-    qreal m_minimumWidth;
-    qreal m_minimumHeight;
-    qreal m_maximumWidth;
-    qreal m_maximumHeight;
-    QQuickComponentsLayout::SizePolicy m_verticalSizePolicy;
-    QQuickComponentsLayout::SizePolicy m_horizontalSizePolicy;
-    QPointer<QQuickComponentsLayout> m_layout;
-
-    friend class QQuickComponentsLayout;
-};
-
-QT_END_NAMESPACE
-
-QML_DECLARE_TYPE(QQuickComponentsLayout)
-QML_DECLARE_TYPEINFO(QQuickComponentsLayout, QML_HAS_ATTACHED_PROPERTIES)
-
-#endif // QQUICKLAYOUT_P_H
diff --git a/src/controls/qquicklayoutengine.cpp b/src/controls/qquicklayoutengine.cpp
deleted file mode 100644
index 1811b453..00000000
--- a/src/controls/qquicklayoutengine.cpp
+++ /dev/null
@@ -1,295 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
-** Contact: http://www.qt-project.org/legal
-**
-** This file is part of the Qt Quick Controls module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and Digia.  For licensing terms and
-** conditions see http://qt.digia.com/licensing.  For further information
-** use the contact form at http://qt.digia.com/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Digia gives you certain additional
-** rights.  These rights are described in the Digia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3.0 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU General Public License version 3.0 requirements will be
-** met: http://www.gnu.org/copyleft/gpl.html.
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "qquicklayoutengine_p.h"
-
-QT_BEGIN_NAMESPACE
-
-/*
-  This function is a modification of qGeomCalc() included in "QtCore/kernel/qlayoutengine_p.h".
-  It is used as a helper function to handle linear layout recalculations for QQuickItems.
-
-  chain contains input and output parameters describing the geometry.
-  count is the count of items in the chain; pos and space give the
-  interval (relative to parentWidget topLeft).
-*/
-void qDeclarativeLayoutCalculate(QVector<QQuickComponentsLayoutInfo> &chain, int start,
-                                 int count, qreal pos, qreal space, qreal spacer)
-{
-    if (chain.count() == 0)
-        return;
-
-    bool wannaGrow = false;
-    qreal totalStretch = 0;
-    qreal totalSpacing = 0;
-    qreal totalSizeHint = 0;
-    qreal totalMinimumSize = 0;
-
-    const int end = start + count;
-    const int spacerCount = chain.count() - 1;
-
-    for (int i = start; i < end; i++) {
-        QQuickComponentsLayoutInfo *data = &chain[i];
-
-        data->done = false;
-
-        totalStretch += data->stretch;
-        totalSizeHint += data->smartSizeHint();
-        totalMinimumSize += data->minimumSize;
-
-        // don't count last spacing
-        if (i < end - 1)
-            totalSpacing += data->effectiveSpacer(spacer);
-
-        wannaGrow = (wannaGrow || data->expansive || data->stretch > 0);
-    }
-
-    qreal extraSpace = 0;
-
-    if (space < totalMinimumSize + totalSpacing) {
-        // Less space than minimumSize; take from the biggest first
-        qreal minSize = totalMinimumSize + totalSpacing;
-
-        // shrink the spacers proportionally
-        if (spacer >= 0) {
-            spacer = minSize > 0 ? spacer * space / minSize : 0;
-            totalSpacing = spacer * spacerCount;
-        }
-
-        QList<qreal> list;
-
-        for (int i = start; i < end; i++)
-            list << chain.at(i).minimumSize;
-
-        qSort(list);
-
-        qreal spaceLeft = space - totalSpacing;
-
-        qreal sum = 0;
-        int idx = 0;
-        qreal spaceUsed = 0;
-        qreal current = 0;
-
-        while (idx < count && spaceUsed < spaceLeft) {
-            current = list.at(idx);
-            spaceUsed = sum + current * (count - idx);
-            sum += current;
-            ++idx;
-        }
-
-        --idx;
-
-        int items = count - idx;
-        qreal deficit = spaceUsed - spaceLeft;
-        qreal deficitPerItem = deficit / items;
-        qreal maxval = current - deficitPerItem;
-
-        for (int i = start; i < end; i++) {
-            QQuickComponentsLayoutInfo *data = &chain[i];
-            data->done = true;
-
-            if (data->minimumSize > 0)
-                data->size = data->minimumSize;
-            else
-                data->size = qMin<qreal>(data->minimumSize, maxval);
-        }
-    } else if (space < totalSizeHint + totalSpacing) {
-        /*
-          Less space than smartSizeHint(), but more than minimumSize.
-          Currently take space equally from each, as in Qt 2.x.
-          Commented-out lines will give more space to stretchier
-          items.
-        */
-        int n = count;
-        qreal spaceLeft = space - totalSpacing;
-        qreal overdraft = totalSizeHint - spaceLeft;
-
-        // first give to the fixed ones
-        for (int i = start; i < end; i++) {
-            QQuickComponentsLayoutInfo *data = &chain[i];
-
-            if (!data->done && data->minimumSize >= data->smartSizeHint()) {
-                data->done = true;
-                data->size = data->smartSizeHint();
-                spaceLeft -= data->smartSizeHint();
-                n--;
-            }
-        }
-
-        bool finished = (n == 0);
-
-        while (!finished) {
-            finished = true;
-
-            for (int i = start; i < end; i++) {
-                QQuickComponentsLayoutInfo *data = &chain[i];
-
-                if (data->done)
-                    continue;
-
-                qreal w = overdraft / n;
-                data->size = data->smartSizeHint() - w;
-
-                if (data->size < data->minimumSize) {
-                    data->done = true;
-                    data->size = data->minimumSize;
-                    finished = false;
-                    overdraft -= data->smartSizeHint() - data->minimumSize;
-                    n--;
-                    break;
-                }
-            }
-        }
-    } else { // extra space
-        int n = count;
-        qreal spaceLeft = space - totalSpacing;
-
-        // first give to the fixed ones, and handle non-expansiveness
-        for (int i = start; i < end; i++) {
-            QQuickComponentsLayoutInfo *data = &chain[i];
-
-            if (data->done)
-                continue;
-
-            if (data->maximumSize <= data->smartSizeHint()
-                || (wannaGrow && !data->expansive && data->stretch == 0)
-                || (!data->expansive && data->stretch == 0)) {
-                data->done = true;
-                data->size = data->smartSizeHint();
-                spaceLeft -= data->size;
-                totalStretch -= data->stretch;
-                n--;
-            }
-        }
-
-        extraSpace = spaceLeft;
-
-        /*
-          Do a trial distribution and calculate how much it is off.
-          If there are more deficit pixels than surplus pixels, give
-          the minimum size items what they need, and repeat.
-          Otherwise give to the maximum size items, and repeat.
-
-          Paul Olav Tvete has a wonderful mathematical proof of the
-          correctness of this principle, but unfortunately this
-          comment is too small to contain it.
-        */
-        qreal surplus, deficit;
-
-        do {
-            surplus = deficit = 0;
-
-            for (int i = start; i < end; i++) {
-                QQuickComponentsLayoutInfo *data = &chain[i];
-
-                if (data->done)
-                    continue;
-
-                extraSpace = 0;
-
-                qreal w;
-
-                if (totalStretch <= 0)
-                    w = (spaceLeft / n);
-                else
-                    w = (spaceLeft * data->stretch) / totalStretch;
-
-                data->size = w;
-
-                if (w < data->smartSizeHint())
-                    deficit +=  data->smartSizeHint() - w;
-                else if (w > data->maximumSize)
-                    surplus += w - data->maximumSize;
-            }
-
-            if (deficit > 0 && surplus <= deficit) {
-                // give to the ones that have too little
-                for (int i = start; i < end; i++) {
-                    QQuickComponentsLayoutInfo *data = &chain[i];
-
-                    if (!data->done && data->size < data->smartSizeHint()) {
-                        data->done = true;
-                        data->size = data->smartSizeHint();
-                        spaceLeft -= data->smartSizeHint();
-                        totalStretch -= data->stretch;
-                        n--;
-                    }
-                }
-            }
-
-            if (surplus > 0 && surplus >= deficit) {
-                // take from the ones that have too much
-                for (int i = start; i < end; i++) {
-                    QQuickComponentsLayoutInfo *data = &chain[i];
-
-                    if (!data->done && data->size > data->maximumSize) {
-                        data->done = true;
-                        data->size = data->maximumSize;
-                        spaceLeft -= data->maximumSize;
-                        totalStretch -= data->stretch;
-                        n--;
-                    }
-                }
-            }
-        } while (n > 0 && surplus != deficit);
-
-        if (n == 0)
-            extraSpace = spaceLeft;
-    }
-
-    /*
-      As a last resort, we distribute the unwanted space equally
-      among the spacers (counting the start and end of the chain). We
-      could, but don't, attempt a sub-pixel allocation of the extra
-      space.
-    */
-    qreal extra = extraSpace / (spacerCount + 2);
-    qreal p = pos + extra;
-
-    for (int i = start; i < end; i++) {
-        QQuickComponentsLayoutInfo *data = &chain[i];
-        data->pos = p;
-        p += data->size;
-        p += data->effectiveSpacer(spacer) + extra;
-    }
-}
-
-QT_END_NAMESPACE
diff --git a/src/controls/qquicklinearlayout.cpp b/src/controls/qquicklinearlayout.cpp
deleted file mode 100644
index baf1d19d..00000000
--- a/src/controls/qquicklinearlayout.cpp
+++ /dev/null
@@ -1,270 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
-** Contact: http://www.qt-project.org/legal
-**
-** This file is part of the Qt Quick Controls module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and Digia.  For licensing terms and
-** conditions see http://qt.digia.com/licensing.  For further information
-** use the contact form at http://qt.digia.com/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Digia gives you certain additional
-** rights.  These rights are described in the Digia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3.0 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU General Public License version 3.0 requirements will be
-** met: http://www.gnu.org/copyleft/gpl.html.
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "qquicklinearlayout_p.h"
-#include "qquicklayoutengine_p.h"
-#include <QtCore/qnumeric.h>
-
-/*!
-    \qmltype RowLayout
-    \instantiates QQuickComponentsRowLayout
-    \inqmlmodule QtQuick.Controls 1.0
-    \brief RowLayout is doing bla...bla...
-*/
-
-/*!
-    \qmltype ColumnLayout
-    \instantiates QQuickComponentsColumnLayout
-    \inqmlmodule QtQuick.Controls 1.0
-    \brief ColumnLayout is doing bla...bla...
-*/
-
-QT_BEGIN_NAMESPACE
-
-static const qreal q_declarativeLayoutDefaultSpacing = 4.0;
-
-
-QQuickComponentsLinearLayout::QQuickComponentsLinearLayout(Orientation orientation,
-                                                           QQuickItem *parent)
-    : QQuickComponentsLayout(parent),
-      m_spacing(q_declarativeLayoutDefaultSpacing),
-      m_orientation(orientation)
-{
-
-}
-
-qreal QQuickComponentsLinearLayout::spacing() const
-{
-    return m_spacing;
-}
-
-void QQuickComponentsLinearLayout::setSpacing(qreal spacing)
-{
-    if (qIsNaN(spacing) || m_spacing == spacing)
-        return;
-
-    m_spacing = spacing;
-    invalidate();
-}
-
-QQuickComponentsLinearLayout::Orientation QQuickComponentsLinearLayout::orientation() const
-{
-    return m_orientation;
-}
-
-void QQuickComponentsLinearLayout::setOrientation(Orientation orientation)
-{
-    if (m_orientation == orientation)
-        return;
-
-    m_orientation = orientation;
-    invalidate();
-
-    emit orientationChanged();
-}
-
-void QQuickComponentsLinearLayout::componentComplete()
-{
-    QQuickComponentsLayout::componentComplete();
-    updateLayoutItems();
-    invalidate();
-}
-
-void QQuickComponentsLinearLayout::updateLayoutItems()
-{
-    const QList<QQuickItem *> &children = childItems();
-    qreal implicitWidth = 0;
-    qreal implicitHeight = 0;
-    foreach (QQuickItem *child, children) {
-        if (m_orientation == Horizontal) {
-            implicitWidth += child->implicitWidth();
-            implicitHeight = qMax(implicitHeight, child->implicitHeight());
-        } else {
-            implicitHeight += child->implicitHeight();
-            implicitWidth = qMax(implicitWidth, child->implicitWidth());
-        }
-        insertLayoutItem(child);
-    }
-    setImplicitWidth(implicitWidth);
-    setImplicitHeight(implicitHeight);
-}
-
-void QQuickComponentsLinearLayout::itemChange(ItemChange change, const ItemChangeData &value)
-{
-    if (isComponentComplete()) {
-        if (change == ItemChildAddedChange)
-            insertLayoutItem(value.item);
-        else if (change == ItemChildRemovedChange)
-            removeLayoutItem(value.item);
-    }
-
-    QQuickComponentsLayout::itemChange(change, value);
-}
-
-void QQuickComponentsLinearLayout::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
-{
-    QQuickComponentsLayout::geometryChanged(newGeometry, oldGeometry);
-    invalidate();
-}
-
-void QQuickComponentsLinearLayout::insertLayoutItem(QQuickItem *item)
-{
-    m_items.append(item);
-    setupItemLayout(item);
-
-    invalidate();
-    QObject::connect(item, SIGNAL(destroyed()), this, SLOT(onItemDestroyed()));
-    QObject::connect(item, SIGNAL(visibleChanged()), this, SLOT(onItemVisibleChanged()));
-}
-
-void QQuickComponentsLinearLayout::removeLayoutItem(QQuickItem *item)
-{
-    if (!m_items.removeOne(item))
-        return;
-
-    invalidate();
-    QObject::disconnect(item, SIGNAL(destroyed()), this, SLOT(onItemDestroyed()));
-    QObject::disconnect(item, SIGNAL(visibleChanged()), this, SLOT(onItemVisibleChanged()));
-}
-
-void QQuickComponentsLinearLayout::onItemVisibleChanged()
-{
-    invalidate();
-}
-
-void QQuickComponentsLinearLayout::onItemDestroyed()
-{
-    if (!m_items.removeOne(static_cast<QQuickItem *>(sender())))
-        return;
-
-    invalidate();
-}
-
-void QQuickComponentsLinearLayout::reconfigureLayout()
-{
-    if (!isComponentComplete())
-        return;
-
-    const int count = m_items.count();
-
-    if (count == 0)
-        return;
-
-    qreal totalSpacing = 0;
-    qreal totalSizeHint = 0;
-    qreal totalMinimumSize = 0;
-    qreal totalMaximumSize = 0;
-
-    QVector<QQuickComponentsLayoutInfo> itemData;
-
-    for (int i = 0; i < count; i++) {
-        QQuickItem *item = m_items.at(i);
-        QObject *attached = qmlAttachedPropertiesObject<QQuickComponentsLayout>(item);
-        QQuickComponentsLayoutAttached *info = static_cast<QQuickComponentsLayoutAttached *>(attached);
-
-        QQuickComponentsLayoutInfo data;
-
-        if (item->isVisible()) {
-            if (m_orientation == Horizontal) {
-                data.sizeHint = item->implicitWidth();
-                data.minimumSize = info->minimumWidth();
-                data.maximumSize = info->maximumWidth();
-                data.expansive = (info->horizontalSizePolicy() == QQuickComponentsLayout::Expanding);
-                data.stretch = info->horizontalSizePolicy() == Expanding ? 1.0 : 0;
-            } else {
-                data.sizeHint = item->implicitHeight();
-                data.minimumSize = info->minimumHeight();
-                data.maximumSize = info->maximumHeight();
-                data.expansive = (info->verticalSizePolicy() == QQuickComponentsLayout::Expanding);
-                data.stretch = info->verticalSizePolicy() == Expanding ? 1.0 : 0;
-            }
-
-            itemData.append(data);
-            // sum
-            totalSizeHint += data.sizeHint;
-            totalMinimumSize += data.minimumSize;
-            totalMaximumSize += data.maximumSize;
-
-            // don't count last spacing
-            if (i < count - 1)
-                totalSpacing += data.spacing + m_spacing;
-        }
-    }
-
-    qreal extent = m_orientation == Horizontal ? width() : height();
-    qDeclarativeLayoutCalculate(itemData, 0, itemData.count(), 0, extent, m_spacing);
-
-    int i = 0;
-    int id = 0;
-    while (i < count) {
-        QQuickItem *item = m_items.at(i++);
-        if (!item->isVisible())
-            continue;
-        const QQuickComponentsLayoutInfo &data = itemData.at(id);
-
-        if (m_orientation == Horizontal) {
-            item->setX(data.pos);
-            item->setY(height()/2 - item->height()/2);
-            item->setWidth(data.size);
-        } else {
-            item->setY(data.pos);
-            item->setX(width()/2 - item->width()/2);
-            item->setHeight(data.size);
-        }
-        ++id;
-    }
-
-    // propagate hints to upper levels
-    QObject *attached = qmlAttachedPropertiesObject<QQuickComponentsLayout>(this);
-    QQuickComponentsLayoutAttached *info = static_cast<QQuickComponentsLayoutAttached *>(attached);
-
-    if (m_orientation == Horizontal) {
-        setImplicitWidth(totalSizeHint);
-        info->setMinimumWidth(totalMinimumSize + totalSpacing);
-        info->setMaximumWidth(totalMaximumSize + totalSpacing);
-    } else {
-        setImplicitHeight(totalSizeHint);
-        info->setMinimumHeight(totalMinimumSize + totalSpacing);
-        info->setMaximumHeight(totalMaximumSize + totalSpacing);
-    }
-}
-
-QT_END_NAMESPACE
diff --git a/src/controls/qquicklinearlayout_p.h b/src/controls/qquicklinearlayout_p.h
deleted file mode 100644
index 6db7562d..00000000
--- a/src/controls/qquicklinearlayout_p.h
+++ /dev/null
@@ -1,116 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
-** Contact: http://www.qt-project.org/legal
-**
-** This file is part of the Qt Quick Controls module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and Digia.  For licensing terms and
-** conditions see http://qt.digia.com/licensing.  For further information
-** use the contact form at http://qt.digia.com/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 2.1 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU Lesser General Public License version 2.1 requirements
-** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
-**
-** In addition, as a special exception, Digia gives you certain additional
-** rights.  These rights are described in the Digia Qt LGPL Exception
-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3.0 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.  Please review the following information to
-** ensure the GNU General Public License version 3.0 requirements will be
-** met: http://www.gnu.org/copyleft/gpl.html.
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef QQUICKLINEARLAYOUT_P_H
-#define QQUICKLINEARLAYOUT_P_H
-
-#include "qquicklayout_p.h"
-
-QT_BEGIN_NAMESPACE
-
-class QQuickComponentsLinearLayout : public QQuickComponentsLayout
-{
-    Q_OBJECT
-    Q_PROPERTY(qreal spacing READ spacing WRITE setSpacing NOTIFY spacingChanged)
-
-public:
-    enum Orientation {
-        Vertical,
-        Horizontal
-    };
-
-    explicit QQuickComponentsLinearLayout(Orientation orientation,
-                                          QQuickItem *parent = 0);
-    ~QQuickComponentsLinearLayout() {}
-
-    qreal spacing() const;
-    void setSpacing(qreal spacing);
-
-    Orientation orientation() const;
-    void setOrientation(Orientation orientation);
-
-    void componentComplete();
-
-signals:
-    void spacingChanged();
-    void orientationChanged();
-
-protected:
-    void updateLayoutItems();
-    void reconfigureLayout();
-    void insertLayoutItem(QQuickItem *item);
-    void removeLayoutItem(QQuickItem *item);
-    void itemChange(ItemChange change, const ItemChangeData &data);
-    void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry);
-
-protected slots:
-    void onItemVisibleChanged();
-    void onItemDestroyed();
-
-private:
-    qreal m_spacing;
-    Orientation m_orientation;
-    QList<QQuickItem *> m_items;
-};
-
-
-class QQuickComponentsRowLayout : public QQuickComponentsLinearLayout
-{
-    Q_OBJECT
-
-public:
-    explicit QQuickComponentsRowLayout(QQuickItem *parent = 0)
-        : QQuickComponentsLinearLayout(Horizontal, parent) {}
-};
-
-
-class QQuickComponentsColumnLayout : public QQuickComponentsLinearLayout
-{
-    Q_OBJECT
-
-public:
-    explicit QQuickComponentsColumnLayout(QQuickItem *parent = 0)
-        : QQuickComponentsLinearLayout(Vertical, parent) {}
-};
-
-QT_END_NAMESPACE
-
-#endif // QQUICKLINEARLAYOUT_P_H
diff --git a/src/layouts/.gitattributes b/src/layouts/.gitattributes
new file mode 100644
index 00000000..4f72c998
--- /dev/null
+++ b/src/layouts/.gitattributes
@@ -0,0 +1 @@
+*.qmltypes  diff=text
\ No newline at end of file
diff --git a/src/layouts/layouts.pro b/src/layouts/layouts.pro
new file mode 100644
index 00000000..20bcf20c
--- /dev/null
+++ b/src/layouts/layouts.pro
@@ -0,0 +1,26 @@
+CXX_MODULE = qml
+TARGET  = qquicklayoutsplugin
+TARGETPATH = QtQuick/Layouts
+IMPORT_VERSION = 2.1
+
+QT *= qml-private quick-private v8-private gui-private core-private
+
+#QMAKE_DOCS = $$PWD/doc/qtquicklayouts.qdocconf
+
+SOURCES += plugin.cpp \
+    qlayoutpolicy.cpp \
+    qgridlayoutengine.cpp \
+    qquicklayout.cpp \
+    qquicklinearlayout.cpp
+
+HEADERS += \
+    qlayoutpolicy_p.h \
+    qgridlayoutengine_p.h \
+    qquickgridlayoutengine_p.h \
+    qquicklayout_p.h \
+    qquicklinearlayout_p.h
+
+OTHER_FILES += \
+$$PWD/plugin.json
+
+load(qml_plugin)
diff --git a/src/controls/qquicklayoutengine_p.h b/src/layouts/plugin.cpp
index f83da4b1..8348d8a0 100644
--- a/src/controls/qquicklayoutengine_p.h
+++ b/src/layouts/plugin.cpp
@@ -3,7 +3,7 @@
 ** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
 ** Contact: http://www.qt-project.org/legal
 **
-** This file is part of the Qt Quick Controls module of the Qt Toolkit.
+** This file is part of the Qt Quick Layouts module of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** Commercial License Usage
@@ -39,51 +39,32 @@
 **
 ****************************************************************************/
 
-#ifndef QQUICKLAYOUTENGINE_P_H
-#define QQUICKLAYOUTENGINE_P_H
+#include <QtQml/qqmlextensionplugin.h>
 
-#include <QVector>
+#include "qquicklinearlayout_p.h"
 
 QT_BEGIN_NAMESPACE
 
-struct QQuickComponentsLayoutInfo
+//![class decl]
+class QtQuickLayoutsPlugin : public QQmlExtensionPlugin
 {
-    QQuickComponentsLayoutInfo()
-        : stretch(1),
-          sizeHint(0),
-          spacing(0),
-          minimumSize(0),
-          maximumSize(0),
-          expansive(true),
-          done(false),
-          pos(0),
-          size(0)
-    { }
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface/1.0")
+public:
+    virtual void registerTypes(const char *uri)
+    {
+        Q_ASSERT(QLatin1String(uri) == QLatin1String("QtQuick.Layouts"));
+        Q_UNUSED(uri);
 
-    inline qreal smartSizeHint() {
-        return (stretch > 0) ? minimumSize : sizeHint;
+        qmlRegisterType<QQuickRowLayout>(uri, 1, 0, "RowLayout");
+        qmlRegisterType<QQuickColumnLayout>(uri, 1, 0, "ColumnLayout");
+        qmlRegisterType<QQuickGridLayout>(uri, 1, 0, "GridLayout");
+        qmlRegisterUncreatableType<QQuickLayout>(uri, 1, 0, "Layout",
+                                                           QLatin1String("Do not create objects of type Layout"));
     }
-
-    inline qreal effectiveSpacer(qreal value) const {
-        return value + spacing;
-    }
-
-    qreal stretch;
-    qreal sizeHint;
-    qreal spacing;
-    qreal minimumSize;
-    qreal maximumSize;
-    bool expansive;
-
-    // result
-    bool done;
-    qreal pos;
-    qreal size;
 };
-
-void qDeclarativeLayoutCalculate(QVector<QQuickComponentsLayoutInfo> &chain, int start,
-                                 int count, qreal pos, qreal space, qreal spacer);
+//![class decl]
 
 QT_END_NAMESPACE
 
-#endif // QQUICKLAYOUTENGINE_P_H
+#include "plugin.moc"
diff --git a/src/layouts/plugin.json b/src/layouts/plugin.json
new file mode 100644
index 00000000..0967ef42
--- /dev/null
+++ b/src/layouts/plugin.json
@@ -0,0 +1 @@
+{}
diff --git a/src/layouts/plugins.qmltypes b/src/layouts/plugins.qmltypes
new file mode 100644
index 00000000..dd3dc69f
--- /dev/null
+++ b/src/layouts/plugins.qmltypes
diff --git a/src/layouts/qgridlayoutengine.cpp b/src/layouts/qgridlayoutengine.cpp
new file mode 100644
index 00000000..11188d56
--- /dev/null
+++ b/src/layouts/qgridlayoutengine.cpp
@@ -0,0 +1,1678 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Quick Layouts module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qglobal.h"
+
+#ifndef QT_NO_GRAPHICSVIEW
+
+#include <math.h>
+
+//#include "qgraphicslayoutitem.h"
+#include "qgridlayoutengine_p.h"
+//#include "qstyleoption.h"
+#include "qvarlengtharray.h"
+
+#include <QtDebug>
+#include <QtCore/qmath.h>
+
+QT_BEGIN_NAMESPACE
+
+template <typename T>
+static void insertOrRemoveItems(QVector<T> &items, int index, int delta)
+{
+    int count = items.count();
+    if (index < count) {
+        if (delta > 0) {
+            items.insert(index, delta, T());
+        } else if (delta < 0) {
+            items.remove(index, qMin(-delta, count - index));
+        }
+    }
+}
+
+static qreal growthFactorBelowPreferredSize(qreal desired, qreal sumAvailable, qreal sumDesired)
+{
+    Q_ASSERT(sumDesired != 0.0);
+    return desired * qPow(sumAvailable / sumDesired, desired / sumDesired);
+}
+
+static qreal fixedDescent(qreal descent, qreal ascent, qreal targetSize)
+{
+    if (descent < 0.0)
+        return -1.0;
+
+    Q_ASSERT(descent >= 0.0);
+    Q_ASSERT(ascent >= 0.0);
+    Q_ASSERT(targetSize >= ascent + descent);
+
+    qreal extra = targetSize - (ascent + descent);
+    return descent + (extra / 2.0);
+}
+
+static qreal compare(const QGridLayoutBox &box1, const QGridLayoutBox &box2, int which)
+{
+    qreal size1 = box1.q_sizes(which);
+    qreal size2 = box2.q_sizes(which);
+
+    if (which == MaximumSize) {
+        return size2 - size1;
+    } else {
+        return size1 - size2;
+    }
+}
+
+void QGridLayoutBox::add(const QGridLayoutBox &other, int stretch, qreal spacing)
+{
+    Q_ASSERT(q_minimumDescent < 0.0);
+
+    q_minimumSize += other.q_minimumSize + spacing;
+    q_preferredSize += other.q_preferredSize + spacing;
+    q_maximumSize += ((stretch == 0) ? other.q_preferredSize : other.q_maximumSize) + spacing;
+}
+
+void QGridLayoutBox::combine(const QGridLayoutBox &other)
+{
+    q_minimumDescent = qMax(q_minimumDescent, other.q_minimumDescent);
+    q_minimumAscent = qMax(q_minimumAscent, other.q_minimumAscent);
+
+    q_minimumSize = qMax(q_minimumAscent + q_minimumDescent,
+                         qMax(q_minimumSize, other.q_minimumSize));
+    qreal maxMax;
+    if (q_maximumSize == FLT_MAX && other.q_maximumSize != FLT_MAX)
+        maxMax = other.q_maximumSize;
+    else if (other.q_maximumSize == FLT_MAX && q_maximumSize != FLT_MAX)
+        maxMax = q_maximumSize;
+    else
+        maxMax = qMax(q_maximumSize, other.q_maximumSize);
+
+    q_maximumSize = qMax(q_minimumSize, maxMax);
+    q_preferredSize = qBound(q_minimumSize, qMax(q_preferredSize, other.q_preferredSize),
+                             q_maximumSize);
+}
+
+void QGridLayoutBox::normalize()
+{
+    q_maximumSize = qMax(qreal(0.0), q_maximumSize);
+    q_minimumSize = qBound(qreal(0.0), q_minimumSize, q_maximumSize);
+    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));
+}
+
+#ifdef QT_DEBUG
+void QGridLayoutBox::dump(int indent) const
+{
+    qDebug("%*sBox (%g <= %g <= %g [%g/%g])", indent, "", q_minimumSize, q_preferredSize,
+           q_maximumSize, q_minimumAscent, q_minimumDescent);
+}
+#endif
+
+bool operator==(const QGridLayoutBox &box1, const QGridLayoutBox &box2)
+{
+    for (int i = 0; i < NSizes; ++i) {
+        if (box1.q_sizes(i) != box2.q_sizes(i))
+            return false;
+    }
+    return box1.q_minimumDescent == box2.q_minimumDescent
+           && box1.q_minimumAscent == box2.q_minimumAscent;
+}
+
+void QGridLayoutRowData::reset(int count)
+{
+    ignore.fill(false, count);
+    boxes.fill(QGridLayoutBox(), count);
+    multiCellMap.clear();
+    stretches.fill(0, count);
+    spacings.fill(0.0, count);
+    hasIgnoreFlag = false;
+}
+
+void QGridLayoutRowData::distributeMultiCells(const QGridLayoutRowInfo &rowInfo)
+{
+    MultiCellMap::const_iterator i = multiCellMap.constBegin();
+    for (; i != multiCellMap.constEnd(); ++i) {
+        int start = i.key().first;
+        int span = i.key().second;
+        int end = start + span;
+        const QGridLayoutBox &box = i.value().q_box;
+        int stretch = i.value().q_stretch;
+
+        QGridLayoutBox totalBox = this->totalBox(start, end);
+        QVarLengthArray<QGridLayoutBox> extras(span);
+        QVarLengthArray<qreal> dummy(span);
+        QVarLengthArray<qreal> newSizes(span);
+
+        for (int j = 0; j < NSizes; ++j) {
+            qreal extra = compare(box, totalBox, j);
+            if (extra > 0.0) {
+                calculateGeometries(start, end, box.q_sizes(j), dummy.data(), newSizes.data(),
+                                    0, totalBox, rowInfo);
+
+                for (int k = 0; k < span; ++k)
+                    extras[k].q_sizes(j) = newSizes[k];
+            }
+        }
+
+        for (int k = 0; k < span; ++k) {
+            boxes[start + k].combine(extras[k]);
+            if (stretch != 0)
+                stretches[start + k] = qMax(stretches[start + k], stretch);
+        }
+    }
+    multiCellMap.clear();
+}
+
+void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSize, qreal *positions,
+                                             qreal *sizes, qreal *descents,
+                                             const QGridLayoutBox &totalBox,
+                                             const QGridLayoutRowInfo &rowInfo)
+{
+    Q_ASSERT(end > start);
+
+    targetSize = qMax(totalBox.q_minimumSize, targetSize);
+
+    int n = end - start;
+    QVarLengthArray<qreal> newSizes(n);
+    QVarLengthArray<qreal> factors(n);
+    qreal sumFactors = 0.0;
+    int sumStretches = 0;
+    qreal sumAvailable;
+
+    for (int i = 0; i < n; ++i) {
+        if (stretches[start + i] > 0)
+            sumStretches += stretches[start + i];
+    }
+
+    if (targetSize < totalBox.q_preferredSize) {
+        stealBox(start, end, MinimumSize, positions, sizes);
+
+        sumAvailable = targetSize - totalBox.q_minimumSize;
+        if (sumAvailable > 0.0) {
+            qreal sumDesired = totalBox.q_preferredSize - totalBox.q_minimumSize;
+
+            for (int i = 0; i < n; ++i) {
+                if (ignore.testBit(start + i)) {
+                    factors[i] = 0.0;
+                    continue;
+                }
+
+                const QGridLayoutBox &box = boxes.at(start + i);
+                qreal desired = box.q_preferredSize - box.q_minimumSize;
+                factors[i] = growthFactorBelowPreferredSize(desired, sumAvailable, sumDesired);
+                sumFactors += factors[i];
+            }
+
+            for (int i = 0; i < n; ++i) {
+                Q_ASSERT(sumFactors > 0.0);
+                qreal delta = sumAvailable * factors[i] / sumFactors;
+                newSizes[i] = sizes[i] + delta;
+            }
+        }
+    } else {
+        bool isLargerThanMaximum = (targetSize > totalBox.q_maximumSize);
+        if (isLargerThanMaximum) {
+            stealBox(start, end, MaximumSize, positions, sizes);
+            sumAvailable = targetSize - totalBox.q_maximumSize;
+        } else {
+            stealBox(start, end, PreferredSize, positions, sizes);
+            sumAvailable = targetSize - totalBox.q_preferredSize;
+        }
+
+        if (sumAvailable > 0.0) {
+            qreal sumCurrentAvailable = sumAvailable;
+            bool somethingHasAMaximumSize = false;
+
+            qreal sumSizes = 0.0;
+            for (int i = 0; i < n; ++i)
+                sumSizes += sizes[i];
+
+            for (int i = 0; i < n; ++i) {
+                if (ignore.testBit(start + i)) {
+                    newSizes[i] = 0.0;
+                    factors[i] = 0.0;
+                    continue;
+                }
+
+                const QGridLayoutBox &box = boxes.at(start + i);
+                qreal boxSize;
+
+                qreal desired;
+                if (isLargerThanMaximum) {
+                    boxSize = box.q_maximumSize;
+                    desired = rowInfo.boxes.value(start + i).q_maximumSize - boxSize;
+                } else {
+                    boxSize = box.q_preferredSize;
+                    desired = box.q_maximumSize - boxSize;
+                }
+                if (desired == 0.0) {
+                    newSizes[i] = sizes[i];
+                    factors[i] = 0.0;
+                } else {
+                    Q_ASSERT(desired > 0.0);
+
+                    int stretch = stretches[start + i];
+                    if (sumStretches == 0) {
+                        if (hasIgnoreFlag) {
+                            factors[i] = (stretch < 0) ? 1.0 : 0.0;
+                        } else {
+                            factors[i] = (stretch < 0) ? sizes[i] : 0.0;
+                        }
+                    } else if (stretch == sumStretches) {
+                        factors[i] = 1.0;
+                    } else if (stretch <= 0) {
+                        factors[i] = 0.0;
+                    } else {
+                        qreal ultimateSize;
+                        qreal ultimateSumSizes;
+                        qreal x = ((stretch * sumSizes)
+                                   - (sumStretches * boxSize))
+                                  / (sumStretches - stretch);
+                        if (x >= 0.0) {
+                            ultimateSize = boxSize + x;
+                            ultimateSumSizes = sumSizes + x;
+                        } else {
+                            ultimateSize = boxSize;
+                            ultimateSumSizes = (sumStretches * boxSize)
+                                                        / stretch;
+                        }
+
+                        /*
+                            We multiply these by 1.5 to give some space for a smooth transition
+                            (at the expense of the stretch factors, which are not fully respected
+                            during the transition).
+                        */
+                        ultimateSize = ultimateSize * 3 / 2;
+                        ultimateSumSizes = ultimateSumSizes * 3 / 2;
+
+                        qreal beta = ultimateSumSizes - sumSizes;
+                        if (!beta) {
+                            factors[i] = 1;
+                        } else {
+                            qreal alpha = qMin(sumCurrentAvailable, beta);
+                            qreal ultimateFactor = (stretch * ultimateSumSizes / sumStretches)
+                                                   - (boxSize);
+                            qreal transitionalFactor = sumCurrentAvailable * (ultimateSize - boxSize) / beta;
+
+                            factors[i] = ((alpha * ultimateFactor)
+                                          + ((beta - alpha) * transitionalFactor)) / beta;
+                        }
+
+                    }
+                    sumFactors += factors[i];
+                    if (desired < sumCurrentAvailable)
+                        somethingHasAMaximumSize = true;
+
+                    newSizes[i] = -1.0;
+                }
+            }
+
+            bool keepGoing = somethingHasAMaximumSize;
+            while (keepGoing) {
+                keepGoing = false;
+
+                for (int i = 0; i < n; ++i) {
+                    if (newSizes[i] >= 0.0)
+                        continue;
+
+                    qreal maxBoxSize;
+                    if (isLargerThanMaximum)
+                        maxBoxSize = rowInfo.boxes.value(start + i).q_maximumSize;
+                    else
+                        maxBoxSize = boxes.at(start + i).q_maximumSize;
+
+                    qreal avail = sumCurrentAvailable * factors[i] / sumFactors;
+                    if (sizes[i] + avail >= maxBoxSize) {
+                        newSizes[i] = maxBoxSize;
+                        sumCurrentAvailable -= maxBoxSize - sizes[i];
+                        sumFactors -= factors[i];
+                        keepGoing = (sumCurrentAvailable > 0.0);
+                        if (!keepGoing)
+                            break;
+                    }
+                }
+            }
+
+            for (int i = 0; i < n; ++i) {
+                if (newSizes[i] < 0.0) {
+                    qreal delta = (sumFactors == 0.0) ? 0.0
+                                                      : sumCurrentAvailable * factors[i] / sumFactors;
+                    newSizes[i] = sizes[i] + delta;
+                }
+            }
+        }
+    }
+
+    if (sumAvailable > 0) {
+        qreal offset = 0;
+        for (int i = 0; i < n; ++i) {
+            qreal delta = newSizes[i] - sizes[i];
+            positions[i] += offset;
+            sizes[i] += delta;
+            offset += delta;
+        }
+
+#if 0 // some "pixel allocation"
+        int surplus = targetSize - (positions[n - 1] + sizes[n - 1]);
+        Q_ASSERT(surplus >= 0 && surplus <= n);
+
+        int prevSurplus = -1;
+        while (surplus > 0 && surplus != prevSurplus) {
+            prevSurplus = surplus;
+
+            int offset = 0;
+            for (int i = 0; i < n; ++i) {
+                const QGridLayoutBox &box = boxes.at(start + i);
+                int delta = (!ignore.testBit(start + i) && surplus > 0
+                             && factors[i] > 0 && sizes[i] < box.q_maximumSize)
+                    ? 1 : 0;
+
+                positions[i] += offset;
+                sizes[i] += delta;
+                offset += delta;
+                surplus -= delta;
+            }
+        }
+        Q_ASSERT(surplus == 0);
+#endif
+    }
+
+    if (descents) {
+        for (int i = 0; i < n; ++i) {
+            if (ignore.testBit(start + i))
+                continue;
+            const QGridLayoutBox &box = boxes.at(start + i);
+            descents[i] = fixedDescent(box.q_minimumDescent, box.q_minimumAscent, sizes[i]);
+        }
+    }
+}
+
+QGridLayoutBox QGridLayoutRowData::totalBox(int start, int end) const
+{
+    QGridLayoutBox result;
+    if (start < end) {
+        result.q_maximumSize = 0.0;
+        qreal nextSpacing = 0.0;
+        for (int i = start; i < end; ++i) {
+            result.add(boxes.at(i), stretches.at(i), nextSpacing);
+            nextSpacing = spacings.at(i);
+        }
+    }
+    return result;
+}
+
+void QGridLayoutRowData::stealBox(int start, int end, int which, qreal *positions, qreal *sizes)
+{
+    qreal offset = 0.0;
+    qreal nextSpacing = 0.0;
+
+    for (int i = start; i < end; ++i) {
+        qreal avail = 0.0;
+
+        if (!ignore.testBit(i)) {
+            const QGridLayoutBox &box = boxes.at(i);
+            avail = box.q_sizes(which);
+            offset += nextSpacing;
+            nextSpacing = spacings.at(i);
+        }
+
+        *positions++ = offset;
+        *sizes++ = avail;
+        offset += avail;
+    }
+}
+
+#ifdef QT_DEBUG
+void QGridLayoutRowData::dump(int indent) const
+{
+    qDebug("%*sData", indent, "");
+
+    for (int i = 0; i < ignore.count(); ++i) {
+        qDebug("%*s Row %d (stretch %d, spacing %g)", indent, "", i, stretches.at(i),
+               spacings.at(i));
+        if (ignore.testBit(i))
+            qDebug("%*s  Ignored", indent, "");
+        boxes.at(i).dump(indent + 2);
+    }
+
+    MultiCellMap::const_iterator it = multiCellMap.constBegin();
+    while (it != multiCellMap.constEnd()) {
+        qDebug("%*s Multi-cell entry <%d, %d> (stretch %d)", indent, "", it.key().first,
+               it.key().second, it.value().q_stretch);
+        it.value().q_box.dump(indent + 2);
+    }
+}
+#endif
+
+QGridLayoutItem::QGridLayoutItem(/*QGridLayoutEngine *engine, */
+                                 int row, int column, int rowSpan, int columnSpan,
+                                 Qt::Alignment alignment)
+    : /*###q_engine(engine), q_layoutItem(layoutItem), */q_alignment(alignment)
+{
+    q_firstRows[Hor] = column;
+    q_firstRows[Ver] = row;
+    q_rowSpans[Hor] = columnSpan;
+    q_rowSpans[Ver] = rowSpan;
+    q_stretches[Hor] = -1;
+    q_stretches[Ver] = -1;
+
+    //q_engine->insertItem(this, itemAtIndex);###
+}
+
+int QGridLayoutItem::firstRow(Qt::Orientation orientation) const
+{
+    return q_firstRows[orientation == Qt::Vertical];
+}
+
+int QGridLayoutItem::firstColumn(Qt::Orientation orientation) const
+{
+    return q_firstRows[orientation == Qt::Horizontal];
+}
+
+int QGridLayoutItem::lastRow(Qt::Orientation orientation) const
+{
+    return firstRow(orientation) + rowSpan(orientation) - 1;
+}
+
+int QGridLayoutItem::lastColumn(Qt::Orientation orientation) const
+{
+    return firstColumn(orientation) + columnSpan(orientation) - 1;
+}
+
+int QGridLayoutItem::rowSpan(Qt::Orientation orientation) const
+{
+    return q_rowSpans[orientation == Qt::Vertical];
+}
+
+int QGridLayoutItem::columnSpan(Qt::Orientation orientation) const
+{
+    return q_rowSpans[orientation == Qt::Horizontal];
+}
+
+void QGridLayoutItem::setFirstRow(int row, Qt::Orientation orientation)
+{
+    q_firstRows[orientation == Qt::Vertical] = row;
+}
+
+void QGridLayoutItem::setRowSpan(int rowSpan, Qt::Orientation orientation)
+{
+    q_rowSpans[orientation == Qt::Vertical] = rowSpan;
+}
+
+int QGridLayoutItem::stretchFactor(Qt::Orientation orientation) const
+{
+    int stretch = q_stretches[orientation == Qt::Vertical];
+    if (stretch >= 0)
+        return stretch;
+
+    QLayoutPolicy::Policy policy = sizePolicy(orientation);
+
+    if (policy & QLayoutPolicy::ExpandFlag) {
+        return 1;
+    } else if (policy & QLayoutPolicy::GrowFlag) {
+        return -1;  // because we max it up
+    } else {
+        return 0;
+    }
+}
+
+void QGridLayoutItem::setStretchFactor(int stretch, Qt::Orientation orientation)
+{
+    Q_ASSERT(stretch >= 0); // ### deal with too big stretches
+    q_stretches[orientation == Qt::Vertical] = stretch;
+}
+
+QLayoutPolicy::ControlTypes QGridLayoutItem::controlTypes(LayoutSide /*side*/) const
+{
+    return QLayoutPolicy::DefaultType;    //###
+}
+
+QGridLayoutBox QGridLayoutItem::box(Qt::Orientation orientation, qreal constraint) const
+{
+    QGridLayoutBox result;
+    QLayoutPolicy::Policy policy = sizePolicy(orientation);
+
+    if (orientation == Qt::Horizontal) {
+        QSizeF constraintSize(-1.0, constraint);
+
+        result.q_preferredSize = sizeHint(Qt::PreferredSize, constraintSize).width();
+
+        if (policy & QLayoutPolicy::ShrinkFlag) {
+            result.q_minimumSize = sizeHint(Qt::MinimumSize, constraintSize).width();
+        } else {
+            result.q_minimumSize = result.q_preferredSize;
+        }
+
+        if (policy & (QLayoutPolicy::GrowFlag | QLayoutPolicy::ExpandFlag)) {
+            result.q_maximumSize = sizeHint(Qt::MaximumSize, constraintSize).width();
+        } else {
+            result.q_maximumSize = result.q_preferredSize;
+        }
+    } else {
+        QSizeF constraintSize(constraint, -1.0);
+
+        result.q_preferredSize = sizeHint(Qt::PreferredSize, constraintSize).height();
+
+        if (policy & QLayoutPolicy::ShrinkFlag) {
+            result.q_minimumSize = sizeHint(Qt::MinimumSize, constraintSize).height();
+        } else {
+            result.q_minimumSize = result.q_preferredSize;
+        }
+
+        if (policy & (QLayoutPolicy::GrowFlag | QLayoutPolicy::ExpandFlag)) {
+            result.q_maximumSize = sizeHint(Qt::MaximumSize, constraintSize).height();
+        } else {
+            result.q_maximumSize = result.q_preferredSize;
+        }
+
+        result.q_minimumDescent = sizeHint(Qt::MinimumDescent, constraintSize).height();
+        if (result.q_minimumDescent >= 0.0)
+            result.q_minimumAscent = result.q_minimumSize - result.q_minimumDescent;
+    }
+    if (policy & QLayoutPolicy::IgnoreFlag)
+        result.q_preferredSize = result.q_minimumSize;
+
+    return result;
+}
+
+QRectF QGridLayoutItem::geometryWithin(qreal x, qreal y, qreal width, qreal height,
+                                       qreal rowDescent, Qt::Alignment align) const
+{
+    rowDescent = -1.0; // ### This disables the descent
+
+    QGridLayoutBox vBox = box(Qt::Vertical);
+    if (vBox.q_minimumDescent < 0.0 || rowDescent < 0.0) {
+        qreal cellWidth = width;
+        qreal cellHeight = height;
+
+
+        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();
+
+        switch (align & Qt::AlignHorizontal_Mask) {
+        case Qt::AlignHCenter:
+            x += (cellWidth - width)/2;
+            break;
+        case Qt::AlignRight:
+            x += cellWidth - width;
+            break;
+        default:
+            break;
+        }
+        switch (align & Qt::AlignVertical_Mask) {
+        case Qt::AlignVCenter:
+            y += (cellHeight - height)/2;
+            break;
+        case Qt::AlignBottom:
+            y += cellHeight - height;
+            break;
+        default:
+            break;
+        }
+        return QRectF(x, y, width, height);
+    } else {
+        qreal descent = vBox.q_minimumDescent;
+        qreal ascent = vBox.q_minimumSize - descent;
+        return QRectF(x, y + height - rowDescent - ascent, width, ascent + descent);
+    }
+}
+
+void QGridLayoutItem::transpose()
+{
+    qSwap(q_firstRows[Hor], q_firstRows[Ver]);
+    qSwap(q_rowSpans[Hor], q_rowSpans[Ver]);
+    qSwap(q_stretches[Hor], q_stretches[Ver]);
+}
+
+void QGridLayoutItem::insertOrRemoveRows(int row, int delta, Qt::Orientation orientation)
+{
+    int oldFirstRow = firstRow(orientation);
+    if (oldFirstRow >= row) {
+        setFirstRow(oldFirstRow + delta, orientation);
+    } else if (lastRow(orientation) >= row) {
+        setRowSpan(rowSpan(orientation) + delta, orientation);
+    }
+}
+/*!
+    \internal
+    returns the effective maximumSize, will take the sizepolicy into
+    consideration. (i.e. if sizepolicy does not have QLayoutPolicy::Grow, then
+    maxSizeHint will be the preferredSize)
+    Note that effectiveSizeHint does not take sizePolicy into consideration,
+    (since it only evaluates the hints, as the name implies)
+*/
+QSizeF QGridLayoutItem::effectiveMaxSize(const QSizeF &constraint) const
+{
+    QSizeF size = constraint;
+    bool vGrow = (sizePolicy(Qt::Vertical) & QLayoutPolicy::GrowFlag) == QLayoutPolicy::GrowFlag;
+    bool hGrow = (sizePolicy(Qt::Horizontal) & QLayoutPolicy::GrowFlag) == QLayoutPolicy::GrowFlag;
+    if (!vGrow || !hGrow) {
+        QSizeF pref = sizeHint(Qt::PreferredSize, constraint);
+        if (!vGrow)
+            size.setHeight(pref.height());
+        if (!hGrow)
+            size.setWidth(pref.width());
+    }
+
+    if (!size.isValid()) {
+        QSizeF maxSize = sizeHint(Qt::MaximumSize, size);
+        if (size.width() == -1)
+            size.setWidth(maxSize.width());
+        if (size.height() == -1)
+            size.setHeight(maxSize.height());
+    }
+    return size;
+}
+
+#ifdef QT_DEBUG
+void QGridLayoutItem::dump(int indent) const
+{
+    qDebug("%*s (%d, %d) %d x %d", indent, "", firstRow(), firstColumn(),   //###
+           rowSpan(), columnSpan());
+
+    if (q_stretches[Hor] >= 0)
+        qDebug("%*s Horizontal stretch: %d", indent, "", q_stretches[Hor]);
+    if (q_stretches[Ver] >= 0)
+        qDebug("%*s Vertical stretch: %d", indent, "", q_stretches[Ver]);
+    if (q_alignment != 0)
+        qDebug("%*s Alignment: %x", indent, "", uint(q_alignment));
+    qDebug("%*s Horizontal size policy: %x Vertical size policy: %x",
+        indent, "", sizePolicy(Qt::Horizontal), sizePolicy(Qt::Vertical));
+}
+#endif
+
+void QGridLayoutRowInfo::insertOrRemoveRows(int row, int delta)
+{
+    count += delta;
+
+    insertOrRemoveItems(stretches, row, delta);
+    insertOrRemoveItems(spacings, row, delta);
+    insertOrRemoveItems(alignments, row, delta);
+    insertOrRemoveItems(boxes, row, delta);
+}
+
+#ifdef QT_DEBUG
+void QGridLayoutRowInfo::dump(int indent) const
+{
+    qDebug("%*sInfo (count: %d)", indent, "", count);
+    for (int i = 0; i < count; ++i) {
+        QString message;
+
+        if (stretches.value(i).value() >= 0)
+            message += QString::fromLatin1(" stretch %1").arg(stretches.value(i).value());
+        if (spacings.value(i).value() >= 0.0)
+            message += QString::fromLatin1(" spacing %1").arg(spacings.value(i).value());
+        if (alignments.value(i) != 0)
+            message += QString::fromLatin1(" alignment %1").arg(int(alignments.value(i)), 16);
+
+        if (!message.isEmpty() || boxes.value(i) != QGridLayoutBox()) {
+            qDebug("%*s Row %d:%s", indent, "", i, qPrintable(message));
+            if (boxes.value(i) != QGridLayoutBox())
+                boxes.value(i).dump(indent + 1);
+        }
+    }
+}
+#endif
+
+QGridLayoutEngine::QGridLayoutEngine()
+{
+    m_visualDirection = Qt::LeftToRight;
+    invalidate();
+}
+
+int QGridLayoutEngine::rowCount(Qt::Orientation orientation) const
+{
+    return q_infos[orientation == Qt::Vertical].count;
+}
+
+int QGridLayoutEngine::columnCount(Qt::Orientation orientation) const
+{
+    return q_infos[orientation == Qt::Horizontal].count;
+}
+
+int QGridLayoutEngine::itemCount() const
+{
+    return q_items.count();
+}
+
+QGridLayoutItem *QGridLayoutEngine::itemAt(int index) const
+{
+    Q_ASSERT(index >= 0 && index < itemCount());
+    return q_items.at(index);
+}
+
+int QGridLayoutEngine::effectiveFirstRow(Qt::Orientation orientation) const
+{
+    ensureEffectiveFirstAndLastRows();
+    return q_cachedEffectiveFirstRows[orientation == Qt::Vertical];
+}
+
+int QGridLayoutEngine::effectiveLastRow(Qt::Orientation orientation) const
+{
+    ensureEffectiveFirstAndLastRows();
+    return q_cachedEffectiveLastRows[orientation == Qt::Vertical];
+}
+
+void QGridLayoutEngine::setSpacing(qreal spacing, Qt::Orientations orientations)
+{
+    Q_ASSERT(spacing >= 0.0);
+    if (orientations & Qt::Horizontal)
+        q_defaultSpacings[Hor].setUserValue(spacing);
+    if (orientations & Qt::Vertical)
+        q_defaultSpacings[Ver].setUserValue(spacing);
+
+    invalidate();
+}
+
+qreal QGridLayoutEngine::spacing(Qt::Orientation orientation, const QLayoutStyleInfo &/*styleInfo*/) const
+{
+    if (q_defaultSpacings[orientation == Qt::Vertical].isDefault()) {
+        /* ###
+        if (QStyle *style = styleInfo.style()) {
+            QStyleOption option;
+            option.initFrom(styleInfo.widget());
+            qreal defaultSpacing = (qreal)style->pixelMetric(orientation == Qt::Vertical ? QStyle::PM_LayoutVerticalSpacing
+                                                   : QStyle::PM_LayoutHorizontalSpacing, &option, styleInfo.widget());
+            q_defaultSpacings[orientation == Qt::Vertical].setCachedValue(defaultSpacing);
+        }
+        */
+    }
+    return q_defaultSpacings[orientation == Qt::Vertical].value();
+}
+
+void QGridLayoutEngine::setRowSpacing(int row, qreal spacing, Qt::Orientation orientation)
+{
+    Q_ASSERT(row >= 0);
+
+    QGridLayoutRowInfo &rowInfo = q_infos[orientation == Qt::Vertical];
+    if (row >= rowInfo.spacings.count())
+        rowInfo.spacings.resize(row + 1);
+    if (spacing >= 0)
+        rowInfo.spacings[row].setUserValue(spacing);
+    else
+        rowInfo.spacings[row] = QLayoutParameter<qreal>();
+    invalidate();
+}
+
+qreal QGridLayoutEngine::rowSpacing(int row, Qt::Orientation orientation) const
+{
+    QLayoutParameter<qreal> spacing = q_infos[orientation == Qt::Vertical].spacings.value(row);
+    if (!spacing.isDefault())
+        return spacing.value();
+    return q_defaultSpacings[orientation == Qt::Vertical].value();
+}
+
+void QGridLayoutEngine::setRowStretchFactor(int row, int stretch, Qt::Orientation orientation)
+{
+    Q_ASSERT(row >= 0);
+    Q_ASSERT(stretch >= 0);
+
+    maybeExpandGrid(row, -1, orientation);
+
+    QGridLayoutRowInfo &rowInfo = q_infos[orientation == Qt::Vertical];
+    if (row >= rowInfo.stretches.count())
+        rowInfo.stretches.resize(row + 1);
+    rowInfo.stretches[row].setUserValue(stretch);
+}
+
+int QGridLayoutEngine::rowStretchFactor(int row, Qt::Orientation orientation) const
+{
+    QStretchParameter stretch = q_infos[orientation == Qt::Vertical].stretches.value(row);
+    if (!stretch.isDefault())
+        return stretch.value();
+    return 0;
+}
+/*
+void QGridLayoutEngine::setStretchFactor(QGraphicsLayoutItem *layoutItem, int stretch,
+                                         Qt::Orientation orientation)
+{
+    Q_ASSERT(stretch >= 0);
+
+    if (QGridLayoutItem *item = findLayoutItem(layoutItem))
+        item->setStretchFactor(stretch, orientation);
+}
+
+int QGridLayoutEngine::stretchFactor(QGraphicsLayoutItem *layoutItem, Qt::Orientation orientation) const
+{
+    if (QGridLayoutItem *item = findLayoutItem(layoutItem))
+        return item->stretchFactor(orientation);
+    return 0;
+}
+*/
+void QGridLayoutEngine::setRowSizeHint(Qt::SizeHint which, int row, qreal size,
+                                       Qt::Orientation orientation)
+{
+    Q_ASSERT(row >= 0);
+    Q_ASSERT(size >= 0.0);
+
+    maybeExpandGrid(row, -1, orientation);
+
+    QGridLayoutRowInfo &rowInfo = q_infos[orientation == Qt::Vertical];
+    if (row >= rowInfo.boxes.count())
+        rowInfo.boxes.resize(row + 1);
+    rowInfo.boxes[row].q_sizes(which) = size;
+}
+
+qreal QGridLayoutEngine::rowSizeHint(Qt::SizeHint which, int row, Qt::Orientation orientation) const
+{
+    return q_infos[orientation == Qt::Vertical].boxes.value(row).q_sizes(which);
+}
+
+void QGridLayoutEngine::setRowAlignment(int row, Qt::Alignment alignment,
+                                        Qt::Orientation orientation)
+{
+    Q_ASSERT(row >= 0);
+
+    maybeExpandGrid(row, -1, orientation);
+
+    QGridLayoutRowInfo &rowInfo = q_infos[orientation == Qt::Vertical];
+    if (row >= rowInfo.alignments.count())
+        rowInfo.alignments.resize(row + 1);
+    rowInfo.alignments[row] = alignment;
+}
+
+Qt::Alignment QGridLayoutEngine::rowAlignment(int row, Qt::Orientation orientation) const
+{
+    Q_ASSERT(row >= 0);
+    return q_infos[orientation == Qt::Vertical].alignments.value(row);
+}
+
+Qt::Alignment QGridLayoutEngine::effectiveAlignment(const QGridLayoutItem *layoutItem) const
+{
+    Qt::Alignment align = layoutItem->alignment();
+    if (!(align & Qt::AlignVertical_Mask)) {
+        // no vertical alignment, respect the row alignment
+        int y = layoutItem->firstRow();
+        align |= (rowAlignment(y, Qt::Vertical) & Qt::AlignVertical_Mask);
+        if (!align)
+            align = Qt::AlignVCenter;
+    }
+    if (!(align & Qt::AlignHorizontal_Mask)) {
+        // no horizontal alignment, respect the column alignment
+        int x = layoutItem->firstColumn();
+        align |= (rowAlignment(x, Qt::Horizontal) & Qt::AlignHorizontal_Mask);
+        if (!align)
+            align = Qt::AlignHCenter;
+    }
+    return align;
+}
+
+/*!
+    \internal
+    The \a index is only used by QGraphicsLinearLayout to ensure that itemAt() reflects the order
+    of visual arrangement. Strictly speaking it does not have to, but most people expect it to.
+    (And if it didn't we would have to add itemArrangedAt(int index) or something..)
+ */
+void QGridLayoutEngine::insertItem(QGridLayoutItem *item, int index)
+{
+    maybeExpandGrid(item->lastRow(), item->lastColumn());
+
+    if (index == -1)
+        q_items.append(item);
+    else
+        q_items.insert(index, item);
+
+    for (int i = item->firstRow(); i <= item->lastRow(); ++i) {
+        for (int j = item->firstColumn(); j <= item->lastColumn(); ++j) {
+            if (itemAt(i, j))
+                qWarning("QGridLayoutEngine::addItem: Cell (%d, %d) already taken", i, j);
+            setItemAt(i, j, item);
+        }
+    }
+}
+
+void QGridLayoutEngine::addItem(QGridLayoutItem *item)
+{
+    insertItem(item, -1);
+}
+
+void QGridLayoutEngine::removeItem(QGridLayoutItem *item)
+{
+    Q_ASSERT(q_items.contains(item));
+
+    invalidate();
+
+    for (int i = item->firstRow(); i <= item->lastRow(); ++i) {
+        for (int j = item->firstColumn(); j <= item->lastColumn(); ++j) {
+            if (itemAt(i, j) == item)
+                setItemAt(i, j, 0);
+        }
+    }
+
+    q_items.removeAll(item);
+}
+
+
+QGridLayoutItem *QGridLayoutEngine::itemAt(int row, int column, Qt::Orientation orientation) const
+{
+    if (orientation == Qt::Horizontal)
+        qSwap(row, column);
+    if (uint(row) >= uint(rowCount()) || uint(column) >= uint(columnCount()))
+        return 0;
+    return q_grid.at((row * internalGridColumnCount()) + column);
+}
+
+void QGridLayoutEngine::invalidate()
+{
+    q_cachedEffectiveFirstRows[Hor] = -1;
+    q_cachedEffectiveFirstRows[Ver] = -1;
+    q_cachedEffectiveLastRows[Hor] = -1;
+    q_cachedEffectiveLastRows[Ver] = -1;
+    q_cachedDataForStyleInfo.invalidate();
+    q_cachedSize = QSizeF();
+    q_cachedConstraintOrientation = UnknownConstraint;
+}
+
+static void visualRect(QRectF *geom, Qt::LayoutDirection dir, const QRectF &contentsRect)
+{
+    if (dir == Qt::RightToLeft)
+        geom->moveRight(contentsRect.right() - (geom->left() - contentsRect.left()));
+}
+
+void QGridLayoutEngine::setGeometries(const QRectF &contentsGeometry, const QLayoutStyleInfo &styleInfo)
+{
+    if (rowCount() < 1 || columnCount() < 1)
+        return;
+
+    ensureGeometries(contentsGeometry.size(), styleInfo);
+
+    for (int i = q_items.count() - 1; i >= 0; --i) {
+        QGridLayoutItem *item = q_items.at(i);
+
+        qreal x = q_xx[item->firstColumn()];
+        qreal y = q_yy[item->firstRow()];
+        qreal width = q_widths[item->lastColumn()];
+        qreal height = q_heights[item->lastRow()];
+
+        if (item->columnSpan() != 1)
+            width += q_xx[item->lastColumn()] - x;
+        if (item->rowSpan() != 1)
+            height += q_yy[item->lastRow()] - y;
+
+        QRectF geom = item->geometryWithin(contentsGeometry.x() + x, contentsGeometry.y() + y,
+                                           width, height, q_descents[item->lastRow()], effectiveAlignment(item));
+        visualRect(&geom, visualDirection(), contentsGeometry);
+        item->setGeometry(geom);
+    }
+}
+
+// ### candidate for deletion
+QRectF QGridLayoutEngine::cellRect(const QRectF &contentsGeometry, int row, int column, int rowSpan,
+                                   int columnSpan, const QLayoutStyleInfo &styleInfo) const
+{
+    if (uint(row) >= uint(rowCount()) || uint(column) >= uint(columnCount())
+            || rowSpan < 1 || columnSpan < 1)
+        return QRectF();
+
+    ensureGeometries(contentsGeometry.size(), styleInfo);
+
+    int lastColumn = qMax(column + columnSpan, columnCount()) - 1;
+    int lastRow = qMax(row + rowSpan, rowCount()) - 1;
+
+    qreal x = q_xx[column];
+    qreal y = q_yy[row];
+    qreal width = q_widths[lastColumn];
+    qreal height = q_heights[lastRow];
+
+    if (columnSpan != 1)
+        width += q_xx[lastColumn] - x;
+    if (rowSpan != 1)
+        height += q_yy[lastRow] - y;
+
+    return QRectF(contentsGeometry.x() + x, contentsGeometry.y() + y, width, height);
+}
+
+QSizeF QGridLayoutEngine::sizeHint(Qt::SizeHint which, const QSizeF &constraint,
+                                   const QLayoutStyleInfo &styleInfo) const
+{
+    QGridLayoutBox sizehint_totalBoxes[NOrientations];
+
+    bool sizeHintCalculated = false;
+
+    if (hasDynamicConstraint() && rowCount() > 0 && columnCount() > 0) {
+        if (constraintOrientation() == Qt::Vertical) {
+            //We have items whose height depends on their width
+            if (constraint.width() >= 0) {
+                if (q_cachedDataForStyleInfo != styleInfo)
+                    ensureColumnAndRowData(&q_columnData, &sizehint_totalBoxes[Hor], NULL, NULL, Qt::Horizontal, styleInfo);
+                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();
+                //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], q_infos[Hor]);
+                ensureColumnAndRowData(&q_rowData, &sizehint_totalBoxes[Ver], sizehint_xx.data(), sizehint_widths.data(), Qt::Vertical, styleInfo);
+                sizeHintCalculated = true;
+            }
+        } else {
+            if (constraint.height() >= 0) {
+                //We have items whose width depends on their height
+                ensureColumnAndRowData(&q_rowData, &sizehint_totalBoxes[Ver], NULL, NULL, Qt::Vertical, styleInfo);
+                QVector<qreal> sizehint_yy;
+                QVector<qreal> sizehint_heights;
+
+                sizehint_yy.resize(rowCount());
+                sizehint_heights.resize(rowCount());
+                qreal height = constraint.height();
+                //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], q_infos[Ver]);
+                ensureColumnAndRowData(&q_columnData, &sizehint_totalBoxes[Hor], sizehint_yy.data(), sizehint_heights.data(), Qt::Horizontal, styleInfo);
+                sizeHintCalculated = true;
+            }
+        }
+    }
+
+    if (!sizeHintCalculated) {
+        //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], NULL, NULL, Qt::Horizontal, styleInfo);
+            ensureColumnAndRowData(&q_rowData, &sizehint_totalBoxes[Ver], NULL, NULL, Qt::Vertical, styleInfo);
+        } else {
+            sizehint_totalBoxes[Hor] = q_totalBoxes[Hor];
+            sizehint_totalBoxes[Ver] = q_totalBoxes[Ver];
+        }
+    }
+
+    switch (which) {
+    case Qt::MinimumSize:
+        return QSizeF(sizehint_totalBoxes[Hor].q_minimumSize, sizehint_totalBoxes[Ver].q_minimumSize);
+    case Qt::PreferredSize:
+        return QSizeF(sizehint_totalBoxes[Hor].q_preferredSize, sizehint_totalBoxes[Ver].q_preferredSize);
+    case Qt::MaximumSize:
+        return QSizeF(sizehint_totalBoxes[Hor].q_maximumSize, sizehint_totalBoxes[Ver].q_maximumSize);
+    case Qt::MinimumDescent:
+        return QSizeF(-1.0, sizehint_totalBoxes[Hor].q_minimumDescent);    // ### doesn't work
+    default:
+        break;
+    }
+    return QSizeF();
+}
+
+QLayoutPolicy::ControlTypes QGridLayoutEngine::controlTypes(LayoutSide side) const
+{
+    Qt::Orientation orientation = (side == Top || side == Bottom) ? Qt::Vertical : Qt::Horizontal;
+    int row = (side == Top || side == Left) ? effectiveFirstRow(orientation)
+                                            : effectiveLastRow(orientation);
+    QLayoutPolicy::ControlTypes result = 0;
+
+    for (int column = columnCount(orientation) - 1; column >= 0; --column) {
+        if (QGridLayoutItem *item = itemAt(row, column, orientation))
+            result |= item->controlTypes(side);
+    }
+    return result;
+}
+
+void QGridLayoutEngine::transpose()
+{
+    invalidate();
+
+    for (int i = q_items.count() - 1; i >= 0; --i)
+        q_items.at(i)->transpose();
+
+    qSwap(q_defaultSpacings[Hor], q_defaultSpacings[Ver]);
+    qSwap(q_infos[Hor], q_infos[Ver]);
+
+    regenerateGrid();
+}
+
+void QGridLayoutEngine::setVisualDirection(Qt::LayoutDirection direction)
+{
+    m_visualDirection = direction;
+}
+
+Qt::LayoutDirection QGridLayoutEngine::visualDirection() const
+{
+    return m_visualDirection;
+}
+
+#ifdef QT_DEBUG
+void QGridLayoutEngine::dump(int indent) const
+{
+    qDebug("%*sEngine", indent, "");
+
+    qDebug("%*s Items (%d)", indent, "", q_items.count());
+    int i;
+    for (i = 0; i < q_items.count(); ++i)
+        q_items.at(i)->dump(indent + 2);
+
+    qDebug("%*s Grid (%d x %d)", indent, "", internalGridRowCount(),
+           internalGridColumnCount());
+    for (int row = 0; row < internalGridRowCount(); ++row) {
+        QString message = QLatin1String("[ ");
+        for (int column = 0; column < internalGridColumnCount(); ++column) {
+            message += QString::number(q_items.indexOf(itemAt(row, column))).rightJustified(3);
+            message += QLatin1Char(' ');
+        }
+        message += QLatin1Char(']');
+        qDebug("%*s  %s", indent, "", qPrintable(message));
+    }
+
+    if (q_defaultSpacings[Hor].value() >= 0.0 || q_defaultSpacings[Ver].value() >= 0.0)
+        qDebug("%*s Default spacings: %g %g", indent, "", q_defaultSpacings[Hor].value(),
+               q_defaultSpacings[Ver].value());
+
+    qDebug("%*s Column and row info", indent, "");
+    q_infos[Hor].dump(indent + 2);
+    q_infos[Ver].dump(indent + 2);
+
+    qDebug("%*s Column and row data", indent, "");
+    q_columnData.dump(indent + 2);
+    q_rowData.dump(indent + 2);
+
+    qDebug("%*s Geometries output", indent, "");
+    QVector<qreal> *cellPos = &q_yy;
+    for (int pass = 0; pass < 2; ++pass) {
+        QString message;
+        for (i = 0; i < cellPos->count(); ++i) {
+            message += QLatin1String((message.isEmpty() ? "[" : ", "));
+            message += QString::number(cellPos->at(i));
+        }
+        message += QLatin1Char(']');
+        qDebug("%*s %s %s", indent, "", (pass == 0 ? "rows:" : "columns:"), qPrintable(message));
+        cellPos = &q_xx;
+    }
+}
+#endif
+
+void QGridLayoutEngine::maybeExpandGrid(int row, int column, Qt::Orientation orientation)
+{
+    invalidate();   // ### move out of here?
+
+    if (orientation == Qt::Horizontal)
+        qSwap(row, column);
+
+    if (row < rowCount() && column < columnCount())
+        return;
+
+    int oldGridRowCount = internalGridRowCount();
+    int oldGridColumnCount = internalGridColumnCount();
+
+    q_infos[Ver].count = qMax(row + 1, rowCount());
+    q_infos[Hor].count = qMax(column + 1, columnCount());
+
+    int newGridRowCount = internalGridRowCount();
+    int newGridColumnCount = internalGridColumnCount();
+
+    int newGridSize = newGridRowCount * newGridColumnCount;
+    if (newGridSize != q_grid.count()) {
+        q_grid.resize(newGridSize);
+
+        if (newGridColumnCount != oldGridColumnCount) {
+            for (int i = oldGridRowCount - 1; i >= 1; --i) {
+                for (int j = oldGridColumnCount - 1; j >= 0; --j) {
+                    int oldIndex = (i * oldGridColumnCount) + j;
+                    int newIndex = (i * newGridColumnCount) + j;
+
+                    Q_ASSERT(newIndex > oldIndex);
+                    q_grid[newIndex] = q_grid[oldIndex];
+                    q_grid[oldIndex] = 0;
+                }
+            }
+        }
+    }
+}
+
+void QGridLayoutEngine::regenerateGrid()
+{
+    q_grid.fill(0);
+
+    for (int i = q_items.count() - 1; i >= 0; --i) {
+        QGridLayoutItem *item = q_items.at(i);
+
+        for (int j = item->firstRow(); j <= item->lastRow(); ++j) {
+            for (int k = item->firstColumn(); k <= item->lastColumn(); ++k) {
+                setItemAt(j, k, item);
+            }
+        }
+    }
+}
+
+void QGridLayoutEngine::setItemAt(int row, int column, QGridLayoutItem *item)
+{
+    Q_ASSERT(row >= 0 && row < rowCount());
+    Q_ASSERT(column >= 0 && column < columnCount());
+    q_grid[(row * internalGridColumnCount()) + column] = item;
+}
+
+void QGridLayoutEngine::insertOrRemoveRows(int row, int delta, Qt::Orientation orientation)
+{
+    int oldRowCount = rowCount(orientation);
+    Q_ASSERT(uint(row) <= uint(oldRowCount));
+
+    invalidate();
+
+    // appending rows (or columns) is easy
+    if (row == oldRowCount && delta > 0) {
+        maybeExpandGrid(oldRowCount + delta - 1, -1, orientation);
+        return;
+    }
+
+    q_infos[orientation == Qt::Vertical].insertOrRemoveRows(row, delta);
+
+    for (int i = q_items.count() - 1; i >= 0; --i)
+        q_items.at(i)->insertOrRemoveRows(row, delta, orientation);
+
+    q_grid.resize(internalGridRowCount() * internalGridColumnCount());
+    regenerateGrid();
+}
+
+void QGridLayoutEngine::fillRowData(QGridLayoutRowData *rowData,
+                                    qreal *colPositions, qreal *colSizes,
+                                    Qt::Orientation orientation,
+                                    const QLayoutStyleInfo &styleInfo) const
+{
+    const int ButtonMask = QLayoutPolicy::ButtonBox | QLayoutPolicy::PushButton;
+    const QGridLayoutRowInfo &rowInfo = q_infos[orientation == Qt::Vertical];
+    const QGridLayoutRowInfo &columnInfo = q_infos[orientation == Qt::Horizontal];
+    LayoutSide top = (orientation == Qt::Vertical) ? Top : Left;
+    LayoutSide bottom = (orientation == Qt::Vertical) ? Bottom : Right;
+
+    //QStyle *style = styleInfo.style();
+    /*###
+    QStyleOption option;
+    option.initFrom(styleInfo.widget());
+    */
+    const QLayoutParameter<qreal> &defaultSpacing = q_defaultSpacings[orientation == Qt::Vertical];
+    qreal innerSpacing = 0.0;
+    /* ###
+    if (style)
+        innerSpacing = (qreal)style->pixelMetric(orientation == Qt::Vertical ? QStyle::PM_LayoutVerticalSpacing
+                                                       : QStyle::PM_LayoutHorizontalSpacing,
+                           &option, styleInfo.widget());
+    */
+    if (innerSpacing >= 0.0)
+        defaultSpacing.setCachedValue(innerSpacing);
+
+    for (int row = 0; row < rowInfo.count; ++row) {
+        bool rowIsEmpty = true;
+        bool rowIsIdenticalToPrevious = (row > 0);
+
+        for (int column = 0; column < columnInfo.count; ++column) {
+            QGridLayoutItem *item = itemAt(row, column, orientation);
+
+            if (rowIsIdenticalToPrevious && item != itemAt(row - 1, column, orientation))
+                rowIsIdenticalToPrevious = false;
+
+            if (item)
+                rowIsEmpty = false;
+        }
+
+        if ((rowIsEmpty || rowIsIdenticalToPrevious)
+                && rowInfo.spacings.value(row).isDefault()
+                && rowInfo.stretches.value(row).isDefault()
+                && rowInfo.boxes.value(row) == QGridLayoutBox())
+            rowData->ignore.setBit(row, true);
+
+        if (rowInfo.spacings.value(row).isUser()) {
+            rowData->spacings[row] = rowInfo.spacings.at(row).value();
+        } else if (!defaultSpacing.isDefault()) {
+            rowData->spacings[row] = defaultSpacing.value();
+        }
+
+        rowData->stretches[row] = rowInfo.stretches.value(row).value();
+    }
+
+    struct RowAdHocData {
+        int q_row;
+        unsigned int q_hasButtons : 8;
+        unsigned int q_hasNonButtons : 8;
+
+        inline RowAdHocData() : q_row(-1), q_hasButtons(false), q_hasNonButtons(false) {}
+        inline void init(int row) {
+            this->q_row = row;
+            q_hasButtons = false;
+            q_hasNonButtons = false;
+        }
+        inline bool hasOnlyButtons() const { return q_hasButtons && !q_hasNonButtons; }
+        inline bool hasOnlyNonButtons() const { return q_hasNonButtons && !q_hasButtons; }
+    };
+    RowAdHocData lastRowAdHocData;
+    RowAdHocData nextToLastRowAdHocData;
+    RowAdHocData nextToNextToLastRowAdHocData;
+
+    rowData->hasIgnoreFlag = false;
+    for (int row = 0; row < rowInfo.count; ++row) {
+        if (rowData->ignore.testBit(row))
+            continue;
+
+        QGridLayoutBox &rowBox = rowData->boxes[row];
+        if (styleInfo.isWindow()) {
+            nextToNextToLastRowAdHocData = nextToLastRowAdHocData;
+            nextToLastRowAdHocData = lastRowAdHocData;
+            lastRowAdHocData.init(row);
+        }
+
+        bool userRowStretch = rowInfo.stretches.value(row).isUser();
+        int &rowStretch = rowData->stretches[row];
+
+        bool hasIgnoreFlag = true;
+        for (int column = 0; column < columnInfo.count; ++column) {
+            QGridLayoutItem *item = itemAt(row, column, orientation);
+            if (item) {
+                int itemRow = item->firstRow(orientation);
+                int itemColumn = item->firstColumn(orientation);
+
+                if (itemRow == row && itemColumn == column) {
+                    int itemStretch = item->stretchFactor(orientation);
+                    if (!(item->sizePolicy(orientation) & QLayoutPolicy::IgnoreFlag))
+                        hasIgnoreFlag = false;
+                    int itemRowSpan = item->rowSpan(orientation);
+
+                    int effectiveRowSpan = 1;
+                    for (int i = 1; i < itemRowSpan; ++i) {
+                        if (!rowData->ignore.testBit(i))
+                            ++effectiveRowSpan;
+                    }
+
+                    QGridLayoutBox *box;
+                    if (effectiveRowSpan == 1) {
+                        box = &rowBox;
+                        if (!userRowStretch && itemStretch != 0)
+                            rowStretch = qMax(rowStretch, itemStretch);
+                    } else {
+                        QGridLayoutMultiCellData &multiCell =
+                                rowData->multiCellMap[qMakePair(row, effectiveRowSpan)];
+                        box = &multiCell.q_box;
+                        multiCell.q_stretch = itemStretch;
+                    }
+                    // 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) {
+                        QLayoutPolicy::ControlTypes controls = item->controlTypes(top);
+                        if (controls & ButtonMask)
+                            lastRowAdHocData.q_hasButtons = true;
+                        if (controls & ~ButtonMask)
+                            lastRowAdHocData.q_hasNonButtons = true;
+                    }
+                }
+            }
+        }
+        if (row < rowInfo.boxes.count()) {
+            QGridLayoutBox rowBoxInfo = rowInfo.boxes.at(row);
+            rowBoxInfo.normalize();
+            rowBox.q_minimumSize = qMax(rowBox.q_minimumSize, rowBoxInfo.q_minimumSize);
+            rowBox.q_maximumSize = qMax(rowBox.q_minimumSize,
+                                        (rowBoxInfo.q_maximumSize != FLT_MAX ?
+                                        rowBoxInfo.q_maximumSize : rowBox.q_maximumSize));
+            rowBox.q_preferredSize = qBound(rowBox.q_minimumSize,
+                                            qMax(rowBox.q_preferredSize, rowBoxInfo.q_preferredSize),
+                                            rowBox.q_maximumSize);
+        }
+        if (hasIgnoreFlag)
+            rowData->hasIgnoreFlag = true;
+    }
+
+    /*
+        Heuristic: Detect button boxes that don't use QLayoutPolicy::ButtonBox.
+        This is somewhat ad hoc but it usually does the trick.
+    */
+    bool lastRowIsButtonBox = (lastRowAdHocData.hasOnlyButtons()
+                               && nextToLastRowAdHocData.hasOnlyNonButtons());
+    bool lastTwoRowsIsButtonBox = (lastRowAdHocData.hasOnlyButtons()
+                                   && nextToLastRowAdHocData.hasOnlyButtons()
+                                   && nextToNextToLastRowAdHocData.hasOnlyNonButtons()
+                                   && orientation == Qt::Vertical);
+
+    if (defaultSpacing.isDefault()) {
+        int prevRow = -1;
+        for (int row = 0; row < rowInfo.count; ++row) {
+            if (rowData->ignore.testBit(row))
+                continue;
+
+            if (prevRow != -1 && !rowInfo.spacings.value(prevRow).isUser()) {
+                qreal &rowSpacing = rowData->spacings[prevRow];
+                for (int column = 0; column < columnInfo.count; ++column) {
+                    QGridLayoutItem *item1 = itemAt(prevRow, column, orientation);
+                    QGridLayoutItem *item2 = itemAt(row, column, orientation);
+
+                    if (item1 && item2 && item1 != item2) {
+                        QLayoutPolicy::ControlTypes controls1 = item1->controlTypes(bottom);
+                        QLayoutPolicy::ControlTypes controls2 = item2->controlTypes(top);
+
+                        if (controls2 & QLayoutPolicy::PushButton) {
+                            if ((row == nextToLastRowAdHocData.q_row && lastTwoRowsIsButtonBox)
+                                    || (row == lastRowAdHocData.q_row && lastRowIsButtonBox)) {
+                                controls2 &= ~QLayoutPolicy::PushButton;
+                                controls2 |= QLayoutPolicy::ButtonBox;
+                            }
+                        }
+
+                        qreal spacing = styleInfo.combinedLayoutSpacing(controls1, controls2,
+                                                                        orientation);
+                        if (orientation == Qt::Horizontal) {
+                            qreal width1 = rowData->boxes.at(prevRow).q_minimumSize;
+                            qreal width2 = rowData->boxes.at(row).q_minimumSize;
+                            QRectF rect1 = item1->geometryWithin(0.0, 0.0, width1, FLT_MAX, -1.0, effectiveAlignment(item1));
+                            QRectF rect2 = item2->geometryWithin(0.0, 0.0, width2, FLT_MAX, -1.0, effectiveAlignment(item2));
+                            spacing -= (width1 - (rect1.x() + rect1.width())) + rect2.x();
+                        } else {
+                            const QGridLayoutBox &box1 = rowData->boxes.at(prevRow);
+                            const QGridLayoutBox &box2 = rowData->boxes.at(row);
+                            qreal height1 = box1.q_minimumSize;
+                            qreal height2 = box2.q_minimumSize;
+                            qreal rowDescent1 = fixedDescent(box1.q_minimumDescent,
+                                                             box1.q_minimumAscent, height1);
+                            qreal rowDescent2 = fixedDescent(box2.q_minimumDescent,
+                                                             box2.q_minimumAscent, height2);
+                            QRectF rect1 = item1->geometryWithin(0.0, 0.0, FLT_MAX, height1,
+                                                                 rowDescent1, effectiveAlignment(item1));
+                            QRectF rect2 = item2->geometryWithin(0.0, 0.0, FLT_MAX, height2,
+                                                                 rowDescent2, effectiveAlignment(item2));
+                            spacing -= (height1 - (rect1.y() + rect1.height())) + rect2.y();
+                        }
+                        rowSpacing = qMax(spacing, rowSpacing);
+                    }
+                }
+            }
+            prevRow = row;
+        }
+    } else if (lastRowIsButtonBox || lastTwoRowsIsButtonBox) {
+        /*
+            Even for styles that define a uniform spacing, we cheat a
+            bit and use the window margin as the spacing. This
+            significantly improves the look of dialogs.
+        */
+        int prevRow = lastRowIsButtonBox ? nextToLastRowAdHocData.q_row
+                                         : nextToNextToLastRowAdHocData.q_row;
+        if (!defaultSpacing.isUser() && !rowInfo.spacings.value(prevRow).isUser()) {
+            qreal windowMargin = styleInfo.windowMargin(orientation);
+            qreal &rowSpacing = rowData->spacings[prevRow];
+            rowSpacing = qMax(windowMargin, rowSpacing);
+        }
+    }
+}
+
+void QGridLayoutEngine::ensureEffectiveFirstAndLastRows() const
+{
+    if (q_cachedEffectiveFirstRows[Hor] == -1 && !q_items.isEmpty()) {
+        int rowCount = this->rowCount();
+        int columnCount = this->columnCount();
+
+        q_cachedEffectiveFirstRows[Ver] = rowCount;
+        q_cachedEffectiveFirstRows[Hor] = columnCount;
+        q_cachedEffectiveLastRows[Ver] = -1;
+        q_cachedEffectiveLastRows[Hor] = -1;
+
+        for (int i = q_items.count() - 1; i >= 0; --i) {
+            const QGridLayoutItem *item = q_items.at(i);
+
+            for (int j = 0; j < NOrientations; ++j) {
+                Qt::Orientation orientation = (j == Hor) ? Qt::Horizontal : Qt::Vertical;
+                if (item->firstRow(orientation) < q_cachedEffectiveFirstRows[j])
+                    q_cachedEffectiveFirstRows[j] = item->firstRow(orientation);
+                if (item->lastRow(orientation) > q_cachedEffectiveLastRows[j])
+                    q_cachedEffectiveLastRows[j] = item->lastRow(orientation);
+            }
+        }
+    }
+}
+
+void QGridLayoutEngine::ensureColumnAndRowData(QGridLayoutRowData *rowData, QGridLayoutBox *totalBox,
+                                               qreal *colPositions, qreal *colSizes,
+                                               Qt::Orientation orientation,
+                                               const QLayoutStyleInfo &styleInfo) const
+{
+    rowData->reset(rowCount(orientation));
+    fillRowData(rowData, colPositions, colSizes, orientation, styleInfo);
+    const QGridLayoutRowInfo &rowInfo = q_infos[orientation == Qt::Vertical];
+    rowData->distributeMultiCells(rowInfo);
+    *totalBox = rowData->totalBox(0, rowCount(orientation));
+        //We have items whose width depends on their height
+}
+
+/**
+   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;
+}
+
+bool QGridLayoutEngine::hasDynamicConstraint() const
+{
+    if (!ensureDynamicConstraint())
+        return false;
+    return q_cachedConstraintOrientation != NoConstraint;
+}
+
+/*
+ * 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 QSizeF &size,
+                                         const QLayoutStyleInfo &styleInfo) const
+{
+    if (q_cachedDataForStyleInfo == styleInfo && q_cachedSize == size)
+        return;
+
+    q_cachedDataForStyleInfo = styleInfo;
+    q_cachedSize = size;
+
+    q_xx.resize(columnCount());
+    q_widths.resize(columnCount());
+    q_yy.resize(rowCount());
+    q_heights.resize(rowCount());
+    q_descents.resize(rowCount());
+
+    if (constraintOrientation() != Qt::Horizontal) {
+        //We might have items whose width depends on their height
+        ensureColumnAndRowData(&q_columnData, &q_totalBoxes[Hor], NULL, NULL, Qt::Horizontal, styleInfo);
+        //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], q_infos[Hor] );
+        ensureColumnAndRowData(&q_rowData, &q_totalBoxes[Ver], q_xx.data(), q_widths.data(), Qt::Vertical, styleInfo);
+        //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], q_infos[Ver]);
+    } else {
+        //We have items whose height depends on their width
+        ensureColumnAndRowData(&q_rowData, &q_totalBoxes[Ver], NULL, NULL, Qt::Vertical, styleInfo);
+        //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], q_infos[Ver]);
+        ensureColumnAndRowData(&q_columnData, &q_totalBoxes[Hor], q_yy.data(), q_heights.data(), Qt::Horizontal, styleInfo);
+        //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], q_infos[Hor]);
+    }
+}
+
+QT_END_NAMESPACE
+
+#endif //QT_NO_GRAPHICSVIEW
diff --git a/src/layouts/qgridlayoutengine_p.h b/src/layouts/qgridlayoutengine_p.h
new file mode 100644
index 00000000..86dec955
--- /dev/null
+++ b/src/layouts/qgridlayoutengine_p.h
@@ -0,0 +1,559 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Quick Layouts module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGRIDLAYOUTENGINE_P_H
+#define QGRIDLAYOUTENGINE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of the graphics view layout classes.  This header
+// file may change from version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qalgorithms.h"
+#include "qbitarray.h"
+#include "qlist.h"
+#include "qmap.h"
+#include "qpair.h"
+#include "qvector.h"
+#include <QtCore/qsize.h>
+#include <QtCore/qrect.h>
+#include "qlayoutpolicy_p.h"
+#include <float.h>
+#include "qdebug.h"
+QT_BEGIN_NAMESPACE
+
+//class QGraphicsLayoutItem;
+class QStyle;
+class QWidget;
+
+class QStyleOption;
+// ### FIX THIS GUY
+class QLayoutStyleInfo
+{
+public:
+    inline QLayoutStyleInfo()
+        : m_valid(true), m_option(0)
+    {
+        m_defaultSpacing[0] = m_defaultSpacing[1] = 6;
+    }
+
+
+    QStyleOption *styleOption() {
+        if (!m_option) {
+            /* ###
+            m_option = new QStyleOption;
+            option.initFrom(styleInfo.widget());
+            */
+        }
+        return m_option;
+    }
+
+    void invalidate() { m_valid = false; }
+    inline QStyle *style() const { return 0; }
+    inline QWidget *widget() const { return 0; }
+    inline bool operator==(const QLayoutStyleInfo &other) const
+    { return m_defaultSpacing[0] == other.m_defaultSpacing[0] && m_defaultSpacing[1] == other.m_defaultSpacing[1]; }
+    inline bool operator!=(const QLayoutStyleInfo &other) const
+        { return !(*this == other); }
+
+    inline void setDefaultSpacing(Qt::Orientation o, qreal spacing){
+        if (spacing >= 0)
+            m_defaultSpacing[o - 1] = spacing;
+    }
+
+    inline qreal defaultSpacing(Qt::Orientation o) const {
+        return m_defaultSpacing[o - 1];
+    }
+
+    inline qreal perItemSpacing(QLayoutPolicy::ControlType /*control1*/,
+                                  QLayoutPolicy::ControlType /*control2*/,
+                                  Qt::Orientation /*orientation*/) const
+    {
+        return 6;
+    }
+
+    inline qreal windowMargin(Qt::Orientation orientation) const
+    {
+        qreal margin = -1;
+        Q_UNUSED(orientation);
+        /*
+        if (style()) {
+            margin = style()->pixelMetric(orientation == Qt::Vertical
+                                            ? QStyle::PM_LayoutBottomMargin
+                                            : QStyle::PM_LayoutRightMargin,
+                                            styleOption(), widget());
+        }
+        */
+        return margin;
+    }
+
+    inline qreal combinedLayoutSpacing(QLayoutPolicy::ControlTypes controls1,
+                                       QLayoutPolicy::ControlTypes controls2, Qt::Orientation orientation) const
+    {
+        qreal spacing = -1;
+        Q_UNUSED(controls1);
+        Q_UNUSED(controls2);
+        Q_UNUSED(orientation);
+        /* ###
+        if (style()) {
+            spacing = style()->combinedLayoutSpacing(controls1, controls2,
+                                                   orientation, styleOption(),
+                                                   widget());
+        }*/
+        return spacing;
+    }
+
+    bool isWindow() const {
+        // return option.state & QStyle::State_Window
+        return false;
+    }
+private:
+    bool m_valid;
+    qreal m_defaultSpacing[2];
+    QStyleOption *m_option;
+};
+
+
+// ### deal with Descent in a similar way
+enum {
+    MinimumSize = Qt::MinimumSize,
+    PreferredSize = Qt::PreferredSize,
+    MaximumSize = Qt::MaximumSize,
+    NSizes
+};
+
+// do not reorder
+enum {
+    Hor,
+    Ver,
+    NOrientations
+};
+
+// do not reorder
+enum LayoutSide {
+    Left,
+    Top,
+    Right,
+    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
+{
+public:
+    enum State { Default, User, Cached };
+
+    inline QLayoutParameter() : q_value(T()), q_state(Default) {}
+    inline QLayoutParameter(T value, State state = Default) : q_value(value), q_state(state) {}
+
+    inline void setUserValue(T value) {
+        q_value = value;
+        q_state = User;
+    }
+    inline void setCachedValue(T value) const {
+        if (q_state != User) {
+            q_value = value;
+            q_state = Cached;
+        }
+    }
+    inline T value() const { return q_value; }
+    inline T value(T defaultValue) const { return isUser() ? q_value : defaultValue; }
+    inline bool isDefault() const { return q_state == Default; }
+    inline bool isUser() const { return q_state == User; }
+    inline bool isCached() const { return q_state == Cached; }
+
+private:
+    mutable T q_value;
+    mutable State q_state;
+};
+
+class QStretchParameter : public QLayoutParameter<int>
+{
+public:
+    QStretchParameter() : QLayoutParameter<int>(-1) {}
+
+};
+
+class QGridLayoutBox
+{
+public:
+    inline QGridLayoutBox()
+        : q_minimumSize(0), q_preferredSize(0), q_maximumSize(FLT_MAX),
+          q_minimumDescent(-1), q_minimumAscent(-1) {}
+
+    void add(const QGridLayoutBox &other, int stretch, qreal spacing);
+    void combine(const QGridLayoutBox &other);
+    void normalize();
+
+#ifdef QT_DEBUG
+    void dump(int indent = 0) const;
+#endif
+    // This code could use the union-struct-array trick, but a compiler
+    // bug prevents this from working.
+    qreal q_minimumSize;
+    qreal q_preferredSize;
+    qreal q_maximumSize;
+    qreal q_minimumDescent;
+    qreal q_minimumAscent;
+    inline qreal &q_sizes(int which)
+    {
+        qreal *t;
+        switch (which) {
+        case Qt::MinimumSize:
+            t = &q_minimumSize;
+            break;
+        case Qt::PreferredSize:
+            t = &q_preferredSize;
+            break;
+        case Qt::MaximumSize:
+            t = &q_maximumSize;
+            break;
+        case Qt::MinimumDescent:
+            t = &q_minimumDescent;
+            break;
+        case (Qt::MinimumDescent + 1):
+            t = &q_minimumAscent;
+            break;
+        default:
+            t = 0;
+            break;
+        }
+        return *t;
+    }
+    inline const qreal &q_sizes(int which) const
+    {
+        const qreal *t;
+        switch (which) {
+        case Qt::MinimumSize:
+            t = &q_minimumSize;
+            break;
+        case Qt::PreferredSize:
+            t = &q_preferredSize;
+            break;
+        case Qt::MaximumSize:
+            t = &q_maximumSize;
+            break;
+        case Qt::MinimumDescent:
+            t = &q_minimumDescent;
+            break;
+        case (Qt::MinimumDescent + 1):
+            t = &q_minimumAscent;
+            break;
+        default:
+            t = 0;
+            break;
+        }
+        return *t;
+    }
+};
+
+bool operator==(const QGridLayoutBox &box1, const QGridLayoutBox &box2);
+inline bool operator!=(const QGridLayoutBox &box1, const QGridLayoutBox &box2)
+    { return !operator==(box1, box2); }
+
+class QGridLayoutMultiCellData
+{
+public:
+    inline QGridLayoutMultiCellData() : q_stretch(-1) {}
+
+    QGridLayoutBox q_box;
+    int q_stretch;
+};
+
+typedef QMap<QPair<int, int>, QGridLayoutMultiCellData> MultiCellMap;
+
+class QGridLayoutRowInfo;
+
+class QGridLayoutRowData
+{
+public:
+    void reset(int count);
+    void distributeMultiCells(const QGridLayoutRowInfo &rowInfo);
+    void calculateGeometries(int start, int end, qreal targetSize, qreal *positions, qreal *sizes,
+                             qreal *descents, const QGridLayoutBox &totalBox,
+                             const QGridLayoutRowInfo &rowInfo);
+    QGridLayoutBox totalBox(int start, int end) const;
+    void stealBox(int start, int end, int which, qreal *positions, qreal *sizes);
+
+#ifdef QT_DEBUG
+    void dump(int indent = 0) const;
+#endif
+
+    QBitArray ignore;   // ### rename q_
+    QVector<QGridLayoutBox> boxes;
+    MultiCellMap multiCellMap;
+    QVector<int> stretches;
+    QVector<qreal> spacings;
+    bool hasIgnoreFlag;
+};
+
+class QGridLayoutItem
+{
+public:
+    QGridLayoutItem(int row, int column, int rowSpan = 1, int columnSpan = 1,
+                    Qt::Alignment alignment = 0);
+
+    inline int firstRow() const { return q_firstRows[Ver]; }
+    inline int firstColumn() const { return q_firstRows[Hor]; }
+    inline int rowSpan() const { return q_rowSpans[Ver]; }
+    inline int columnSpan() const { return q_rowSpans[Hor]; }
+    inline int lastRow() const { return firstRow() + rowSpan() - 1; }
+    inline int lastColumn() const { return firstColumn() + columnSpan() - 1; }
+
+    int firstRow(Qt::Orientation orientation) const;
+    int firstColumn(Qt::Orientation orientation) const;
+    int lastRow(Qt::Orientation orientation) const;
+    int lastColumn(Qt::Orientation orientation) const;
+    int rowSpan(Qt::Orientation orientation) const;
+    int columnSpan(Qt::Orientation orientation) const;
+    void setFirstRow(int row, Qt::Orientation orientation = Qt::Vertical);
+    void setRowSpan(int rowSpan, Qt::Orientation orientation = Qt::Vertical);
+
+    int stretchFactor(Qt::Orientation orientation) const;
+    void setStretchFactor(int stretch, Qt::Orientation orientation);
+
+    inline Qt::Alignment alignment() const { return q_alignment; }
+    inline void setAlignment(Qt::Alignment alignment) { q_alignment = alignment; }
+
+    virtual QLayoutPolicy::Policy sizePolicy(Qt::Orientation orientation) const = 0;
+    virtual QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const = 0;
+
+    virtual void setGeometry(const QRectF &rect) = 0;
+    /*
+      returns true if the size policy returns true for either hasHeightForWidth()
+      or hasWidthForHeight()
+     */
+    virtual bool hasDynamicConstraint() const { return false; }
+    virtual Qt::Orientation dynamicConstraintOrientation() const { return Qt::Horizontal; }
+
+
+    QLayoutPolicy::ControlTypes controlTypes(LayoutSide side) const;
+
+    QGridLayoutBox box(Qt::Orientation orientation, qreal constraint = -1.0) const;
+    QRectF geometryWithin(qreal x, qreal y, qreal width, qreal height, qreal rowDescent, Qt::Alignment align) const;
+
+
+    void transpose();
+    void insertOrRemoveRows(int row, int delta, Qt::Orientation orientation = Qt::Vertical);
+    QSizeF effectiveMaxSize(const QSizeF &constraint) const;
+
+#ifdef QT_DEBUG
+    void dump(int indent = 0) const;
+#endif
+
+//private:
+    //###QGridLayoutEngine *q_engine;   // ### needed?
+    int q_firstRows[NOrientations];
+    int q_rowSpans[NOrientations];
+    int q_stretches[NOrientations];
+    Qt::Alignment q_alignment;
+};
+
+class QGridLayoutRowInfo
+{
+public:
+    inline QGridLayoutRowInfo() : count(0) {}
+
+    void insertOrRemoveRows(int row, int delta);
+
+#ifdef QT_DEBUG
+    void dump(int indent = 0) const;
+#endif
+
+    int count;
+    QVector<QStretchParameter> stretches;
+    QVector<QLayoutParameter<qreal> > spacings;
+    QVector<Qt::Alignment> alignments;
+    QVector<QGridLayoutBox> boxes;
+};
+
+class QGridLayoutEngine
+{
+public:
+    QGridLayoutEngine();
+    inline ~QGridLayoutEngine() { qDeleteAll(q_items); }
+
+    int rowCount(Qt::Orientation orientation) const;
+    int columnCount(Qt::Orientation orientation) const;
+    inline int rowCount() const { return q_infos[Ver].count; }
+    inline int columnCount() const { return q_infos[Hor].count; }
+    // returns the number of items inserted, which may be less than (rowCount * columnCount)
+    int itemCount() const;
+    QGridLayoutItem *itemAt(int index) const;
+
+    int effectiveFirstRow(Qt::Orientation orientation = Qt::Vertical) const;
+    int effectiveLastRow(Qt::Orientation orientation = Qt::Vertical) const;
+
+    void setSpacing(qreal spacing, Qt::Orientations orientations);
+    qreal spacing(Qt::Orientation orientation, const QLayoutStyleInfo &styleInfo = QLayoutStyleInfo()) const;
+    // ### setSpacingAfterRow(), spacingAfterRow()
+    void setRowSpacing(int row, qreal spacing, Qt::Orientation orientation = Qt::Vertical);
+    qreal rowSpacing(int row, Qt::Orientation orientation = Qt::Vertical) const;
+
+    void setRowStretchFactor(int row, int stretch, Qt::Orientation orientation = Qt::Vertical);
+    int rowStretchFactor(int row, Qt::Orientation orientation = Qt::Vertical) const;
+
+    //void setStretchFactor(QGraphicsLayoutItem *layoutItem, int stretch,
+    //                      Qt::Orientation orientation);
+    //int stretchFactor(QGraphicsLayoutItem *layoutItem, Qt::Orientation orientation) const;
+
+    void setRowSizeHint(Qt::SizeHint which, int row, qreal size,
+                        Qt::Orientation orientation = Qt::Vertical);
+    qreal rowSizeHint(Qt::SizeHint which, int row,
+                      Qt::Orientation orientation = Qt::Vertical) const;
+
+    void setRowAlignment(int row, Qt::Alignment alignment, Qt::Orientation orientation);
+    Qt::Alignment rowAlignment(int row, Qt::Orientation orientation) const;
+
+    //void setAlignment(QGraphicsLayoutItem *layoutItem, Qt::Alignment alignment);
+    //Qt::Alignment alignment(QGraphicsLayoutItem *layoutItem) const;
+    Qt::Alignment effectiveAlignment(const QGridLayoutItem *layoutItem) const;
+
+
+    void insertItem(QGridLayoutItem *item, int index);
+    void addItem(QGridLayoutItem *item);
+    void removeItem(QGridLayoutItem *item);
+    void deleteItems()
+    {
+        const QList<QGridLayoutItem *> oldItems = q_items;
+        q_items.clear();    // q_items are used as input when the grid is regenerated in removeRows
+        // The following calls to removeRows are suboptimal
+        int rows = rowCount(Qt::Vertical);
+        removeRows(0, rows, Qt::Vertical);
+        rows = rowCount(Qt::Horizontal);
+        removeRows(0, rows, Qt::Horizontal);
+        qDeleteAll(oldItems);
+    }
+
+    QGridLayoutItem *itemAt(int row, int column, Qt::Orientation orientation = Qt::Vertical) const;
+    inline void insertRow(int row, Qt::Orientation orientation = Qt::Vertical)
+        { insertOrRemoveRows(row, +1, orientation); }
+    inline void removeRows(int row, int count, Qt::Orientation orientation)
+        { insertOrRemoveRows(row, -count, orientation); }
+
+    void invalidate();
+    void setGeometries(const QRectF &contentsGeometry, const QLayoutStyleInfo &styleInfo = QLayoutStyleInfo());
+    QRectF cellRect(const QRectF &contentsGeometry, int row, int column, int rowSpan, int columnSpan,
+                    const QLayoutStyleInfo &styleInfo = QLayoutStyleInfo()) const;
+    QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint,
+                    const QLayoutStyleInfo &styleInfo = QLayoutStyleInfo()) const;
+
+    // heightForWidth / widthForHeight support
+    QSizeF dynamicallyConstrainedSizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
+    bool ensureDynamicConstraint() const;
+    bool hasDynamicConstraint() const;
+    Qt::Orientation constraintOrientation() const;
+
+
+    QLayoutPolicy::ControlTypes controlTypes(LayoutSide side) const;
+    void transpose();
+    void setVisualDirection(Qt::LayoutDirection direction);
+    Qt::LayoutDirection visualDirection() const;
+#ifdef QT_DEBUG
+    void dump(int indent = 0) const;
+#endif
+
+//private:
+    static int grossRoundUp(int n) { return ((n + 2) | 0x3) - 2; }
+
+    void maybeExpandGrid(int row, int column, Qt::Orientation orientation = Qt::Vertical);
+    void regenerateGrid();
+    inline int internalGridRowCount() const { return grossRoundUp(rowCount()); }
+    inline int internalGridColumnCount() const { return grossRoundUp(columnCount()); }
+    void setItemAt(int row, int column, QGridLayoutItem *item);
+    void insertOrRemoveRows(int row, int delta, Qt::Orientation orientation = Qt::Vertical);
+    void fillRowData(QGridLayoutRowData *rowData,
+                                    qreal *colPositions, qreal *colSizes,
+                                    Qt::Orientation orientation = Qt::Vertical, const QLayoutStyleInfo &styleInfo = QLayoutStyleInfo()) const;
+    void ensureEffectiveFirstAndLastRows() const;
+    void ensureColumnAndRowData(QGridLayoutRowData *rowData, QGridLayoutBox *totalBox,
+                                            qreal *colPositions, qreal *colSizes,
+                                            Qt::Orientation orientation,
+                                            const QLayoutStyleInfo &styleInfo = QLayoutStyleInfo()) const;
+
+    void ensureGeometries(const QSizeF &size, const QLayoutStyleInfo &styleInfo = QLayoutStyleInfo()) const;
+
+    // User input
+    QVector<QGridLayoutItem *> q_grid;
+    QList<QGridLayoutItem *> q_items;
+    QLayoutParameter<qreal> q_defaultSpacings[NOrientations];
+    QGridLayoutRowInfo q_infos[NOrientations];
+    Qt::LayoutDirection m_visualDirection;
+
+    // Lazily computed from the above user input
+    mutable int q_cachedEffectiveFirstRows[NOrientations];
+    mutable int q_cachedEffectiveLastRows[NOrientations];
+    mutable quint8 q_cachedConstraintOrientation : 3;
+
+    // Layout item input
+    mutable QLayoutStyleInfo q_cachedDataForStyleInfo;
+    mutable QGridLayoutRowData q_columnData;
+    mutable QGridLayoutRowData q_rowData;
+    mutable QGridLayoutBox q_totalBoxes[NOrientations];
+
+    // Output
+    mutable QSizeF q_cachedSize;
+    mutable QVector<qreal> q_xx;
+    mutable QVector<qreal> q_yy;
+    mutable QVector<qreal> q_widths;
+    mutable QVector<qreal> q_heights;
+    mutable QVector<qreal> q_descents;
+
+    friend class QGridLayoutItem;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/layouts/qlayoutpolicy.cpp b/src/layouts/qlayoutpolicy.cpp
new file mode 100644
index 00000000..9a154768
--- /dev/null
+++ b/src/layouts/qlayoutpolicy.cpp
@@ -0,0 +1,136 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Quick Layouts module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qlayoutpolicy_p.h"
+#include <QtCore/qdebug.h>
+#include <QtCore/qdatastream.h>
+
+QT_BEGIN_NAMESPACE
+
+void QLayoutPolicy::setControlType(ControlType type)
+{
+    /*
+        The control type is a flag type, with values 0x1, 0x2, 0x4, 0x8, 0x10,
+        etc. In memory, we pack it onto the available bits (CTSize) in
+        setControlType(), and unpack it here.
+
+        Example:
+
+            0x00000001 maps to 0
+            0x00000002 maps to 1
+            0x00000004 maps to 2
+            0x00000008 maps to 3
+            etc.
+    */
+
+    int i = 0;
+    while (true) {
+        if (type & (0x1 << i)) {
+            bits.ctype = i;
+            return;
+        }
+        ++i;
+    }
+}
+
+QLayoutPolicy::ControlType QLayoutPolicy::controlType() const
+{
+    return QLayoutPolicy::ControlType(1 << bits.ctype);
+}
+
+#ifndef QT_NO_DATASTREAM
+
+/*!
+    \relates QLayoutPolicy
+
+    Writes the size \a policy to the data stream \a stream.
+
+    \sa{Serializing Qt Data Types}{Format of the QDataStream operators}
+*/
+QDataStream &operator<<(QDataStream &stream, const QLayoutPolicy &policy)
+{
+    // The order here is for historical reasons. (compatibility with Qt4)
+    quint32 data = (policy.bits.horPolicy |         // [0, 3]
+                    policy.bits.verPolicy << 4 |    // [4, 7]
+                    policy.bits.hfw << 8 |          // [8]
+                    policy.bits.ctype << 9 |        // [9, 13]
+                    policy.bits.wfh << 14 |         // [14]
+                  //policy.bits.padding << 15 |     // [15]
+                    policy.bits.verStretch << 16 |  // [16, 23]
+                    policy.bits.horStretch << 24);  // [24, 31]
+    return stream << data;
+}
+
+#define VALUE_OF_BITS(data, bitstart, bitcount) ((data >> bitstart) & ((1 << bitcount) -1))
+
+/*!
+    \relates QLayoutPolicy
+
+    Reads the size \a policy from the data stream \a stream.
+
+    \sa{Serializing Qt Data Types}{Format of the QDataStream operators}
+*/
+QDataStream &operator>>(QDataStream &stream, QLayoutPolicy &policy)
+{
+    quint32 data;
+    stream >> data;
+    policy.bits.horPolicy =  VALUE_OF_BITS(data, 0, 4);
+    policy.bits.verPolicy =  VALUE_OF_BITS(data, 4, 4);
+    policy.bits.hfw =        VALUE_OF_BITS(data, 8, 1);
+    policy.bits.ctype =      VALUE_OF_BITS(data, 9, 5);
+    policy.bits.wfh =        VALUE_OF_BITS(data, 14, 1);
+    policy.bits.padding =   0;
+    policy.bits.verStretch = VALUE_OF_BITS(data, 16, 8);
+    policy.bits.horStretch = VALUE_OF_BITS(data, 24, 8);
+    return stream;
+}
+#endif // QT_NO_DATASTREAM
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug dbg, const QLayoutPolicy &p)
+{
+    dbg.nospace() << "QLayoutPolicy(horizontalPolicy = " << p.horizontalPolicy()
+                  << ", verticalPolicy = " << p.verticalPolicy() << ')';
+    return dbg.space();
+}
+#endif
+
+QT_END_NAMESPACE
diff --git a/src/layouts/qlayoutpolicy_p.h b/src/layouts/qlayoutpolicy_p.h
new file mode 100644
index 00000000..0f3e6a08
--- /dev/null
+++ b/src/layouts/qlayoutpolicy_p.h
@@ -0,0 +1,180 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Quick Layouts module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QLAYOUTPOLICY_H
+#define QLAYOUTPOLICY_H
+
+#include <QtCore/qobject.h>
+
+QT_BEGIN_NAMESPACE
+
+
+class QVariant;
+
+class QLayoutPolicy
+{
+    Q_ENUMS(Policy)
+
+public:
+    enum PolicyFlag {
+        GrowFlag = 1,
+        ExpandFlag = 2,
+        ShrinkFlag = 4,
+        IgnoreFlag = 8
+    };
+
+    enum Policy {
+        Fixed = 0,
+        Minimum = GrowFlag,
+        Maximum = ShrinkFlag,
+        Preferred = GrowFlag | ShrinkFlag,
+        MinimumExpanding = GrowFlag | ExpandFlag,
+        Expanding = GrowFlag | ShrinkFlag | ExpandFlag,
+        Ignored = ShrinkFlag | GrowFlag | IgnoreFlag
+    };
+
+    enum ControlType {
+        DefaultType      = 0x00000001,
+        ButtonBox        = 0x00000002,
+        CheckBox         = 0x00000004,
+        ComboBox         = 0x00000008,
+        Frame            = 0x00000010,
+        GroupBox         = 0x00000020,
+        Label            = 0x00000040,
+        Line             = 0x00000080,
+        LineEdit         = 0x00000100,
+        PushButton       = 0x00000200,
+        RadioButton      = 0x00000400,
+        Slider           = 0x00000800,
+        SpinBox          = 0x00001000,
+        TabWidget        = 0x00002000,
+        ToolButton       = 0x00004000
+    };
+    Q_DECLARE_FLAGS(ControlTypes, ControlType)
+
+    QLayoutPolicy() : data(0) { }
+
+    QLayoutPolicy(Policy horizontal, Policy vertical, ControlType type = DefaultType)
+        : data(0) {
+        bits.horPolicy = horizontal;
+        bits.verPolicy = vertical;
+        setControlType(type);
+    }
+    Policy horizontalPolicy() const { return static_cast<Policy>(bits.horPolicy); }
+    Policy verticalPolicy() const { return static_cast<Policy>(bits.verPolicy); }
+    ControlType controlType() const;
+
+    void setHorizontalPolicy(Policy d) { bits.horPolicy = d; }
+    void setVerticalPolicy(Policy d) { bits.verPolicy = d; }
+    void setControlType(ControlType type);
+
+    Qt::Orientations expandingDirections() const {
+        Qt::Orientations result;
+        if (verticalPolicy() & ExpandFlag)
+            result |= Qt::Vertical;
+        if (horizontalPolicy() & ExpandFlag)
+            result |= Qt::Horizontal;
+        return result;
+    }
+
+    void setHeightForWidth(bool b) { bits.hfw = b;  }
+    bool hasHeightForWidth() const { return bits.hfw; }
+    void setWidthForHeight(bool b) { bits.wfh = b;  }
+    bool hasWidthForHeight() const { return bits.wfh; }
+
+    bool operator==(const QLayoutPolicy& s) const { return data == s.data; }
+    bool operator!=(const QLayoutPolicy& s) const { return data != s.data; }
+
+    int horizontalStretch() const { return static_cast<int>(bits.horStretch); }
+    int verticalStretch() const { return static_cast<int>(bits.verStretch); }
+    void setHorizontalStretch(int stretchFactor) { bits.horStretch = static_cast<quint32>(qBound(0, stretchFactor, 255)); }
+    void setVerticalStretch(int stretchFactor) { bits.verStretch = static_cast<quint32>(qBound(0, stretchFactor, 255)); }
+
+    void transpose();
+
+
+private:
+#ifndef QT_NO_DATASTREAM
+    friend QDataStream &operator<<(QDataStream &, const QLayoutPolicy &);
+    friend QDataStream &operator>>(QDataStream &, QLayoutPolicy &);
+#endif
+    QLayoutPolicy(int i) : data(i) { }
+
+    union {
+        struct {
+            quint32 horStretch : 8;
+            quint32 verStretch : 8;
+            quint32 horPolicy : 4;
+            quint32 verPolicy : 4;
+            quint32 ctype : 5;
+            quint32 hfw : 1;
+            quint32 wfh : 1;
+            quint32 padding : 1;   // feel free to use
+        } bits;
+        quint32 data;
+    };
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(QLayoutPolicy::ControlTypes)
+
+#ifndef QT_NO_DATASTREAM
+QDataStream &operator<<(QDataStream &, const QLayoutPolicy &);
+QDataStream &operator>>(QDataStream &, QLayoutPolicy &);
+#endif
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug dbg, const QLayoutPolicy &);
+#endif
+
+inline void QLayoutPolicy::transpose() {
+    Policy hData = horizontalPolicy();
+    Policy vData = verticalPolicy();
+    int hStretch = horizontalStretch();
+    int vStretch = verticalStretch();
+    setHorizontalPolicy(vData);
+    setVerticalPolicy(hData);
+    setHorizontalStretch(vStretch);
+    setVerticalStretch(hStretch);
+}
+
+QT_END_NAMESPACE
+
+#endif // QLAYOUTPOLICY_H
diff --git a/src/layouts/qmldir b/src/layouts/qmldir
new file mode 100644
index 00000000..ec1d66a2
--- /dev/null
+++ b/src/layouts/qmldir
@@ -0,0 +1,3 @@
+module QtQuick.Layouts
+plugin qquicklayoutsplugin
+typeinfo plugins.qmltypes
diff --git a/src/layouts/qquickgridlayoutengine_p.h b/src/layouts/qquickgridlayoutengine_p.h
new file mode 100644
index 00000000..7a81f3c4
--- /dev/null
+++ b/src/layouts/qquickgridlayoutengine_p.h
@@ -0,0 +1,326 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Quick Layouts module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQUICKGRIDLAYOUTENGINE_P_H
+#define QQUICKGRIDLAYOUTENGINE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of the graphics view layout classes.  This header
+// file may change from version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qgridlayoutengine_p.h"
+#include "qquickitem.h"
+#include "qquicklayout_p.h"
+#include <QtWidgets/qsizepolicy.h>
+#include "qdebug.h"
+QT_BEGIN_NAMESPACE
+
+
+/*
+  The layout engine assumes:
+    1. minimum <= preferred <= maximum
+    2. descent is within minimum and maximum bounds     (### verify)
+
+    This function helps to ensure that by the following rules (in the following order):
+    1. If minimum > maximum, set minimum = maximum
+    2. Make sure preferred is not outside the [minimum,maximum] range.
+    3. If descent > minimum, set descent = minimum      (### verify if this is correct, it might
+                                                        need some refinements to multiline texts)
+
+    If any values are "not set" (i.e. 0 or less), they will be left untouched, so that we
+    know which values needs to be fetched from the implicit hints (not user hints).
+  */
+static void normalizeHints(qreal &minimum, qreal &preferred, qreal &maximum, qreal &descent)
+{
+    if (minimum > 0 && maximum > 0 && minimum > maximum)
+        minimum = maximum;
+
+    if (preferred > 0) {
+        if (minimum > 0 && preferred < minimum) {
+            preferred = minimum;
+        } else if (maximum > 0 && preferred > maximum) {
+            preferred = maximum;
+        }
+    }
+
+    if (minimum > 0 && descent > minimum)
+        descent = minimum;
+}
+
+static void boundSize(QSizeF &result, const QSizeF &size)
+{
+    if (size.width() > 0 && size.width() < result.width())
+        result.setWidth(size.width());
+    if (size.height() > 0 && size.height() < result.height())
+        result.setHeight(size.height());
+}
+
+static void expandSize(QSizeF &result, const QSizeF &size)
+{
+    if (size.width() > 0 && size.width() > result.width())
+        result.setWidth(size.width());
+    if (size.height() > 0 && size.height() > result.height())
+        result.setHeight(size.height());
+}
+
+static inline void combineHints(qreal &current, qreal fallbackHint)
+{
+    if (current <= 0)
+        current = fallbackHint;
+}
+
+class QQuickGridLayoutItem : public QGridLayoutItem {
+public:
+    QQuickGridLayoutItem(QQuickItem *item, int row, int column,
+                         int rowSpan = 1, int columnSpan = 1, Qt::Alignment alignment = 0)
+        : QGridLayoutItem(row, column, rowSpan, columnSpan, alignment), m_item(item), sizeHintCacheDirty(true) {}
+
+
+    typedef qreal (QQuickLayoutAttached::*SizeGetter)() const;
+
+    QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
+    {
+        Q_UNUSED(constraint);   // Quick Layouts does not support constraint atm
+        return effectiveSizeHints()[which];
+    }
+
+    QSizeF *effectiveSizeHints() const
+    {
+        if (!sizeHintCacheDirty)
+            return cachedSizeHints;
+
+        QQuickLayoutAttached *info = 0;
+        // First, retrieve the user-specified hints from the attached "Layout." properties
+        if (QObject *attached = qmlAttachedPropertiesObject<QQuickLayout>(m_item, false)) {
+            info = static_cast<QQuickLayoutAttached *>(attached);
+
+            struct Getters {
+                SizeGetter call[NSizes];
+            };
+
+            static Getters horGetters = {
+                {&QQuickLayoutAttached::minimumWidth, &QQuickLayoutAttached::preferredWidth, &QQuickLayoutAttached::maximumWidth},
+            };
+
+            static Getters verGetters = {
+                {&QQuickLayoutAttached::minimumHeight, &QQuickLayoutAttached::preferredHeight, &QQuickLayoutAttached::maximumHeight}
+            };
+            for (int i = 0; i < NSizes; ++i) {
+                SizeGetter getter = horGetters.call[i];
+                Q_ASSERT(getter);
+                cachedSizeHints[i].setWidth((info->*getter)());
+                getter = verGetters.call[i];
+                Q_ASSERT(getter);
+                cachedSizeHints[i].setHeight((info->*getter)());
+            }
+        } else {
+            for (int i = 0; i < NSizes; ++i)
+                cachedSizeHints[i] = QSize();
+        }
+        cachedSizeHints[Qt::MinimumDescent] = QSize();  //### FIXME when baseline support is added
+
+        QSizeF &minS = cachedSizeHints[Qt::MinimumSize];
+        QSizeF &prefS = cachedSizeHints[Qt::PreferredSize];
+        QSizeF &maxS = cachedSizeHints[Qt::MaximumSize];
+        QSizeF &descentS = cachedSizeHints[Qt::MinimumDescent];
+
+        // For instance, will normalize the following user-set hints
+        // from: [10, 5, 60]
+        // to:   [10, 10, 60]
+        normalizeHints(minS.rwidth(), prefS.rwidth(), maxS.rwidth(), descentS.rwidth());
+        normalizeHints(minS.rheight(), prefS.rheight(), maxS.rheight(), descentS.rheight());
+/*
+      The following table illustrates the preference of the properties used for measuring layout
+      items. If present, the USER properties will be preferred. If USER properties are not present,
+      the HINT 1 properties will be preferred. Finally, the HINT 2 properties will be used as an
+      ultimate fallback.
+
+           | USER                           | HINT 1            | HINT 2
+      -----+--------------------------------+-------------------+-------
+      MIN  | Layout.minimumWidth            |                   | 0
+      PREF | Layout.preferredWidth          | implicitWidth     | width
+      MAX  | Layout.maximumWidth            |                   | 100000
+      -----+--------------------------------+-------------------+--------
+SizePolicy | Layout.horizontalSizePolicy    | Expanding if layout, Fixed if item |
+
+*/
+        //--- GATHER MINIMUM SIZE HINTS ---
+        // They are always 0
+
+        //--- GATHER PREFERRED SIZE HINTS ---
+        // First, from implicitWidth/Height
+        qreal &prefWidth = cachedSizeHints[Qt::PreferredSize].rwidth();
+        qreal &prefHeight = cachedSizeHints[Qt::PreferredSize].rheight();
+        combineHints(prefWidth, m_item->implicitWidth());
+        combineHints(prefHeight, m_item->implicitHeight());
+
+        // If that fails, make an ultimate fallback to width/height
+
+        if (!info && prefWidth <= 0 || prefHeight <= 0)
+            info = static_cast<QQuickLayoutAttached *>(qmlAttachedPropertiesObject<QQuickLayout>(m_item));
+
+        const bool was = info->setChangesNotificationEnabled(false);
+        if (prefWidth <= 0) {
+            prefWidth = m_item->width();
+            info->setPreferredWidth(prefWidth);
+        }
+        if (prefHeight <= 0) {
+            prefHeight = m_item->height();
+            info->setPreferredHeight(prefHeight);
+        }
+        info->setChangesNotificationEnabled(was);
+
+        //--- GATHER MAXIMUM SIZE HINTS ---
+        // They are always q_declarativeLayoutMaxSize
+        combineHints(cachedSizeHints[Qt::MaximumSize].rwidth(), q_declarativeLayoutMaxSize);
+        combineHints(cachedSizeHints[Qt::MaximumSize].rheight(), q_declarativeLayoutMaxSize);
+
+        //--- GATHER DESCENT
+        // ### Not implemented
+
+
+        // Normalize again after the implicit hints have been gathered
+        // (using different rules than normalizeHints actually??))
+        // This is consistent with QGraphicsLayoutItemPrivate::effectiveSizeHints()
+/*
+The following shows how the different [min,pref,max] combinations are normalized after performing
+each normalization stage (maxS, minS and prefS):
+
+input   [1, 2, 3]   [1, 3, 2] [2, 1, 3] [2, 3, 1] [3, 2, 1] [3, 1, 2]
+------------------------------------------------------------------
+maxS    [1, 2, 3]   [1, 3, 3] [2, 1, 3] [2, 3, 3] [3, 2, 3] [3, 1, 3]
+minS    [1, 2, 3]   [1, 3, 3] [1, 1, 3] [2, 3, 3] [2, 2, 3] [1, 1, 3]
+prefS   [1, 2, 3]   [1, 3, 3] [1, 1, 3] [2, 3, 3] [2, 2, 3] [1, 1, 3] ###No change here.
+*/
+        boundSize(minS, maxS);
+        expandSize(prefS, minS);
+        boundSize(prefS, maxS);
+        //expandSize(maxS, prefS);    // [3,2,1] > [3,2,2]
+        //expandSize(maxS, minS);
+        //boundSize(maxS, QSizeF(q_declarativeLayoutMaxSize, q_declarativeLayoutMaxSize));
+
+
+        //boundSize(minS, prefS);     // [3,2,1] > [2,2,1]
+        //boundSize(minS, maxS);
+
+        // Both of these are invariants and inconsistent with the above combinations of the
+        // "symmetric" combination (i.e. boundSize(minS, prefS) and expandSize(maxS, prefS)
+        //expandSize(prefS, minS);    //[3,2,1] > [3,3,1]
+        //boundSize(prefS, maxS);     //[3,2,1] > [3,1,1]
+
+        sizeHintCacheDirty = false;
+        return cachedSizeHints;
+    }
+
+    void invalidate()
+    {
+        quickLayoutDebug() << "engine::invalidate()";
+        sizeHintCacheDirty = true;
+    }
+
+
+    static QLayoutPolicy::Policy fromSizePolicy(QQuickLayout::SizePolicy policy) {
+        return (policy == QQuickLayout::Fixed ? QLayoutPolicy::Fixed : QLayoutPolicy::Preferred);
+    }
+
+    QLayoutPolicy::Policy sizePolicy(Qt::Orientation orientation) const
+    {
+        if (QObject *attached = qmlAttachedPropertiesObject<QQuickLayout>(m_item, false)) {
+            QQuickLayoutAttached *info = static_cast<QQuickLayoutAttached *>(attached);
+            if (info) {
+                QLayoutPolicy sp(fromSizePolicy(info->horizontalSizePolicy()), fromSizePolicy(info->verticalSizePolicy()));
+                return (orientation == Qt::Horizontal) ? sp.horizontalPolicy()
+                                                       : sp.verticalPolicy();
+            }
+        }
+        // ### Correct way is to, go through all child items and combine the policies.
+        return qobject_cast<QQuickLayout*>(m_item) ? QLayoutPolicy::Preferred : QLayoutPolicy::Fixed;
+    }
+
+    void setGeometry(const QRectF &rect)
+    {
+        m_item->setPosition(rect.topLeft());
+        m_item->setSize(rect.size());
+    }
+
+    QQuickItem *layoutItem() const { return m_item; }
+
+    QQuickItem *m_item;
+private:
+    mutable QSizeF cachedSizeHints[Qt::NSizeHints];
+    mutable bool sizeHintCacheDirty;
+};
+
+class QQuickGridLayoutEngine : public QGridLayoutEngine {
+public:
+    QQuickGridLayoutEngine() : QGridLayoutEngine() {} //### not needed
+
+    int indexOf(QQuickItem *item) const {
+        for (int i = 0; i < q_items.size(); ++i) {
+            if (item == static_cast<QQuickGridLayoutItem*>(q_items.at(i))->layoutItem())
+                return i;
+        }
+        return -1;
+    }
+
+    QQuickGridLayoutItem *findLayoutItem(QQuickItem *layoutItem) const
+    {
+        for (int i = q_items.count() - 1; i >= 0; --i) {
+            QQuickGridLayoutItem *item = static_cast<QQuickGridLayoutItem*>(q_items.at(i));
+            if (item->layoutItem() == layoutItem)
+                return item;
+        }
+        return 0;
+    }
+};
+
+
+
+QT_END_NAMESPACE
+
+#endif // QQUICKGRIDLAYOUTENGINE_P_H
diff --git a/src/controls/qquicklayout.cpp b/src/layouts/qquicklayout.cpp
index 2013a487..e295e6cd 100644
--- a/src/controls/qquicklayout.cpp
+++ b/src/layouts/qquicklayout.cpp
@@ -3,7 +3,7 @@
 ** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
 ** Contact: http://www.qt-project.org/legal
 **
-** This file is part of the Qt Quick Controls module of the Qt Toolkit.
+** This file is part of the Qt Quick Layouts module of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** Commercial License Usage
@@ -41,164 +41,204 @@
 
 #include "qquicklayout_p.h"
 #include <QEvent>
-#include <QApplication>
+#include <QtCore/qcoreapplication.h>
 #include <QtCore/qnumeric.h>
 
 QT_BEGIN_NAMESPACE
 
-static const qreal q_declarativeLayoutMaxSize = 10e8;
-
-
-QQuickComponentsLayoutAttached::QQuickComponentsLayoutAttached(QObject *parent)
+QQuickLayoutAttached::QQuickLayoutAttached(QObject *parent)
     : QObject(parent),
       m_minimumWidth(0),
       m_minimumHeight(0),
+      m_preferredWidth(0),
+      m_preferredHeight(0),
       m_maximumWidth(q_declarativeLayoutMaxSize),
       m_maximumHeight(q_declarativeLayoutMaxSize),
-      m_verticalSizePolicy(QQuickComponentsLayout::Fixed),
-      m_horizontalSizePolicy(QQuickComponentsLayout::Fixed)
+      m_verticalSizePolicy(QQuickLayout::Fixed),
+      m_horizontalSizePolicy(QQuickLayout::Fixed),
+      m_row(0),
+      m_column(0),
+      m_rowSpan(1),
+      m_columnSpan(1),
+      m_changesNotificationEnabled(true)
 {
 
 }
 
-void QQuickComponentsLayoutAttached::setMinimumWidth(qreal width)
+void QQuickLayoutAttached::setMinimumWidth(qreal width)
 {
     if (qIsNaN(width) || m_minimumWidth == width)
         return;
 
     m_minimumWidth = width;
-    updateLayout();
+    invalidateItem();
     emit minimumWidthChanged();
 }
 
-void QQuickComponentsLayoutAttached::setMinimumHeight(qreal height)
+void QQuickLayoutAttached::setMinimumHeight(qreal height)
 {
     if (qIsNaN(height) || m_minimumHeight == height)
         return;
 
     m_minimumHeight = height;
-    updateLayout();
+    invalidateItem();
     emit minimumHeightChanged();
 }
 
-void QQuickComponentsLayoutAttached::setMaximumWidth(qreal width)
+void QQuickLayoutAttached::setPreferredWidth(qreal width)
+{
+    if (qIsNaN(width) || m_preferredWidth == width)
+        return;
+
+    m_preferredWidth = width;
+    if (m_changesNotificationEnabled)
+        invalidateItem();
+    emit preferredWidthChanged();
+}
+
+void QQuickLayoutAttached::setPreferredHeight(qreal height)
+{
+    if (qIsNaN(height) || m_preferredHeight == height)
+        return;
+
+    m_preferredHeight = height;
+    if (m_changesNotificationEnabled)
+        invalidateItem();
+    emit preferredHeightChanged();
+}
+
+void QQuickLayoutAttached::setMaximumWidth(qreal width)
 {
     if (qIsNaN(width) || m_maximumWidth == width)
         return;
 
     m_maximumWidth = width;
-    updateLayout();
+    invalidateItem();
     emit maximumWidthChanged();
 }
 
-void QQuickComponentsLayoutAttached::setMaximumHeight(qreal height)
+void QQuickLayoutAttached::setMaximumHeight(qreal height)
 {
     if (qIsNaN(height) || m_maximumHeight == height)
         return;
 
     m_maximumHeight = height;
-    updateLayout();
+    invalidateItem();
     emit maximumHeightChanged();
 }
 
-void QQuickComponentsLayoutAttached::setVerticalSizePolicy(QQuickComponentsLayout::SizePolicy policy)
+void QQuickLayoutAttached::setVerticalSizePolicy(QQuickLayout::SizePolicy policy)
 {
     if (m_verticalSizePolicy != policy) {
         m_verticalSizePolicy = policy;
-        updateLayout();
+        invalidateItem();
         emit verticalSizePolicyChanged();
     }
 }
 
-void QQuickComponentsLayoutAttached::setHorizontalSizePolicy(QQuickComponentsLayout::SizePolicy policy)
+void QQuickLayoutAttached::setHorizontalSizePolicy(QQuickLayout::SizePolicy policy)
 {
     if (m_horizontalSizePolicy != policy) {
         m_horizontalSizePolicy = policy;
-        updateLayout();
+        invalidateItem();
         emit horizontalSizePolicyChanged();
     }
 }
 
-void QQuickComponentsLayoutAttached::updateLayout()
+void QQuickLayoutAttached::invalidateItem()
 {
-    if (m_layout)
-        m_layout->invalidate();
+    quickLayoutDebug() << "QQuickLayoutAttached::invalidateItem";
+    if (QQuickLayout *layout = parentLayout()) {
+        layout->invalidate(item());
+    }
 }
 
+QQuickLayout *QQuickLayoutAttached::parentLayout() const
+{
+    QQuickItem *parentItem = item()->parentItem();
+    if (qobject_cast<QQuickLayout *>(parentItem))
+        return static_cast<QQuickLayout *>(parentItem);
+    return 0;
+}
+
+QQuickItem *QQuickLayoutAttached::item() const
+{
+    Q_ASSERT(qobject_cast<QQuickItem*>(parent()));
+    return static_cast<QQuickItem*>(parent());
+}
+
+
+
 
 
-QQuickComponentsLayout::QQuickComponentsLayout(QQuickItem *parent)
-    : QQuickItem(parent),
+QQuickLayout::QQuickLayout(QQuickLayoutPrivate &dd, QQuickItem *parent)
+    : QQuickItem(dd, parent),
       m_dirty(false)
 {
-
 }
 
-QQuickComponentsLayout::~QQuickComponentsLayout()
+QQuickLayout::~QQuickLayout()
 {
 
 }
 
-void QQuickComponentsLayout::setupItemLayout(QQuickItem *item)
+void QQuickLayout::setupItemLayout(QQuickItem *item)
 {
-    QObject *attached = qmlAttachedPropertiesObject<QQuickComponentsLayout>(item);
-    QQuickComponentsLayoutAttached *info = static_cast<QQuickComponentsLayoutAttached *>(attached);
-    info->m_layout = this;
+    //### not needed anymore, since these are deducted from hierarcy?
+    qmlAttachedPropertiesObject<QQuickLayout>(item);
 }
 
-QQuickComponentsLayoutAttached *QQuickComponentsLayout::qmlAttachedProperties(QObject *object)
+QQuickLayoutAttached *QQuickLayout::qmlAttachedProperties(QObject *object)
 {
-    return new QQuickComponentsLayoutAttached(object);
+    return new QQuickLayoutAttached(object);
 }
 
-bool QQuickComponentsLayout::event(QEvent *e)
+bool QQuickLayout::event(QEvent *e)
 {
     if (e->type() == QEvent::LayoutRequest)
-        reconfigureTopDown();
+        rearrangeTopDown();
 
     return QQuickItem::event(e);
 }
 
-void QQuickComponentsLayout::invalidate()
+void QQuickLayout::componentComplete()
+{
+    QQuickItem::componentComplete();
+}
+
+void QQuickLayout::invalidate(QQuickItem * /*childItem*/)
 {
     if (m_dirty)
         return;
 
-    QQuickComponentsLayout *layout = this;
-    QQuickComponentsLayout *parentLayout = 0;
-
-    while (!layout->m_dirty) {
-        layout->m_dirty = true;
-        parentLayout = qobject_cast<QQuickComponentsLayout *>(layout->parentItem());
+    m_dirty = true;
 
-        if (!parentLayout)
-            break;
-        else
-            layout = parentLayout;
+    if (QQuickLayout *parentLayout = qobject_cast<QQuickLayout *>(parentItem())) {
+        parentLayout->invalidate(this);
+    } else {
+        quickLayoutDebug() << "QQuickLayout::invalidate(), postEvent";
+        QCoreApplication::postEvent(this, new QEvent(QEvent::LayoutRequest));
     }
-
-    // just post events for top level layouts
-    if (!parentLayout)
-        QApplication::postEvent(layout, new QEvent(QEvent::LayoutRequest));
 }
 
-void QQuickComponentsLayout::reconfigureTopDown()
+void QQuickLayout::rearrangeTopDown()
 {
+    quickLayoutDebug() << "QQuickLayout::rearrangeTopDown()";
     const QList<QQuickItem *> &children = childItems();
 
-    reconfigureLayout();
+    rearrange();
 
     foreach (QQuickItem *child, children) {
-        QQuickComponentsLayout *layout = qobject_cast<QQuickComponentsLayout *>(child);
+        QQuickLayout *layout = qobject_cast<QQuickLayout *>(child);
 
         if (layout && layout->m_dirty)
-            layout->reconfigureTopDown();
+            layout->rearrangeTopDown();
     }
 
     m_dirty = false;
 }
 
-void QQuickComponentsLayout::reconfigureLayout()
+void QQuickLayout::rearrange()
 {
 
 }
diff --git a/src/layouts/qquicklayout_p.h b/src/layouts/qquicklayout_p.h
new file mode 100644
index 00000000..9c7c04e7
--- /dev/null
+++ b/src/layouts/qquicklayout_p.h
@@ -0,0 +1,220 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Quick Layouts module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQUICKLAYOUT_P_H
+#define QQUICKLAYOUT_P_H
+
+#include <QPointer>
+#include <QQuickItem>
+#include <private/qquickitem_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QQuickLayoutAttached;
+
+static const qreal q_declarativeLayoutMaxSize = 10e8;
+
+#if 0 && !defined(QT_NO_DEBUG) && !defined(QT_NO_DEBUG_OUTPUT)
+# define quickLayoutDebug QMessageLogger(__FILE__, __LINE__, Q_FUNC_INFO).debug
+#else
+# define quickLayoutDebug QT_NO_QWARNING_MACRO
+#endif
+
+class QQuickLayoutPrivate;
+class QQuickLayout : public QQuickItem
+{
+    Q_OBJECT
+    Q_ENUMS(SizePolicy)
+public:
+    enum SizePolicy {
+        Fixed,
+        Expanding
+    };
+
+    enum SizeHint {
+        MinimumSize = 0,
+        PreferredSize,
+        MaximumSize,
+        NSizes
+    };
+
+    explicit QQuickLayout(QQuickLayoutPrivate &dd, QQuickItem *parent = 0);
+    ~QQuickLayout();
+
+    static QQuickLayoutAttached *qmlAttachedProperties(QObject *object);
+
+
+    void componentComplete();
+    virtual void invalidate(QQuickItem * childItem = 0);
+protected:
+    bool event(QEvent *e);
+    void rearrangeTopDown();
+    virtual void rearrange();
+    void setupItemLayout(QQuickItem *item);
+
+
+    enum Orientation {
+        Vertical = 0,
+        Horizontal,
+        NOrientations
+    };
+
+private:
+    bool m_dirty;
+
+    Q_DECLARE_PRIVATE(QQuickLayout)
+
+    friend class QQuickLayoutAttached;
+};
+
+
+class QQuickLayoutPrivate : public QQuickItemPrivate
+{
+    Q_DECLARE_PUBLIC(QQuickLayout)
+};
+
+
+class QQuickLayoutAttached : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(qreal minimumWidth READ minimumWidth WRITE setMinimumWidth NOTIFY minimumWidthChanged)
+    Q_PROPERTY(qreal minimumHeight READ minimumHeight WRITE setMinimumHeight NOTIFY minimumHeightChanged)
+    Q_PROPERTY(qreal preferredWidth READ preferredWidth WRITE setPreferredWidth NOTIFY preferredWidthChanged)
+    Q_PROPERTY(qreal preferredHeight READ preferredHeight WRITE setPreferredHeight NOTIFY preferredHeightChanged)
+    Q_PROPERTY(qreal maximumWidth READ maximumWidth WRITE setMaximumWidth NOTIFY maximumWidthChanged)
+    Q_PROPERTY(qreal maximumHeight READ maximumHeight WRITE setMaximumHeight NOTIFY maximumHeightChanged)
+    Q_PROPERTY(QQuickLayout::SizePolicy verticalSizePolicy READ verticalSizePolicy WRITE setVerticalSizePolicy)
+    Q_PROPERTY(QQuickLayout::SizePolicy horizontalSizePolicy READ horizontalSizePolicy WRITE setHorizontalSizePolicy)
+    Q_PROPERTY(int row READ row WRITE setRow)
+    Q_PROPERTY(int column READ column WRITE setColumn)
+    Q_PROPERTY(int rowSpan READ rowSpan WRITE setRowSpan)
+    Q_PROPERTY(int columnSpan READ columnSpan WRITE setColumnSpan)
+
+public:
+    QQuickLayoutAttached(QObject *object);
+
+    qreal minimumWidth() const { return m_minimumWidth; }
+    void setMinimumWidth(qreal width);
+
+    qreal minimumHeight() const { return m_minimumHeight; }
+    void setMinimumHeight(qreal height);
+
+    qreal preferredWidth() const { return m_preferredWidth; }
+    void setPreferredWidth(qreal width);
+
+    qreal preferredHeight() const { return m_preferredHeight; }
+    void setPreferredHeight(qreal width);
+
+    qreal maximumWidth() const { return m_maximumWidth; }
+    void setMaximumWidth(qreal width);
+
+    qreal maximumHeight() const { return m_maximumHeight; }
+    void setMaximumHeight(qreal height);
+
+    QQuickLayout::SizePolicy verticalSizePolicy() const { return m_verticalSizePolicy; }
+    void setVerticalSizePolicy(QQuickLayout::SizePolicy policy);
+
+    QQuickLayout::SizePolicy horizontalSizePolicy() const { return m_horizontalSizePolicy; }
+    void setHorizontalSizePolicy(QQuickLayout::SizePolicy policy);
+
+    int row() const { return m_row; }
+    void setRow(int row) { m_row = row; }
+    int column() const { return m_column; }
+    void setColumn(int column) { m_column = column; }
+
+    int rowSpan() const { return m_rowSpan; }
+    void setRowSpan(int span) { m_rowSpan = span; }
+    int columnSpan() const { return m_columnSpan; }
+    void setColumnSpan(int span) { m_columnSpan = span; }
+
+    bool setChangesNotificationEnabled(bool enabled)
+    {
+        const bool old = m_changesNotificationEnabled;
+        m_changesNotificationEnabled = enabled;
+        return old;
+    }
+
+signals:
+    void minimumWidthChanged();
+    void minimumHeightChanged();
+    void preferredWidthChanged();
+    void preferredHeightChanged();
+    void maximumWidthChanged();
+    void maximumHeightChanged();
+    void verticalSizePolicyChanged();
+    void horizontalSizePolicyChanged();
+
+private:
+    void invalidateItem();
+    QQuickLayout *parentLayout() const;
+    QQuickItem *item() const;
+private:
+    qreal m_minimumWidth;
+    qreal m_minimumHeight;
+    qreal m_preferredWidth;
+    qreal m_preferredHeight;
+    qreal m_maximumWidth;
+    qreal m_maximumHeight;
+    QQuickLayout::SizePolicy m_verticalSizePolicy;
+    QQuickLayout::SizePolicy m_horizontalSizePolicy;
+
+    // GridLayout specific properties
+    int m_row;
+    int m_column;
+    int m_rowSpan;
+    int m_columnSpan;
+
+    bool m_changesNotificationEnabled;
+
+    friend class QQuickLayout;
+};
+
+inline QQuickLayoutAttached *attachedLayoutObject(QQuickItem *item, bool create = true)
+{
+    return static_cast<QQuickLayoutAttached *>(qmlAttachedPropertiesObject<QQuickLayout>(item, create));
+}
+
+QT_END_NAMESPACE
+
+QML_DECLARE_TYPE(QQuickLayout)
+QML_DECLARE_TYPEINFO(QQuickLayout, QML_HAS_ATTACHED_PROPERTIES)
+
+#endif // QQUICKLAYOUT_P_H
diff --git a/src/layouts/qquicklinearlayout.cpp b/src/layouts/qquicklinearlayout.cpp
new file mode 100644
index 00000000..2d6b830a
--- /dev/null
+++ b/src/layouts/qquicklinearlayout.cpp
@@ -0,0 +1,426 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Quick Layouts module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qquicklinearlayout_p.h"
+#include <QtCore/qnumeric.h>
+#include "qdebug.h"
+/*!
+    \qmltype RowLayout
+    \instantiates QQuickRowLayout
+    \inqmlmodule QtDesktop 1.0
+    \brief RowLayout is doing bla...bla...
+*/
+
+/*!
+    \qmltype ColumnLayout
+    \instantiates QQuickColumnLayout
+    \inqmlmodule QtDesktop 1.0
+    \brief ColumnLayout is doing bla...bla...
+*/
+
+QT_BEGIN_NAMESPACE
+
+static const qreal q_declarativeLayoutDefaultSpacing = 4.0;
+
+
+QQuickGridLayoutBase::QQuickGridLayoutBase(QQuickGridLayoutBasePrivate &dd,
+                                           Qt::Orientation orientation,
+                                           QQuickItem *parent /*= 0*/)
+    : QQuickLayout(dd, parent)
+{
+    Q_D(QQuickGridLayoutBase);
+    d->orientation = orientation;
+}
+
+Qt::Orientation QQuickGridLayoutBase::orientation() const
+{
+    Q_D(const QQuickGridLayoutBase);
+    return d->orientation;
+}
+
+void QQuickGridLayoutBase::setOrientation(Qt::Orientation orientation)
+{
+    Q_D(QQuickGridLayoutBase);
+    if (d->orientation == orientation)
+        return;
+
+    d->orientation = orientation;
+    invalidate();
+}
+
+void QQuickGridLayoutBase::componentComplete()
+{
+    QQuickLayout::componentComplete();
+    quickLayoutDebug() << "QQuickGridLayoutBase::componentComplete()";
+    updateLayoutItems();
+    quickLayoutDebug() << "QQuickGridLayoutBase::componentComplete() DONE";
+
+}
+
+/*
+  Invalidation happens like this as a reaction to that a size hint changes on an item "a":
+
+  Suppose we have the following Qml document:
+    RowLayout {
+        id: l1
+        RowLayout {
+            id: l2
+            Item {
+                id: a
+            }
+            Item {
+                id: b
+            }
+        }
+    }
+
+  1.    l2->invalidateChildItem(a) is called on l2, where item refers to "a".
+        (this will dirty the cached size hints of item "a")
+  2.    l2->invalidate() is called
+        this will :
+            i)  invalidate the layout engine
+            ii) dirty the cached size hints of item "l2" (by calling parentLayout()->invalidateChildItem
+
+ */
+/*!
+   \internal
+
+    Invalidates \a childItem and this layout.
+    After a call to invalidate, the next call to retrieve e.g. sizeHint will be up-to date.
+    This function will also call QQuickLayout::invalidate(0), to ensure that the parent layout
+    is invalidated.
+ */
+void QQuickGridLayoutBase::invalidate(QQuickItem *childItem)
+{
+    Q_D(QQuickGridLayoutBase);
+    if (!isComponentComplete())
+        return;
+    quickLayoutDebug() << "QQuickGridLayoutBase::invalidate()";
+
+    if (childItem) {
+        if (QQuickGridLayoutItem *layoutItem = d->engine.findLayoutItem(childItem))
+            layoutItem->invalidate();
+    }
+    // invalidate engine
+    d->engine.invalidate();
+
+    QQuickLayout::invalidate(this);
+}
+
+void QQuickGridLayoutBase::updateLayoutItems()
+{
+    Q_D(QQuickGridLayoutBase);
+    if (!isComponentComplete())
+        return;
+    quickLayoutDebug() << "QQuickGridLayoutBase::updateLayoutItems";
+    d->engine.deleteItems();
+    foreach (QQuickItem *child,  childItems()) {
+        if (child->isVisible())
+            insertLayoutItem(child);
+    }
+
+    invalidate();
+    quickLayoutDebug() << "QQuickGridLayoutBase::updateLayoutItems LEAVING";
+    //propagateLayoutSizeHints();
+}
+
+void QQuickGridLayoutBase::propagateLayoutSizeHints()
+{
+    Q_D(QQuickGridLayoutBase);
+    quickLayoutDebug() << "propagateLayoutSizeHints()";
+    QObject *attached = qmlAttachedPropertiesObject<QQuickLayout>(this);
+    QQuickLayoutAttached *info = static_cast<QQuickLayoutAttached *>(attached);
+
+    const QSizeF min = d->engine.sizeHint(Qt::MinimumSize, QSizeF());
+    const QSizeF pref = d->engine.sizeHint(Qt::PreferredSize, QSizeF());
+    const QSizeF max = d->engine.sizeHint(Qt::MaximumSize, QSizeF());
+
+    info->setMinimumWidth(min.width());
+    info->setMinimumHeight(min.height());
+    setImplicitWidth(pref.width());
+    setImplicitHeight(pref.height());
+    info->setMaximumWidth(max.width());
+    info->setMaximumHeight(max.height());
+}
+
+void QQuickGridLayoutBase::itemChange(ItemChange change, const ItemChangeData &value)
+{
+    if (change == ItemChildAddedChange) {
+        quickLayoutDebug() << "ItemChildAddedChange";
+        QQuickItem *item = value.item;
+        QObject::connect(item, SIGNAL(destroyed()), this, SLOT(onItemDestroyed()));
+        QObject::connect(item, SIGNAL(visibleChanged()), this, SLOT(onItemVisibleChanged()));
+        QObject::connect(item, SIGNAL(implicitWidthChanged()), this, SLOT(onItemImplicitSizeChanged()));
+
+        if (isComponentComplete() && isVisible())
+            updateLayoutItems();
+    } else if (change == ItemChildRemovedChange) {
+        quickLayoutDebug() << "ItemChildRemovedChange";
+        QQuickItem *item = value.item;
+        QObject::disconnect(item, SIGNAL(destroyed()), this, SLOT(onItemDestroyed()));
+        QObject::disconnect(item, SIGNAL(visibleChanged()), this, SLOT(onItemVisibleChanged()));
+        QObject::disconnect(item, SIGNAL(implicitWidthChanged()), this, SLOT(onItemImplicitSizeChanged()));
+        if (isComponentComplete() && isVisible())
+            updateLayoutItems();
+    }
+
+    QQuickLayout::itemChange(change, value);
+}
+
+void QQuickGridLayoutBase::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
+{
+    QQuickLayout::geometryChanged(newGeometry, oldGeometry);
+    if (!isComponentComplete() || !newGeometry.isValid())
+        return;
+    quickLayoutDebug() << "QQuickGridLayoutBase::geometryChanged" << newGeometry << oldGeometry;
+    rearrange();
+}
+
+void QQuickGridLayoutBase::insertLayoutItem(QQuickItem *item)
+{
+    Q_D(QQuickGridLayoutBase);
+    if (!item) {
+        qWarning("QGraphicsGridLayout::addItem: cannot add null item");
+        return;
+    }
+    QQuickLayoutAttached *info = attachedLayoutObject(item, false);
+    int row = 0;
+    int column = 0;
+    int rowSpan = 1;
+    int columnSpan = 1;
+    Qt::Alignment alignment = 0;
+    if (info) {
+        row = info->row();
+        column = info->column();
+        rowSpan = info->rowSpan();
+        columnSpan = info->columnSpan();
+    }
+    if (row < 0 || column < 0) {
+        qWarning("QQuickGridLayoutBase::insertLayoutItemAt: invalid row/column: %d",
+                 row < 0 ? row : column);
+        return;
+    }
+    if (columnSpan < 1 || rowSpan < 1) {
+        qWarning("QQuickGridLayoutBase::addItem: invalid row span/column span: %d",
+                 rowSpan < 1 ? rowSpan : columnSpan);
+        return;
+    }
+    QQuickGridLayoutItem *layoutItem = new QQuickGridLayoutItem(item, row, column, rowSpan, columnSpan, alignment);
+    d->engine.insertItem(layoutItem, -1);
+
+    setupItemLayout(item);
+}
+
+void QQuickGridLayoutBase::removeGridItem(QGridLayoutItem *gridItem)
+{
+    Q_D(QQuickGridLayoutBase);
+    const int index = gridItem->firstRow(d->orientation);
+    d->engine.removeItem(gridItem);
+    d->engine.removeRows(index, 1, d->orientation);
+}
+
+void QQuickGridLayoutBase::removeLayoutItem(QQuickItem *item)
+{
+    Q_D(QQuickGridLayoutBase);
+    quickLayoutDebug() << "QQuickGridLayoutBase::removeLayoutItem";
+    if (QQuickGridLayoutItem *gridItem = d->engine.findLayoutItem(item)) {
+        removeGridItem(gridItem);
+        delete gridItem;
+        invalidate();
+    }
+}
+
+void QQuickGridLayoutBase::onItemVisibleChanged()
+{
+    if (!isComponentComplete())
+        return;
+    quickLayoutDebug() << "QQuickGridLayoutBase::onItemVisibleChanged";
+    updateLayoutItems();
+}
+
+void QQuickGridLayoutBase::onItemDestroyed()
+{
+    Q_D(QQuickGridLayoutBase);
+    quickLayoutDebug() << "QQuickGridLayoutBase::onItemDestroyed";
+    QQuickItem *inDestruction = static_cast<QQuickItem *>(sender());
+    if (QQuickGridLayoutItem *gridItem = d->engine.findLayoutItem(inDestruction)) {
+        removeGridItem(gridItem);
+        delete gridItem;
+        invalidate();
+    }
+}
+
+void QQuickGridLayoutBase::onItemImplicitSizeChanged()
+{
+    Q_D(QQuickGridLayoutBase);
+    QQuickItem *item = static_cast<QQuickItem *>(sender());
+    Q_ASSERT(item);
+    //invalidate(item);
+}
+
+void QQuickGridLayoutBase::rearrange()
+{
+    Q_D(QQuickGridLayoutBase);
+    if (!isComponentComplete())
+        return;
+
+    quickLayoutDebug() << "QQuickGridLayoutBase::rearrange()";
+    Qt::LayoutDirection visualDir = Qt::LeftToRight;    // ### Fix if RTL support is needed
+    d->engine.setVisualDirection(visualDir);
+
+    /*
+    qreal left, top, right, bottom;
+    left = top = right = bottom = 0;                    // ### support for margins?
+    if (visualDir == Qt::RightToLeft)
+        qSwap(left, right);
+    */
+
+    QRectF effectiveRect(0, 0, width(), height());
+    d->engine.setGeometries(effectiveRect);
+
+    // propagate hints to upper levels
+    propagateLayoutSizeHints();
+}
+
+
+/**********************************
+ **
+ ** QQuickGridLayout
+ **
+ **/
+QQuickGridLayout::QQuickGridLayout(QQuickItem *parent /* = 0*/)
+    : QQuickGridLayoutBase(*new QQuickGridLayoutPrivate, Qt::Horizontal, parent)
+{
+    Q_D(QQuickGridLayout);
+    d->horizontalSpacing = q_declarativeLayoutDefaultSpacing;
+    d->verticalSpacing = q_declarativeLayoutDefaultSpacing;
+    d->engine.setSpacing(d->horizontalSpacing, Qt::Horizontal);
+    d->engine.setSpacing(d->verticalSpacing, Qt::Vertical);
+}
+
+qreal QQuickGridLayout::horizontalSpacing() const
+{
+    Q_D(const QQuickGridLayout);
+    return d->horizontalSpacing;
+}
+
+void QQuickGridLayout::setHorizontalSpacing(qreal spacing)
+{
+    Q_D(QQuickGridLayout);
+    if (qIsNaN(spacing) || d->horizontalSpacing == spacing)
+        return;
+
+    d->horizontalSpacing = spacing;
+    d->engine.setSpacing(spacing, Qt::Horizontal | Qt::Vertical);
+    invalidate();
+}
+
+qreal QQuickGridLayout::verticalSpacing() const
+{
+    Q_D(const QQuickGridLayout);
+    return d->verticalSpacing;
+}
+
+void QQuickGridLayout::setVerticalSpacing(qreal spacing)
+{
+    Q_D(QQuickGridLayout);
+    if (qIsNaN(spacing) || d->verticalSpacing == spacing)
+        return;
+
+    d->verticalSpacing = spacing;
+    d->engine.setSpacing(spacing, Qt::Horizontal | Qt::Vertical);
+    invalidate();
+}
+
+
+/**********************************
+ **
+ ** QQuickLinearLayout
+ **
+ **/
+QQuickLinearLayout::QQuickLinearLayout(Qt::Orientation orientation,
+                                        QQuickItem *parent /*= 0*/)
+    : QQuickGridLayoutBase(*new QQuickLinearLayoutPrivate, orientation, parent)
+{
+    Q_D(QQuickLinearLayout);
+    d->spacing = q_declarativeLayoutDefaultSpacing;
+    d->engine.setSpacing(d->spacing, Qt::Horizontal | Qt::Vertical);
+}
+
+qreal QQuickLinearLayout::spacing() const
+{
+    Q_D(const QQuickLinearLayout);
+    return d->spacing;
+}
+
+void QQuickLinearLayout::setSpacing(qreal spacing)
+{
+    Q_D(QQuickLinearLayout);
+    if (qIsNaN(spacing) || d->spacing == spacing)
+        return;
+
+    d->spacing = spacing;
+    d->engine.setSpacing(spacing, Qt::Horizontal | Qt::Vertical);
+    invalidate();
+}
+
+
+void QQuickLinearLayout::insertLayoutItem(QQuickItem *item)
+{
+    Q_D(QQuickLinearLayout);
+    const int index = d->engine.rowCount(d->orientation);
+    d->engine.insertRow(index, d->orientation);
+
+    int gridRow = 0;
+    int gridColumn = index;
+    if (d->orientation == Qt::Vertical)
+        qSwap(gridRow, gridColumn);
+    QQuickGridLayoutItem *layoutItem = new QQuickGridLayoutItem(item, gridRow, gridColumn, 1, 1, 0);
+    d->engine.insertItem(layoutItem, index);
+
+    setupItemLayout(item);
+
+    invalidate();
+}
+
+
+
+QT_END_NAMESPACE
diff --git a/src/layouts/qquicklinearlayout_p.h b/src/layouts/qquicklinearlayout_p.h
new file mode 100644
index 00000000..0a8db1cd
--- /dev/null
+++ b/src/layouts/qquicklinearlayout_p.h
@@ -0,0 +1,199 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Quick Layouts module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQUICKLINEARLAYOUT_P_H
+#define QQUICKLINEARLAYOUT_P_H
+
+#include "qquicklayout_p.h"
+#include "qquickgridlayoutengine_p.h"
+
+QT_BEGIN_NAMESPACE
+
+/**********************************
+ **
+ ** QQuickGridLayoutBase
+ **
+ **/
+class QQuickGridLayoutBasePrivate;
+
+class QQuickGridLayoutBase : public QQuickLayout
+{
+    Q_OBJECT
+public:
+    explicit QQuickGridLayoutBase(QQuickGridLayoutBasePrivate &dd,
+                                  Qt::Orientation orientation,
+                                  QQuickItem *parent = 0);
+    ~QQuickGridLayoutBase() {}
+
+    void componentComplete();
+    void invalidate(QQuickItem *childItem = 0);
+    Qt::Orientation orientation() const;
+    void setOrientation(Qt::Orientation orientation);
+
+protected:
+    void updateLayoutItems();
+    void rearrange();
+    virtual void insertLayoutItem(QQuickItem *item);
+    void removeLayoutItem(QQuickItem *item);
+    void itemChange(ItemChange change, const ItemChangeData &data);
+    void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry);
+
+protected slots:
+    void onItemVisibleChanged();
+    void onItemDestroyed();
+    void onItemImplicitSizeChanged();
+
+private:
+    void removeGridItem(QGridLayoutItem *gridItem);
+    void propagateLayoutSizeHints();
+    Q_DECLARE_PRIVATE(QQuickGridLayoutBase)
+};
+
+
+class QQuickGridLayoutBasePrivate : public QQuickLayoutPrivate
+{
+    Q_DECLARE_PUBLIC(QQuickGridLayoutBase)
+
+public:
+    QQuickGridLayoutBasePrivate() { }
+    QQuickGridLayoutEngine engine;
+    Qt::Orientation orientation;
+};
+
+/**********************************
+ **
+ ** QQuickGridLayout
+ **
+ **/
+class QQuickGridLayoutPrivate;
+class QQuickGridLayout : public QQuickGridLayoutBase
+{
+    Q_OBJECT
+    Q_PROPERTY(qreal horizontalSpacing READ horizontalSpacing WRITE setHorizontalSpacing NOTIFY horizontalSpacingChanged)
+    Q_PROPERTY(qreal verticalSpacing READ verticalSpacing WRITE setVerticalSpacing NOTIFY verticalSpacingChanged)
+public:
+    explicit QQuickGridLayout(QQuickItem *parent = 0);
+    qreal horizontalSpacing() const;
+    void setHorizontalSpacing(qreal spacing);
+    qreal verticalSpacing() const;
+    void setVerticalSpacing(qreal spacing);
+signals:
+    void horizontalSpacingChanged();
+    void verticalSpacingChanged();
+
+private:
+    Q_DECLARE_PRIVATE(QQuickGridLayout)
+};
+
+class QQuickGridLayoutPrivate : public QQuickGridLayoutBasePrivate
+{
+    Q_DECLARE_PUBLIC(QQuickGridLayout)
+public:
+    QQuickGridLayoutPrivate() {}
+    qreal horizontalSpacing;
+    qreal verticalSpacing;
+};
+
+
+/**********************************
+ **
+ ** QQuickLinearLayout
+ **
+ **/
+class QQuickLinearLayoutPrivate;
+class QQuickLinearLayout : public QQuickGridLayoutBase
+{
+    Q_OBJECT
+    Q_PROPERTY(qreal spacing READ spacing WRITE setSpacing NOTIFY spacingChanged)
+public:
+    explicit QQuickLinearLayout(Qt::Orientation orientation,
+                                QQuickItem *parent = 0);
+    void insertLayoutItem(QQuickItem *item);
+    qreal spacing() const;
+    void setSpacing(qreal spacing);
+
+signals:
+    void spacingChanged();
+private:
+    Q_DECLARE_PRIVATE(QQuickLinearLayout)
+};
+
+class QQuickLinearLayoutPrivate : public QQuickGridLayoutBasePrivate
+{
+    Q_DECLARE_PUBLIC(QQuickLinearLayout)
+public:
+    QQuickLinearLayoutPrivate() {}
+    qreal spacing;
+};
+
+
+/**********************************
+ **
+ ** QQuickRowLayout
+ **
+ **/
+class QQuickRowLayout : public QQuickLinearLayout
+{
+    Q_OBJECT
+
+public:
+    explicit QQuickRowLayout(QQuickItem *parent = 0)
+        : QQuickLinearLayout(Qt::Horizontal, parent) {}
+};
+
+
+/**********************************
+ **
+ ** QQuickColumnLayout
+ **
+ **/
+class QQuickColumnLayout : public QQuickLinearLayout
+{
+    Q_OBJECT
+
+public:
+    explicit QQuickColumnLayout(QQuickItem *parent = 0)
+        : QQuickLinearLayout(Qt::Vertical, parent) {}
+};
+
+QT_END_NAMESPACE
+
+#endif // QQUICKLINEARLAYOUT_P_H
diff --git a/src/src.pro b/src/src.pro
index 77753b0a..7bd5b33e 100644
--- a/src/src.pro
+++ b/src/src.pro
@@ -1,3 +1,5 @@
 TEMPLATE = subdirs
 
 SUBDIRS += controls styles experimental private
+
+SUBDIRS += layouts