qquickstackview.cpp

Go to the documentation of this file.

// Copyright (C) 2017 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qquickstackview_p.h"
#include "qquickstackview_p_p.h"
#include "qquickstackelement_p_p.h"
#if QT_CONFIG(quick_viewtransitions)
#include "qquickstacktransition_p_p.h"
#endif
 
#include <QtCore/qscopedvaluerollback.h>
#include <QtQml/qjsvalue.h>
#include <QtQml/qqmlengine.h>
#include <QtQml/qqmlinfo.h>
 
#include <private/qv4qobjectwrapper_p.h>
#include <private/qqmlengine_p.h>
 
QT_BEGIN_NAMESPACE
 
QQuickStackViewArg::QQuickStackViewArg(QQuickItem *item)
    : mItem(item)
{
}
 
QQuickStackViewArg::QQuickStackViewArg(const QUrl &url)
    : mUrl(url)
{
}
 
QQuickStackViewArg::QQuickStackViewArg(QQmlComponent *component)
    : mComponent(component)
{
}
 
QQuickStackViewArg::QQuickStackViewArg(const QVariantMap &properties)
    : mProperties(properties)
{
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug debug, const QQuickStackViewArg &arg)
{
    QDebugStateSaver saver(debug);
    debug.nospace() << "QQuickStackViewArg("
        << "mItem=" << arg.mItem
        << " mComponent=" << arg.mComponent
        << " mUrl=" << arg.mUrl
        << ")";
    return debug;
}
#endif
 
 
QQuickStackView::QQuickStackView(QQuickItem *parent)
    : QQuickControl(*(new QQuickStackViewPrivate), parent)
{
    setFlag(ItemIsFocusScope);
}
 
QQuickStackView::~QQuickStackView()
{
    Q_D(QQuickStackView);
#if QT_CONFIG(quick_viewtransitions)
    if (d->transitioner) {
        d->transitioner->setChangeListener(nullptr);
        delete d->transitioner;
    }
#endif
    qDeleteAll(d->removing);
    qDeleteAll(d->removed);
    qDeleteAll(d->elements);
}
 
QQuickStackViewAttached *QQuickStackView::qmlAttachedProperties(QObject *object)
{
    return new QQuickStackViewAttached(object);
}
 
bool QQuickStackView::isBusy() const
{
    Q_D(const QQuickStackView);
    return d->busy;
}
 
int QQuickStackView::depth() const
{
    Q_D(const QQuickStackView);
    return d->elements.size();
}
 
QQuickItem *QQuickStackView::currentItem() const
{
    Q_D(const QQuickStackView);
    return d->currentItem;
}
 
QQuickItem *QQuickStackView::get(int index, LoadBehavior behavior)
{
    Q_D(QQuickStackView);
    QQuickStackElement *element = d->elements.value(index);
    if (element) {
        if (behavior == ForceLoad)
            element->load(this);
        return element->item;
    }
    return nullptr;
}
 
QQuickItem *QQuickStackView::find(const QJSValue &callback, LoadBehavior behavior)
{
    Q_D(QQuickStackView);
    QJSValue func(callback);
    QQmlEngine *engine = qmlEngine(this);
    if (!engine || !func.isCallable()) // TODO: warning?
        return nullptr;
 
    for (int i = d->elements.size() - 1; i >= 0; --i) {
        QQuickStackElement *element = d->elements.at(i);
        if (behavior == ForceLoad)
            element->load(this);
        if (element->item) {
            QJSValue rv = func.call(QJSValueList() << engine->newQObject(element->item) << i);
            if (rv.toBool())
                return element->item;
        }
    }
 
    return nullptr;
}
 
