File indexing completed on 2024-04-28 15:27:43

 /*
  *  SPDX-FileCopyrightText: 2020 Carson Black <uhhadd@gmail.com>
  *
  *  SPDX-License-Identifier: LGPL-2.0-or-later
  */
 
 #include "pagerouter.h"
 #include "loggingcategory.h"
 #include <QJSEngine>
 #include <QJSValue>
 #include <QJsonObject>
 #include <QJsonValue>
 #include <QQmlProperty>
 #include <QQuickWindow>
 #include <QTimer>
 #include <qqmlpropertymap.h>
 
 ParsedRoute *parseRoute(QJSValue value)
 {
     if (value.isUndefined()) {
         return new ParsedRoute{};
     } else if (value.isString()) {
         return new ParsedRoute{value.toString(), QVariant()};
     } else {
         auto map = value.toVariant().value<QVariantMap>();
         map.remove(QStringLiteral("route"));
         map.remove(QStringLiteral("data"));
         return new ParsedRoute{value.property(QStringLiteral("route")).toString(), //
                                value.property(QStringLiteral("data")).toVariant(),
                                map,
                                false};
     }
 }
 
 QList<ParsedRoute *> parseRoutes(QJSValue values)
 {
     QList<ParsedRoute *> ret;
     if (values.isArray()) {
         const auto valuesList = values.toVariant().toList();
         for (const auto &route : valuesList) {
             if (route.toString() != QString()) {
                 ret << new ParsedRoute{route.toString(), QVariant(), QVariantMap(), false, nullptr};
             } else if (route.canConvert<QVariantMap>()) {
                 auto map = route.value<QVariantMap>();
                 auto copy = map;
                 copy.remove(QStringLiteral("route"));
                 copy.remove(QStringLiteral("data"));
 
                 ret << new ParsedRoute{map.value(QStringLiteral("route")).toString(), map.value(QStringLiteral("data")), copy, false, nullptr};
             }
         }
     } else {
         ret << parseRoute(values);
     }
     return ret;
 }
 
 PageRouter::PageRouter(QQuickItem *parent)
     : QObject(parent)
     , m_paramMap(new QQmlPropertyMap)
     , m_cache()
     , m_preload()
 {
     connect(this, &PageRouter::pageStackChanged, [=]() {
         connect(m_pageStack, &ColumnView::currentIndexChanged, this, &PageRouter::currentIndexChanged);
     });
 }
 
 QQmlListProperty<PageRoute> PageRouter::routes()
 {
     return QQmlListProperty<PageRoute>(this, nullptr, appendRoute, routeCount, route, clearRoutes);
 }
 
 void PageRouter::appendRoute(QQmlListProperty<PageRoute> *prop, PageRoute *route)
 {
     auto router = qobject_cast<PageRouter *>(prop->object);
     router->m_routes.append(route);
 }
 
 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
 int PageRouter::routeCount(QQmlListProperty<PageRoute> *prop)
 #else
 qsizetype PageRouter::routeCount(QQmlListProperty<PageRoute> *prop)
 #endif
 {
     auto router = qobject_cast<PageRouter *>(prop->object);
     return router->m_routes.length();
 }
 
 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
 PageRoute *PageRouter::route(QQmlListProperty<PageRoute> *prop, int index)
 #else
 PageRoute *PageRouter::route(QQmlListProperty<PageRoute> *prop, qsizetype index)
 #endif
 {
     auto router = qobject_cast<PageRouter *>(prop->object);
     return router->m_routes[index];
 }
 
 void PageRouter::clearRoutes(QQmlListProperty<PageRoute> *prop)
 {
     auto router = qobject_cast<PageRouter *>(prop->object);
     router->m_routes.clear();
 }
 
 PageRouter::~PageRouter()
 {
 }
 
 void PageRouter::classBegin()
 {
 }
 
 void PageRouter::componentComplete()
 {
     if (m_pageStack == nullptr) {
         qCCritical(KirigamiLog)
             << "PageRouter should be created with a ColumnView. Not doing so is undefined behaviour, and is likely to result in a crash upon further "
                "interaction.";
     } else {
         Q_EMIT pageStackChanged();
         m_currentRoutes.clear();
         push(parseRoute(initialRoute()));
     }
 }
 
 bool PageRouter::routesContainsKey(const QString &key) const
 {
     for (auto route : m_routes) {
         if (route->name() == key) {
             return true;
         }
     }
     return false;
 }
 
 QQmlComponent *PageRouter::routesValueForKey(const QString &key) const
 {
     for (auto route : m_routes) {
         if (route->name() == key) {
             return route->component();
         }
     }
     return nullptr;
 }
 
 bool PageRouter::routesCacheForKey(const QString &key) const
 {
     for (auto route : m_routes) {
         if (route->name() == key) {
             return route->cache();
         }
     }
     return false;
 }
 
 int PageRouter::routesCostForKey(const QString &key) const
 {
     for (auto route : m_routes) {
         if (route->name() == key) {
             return route->cost();
         }
     }
     return -1;
 }
 
 // It would be nice if this could surgically update the
 // param map instead of doing this brute force approach,
 // but this seems to work well enough, and prematurely
 // optimising stuff is pretty bad if it isn't found as
 // a performance bottleneck.
 void PageRouter::reevaluateParamMapProperties()
 {
     QStringList currentKeys;
 
     for (auto item : m_currentRoutes) {
         for (auto key : item->properties.keys()) {
             currentKeys << key;
 
             auto &value = item->properties[key];
             m_paramMap->insert(key, value);
         }
     }
 
     for (auto key : m_paramMap->keys()) {
         if (!currentKeys.contains(key)) {
             m_paramMap->clear(key);
         }
     }
 }
 
 void PageRouter::push(ParsedRoute *route)
 {
     Q_ASSERT(route);
     if (!routesContainsKey(route->name)) {
         qCCritical(KirigamiLog) << "Route" << route->name << "not defined";
         return;
     }
     if (routesCacheForKey(route->name)) {
         auto push = [route, this](ParsedRoute *item) {
             m_currentRoutes << item;
 
             for (auto it = route->properties.begin(); it != route->properties.end(); it++) {
                 item->item->setProperty(qUtf8Printable(it.key()), it.value());
                 item->properties[it.key()] = it.value();
             }
             reevaluateParamMapProperties();
 
             m_pageStack->addItem(item->item);
         };
         auto item = m_cache.take(qMakePair(route->name, route->hash()));
         if (item && item->item) {
             push(item);
             return;
         }
         item = m_preload.take(qMakePair(route->name, route->hash()));
         if (item && item->item) {
             push(item);
             return;
         }
     }
     auto context = qmlContext(this);
     auto component = routesValueForKey(route->name);
     auto createAndPush = [component, context, route, this]() {
         // We use beginCreate and completeCreate to allow
         // for a PageRouterAttached to find its parent
         // on construction time.
         auto item = component->beginCreate(context);
         if (item == nullptr) {
             return;
         }
         item->setParent(this);
         auto qqItem = qobject_cast<QQuickItem *>(item);
         if (!qqItem) {
             qCCritical(KirigamiLog) << "Route" << route->name << "is not an item! This is undefined behaviour and will likely crash your application.";
         }
         for (auto it = route->properties.begin(); it != route->properties.end(); it++) {
             qqItem->setProperty(qUtf8Printable(it.key()), it.value());
         }
         route->setItem(qqItem);
         route->cache = routesCacheForKey(route->name);
         m_currentRoutes << route;
         reevaluateParamMapProperties();
 
         auto attached = qobject_cast<PageRouterAttached *>(qmlAttachedPropertiesObject<PageRouter>(item, true));
         attached->m_router = this;
         component->completeCreate();
         m_pageStack->addItem(qqItem);
         m_pageStack->setCurrentIndex(m_currentRoutes.length() - 1);
     };
 
     if (component->status() == QQmlComponent::Ready) {
         createAndPush();
     } else if (component->status() == QQmlComponent::Loading) {
         connect(component, &QQmlComponent::statusChanged, [=](QQmlComponent::Status status) {
             // Loading can only go to Ready or Error.
             if (status != QQmlComponent::Ready) {
                 qCCritical(KirigamiLog) << "Failed to push route:" << component->errors();
             }
             createAndPush();
         });
     } else {
         qCCritical(KirigamiLog) << "Failed to push route:" << component->errors();
     }
 }
 
 QJSValue PageRouter::initialRoute() const
 {
     return m_initialRoute;
 }
 
 void PageRouter::setInitialRoute(QJSValue value)
 {
     m_initialRoute = value;
 }
 
 void PageRouter::navigateToRoute(QJSValue route)
 {
     auto incomingRoutes = parseRoutes(route);
     QList<ParsedRoute *> resolvedRoutes;
 
     if (incomingRoutes.length() <= m_currentRoutes.length()) {
         resolvedRoutes = m_currentRoutes.mid(0, incomingRoutes.length());
     } else {
         resolvedRoutes = m_currentRoutes;
         resolvedRoutes.reserve(incomingRoutes.length() - m_currentRoutes.length());
     }
 
     for (int i = 0; i < incomingRoutes.length(); i++) {
         auto incoming = incomingRoutes.at(i);
         Q_ASSERT(incoming);
         if (i >= resolvedRoutes.length()) {
             resolvedRoutes.append(incoming);
         } else {
             auto current = resolvedRoutes.value(i);
             Q_ASSERT(current);
             auto props = incoming->properties;
             if (current->name != incoming->name || current->data != incoming->data) {
                 resolvedRoutes.replace(i, incoming);
             }
             resolvedRoutes[i]->properties.clear();
             for (auto it = props.constBegin(); it != props.constEnd(); it++) {
                 resolvedRoutes[i]->properties.insert(it.key(), it.value());
             }
         }
     }
 
     for (const auto &route : std::as_const(m_currentRoutes)) {
         if (!resolvedRoutes.contains(route)) {
             placeInCache(route);
         }
     }
 
     m_pageStack->clear();
     m_currentRoutes.clear();
     for (auto toPush : std::as_const(resolvedRoutes)) {
         push(toPush);
     }
     reevaluateParamMapProperties();
     Q_EMIT navigationChanged();
 }
 
 void PageRouter::bringToView(QJSValue route)
 {
     if (route.isNumber()) {
         auto index = route.toNumber();
         m_pageStack->setCurrentIndex(index);
     } else {
         auto parsed = parseRoute(route);
         auto index = 0;
         for (auto currentRoute : std::as_const(m_currentRoutes)) {
             if (currentRoute->name == parsed->name && currentRoute->data == parsed->data) {
                 m_pageStack->setCurrentIndex(index);
                 return;
             }
             index++;
         }
         qCWarning(KirigamiLog) << "Route" << parsed->name << "with data" << parsed->data << "is not on the current stack of routes.";
     }
 }
 
 bool PageRouter::routeActive(QJSValue route)
 {
     auto parsed = parseRoutes(route);
     if (parsed.length() > m_currentRoutes.length()) {
         return false;
     }
     for (int i = 0; i < parsed.length(); i++) {
         if (parsed[i]->name != m_currentRoutes[i]->name) {
             return false;
         }
         if (parsed[i]->data.isValid()) {
             if (parsed[i]->data != m_currentRoutes[i]->data) {
                 return false;
             }
         }
     }
     return true;
 }
 
 void PageRouter::pushRoute(QJSValue route)
 {
     push(parseRoute(route));
     Q_EMIT navigationChanged();
 }
 
 void PageRouter::popRoute()
 {
     m_pageStack->pop(m_currentRoutes.last()->item);
     placeInCache(m_currentRoutes.last());
     m_currentRoutes.removeLast();
     reevaluateParamMapProperties();
     Q_EMIT navigationChanged();
 }
 
 QVariant PageRouter::dataFor(QObject *object)
 {
     auto pointer = object;
     auto qqiPointer = qobject_cast<QQuickItem *>(object);
     QHash<QQuickItem *, ParsedRoute *> routes;
     for (auto route : std::as_const(m_cache.items)) {
         routes[route->item] = route;
     }
     for (auto route : std::as_const(m_preload.items)) {
         routes[route->item] = route;
     }
     for (auto route : std::as_const(m_currentRoutes)) {
         routes[route->item] = route;
     }
     while (qqiPointer != nullptr) {
         const auto keys = routes.keys();
         for (auto item : keys) {
             if (item == qqiPointer) {
                 return routes[item]->data;
             }
         }
         qqiPointer = qqiPointer->parentItem();
     }
     while (pointer != nullptr) {
         const auto keys = routes.keys();
         for (auto item : keys) {
             if (item == pointer) {
                 return routes[item]->data;
             }
         }
         pointer = pointer->parent();
     }
     return QVariant();
 }
 
 bool PageRouter::isActive(QObject *object)
 {
     auto pointer = object;
     while (pointer != nullptr) {
         auto index = 0;
         for (auto route : std::as_const(m_currentRoutes)) {
             if (route->item == pointer) {
                 return m_pageStack->currentIndex() == index;
             }
             index++;
         }
         pointer = pointer->parent();
     }
     qCWarning(KirigamiLog) << "Object" << object << "not in current routes";
     return false;
 }
 
 PageRouterAttached *PageRouter::qmlAttachedProperties(QObject *object)
 {
     auto attached = new PageRouterAttached(object);
     return attached;
 }
 
 QSet<QObject *> flatParentTree(QObject *object)
 {
     // See below comment in Climber::climbObjectParents for why this is here.
     static const QMetaObject *metaObject = QMetaType::metaObjectForType(QMetaType::type("QQuickItem*"));
     QSet<QObject *> ret;
     // Use an inline struct type so that climbItemParents and climbObjectParents
     // can call each other
     struct Climber {
         void climbItemParents(QSet<QObject *> &out, QQuickItem *item)
         {
             auto parent = item->parentItem();
             while (parent != nullptr) {
                 out << parent;
                 climbObjectParents(out, parent);
                 parent = parent->parentItem();
             }
         }
         void climbObjectParents(QSet<QObject *> &out, QObject *object)
         {
             auto parent = object->parent();
             while (parent != nullptr) {
                 out << parent;
                 // We manually call metaObject()->inherits() and
                 // use a reinterpret cast because qobject_cast seems
                 // to have stability issues here due to mutable
                 // pointer mechanics.
                 if (parent->metaObject()->inherits(metaObject)) {
                     climbItemParents(out, reinterpret_cast<QQuickItem *>(parent));
                 }
                 parent = parent->parent();
             }
         }
     };
     Climber climber;
     if (qobject_cast<QQuickItem *>(object)) {
         climber.climbItemParents(ret, qobject_cast<QQuickItem *>(object));
     }
     climber.climbObjectParents(ret, object);
     return ret;
 }
 
 void PageRouter::preload(ParsedRoute *route)
 {
     for (auto preloaded : std::as_const(m_preload.items)) {
         if (preloaded->equals(route)) {
             delete route;
             return;
         }
     }
     if (!routesContainsKey(route->name)) {
         qCCritical(KirigamiLog) << "Route" << route->name << "not defined";
         delete route;
         return;
     }
     auto context = qmlContext(this);
     auto component = routesValueForKey(route->name);
     auto createAndCache = [component, context, route, this]() {
         auto item = component->beginCreate(context);
         item->setParent(this);
         auto qqItem = qobject_cast<QQuickItem *>(item);
         if (!qqItem) {
             qCCritical(KirigamiLog) << "Route" << route->name << "is not an item! This is undefined behaviour and will likely crash your application.";
         }
         for (auto it = route->properties.begin(); it != route->properties.end(); it++) {
             qqItem->setProperty(qUtf8Printable(it.key()), it.value());
         }
         route->setItem(qqItem);
         route->cache = routesCacheForKey(route->name);
         auto attached = qobject_cast<PageRouterAttached *>(qmlAttachedPropertiesObject<PageRouter>(item, true));
         attached->m_router = this;
         component->completeCreate();
         if (!route->cache) {
             qCCritical(KirigamiLog) << "Route" << route->name << "is being preloaded despite it not having caching enabled.";
             delete route;
             return;
         }
         auto string = route->name;
         auto hash = route->hash();
         m_preload.insert(qMakePair(string, hash), route, routesCostForKey(route->name));
     };
 
     if (component->status() == QQmlComponent::Ready) {
         createAndCache();
     } else if (component->status() == QQmlComponent::Loading) {
         connect(component, &QQmlComponent::statusChanged, [=](QQmlComponent::Status status) {
             // Loading can only go to Ready or Error.
             if (status != QQmlComponent::Ready) {
                 qCCritical(KirigamiLog) << "Failed to push route:" << component->errors();
             }
             createAndCache();
         });
     } else {
         qCCritical(KirigamiLog) << "Failed to push route:" << component->errors();
     }
 }
 
 void PageRouter::unpreload(ParsedRoute *route)
 {
     ParsedRoute *toDelete = nullptr;
     for (auto preloaded : std::as_const(m_preload.items)) {
         if (preloaded->equals(route)) {
             toDelete = preloaded;
         }
     }
     if (toDelete != nullptr) {
         m_preload.take(qMakePair(toDelete->name, toDelete->hash()));
         delete toDelete;
     }
     delete route;
 }
 
 void PreloadRouteGroup::handleChange()
 {
     if (!(m_parent->m_router)) {
         qCCritical(KirigamiLog) << "PreloadRouteGroup does not have a parent PageRouter";
         return;
     }
     auto r = m_parent->m_router;
     auto parsed = parseRoute(m_route);
     if (m_when) {
         r->preload(parsed);
     } else {
         r->unpreload(parsed);
     }
 }
 
 PreloadRouteGroup::~PreloadRouteGroup()
 {
     if (m_parent->m_router) {
         m_parent->m_router->unpreload(parseRoute(m_route));
     }
 }
 
 void PageRouterAttached::findParent()
 {
     QQuickItem *parent = qobject_cast<QQuickItem *>(this->parent());
     while (parent != nullptr) {
         auto attached = qobject_cast<PageRouterAttached *>(qmlAttachedPropertiesObject<PageRouter>(parent, false));
         if (attached != nullptr && attached->m_router != nullptr) {
             m_router = attached->m_router;
             Q_EMIT routerChanged();
             Q_EMIT dataChanged();
             Q_EMIT isCurrentChanged();
             Q_EMIT navigationChanged();
             break;
         }
         parent = parent->parentItem();
     }
 }
 
 void PageRouterAttached::navigateToRoute(QJSValue route)
 {
     if (m_router) {
         m_router->navigateToRoute(route);
     } else {
         qCCritical(KirigamiLog) << "PageRouterAttached does not have a parent PageRouter";
         return;
     }
 }
 
 bool PageRouterAttached::routeActive(QJSValue route)
 {
     if (m_router) {
         return m_router->routeActive(route);
     } else {
         qCCritical(KirigamiLog) << "PageRouterAttached does not have a parent PageRouter";
         return false;
     }
 }
 
 void PageRouterAttached::pushRoute(QJSValue route)
 {
     if (m_router) {
         m_router->pushRoute(route);
     } else {
         qCCritical(KirigamiLog) << "PageRouterAttached does not have a parent PageRouter";
         return;
     }
 }
 
 void PageRouterAttached::popRoute()
 {
     if (m_router) {
         m_router->popRoute();
     } else {
         qCCritical(KirigamiLog) << "PageRouterAttached does not have a parent PageRouter";
         return;
     }
 }
 
 void PageRouterAttached::bringToView(QJSValue route)
 {
     if (m_router) {
         m_router->bringToView(route);
     } else {
         qCCritical(KirigamiLog) << "PageRouterAttached does not have a parent PageRouter";
         return;
     }
 }
 
 QVariant PageRouterAttached::data() const
 {
     if (m_router) {
         return m_router->dataFor(parent());
     } else {
         qCCritical(KirigamiLog) << "PageRouterAttached does not have a parent PageRouter";
         return QVariant();
     }
 }
 
 bool PageRouterAttached::isCurrent() const
 {
     if (m_router) {
         return m_router->isActive(parent());
     } else {
         qCCritical(KirigamiLog) << "PageRouterAttached does not have a parent PageRouter";
         return false;
     }
 }
 
 bool PageRouterAttached::watchedRouteActive()
 {
     if (m_router) {
         return m_router->routeActive(m_watchedRoute);
     } else {
         qCCritical(KirigamiLog) << "PageRouterAttached does not have a parent PageRouter";
         return false;
     }
 }
 
 void PageRouterAttached::setWatchedRoute(QJSValue route)
 {
     m_watchedRoute = route;
     Q_EMIT watchedRouteChanged();
 }
 
 QJSValue PageRouterAttached::watchedRoute()
 {
     return m_watchedRoute;
 }
 
 void PageRouterAttached::pushFromHere(QJSValue route)
 {
     if (m_router) {
         m_router->pushFromObject(parent(), route);
     } else {
         qCCritical(KirigamiLog) << "PageRouterAttached does not have a parent PageRouter";
     }
 }
 
 void PageRouterAttached::replaceFromHere(QJSValue route)
 {
     if (m_router) {
         m_router->pushFromObject(parent(), route, true);
     } else {
         qCCritical(KirigamiLog) << "PageRouterAttached does not have a parent PageRouter";
     }
 }
 
 void PageRouterAttached::popFromHere()
 {
     if (m_router) {
         m_router->pushFromObject(parent(), QJSValue());
     } else {
         qCCritical(KirigamiLog) << "PageRouterAttached does not have a parent PageRouter";
     }
 }
 
 void PageRouter::placeInCache(ParsedRoute *route)
 {
     Q_ASSERT(route);
     if (!route->cache) {
         delete route;
         return;
     }
     auto string = route->name;
     auto hash = route->hash();
     m_cache.insert(qMakePair(string, hash), route, routesCostForKey(route->name));
 }
 
 void PageRouter::pushFromObject(QObject *object, QJSValue inputRoute, bool replace)
 {
     const auto parsed = parseRoutes(inputRoute);
     const auto objects = flatParentTree(object);
 
     for (const auto &obj : objects) {
         bool popping = false;
         for (auto route : std::as_const(m_currentRoutes)) {
             if (popping) {
                 m_currentRoutes.removeAll(route);
                 reevaluateParamMapProperties();
                 placeInCache(route);
                 continue;
             }
             if (route->item == obj) {
                 m_pageStack->pop(route->item);
                 if (replace) {
                     m_currentRoutes.removeAll(route);
                     reevaluateParamMapProperties();
                     m_pageStack->removeItem(route->item);
                 }
                 popping = true;
             }
         }
         if (popping) {
             if (!inputRoute.isUndefined()) {
                 for (auto route : parsed) {
                     push(route);
                 }
             }
             Q_EMIT navigationChanged();
             return;
         }
     }
     qCWarning(KirigamiLog) << "Object" << object << "not in current routes";
 }
 
 QJSValue PageRouter::currentRoutes() const
 {
     auto engine = qjsEngine(this);
     auto ret = engine->newArray(m_currentRoutes.length());
     for (int i = 0; i < m_currentRoutes.length(); ++i) {
         auto object = engine->newObject();
         object.setProperty(QStringLiteral("route"), m_currentRoutes[i]->name);
         object.setProperty(QStringLiteral("data"), engine->toScriptValue(m_currentRoutes[i]->data));
         auto keys = m_currentRoutes[i]->properties.keys();
         for (auto key : keys) {
             object.setProperty(key, engine->toScriptValue(m_currentRoutes[i]->properties[key]));
         }
         ret.setProperty(i, object);
     }
     return ret;
 }
 
 PageRouterAttached::PageRouterAttached(QObject *parent)
     : QObject(parent)
     , m_preload(new PreloadRouteGroup(this))
 {
     findParent();
     auto item = qobject_cast<QQuickItem *>(parent);
     if (item != nullptr) {
         connect(item, &QQuickItem::windowChanged, this, [this]() {
             findParent();
         });
         connect(item, &QQuickItem::parentChanged, this, [this]() {
             findParent();
         });
     }
 }
 
 #include "moc_pagerouter.cpp"