5 files changed, 442 insertions, 3 deletions
diff --git a/src/layouts/layouts.pro b/src/layouts/layouts.pro
index 3ef18f85d..f7a73b7e3 100644
--- a/src/layouts/layouts.pro
+++ b/src/layouts/layouts.pro
@@ -10,12 +10,14 @@ QMAKE_DOCS = $$PWD/doc/qtquicklayouts.qdocconf
 SOURCES += plugin.cpp \
     qquicklayout.cpp \
     qquicklinearlayout.cpp \
+    qquickstacklayout.cpp \
     qquickgridlayoutengine.cpp \
     qquicklayoutstyleinfo.cpp
 
 HEADERS += \
     qquicklayout_p.h \
     qquicklinearlayout_p.h \
+    qquickstacklayout_p.h \
     qquickgridlayoutengine_p.h \
     qquicklayoutstyleinfo_p.h
 
diff --git a/src/layouts/plugin.cpp b/src/layouts/plugin.cpp
index fa72fa8d7..6a6705398 100644
--- a/src/layouts/plugin.cpp
+++ b/src/layouts/plugin.cpp
@@ -37,6 +37,7 @@
 #include <QtQml/qqmlextensionplugin.h>
 
 #include "qquicklinearlayout_p.h"
+#include "qquickstacklayout_p.h"
 
 QT_BEGIN_NAMESPACE
 
@@ -54,6 +55,7 @@ public:
         qmlRegisterType<QQuickRowLayout>(uri, 1, 0, "RowLayout");
         qmlRegisterType<QQuickColumnLayout>(uri, 1, 0, "ColumnLayout");
         qmlRegisterType<QQuickGridLayout>(uri, 1, 0, "GridLayout");
+        qmlRegisterType<QQuickStackLayout>(uri, 1, 3, "StackLayout");
         qmlRegisterUncreatableType<QQuickLayout>(uri, 1, 0, "Layout",
                                                            QStringLiteral("Do not create objects of type Layout"));
         qmlRegisterUncreatableType<QQuickLayout>(uri, 1, 2, "Layout",
diff --git a/src/layouts/qquicklayout.cpp b/src/layouts/qquicklayout.cpp
index 6fbb2eadc..4a80beada 100644
--- a/src/layouts/qquicklayout.cpp
+++ b/src/layouts/qquicklayout.cpp
@@ -685,9 +685,6 @@ QQuickItem *QQuickLayoutAttached::item() const
 }
 
 
-
-
-
 QQuickLayout::QQuickLayout(QQuickLayoutPrivate &dd, QQuickItem *parent)
     : QQuickItem(dd, parent),
       m_dirty(false)