void QQuickStackView::push(QQmlV4Function *args)
{
    Q_D(QQuickStackView);
    const QString operationName = QStringLiteral("push");
    if (d->modifyingElements) {
        d->warnOfInterruption(operationName);
        return;
    }
 
    QScopedValueRollback<bool> modifyingElements(d->modifyingElements, true);
    QScopedValueRollback<QString> operationNameRollback(d->operation, operationName);
    if (args->length() <= 0) {
        d->warn(QStringLiteral("missing arguments"));
        args->setReturnValue(QV4::Encode::null());
        return;
    }
 
    QV4::ExecutionEngine *v4 = args->v4engine();
    QV4::Scope scope(v4);
 
#if QT_CONFIG(quick_viewtransitions)
    Operation operation = d->elements.isEmpty() ? Immediate : PushTransition;
    QV4::ScopedValue lastArg(scope, (*args)[args->length() - 1]);
    if (lastArg->isInt32())
        operation = static_cast<Operation>(lastArg->toInt32());
#endif
 
    QStringList errors;
    QList<QQuickStackElement *> elements = d->parseElements(0, args, &errors);
    // Remove any items that are already in the stack, as they can't be in two places at once.
    // not using erase_if, as we have to delete the elements first
    auto removeIt = std::remove_if(elements.begin(), elements.end(), [&](QQuickStackElement *element) {
        return element->item && d->findElement(element->item);
    });
    for (auto it = removeIt, end = elements.end(); it != end; ++it)
        delete *it;
    elements.erase(removeIt, elements.end());
 
    if (!errors.isEmpty() || elements.isEmpty()) {
        if (!errors.isEmpty()) {
            for (const QString &error : std::as_const(errors))
                d->warn(error);
        } else {
            d->warn(QStringLiteral("nothing to push"));
        }
        args->setReturnValue(QV4::Encode::null());
        return;
    }
 
#if QT_CONFIG(quick_viewtransitions)
    QQuickStackElement *exit = nullptr;
    if (!d->elements.isEmpty())
        exit = d->elements.top();
#endif
 
    int oldDepth = d->elements.size();
    if (d->pushElements(elements)) {
        d->depthChange(d->elements.size(), oldDepth);
        QQuickStackElement *enter = d->elements.top();
#if QT_CONFIG(quick_viewtransitions)
        d->startTransition(QQuickStackTransition::pushEnter(operation, enter, this),
                           QQuickStackTransition::pushExit(operation, exit, this),
                           operation == Immediate);
#endif
        d->setCurrentItem(enter);
    }
 
    if (d->currentItem) {
        QV4::ScopedValue rv(scope, QV4::QObjectWrapper::wrap(v4, d->currentItem));
        args->setReturnValue(rv->asReturnedValue());
    } else {
        args->setReturnValue(QV4::Encode::null());
    }
}
 
void QQuickStackView::pop(QQmlV4Function *args)
{
    Q_D(QQuickStackView);
    const QString operationName = QStringLiteral("pop");
    if (d->modifyingElements) {
        d->warnOfInterruption(operationName);
        args->setReturnValue(QV4::Encode::null());
        return;
    }
 
    QScopedValueRollback<bool> modifyingElements(d->modifyingElements, true);
    QScopedValueRollback<QString> operationNameRollback(d->operation, operationName);
    int argc = args->length();
    if (d->elements.size() <= 1 || argc > 2) {
        if (argc > 2)
            d->warn(QStringLiteral("too many arguments"));
        args->setReturnValue(QV4::Encode::null());
        return;
    }
 
    int oldDepth = d->elements.size();
    QQuickStackElement *exit = d->elements.pop();
    QQuickStackElement *enter = d->elements.top();
 
    QV4::ExecutionEngine *v4 = args->v4engine();
    QV4::Scope scope(v4);
 
    if (argc > 0) {
        QV4::ScopedValue value(scope, (*args)[0]);
        if (value->isNull()) {
            enter = d->elements.value(0);
        } else if (const QV4::QObjectWrapper *o = value->as<QV4::QObjectWrapper>()) {
            QQuickItem *item = qobject_cast<QQuickItem *>(o->object());
            enter = d->findElement(item);
            if (!enter) {
                if (item != d->currentItem)
                    d->warn(QStringLiteral("can't find item to pop: ") + value->toQString());
                args->setReturnValue(QV4::Encode::null());
                d->elements.push(exit); // restore
                return;
            }
        }
    }
 
#if QT_CONFIG(quick_viewtransitions)
    Operation operation = PopTransition;
    if (argc > 0) {
        QV4::ScopedValue lastArg(scope, (*args)[argc - 1]);
        if (lastArg->isInt32())
            operation = static_cast<Operation>(lastArg->toInt32());
    }
#endif
 
    QQuickItem *previousItem = nullptr;
 
    if (d->popElements(enter)) {
        if (exit) {
            exit->removal = true;
            d->removing.insert(exit);
            previousItem = exit->item;
        }
        d->depthChange(d->elements.size(), oldDepth);
#if QT_CONFIG(quick_viewtransitions)
        d->startTransition(QQuickStackTransition::popExit(operation, exit, this),
                           QQuickStackTransition::popEnter(operation, enter, this),
                           operation == Immediate);
#endif
        d->setCurrentItem(enter);
    }
 
    if (previousItem) {
        QV4::ScopedValue rv(scope, QV4::QObjectWrapper::wrap(v4, previousItem));
        args->setReturnValue(rv->asReturnedValue());
    } else {
        args->setReturnValue(QV4::Encode::null());
    }
}
 
void QQuickStackView::replace(QQmlV4Function *args)
{
    Q_D(QQuickStackView);
    const QString operationName = QStringLiteral("replace");
    if (d->modifyingElements) {
        d->warnOfInterruption(operationName);
        args->setReturnValue(QV4::Encode::null());
        return;
    }
 
    QScopedValueRollback<bool> modifyingElements(d->modifyingElements, true);
    QScopedValueRollback<QString> operationNameRollback(d->operation, operationName);
    if (args->length() <= 0) {
        d->warn(QStringLiteral("missing arguments"));
        args->setReturnValue(QV4::Encode::null());
        return;
    }
 
    QV4::ExecutionEngine *v4 = args->v4engine();
    QV4::Scope scope(v4);
 
#if QT_CONFIG(quick_viewtransitions)
    Operation operation = d->elements.isEmpty() ? Immediate : ReplaceTransition;
    QV4::ScopedValue lastArg(scope, (*args)[args->length() - 1]);
    if (lastArg->isInt32())
        operation = static_cast<Operation>(lastArg->toInt32());
#endif
 
    QQuickStackElement *target = nullptr;
    QV4::ScopedValue firstArg(scope, (*args)[0]);
    if (firstArg->isNull())
        target = d->elements.value(0);
    else if (!firstArg->isInt32())
        target = d->findElement(firstArg);
 
    QStringList errors;
    QList<QQuickStackElement *> elements = d->parseElements(target ? 1 : 0, args, &errors);
    if (!errors.isEmpty() || elements.isEmpty()) {
        if (!errors.isEmpty()) {
            for (const QString &error : std::as_const(errors))
                d->warn(error);
        } else {
            d->warn(QStringLiteral("nothing to push"));
        }
        args->setReturnValue(QV4::Encode::null());
        return;
    }
 
    int oldDepth = d->elements.size();
    QQuickStackElement* exit = nullptr;
    if (!d->elements.isEmpty())
        exit = d->elements.pop();
 
    if (exit != target ? d->replaceElements(target, elements) : d->pushElements(elements)) {
        d->depthChange(d->elements.size(), oldDepth);
        if (exit) {
            exit->removal = true;
            d->removing.insert(exit);
        }
        QQuickStackElement *enter = d->elements.top();
#if QT_CONFIG(quick_viewtransitions)
        d->startTransition(QQuickStackTransition::replaceExit(operation, exit, this),
                           QQuickStackTransition::replaceEnter(operation, enter, this),
                           operation == Immediate);
#endif
        d->setCurrentItem(enter);
    }
 
    if (d->currentItem) {
        QV4::ScopedValue rv(scope, QV4::QObjectWrapper::wrap(v4, d->currentItem));
        args->setReturnValue(rv->asReturnedValue());
    } else {
        args->setReturnValue(QV4::Encode::null());
    }
}
 