diff --git a/src/layouts/qquickstacklayout.cpp b/src/layouts/qquickstacklayout.cpp
new file mode 100644
index 000000000..3ada3b1eb
--- /dev/null
+++ b/src/layouts/qquickstacklayout.cpp
@@ -0,0 +1,333 @@
+/****************************************************************************
+**
+** Copyright (C) 2015 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the Qt Quick Layouts module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** 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 The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/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 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later 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 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qquickstacklayout_p.h"
+#include <limits>
+
+/*!
+    \qmltype StackLayout
+    \instantiates QQuickStackLayout
+    \inherits Item
+    \inqmlmodule QtQuick.Layouts
+    \ingroup layouts
+    \brief The StackLayout class provides a stack of items where
+    only one item is visible at a time.
+
+    The current visible item can be modified by setting the \l currentIndex property.
+    The index corresponds to the order of the StackLayout's children.
+
+    In contrast to most other layouts, child Items' \l{Layout::fillWidth}{Layout.fillWidth} and \l{Layout::fillHeight}{Layout.fillHeight} properties
+    defaults to \c true. As a consequence, child items are by default filled to match the size of the StackLayout as long as their
+    \l{Layout::maximumWidth}{Layout.maximumWidth} or \l{Layout::maximumHeight}{Layout.maximumHeight} does not prevent it.
+
+    Items are added to the layout by reparenting the item to the layout. Similarly, removal is done by reparenting the item from the layout.
+    Both of these operations will affect the layouts \l count property.
+
+    The following code will create a StackLayout where only the 'plum' rectangle is visible.
+    \code
+    StackLayout {
+        id: layout
+        anchors.fill: parent
+        currentIndex: 1
+        Rectangle {
+            color: 'teal'
+            implicitWidth: 200
+            implicitHeight: 200
+        }
+        Rectangle {
+            color: 'plum'
+            implicitWidth: 300
+            implicitHeight: 200
+        }
+    }
+    \endcode
+
+    Items in a StackLayout support these attached properties:
+    \list
+        \li \l{Layout::minimumWidth}{Layout.minimumWidth}
+        \li \l{Layout::minimumHeight}{Layout.minimumHeight}
+        \li \l{Layout::preferredWidth}{Layout.preferredWidth}
+        \li \l{Layout::preferredHeight}{Layout.preferredHeight}
+        \li \l{Layout::maximumWidth}{Layout.maximumWidth}
+        \li \l{Layout::maximumHeight}{Layout.maximumHeight}
+        \li \l{Layout::fillWidth}{Layout.fillWidth}
+        \li \l{Layout::fillHeight}{Layout.fillHeight}
+    \endlist
+
+    Read more about attached properties \l{QML Object Attributes}{here}.
+    \sa ColumnLayout
+    \sa GridLayout
+    \sa RowLayout
+    \sa StackView
+*/
+
+QQuickStackLayout::QQuickStackLayout(QQuickItem *parent) :
+    QQuickLayout(*new QQuickStackLayoutPrivate, parent)
+{
+}
+
+/*!
+    \qmlproperty int StackLayout::count
+
+    This property holds the number of items that belongs to the layout.
+
+    Only items that are children of the StackLayout will be candidates for layouting.
+*/
+int QQuickStackLayout::count() const
+{
+    Q_D(const QQuickStackLayout);
+    return d->count;
+}
+
+/*!
+    \qmlproperty int StackLayout::currentIndex
+
+    This property holds the current index of which of the StackLayout's items that should be visible.
+    By default it will be -1 for an empty layout, otherwise the default is 0 (referring to the first item).
+*/
+int QQuickStackLayout::currentIndex() const
+{
+    Q_D(const QQuickStackLayout);
+    return d->currentIndex;
+}
+
+void QQuickStackLayout::setCurrentIndex(int index)
+{
+    Q_D(QQuickStackLayout);
+    if (index != d->currentIndex) {
+        QQuickItem *prev = itemAt(d->currentIndex);
+        QQuickItem *next = itemAt(index);
+        d->currentIndex = index;
+        d->explicitCurrentIndex = true;
+        if (prev)
+            prev->setVisible(false);
+        if (next)
+            next->setVisible(true);
+
+        if (isComponentComplete()) {
+            rearrange(QSizeF(width(), height()));
+            emit currentIndexChanged();
+        }
+    }
+}
+
+void QQuickStackLayout::componentComplete()
+{
+    QQuickLayout::componentComplete();    // will call our geometryChange(), (where isComponentComplete() == true)
+
+    updateLayoutItems();
+
+    QQuickItem *par = parentItem();
+    if (qobject_cast<QQuickLayout*>(par))
+        return;
+
+    rearrange(QSizeF(width(), height()));
+}
+
+QSizeF QQuickStackLayout::sizeHint(Qt::SizeHint whichSizeHint) const
+{
+    QSizeF &askingFor = m_cachedSizeHints[whichSizeHint];
+    if (!askingFor.isValid()) {
+        QSizeF &minS = m_cachedSizeHints[Qt::MinimumSize];
+        QSizeF &prefS = m_cachedSizeHints[Qt::PreferredSize];
+        QSizeF &maxS = m_cachedSizeHints[Qt::MaximumSize];
+
+        minS = QSizeF(0,0);
+        prefS = QSizeF(0,0);
+        maxS = QSizeF(std::numeric_limits<qreal>::infinity(), std::numeric_limits<qreal>::infinity());
+
+        const int count = itemCount();
+        m_cachedItemSizeHints.resize(count);
+        for (int i = 0; i < count; ++i) {
+            SizeHints &hints = m_cachedItemSizeHints[i];
+            QQuickStackLayout::collectItemSizeHints(itemAt(i), hints.array);
+            minS = minS.expandedTo(hints.min());
+            prefS = prefS.expandedTo(hints.pref());
+            //maxS = maxS.boundedTo(hints.max());       // Can be resized to be larger than any of its items.
+                                                        // This is the same as QStackLayout does it.
+            // Not sure how descent makes sense here...
+        }
+    }
+    return askingFor;
+}
+
+int QQuickStackLayout::indexOf(QQuickItem *childItem) const
+{
+    if (childItem) {
+        int indexOfItem = 0;
+        foreach (QQuickItem *item, childItems()) {
+            if (shouldIgnoreItem(item))
+                continue;
+            if (childItem == item)
+                return indexOfItem;
+            ++indexOfItem;
+        }
+    }
+    return -1;
+}
+
+QQuickItem *QQuickStackLayout::itemAt(int index) const
+{
+    foreach (QQuickItem *item, childItems()) {
+        if (shouldIgnoreItem(item))
+            continue;
+        if (index == 0)
+            return item;
+        --index;
+    }
+    return 0;
+}
+
+int QQuickStackLayout::itemCount() const
+{
+    int count = 0;
+    foreach (QQuickItem *item, childItems()) {
+        if (shouldIgnoreItem(item))
+            continue;
+        ++count;
+    }
+    return count;
+}
+
+void QQuickStackLayout::setAlignment(QQuickItem * /*item*/, Qt::Alignment /*align*/)
+{
+    // ### Do we have to respect alignment?
+}
+
+void QQuickStackLayout::invalidate(QQuickItem *childItem)
+{
+    Q_D(QQuickStackLayout);
+    if (d->m_ignoredItems.contains(childItem)) {
+        // If an invalid item gets a valid size, it should be included, as it was added to the layout
+        updateLayoutItems();
+        return;
+    }
+
+    const int indexOfChild = indexOf(childItem);
+    if (indexOfChild >= 0 && indexOfChild < m_cachedItemSizeHints.count()) {
+        m_cachedItemSizeHints[indexOfChild].min() = QSizeF();
+        m_cachedItemSizeHints[indexOfChild].pref() = QSizeF();
+        m_cachedItemSizeHints[indexOfChild].max() = QSizeF();
+    }
+
+    for (int i = 0; i < Qt::NSizeHints; ++i)
+        m_cachedSizeHints[i] = QSizeF();
+    QQuickLayout::invalidate(this);
+
+    QQuickLayoutAttached *info = attachedLayoutObject(this);
+
+    const QSizeF min = sizeHint(Qt::MinimumSize);
+    const QSizeF pref = sizeHint(Qt::PreferredSize);
+    const QSizeF max = sizeHint(Qt::MaximumSize);
+
+    const bool old = info->setChangesNotificationEnabled(false);
+    info->setMinimumImplicitSize(min);
+    info->setMaximumImplicitSize(max);
+    info->setChangesNotificationEnabled(old);
+    if (pref.width() == implicitWidth() && pref.height() == implicitHeight()) {
+        // In case setImplicitSize does not emit implicit{Width|Height}Changed
+        if (QQuickLayout *parentLayout = qobject_cast<QQuickLayout *>(parentItem()))
+            parentLayout->invalidate(this);
+    } else {
+        setImplicitSize(pref.width(), pref.height());
+    }
+}
+
+void QQuickStackLayout::updateLayoutItems()
+{
+    Q_D(QQuickStackLayout);
+    d->m_ignoredItems.clear();
+    const int count = itemCount();
+    int oldIndex = d->currentIndex;
+    if (!d->explicitCurrentIndex)
+        d->currentIndex = (count > 0 ? 0 : -1);
+
+    if (d->currentIndex != oldIndex)
+        emit currentIndexChanged();
+
+    if (count != d->count) {
+        d->count = count;
+        emit countChanged();
+    }
+    for (int i = 0; i < count; ++i)
+        itemAt(i)->setVisible(d->currentIndex == i);
+
+    invalidate();
+}
+
+void QQuickStackLayout::rearrange(const QSizeF &newSize)
+{
+    Q_D(QQuickStackLayout);
+    if (newSize.isNull() || !newSize.isValid())
+        return;
+    (void)sizeHint(Qt::PreferredSize);  // Make sure m_cachedItemSizeHints are valid
+
+    if (d->currentIndex == -1 || d->currentIndex >= m_cachedItemSizeHints.count())
+        return;
+    QQuickStackLayout::SizeHints &hints = m_cachedItemSizeHints[d->currentIndex];
+    QQuickItem *item = itemAt(d->currentIndex);
+    Q_ASSERT(item);
+    item->setPosition(QPointF(0,0));    // ### respect alignment?
+    item->setSize(newSize.expandedTo(hints.min()).boundedTo(hints.max()));
+    QQuickLayout::rearrange(newSize);
+}
+
+void QQuickStackLayout::collectItemSizeHints(QQuickItem *item, QSizeF *sizeHints)
+{
+    QQuickLayoutAttached *info = 0;
+    QQuickLayout::effectiveSizeHints_helper(item, sizeHints, &info, true);
+    if (!info)
+        return;
+    if (info->isFillWidthSet() && !info->fillWidth()) {
+        const qreal pref = sizeHints[Qt::PreferredSize].width();
+        sizeHints[Qt::MinimumSize].setWidth(pref);
+        sizeHints[Qt::MaximumSize].setWidth(pref);
+    }
+
+    if (info->isFillHeightSet() && !info->fillHeight()) {
+        const qreal pref = sizeHints[Qt::PreferredSize].height();
+        sizeHints[Qt::MinimumSize].setHeight(pref);
+        sizeHints[Qt::MaximumSize].setHeight(pref);
+    }
+}
+
+bool QQuickStackLayout::shouldIgnoreItem(QQuickItem *item) const
+{
+    const bool ignored = QQuickItemPrivate::get(item)->isTransparentForPositioner();
+    if (ignored)
+        d_func()->m_ignoredItems << item;
+    return ignored;
+}
diff --git a/src/layouts/qquickstacklayout_p.h b/src/layouts/qquickstacklayout_p.h
new file mode 100644
index 000000000..921214002
--- /dev/null
+++ b/src/layouts/qquickstacklayout_p.h
@@ -0,0 +1,105 @@
+/****************************************************************************
+**
+** Copyright (C) 2015 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the Qt Quick Layouts module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** 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 The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/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 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later 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 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQUICKSTACKLAYOUT_H
+#define QQUICKSTACKLAYOUT_H
+
+#include <qquicklayout_p.h>
+
+class QQuickStackLayoutPrivate;
+
+class QQuickStackLayout : public QQuickLayout
+{
+    Q_OBJECT
+    Q_PROPERTY(int count READ count NOTIFY countChanged)
+    Q_PROPERTY(int currentIndex READ currentIndex WRITE setCurrentIndex NOTIFY currentIndexChanged)
+
+public:
+    explicit QQuickStackLayout(QQuickItem *parent = 0);
+    int count() const;
+    int currentIndex() const;
+    void setCurrentIndex(int index);
+
+    void componentComplete() Q_DECL_OVERRIDE;
+    QSizeF sizeHint(Qt::SizeHint whichSizeHint) const Q_DECL_OVERRIDE;
+    void setAlignment(QQuickItem *item, Qt::Alignment align)  Q_DECL_OVERRIDE;
+    void invalidate(QQuickItem *childItem = 0)  Q_DECL_OVERRIDE;
+    void updateLayoutItems()  Q_DECL_OVERRIDE;
+    void rearrange(const QSizeF &) Q_DECL_OVERRIDE;
+
+    // iterator
+    Q_INVOKABLE QQuickItem *itemAt(int index) const Q_DECL_OVERRIDE;
+    int itemCount() const Q_DECL_OVERRIDE;
+    int indexOf(QQuickItem *item) const;
+
+
+
+signals:
+    void currentIndexChanged();
+    void countChanged();
+
+public slots:
+
+private:
+    static void collectItemSizeHints(QQuickItem *item, QSizeF *sizeHints);
+    bool shouldIgnoreItem(QQuickItem *item) const;
+    Q_DECLARE_PRIVATE(QQuickStackLayout)
+
+    QList<QQuickItem*> m_items;
+
+    typedef struct {
+        inline QSizeF &min() { return array[Qt::MinimumSize]; }
+        inline QSizeF &pref() { return array[Qt::PreferredSize]; }
+        inline QSizeF &max() { return array[Qt::MaximumSize]; }
+        QSizeF array[Qt::NSizeHints];
+    } SizeHints;
+
+    mutable QVector<SizeHints> m_cachedItemSizeHints;
+    mutable QSizeF m_cachedSizeHints[Qt::NSizeHints];
+};
+
+class QQuickStackLayoutPrivate : public QQuickLayoutPrivate
+{
+    Q_DECLARE_PUBLIC(QQuickStackLayout)
+public:
+    QQuickStackLayoutPrivate() : count(0), currentIndex(-1), explicitCurrentIndex(false) {}
+private:
+    int count;
+    int currentIndex;
+    bool explicitCurrentIndex;
+};
+
+#endif // QQUICKSTACKLAYOUT_H