QQuickItem *QQuickStackView::pushItems(QList<QQuickStackViewArg> args, Operation operation)
{
    Q_D(QQuickStackView);
    const QString operationName = QStringLiteral("pushItem");
    if (d->modifyingElements) {
        d->warnOfInterruption(operationName);
        return nullptr;
    }
 
    QScopedValueRollback<bool> modifyingElements(d->modifyingElements, true);
    QScopedValueRollback<QString> operationNameRollback(d->operation, operationName);
 
    const QList<QQuickStackElement *> stackElements = d->parseElements(args);
 
#if QT_CONFIG(quick_viewtransitions)
    QQuickStackElement *exit = nullptr;
    if (!d->elements.isEmpty())
        exit = d->elements.top();
#endif
 
    const int oldDepth = d->elements.size();
    if (d->pushElements(stackElements)) {
        d->depthChange(d->elements.size(), oldDepth);
        QQuickStackElement *enter = d->elements.top();
#if QT_CONFIG(quick_viewtransitions)
        d->startTransition(QQuickStackTransition::pushEnter(operation, enter, this),
            QQuickStackTransition::pushExit(operation, exit, this),
            operation == Immediate);
#endif
        d->setCurrentItem(enter);
    }
 
    return d->currentItem;
}
 
QQuickItem *QQuickStackView::pushItem(QQuickItem *item, const QVariantMap &properties, Operation operation)
{
    return pushItems({ item, properties }, operation);
}
 
QQuickItem *QQuickStackView::pushItem(QQmlComponent *component, const QVariantMap &properties, Operation operation)
{
    return pushItems({ component, properties }, operation);
}
 
QQuickItem *QQuickStackView::pushItem(const QUrl &url, const QVariantMap &properties, Operation operation)
{
    return pushItems({ url, properties }, operation);
}
 
QQuickItem *QQuickStackView::popToItem(QQuickItem *item, Operation operation)
{
    Q_D(QQuickStackView);
    return d->popToItem(item, operation, QQuickStackViewPrivate::CurrentItemPolicy::DoNotPop);
}
 
QQuickItem *QQuickStackView::popToIndex(int index, Operation operation)
{
    Q_D(QQuickStackView);
    if (index < 0 || index >= d->elements.size()) {
        d->warn(QString::fromLatin1("popToIndex: index %1 is out of bounds (%2 item(s))")
            .arg(index).arg(d->elements.size()));
        return nullptr;
    }
 
    if (index == d->elements.size() - 1) {
        // This would pop down to the current item, which is a no-op.
        return nullptr;
    }
 
    QQuickStackElement *element = d->elements.at(index);
    element->load(this);
    return d->popToItem(element->item, operation, QQuickStackViewPrivate::CurrentItemPolicy::Pop);
}
 
QQuickItem *QQuickStackView::popCurrentItem(Operation operation)
{
    Q_D(QQuickStackView);
    if (d->elements.size() == 1) {
        auto lastItemRemoved = d->elements.last()->item;
        clear(operation);
        return lastItemRemoved;
    }
    return d->popToItem(d->currentItem, operation, QQuickStackViewPrivate::CurrentItemPolicy::Pop);
}
 
QQuickItem *QQuickStackView::replaceCurrentItem(const QList<QQuickStackViewArg> &args,
    Operation operation)
{
    Q_D(QQuickStackView);
    const QString operationName = QStringLiteral("replace");
    if (d->modifyingElements) {
        d->warnOfInterruption(operationName);
        return nullptr;
    }
 
    QScopedValueRollback<bool> modifyingElements(d->modifyingElements, true);
    QScopedValueRollback<QString> operationNameRollback(d->operation, operationName);
 
    QQuickStackElement *currentElement = !d->elements.isEmpty() ? d->elements.top() : nullptr;
 
    const QList<QQuickStackElement *> stackElements = d->parseElements(args);
 
    int oldDepth = d->elements.size();
    QQuickStackElement* exit = nullptr;
    if (!d->elements.isEmpty())
        exit = d->elements.pop();
 
    const bool successfullyReplaced = exit != currentElement
        ? d->replaceElements(currentElement, stackElements)
        : d->pushElements(stackElements);
    if (successfullyReplaced) {
        d->depthChange(d->elements.size(), oldDepth);
        if (exit) {
            exit->removal = true;
            d->removing.insert(exit);
        }
        QQuickStackElement *enter = d->elements.top();
#if QT_CONFIG(quick_viewtransitions)
        d->startTransition(QQuickStackTransition::replaceExit(operation, exit, this),
            QQuickStackTransition::replaceEnter(operation, enter, this),
            operation == Immediate);
#endif
        d->setCurrentItem(enter);
    }
 
    return d->currentItem;
}
 
QQuickItem *QQuickStackView::replaceCurrentItem(QQuickItem *item, const QVariantMap &properties,
    Operation operation)
{
    const QList<QQuickStackViewArg> args = { QQuickStackViewArg(item), QQuickStackViewArg(properties) };
    return replaceCurrentItem(args, operation);
}
 
QQuickItem *QQuickStackView::replaceCurrentItem(QQmlComponent *component, const QVariantMap &properties,
    Operation operation)
{
    const QList<QQuickStackViewArg> args = { QQuickStackViewArg(component), QQuickStackViewArg(properties) };
    return replaceCurrentItem(args, operation);
}
 
QQuickItem *QQuickStackView::replaceCurrentItem(const QUrl &url, const QVariantMap &properties,
    Operation operation)
{
    const QList<QQuickStackViewArg> args = { QQuickStackViewArg(url), QQuickStackViewArg(properties) };
    return replaceCurrentItem(args, operation);
}
 
bool QQuickStackView::isEmpty() const
{
    Q_D(const QQuickStackView);
    return d->elements.isEmpty();
}
 
void QQuickStackView::clear(Operation operation)
{
#if !QT_CONFIG(quick_viewtransitions)
    Q_UNUSED(operation)
#endif
    Q_D(QQuickStackView);
    if (d->elements.isEmpty())
        return;
 
    const QString operationName = QStringLiteral("clear");
    if (d->modifyingElements) {
        d->warnOfInterruption(operationName);
        return;
    }
 
    const int oldDepth = d->elements.size();
 
    QScopedValueRollback<bool> modifyingElements(d->modifyingElements, true);
    QScopedValueRollback<QString> operationNameRollback(d->operation, operationName);
#if QT_CONFIG(quick_viewtransitions)
    if (operation != Immediate) {
        QQuickStackElement *exit = d->elements.pop();
        exit->removal = true;
        d->removing.insert(exit);
        d->startTransition(QQuickStackTransition::popExit(operation, exit, this),
                           QQuickStackTransition::popEnter(operation, nullptr, this), false);
    }
#endif
 
    d->setCurrentItem(nullptr);
    qDeleteAll(d->elements);
    d->elements.clear();
    d->depthChange(0, oldDepth);
}
 
QJSValue QQuickStackView::initialItem() const
{
    Q_D(const QQuickStackView);
    return d->initialItem;
}
 
void QQuickStackView::setInitialItem(const QJSValue &item)
{
    Q_D(QQuickStackView);
    d->initialItem = item;
}
 
#if QT_CONFIG(quick_viewtransitions)
QQuickTransition *QQuickStackView::popEnter() const
{
    Q_D(const QQuickStackView);
    if (d->transitioner)
        return d->transitioner->removeDisplacedTransition;
    return nullptr;
}
 
void QQuickStackView::setPopEnter(QQuickTransition *enter)
{
    Q_D(QQuickStackView);
    d->ensureTransitioner();
    if (d->transitioner->removeDisplacedTransition == enter)
        return;
 
    d->transitioner->removeDisplacedTransition = enter;
    emit popEnterChanged();
}
 
QQuickTransition *QQuickStackView::popExit() const
{
    Q_D(const QQuickStackView);
    if (d->transitioner)
        return d->transitioner->removeTransition;
    return nullptr;
}
 
void QQuickStackView::setPopExit(QQuickTransition *exit)
{
    Q_D(QQuickStackView);
    d->ensureTransitioner();
    if (d->transitioner->removeTransition == exit)
        return;
 
    d->transitioner->removeTransition = exit;
    emit popExitChanged();
}
 
QQuickTransition *QQuickStackView::pushEnter() const
{
    Q_D(const QQuickStackView);
    if (d->transitioner)
        return d->transitioner->addTransition;
    return nullptr;
}
 
void QQuickStackView::setPushEnter(QQuickTransition *enter)
{
    Q_D(QQuickStackView);
    d->ensureTransitioner();
    if (d->transitioner->addTransition == enter)
        return;
 
    d->transitioner->addTransition = enter;
    emit pushEnterChanged();
}
 
QQuickTransition *QQuickStackView::pushExit() const
{
    Q_D(const QQuickStackView);
    if (d->transitioner)
        return d->transitioner->addDisplacedTransition;
    return nullptr;
}
 
void QQuickStackView::setPushExit(QQuickTransition *exit)
{
    Q_D(QQuickStackView);
    d->ensureTransitioner();
    if (d->transitioner->addDisplacedTransition == exit)
        return;
 
    d->transitioner->addDisplacedTransition = exit;
    emit pushExitChanged();
}
 
QQuickTransition *QQuickStackView::replaceEnter() const
{
    Q_D(const QQuickStackView);
    if (d->transitioner)
        return d->transitioner->moveTransition;
    return nullptr;
}
 
void QQuickStackView::setReplaceEnter(QQuickTransition *enter)
{
    Q_D(QQuickStackView);
    d->ensureTransitioner();
    if (d->transitioner->moveTransition == enter)
        return;
 
    d->transitioner->moveTransition = enter;
    emit replaceEnterChanged();
}
 
QQuickTransition *QQuickStackView::replaceExit() const
{
    Q_D(const QQuickStackView);
    if (d->transitioner)
        return d->transitioner->moveDisplacedTransition;
    return nullptr;
}
 
void QQuickStackView::setReplaceExit(QQuickTransition *exit)
{
    Q_D(QQuickStackView);
    d->ensureTransitioner();
    if (d->transitioner->moveDisplacedTransition == exit)
        return;
 
    d->transitioner->moveDisplacedTransition = exit;
    emit replaceExitChanged();
}
#endif
 
void QQuickStackView::componentComplete()
{
    QQuickControl::componentComplete();
 
    Q_D(QQuickStackView);
    QScopedValueRollback<QString> operationNameRollback(d->operation, QStringLiteral("initialItem"));
    QQuickStackElement *element = nullptr;
    QString error;
    int oldDepth = d->elements.size();
    if (QObject *o = d->initialItem.toQObject())
        element = QQuickStackElement::fromObject(o, this, &error);
    else if (d->initialItem.isString())
        element = QQuickStackElement::fromString(d->initialItem.toString(), this, &error);
    if (!error.isEmpty()) {
        d->warn(error);
        delete element;
    } else if (d->pushElement(element)) {
        d->depthChange(d->elements.size(), oldDepth);
        d->setCurrentItem(element);
        element->setStatus(QQuickStackView::Active);
    }
}
 
void QQuickStackView::geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry)
{
    QQuickControl::geometryChange(newGeometry, oldGeometry);
 
    Q_D(QQuickStackView);
    for (QQuickStackElement *element : std::as_const(d->elements)) {
        if (element->item) {
            if (!element->widthValid)
                element->item->setWidth(newGeometry.width());
            if (!element->heightValid)
                element->item->setHeight(newGeometry.height());
        }
    }
}
 
bool QQuickStackView::childMouseEventFilter(QQuickItem *item, QEvent *event)
{
    // in order to block accidental user interaction while busy/transitioning,
    // StackView filters out childrens' mouse events. therefore we block all
    // press events. however, since push() may be called from signal handlers
    // such as onPressed or onDoubleClicked, we must let the current mouse
    // grabber item receive the respective mouse release event to avoid
    // breaking its state (QTBUG-50305).
    if (event->type() == QEvent::MouseButtonPress)
        return true;
    if (event->type() == QEvent::UngrabMouse)
        return false;
    QQuickWindow *window = item->window();
    return window && !window->mouseGrabberItem();
}
 
#if QT_CONFIG(quicktemplates2_multitouch)
void QQuickStackView::touchEvent(QTouchEvent *event)
{
    event->ignore(); // QTBUG-65084
}
#endif
 
#if QT_CONFIG(accessibility)
QAccessible::Role QQuickStackView::accessibleRole() const
{
    return QAccessible::LayeredPane;
}
#endif
 
void QQuickStackViewAttachedPrivate::itemParentChanged(QQuickItem *item, QQuickItem *parent)
{
    Q_Q(QQuickStackViewAttached);
    int oldIndex = element ? element->index : -1;
    QQuickStackView *oldView = element ? element->view : nullptr;
    QQuickStackView::Status oldStatus = element ? element->status : QQuickStackView::Inactive;
 
    QQuickStackView *newView = qobject_cast<QQuickStackView *>(parent);
    element = newView ? QQuickStackViewPrivate::get(newView)->findElement(item) : nullptr;
 
    int newIndex = element ? element->index : -1;
    QQuickStackView::Status newStatus = element ? element->status : QQuickStackView::Inactive;
 
    if (oldIndex != newIndex)
        emit q->indexChanged();
    if (oldView != newView)
        emit q->viewChanged();
    if (oldStatus != newStatus)
        emit q->statusChanged();
}
 
QQuickStackViewAttached::QQuickStackViewAttached(QObject *parent)
    : QObject(*(new QQuickStackViewAttachedPrivate), parent)
{
    Q_D(QQuickStackViewAttached);
    QQuickItem *item = qobject_cast<QQuickItem *>(parent);
    if (item) {
        connect(item, &QQuickItem::visibleChanged, this, &QQuickStackViewAttached::visibleChanged);
        QQuickItemPrivate::get(item)->addItemChangeListener(d, QQuickItemPrivate::Parent);
        d->itemParentChanged(item, item->parentItem());
    } else if (parent) {
        qmlWarning(parent) << "StackView must be attached to an Item";
    }
}
 
QQuickStackViewAttached::~QQuickStackViewAttached()
{
    Q_D(QQuickStackViewAttached);
    QQuickItem *parentItem = qobject_cast<QQuickItem *>(parent());
    if (parentItem)
        QQuickItemPrivate::get(parentItem)->removeItemChangeListener(d, QQuickItemPrivate::Parent);
}
 
int QQuickStackViewAttached::index() const
{
    Q_D(const QQuickStackViewAttached);
    return d->element ? d->element->index : -1;
}
 
QQuickStackView *QQuickStackViewAttached::view() const
{
    Q_D(const QQuickStackViewAttached);
    return d->element ? d->element->view : nullptr;
}
 
QQuickStackView::Status QQuickStackViewAttached::status() const
{
    Q_D(const QQuickStackViewAttached);
    return d->element ? d->element->status : QQuickStackView::Inactive;
}
 
bool QQuickStackViewAttached::isVisible() const
{
    const QQuickItem *parentItem = qobject_cast<QQuickItem *>(parent());
    return parentItem && parentItem->isVisible();
}
 
void QQuickStackViewAttached::setVisible(bool visible)
{
    Q_D(QQuickStackViewAttached);
    d->explicitVisible = true;
    QQuickItem *parentItem = qobject_cast<QQuickItem *>(parent());
    if (parentItem)
        parentItem->setVisible(visible);
}
 
void QQuickStackViewAttached::resetVisible()
{
    Q_D(QQuickStackViewAttached);
    d->explicitVisible = false;
    if (!d->element || !d->element->view)
        return;
 
    QQuickItem *parentItem = qobject_cast<QQuickItem *>(parent());
    if (parentItem)
        parentItem->setVisible(parentItem == d->element->view->currentItem());
}
 
QT_END_NAMESPACE
 
#include "moc_qquickstackview_p.cpp"