File indexing completed on 2024-12-22 05:13:39

 /*
     SPDX-FileCopyrightText: 2012-2016 Ivan Cukic <ivan.cukic(at)kde.org>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 // Self
 #include "activitiesmodel.h"
 #include "activitiesmodel_p.h"
 
 // Qt
 #include <QByteArray>
 #include <QDBusPendingCall>
 #include <QDBusPendingCallWatcher>
 #include <QDebug>
 #include <QFutureWatcher>
 #include <QHash>
 #include <QModelIndex>
 
 // Local
 #include "utils/remove_if.h"
 
 namespace KActivities
 {
 namespace Private
 {
 template<typename _Container>
 struct ActivityPosition {
     ActivityPosition()
         : isValid(false)
         , index(0)
         , iterator()
     {
     }
 
     ActivityPosition(unsigned int index, typename _Container::const_iterator iterator)
         : isValid(true)
         , index(index)
         , iterator(iterator)
     {
     }
 
     operator bool() const
     {
         return isValid;
     }
 
     const bool isValid;
     const unsigned int index;
     const typename _Container::const_iterator iterator;
 
     typedef typename _Container::value_type ContainerElement;
 };
 
 /**
  * Returns whether the activity has a desired state.
  * If the state is 0, returns true
  */
 template<typename T>
 inline bool matchingState(ActivitiesModelPrivate::InfoPtr activity, const T &states)
 {
     return states.empty() || states.contains(activity->state());
 }
 
 /**
  * Searches for the activity.
  * Returns an option(index, iterator) for the found activity.
  */
 template<typename _Container>
 inline ActivityPosition<_Container> activityPosition(const _Container &container, const QString &activityId)
 {
     auto position = std::find_if(container.begin(), container.end(), [&](const typename ActivityPosition<_Container>::ContainerElement &activity) {
         return activity->id() == activityId;
     });
 
     return (position != container.end()) ? ActivityPosition<_Container>(position - container.begin(), position) : ActivityPosition<_Container>();
 }
 
 /**
  * Notifies the model that an activity was updated
  */
 template<typename _Model, typename _Container>
 inline void emitActivityUpdated(_Model *model, const _Container &container, const QString &activity, int role)
 {
     auto position = Private::activityPosition(container, activity);
 
     if (position) {
         Q_EMIT model->q->dataChanged(model->q->index(position.index),
                                      model->q->index(position.index),
                                      role == Qt::DecorationRole ? QList<int>{role, ActivitiesModel::ActivityIconSource} : QList<int>{role});
     }
 }
 
 /**
  * Notifies the model that an activity was updated
  */
 template<typename _Model, typename _Container>
 inline void emitActivityUpdated(_Model *model, const _Container &container, QObject *activityInfo, int role)
 {
     const auto activity = static_cast<Info *>(activityInfo);
     emitActivityUpdated(model, container, activity->id(), role);
 }
 
 }
 
 ActivitiesModelPrivate::ActivitiesModelPrivate(ActivitiesModel *parent)
     : q(parent)
 {
 }
 
 ActivitiesModel::ActivitiesModel(QObject *parent)
     : QAbstractListModel(parent)
     , d(new ActivitiesModelPrivate(this))
 {
     // Initializing role names for qml
     connect(&d->activities, &Consumer::serviceStatusChanged, this, [this](Consumer::ServiceStatus status) {
         d->setServiceStatus(status);
     });
 
     connect(&d->activities, &Consumer::activityAdded, this, [this](const QString &activity) {
         d->onActivityAdded(activity);
     });
     connect(&d->activities, &Consumer::activityRemoved, this, [this](const QString &activity) {
         d->onActivityRemoved(activity);
     });
     connect(&d->activities, &Consumer::currentActivityChanged, this, [this](const QString &activity) {
         d->onCurrentActivityChanged(activity);
     });
 
     d->setServiceStatus(d->activities.serviceStatus());
 }
 
 ActivitiesModel::ActivitiesModel(QList<Info::State> shownStates, QObject *parent)
     : QAbstractListModel(parent)
     , d(new ActivitiesModelPrivate(this))
 {
     d->shownStates = shownStates;
 
     // Initializing role names for qml
     connect(&d->activities, &Consumer::serviceStatusChanged, this, [this](Consumer::ServiceStatus status) {
         d->setServiceStatus(status);
     });
 
     connect(&d->activities, &Consumer::activityAdded, this, [this](const QString &activity) {
         d->onActivityAdded(activity);
     });
     connect(&d->activities, &Consumer::activityRemoved, this, [this](const QString &activity) {
         d->onActivityRemoved(activity);
     });
     connect(&d->activities, &Consumer::currentActivityChanged, this, [this](const QString &activity) {
         d->onCurrentActivityChanged(activity);
     });
 
     d->setServiceStatus(d->activities.serviceStatus());
 }
 
 ActivitiesModel::~ActivitiesModel() = default;
 
 QHash<int, QByteArray> ActivitiesModel::roleNames() const
 {
     return {{ActivityName, "name"},
             {ActivityState, "state"},
             {ActivityId, "id"},
             {ActivityIconSource, "iconSource"},
             {ActivityDescription, "description"},
             {ActivityBackground, "background"},
             {ActivityIsCurrent, "isCurrent"}};
 }
 
 void ActivitiesModelPrivate::setServiceStatus(Consumer::ServiceStatus)
 {
     replaceActivities(activities.activities());
 }
 
 void ActivitiesModelPrivate::replaceActivities(const QStringList &activities)
 {
     q->beginResetModel();
 
     knownActivities.clear();
     shownActivities.clear();
 
     for (const QString &activity : activities) {
         onActivityAdded(activity, false);
     }
 
     q->endResetModel();
 }
 
 void ActivitiesModelPrivate::onActivityAdded(const QString &id, bool notifyClients)
 {
     auto info = registerActivity(id);
 
     showActivity(info, notifyClients);
 }
 
 void ActivitiesModelPrivate::onActivityRemoved(const QString &id)
 {
     hideActivity(id);
     unregisterActivity(id);
 }
 
 void ActivitiesModelPrivate::onCurrentActivityChanged(const QString &id)
 {
     Q_UNUSED(id);
 
     for (const auto &activity : shownActivities) {
         Private::emitActivityUpdated(this, shownActivities, activity->id(), ActivitiesModel::ActivityIsCurrent);
     }
 }
 
 ActivitiesModelPrivate::InfoPtr ActivitiesModelPrivate::registerActivity(const QString &id)
 {
     auto position = Private::activityPosition(knownActivities, id);
 
     if (position) {
         return *(position.iterator);
 
     } else {
         auto activityInfo = std::make_shared<Info>(id);
 
         auto ptr = activityInfo.get();
 
         connect(ptr, &Info::nameChanged, this, &ActivitiesModelPrivate::onActivityNameChanged);
         connect(ptr, &Info::descriptionChanged, this, &ActivitiesModelPrivate::onActivityDescriptionChanged);
         connect(ptr, &Info::iconChanged, this, &ActivitiesModelPrivate::onActivityIconChanged);
         connect(ptr, &Info::stateChanged, this, &ActivitiesModelPrivate::onActivityStateChanged);
 
         knownActivities.insert(InfoPtr(activityInfo));
 
         return activityInfo;
     }
 }
 
 void ActivitiesModelPrivate::unregisterActivity(const QString &id)
 {
     auto position = Private::activityPosition(knownActivities, id);
 
     if (position) {
         if (auto shown = Private::activityPosition(shownActivities, id)) {
             q->beginRemoveRows(QModelIndex(), shown.index, shown.index);
             shownActivities.removeAt(shown.index);
             q->endRemoveRows();
         }
 
         knownActivities.removeAt(position.index);
     }
 }
 
 void ActivitiesModelPrivate::showActivity(InfoPtr activityInfo, bool notifyClients)
 {
     // Should it really be shown?
     if (!Private::matchingState(activityInfo, shownStates)) {
         return;
     }
 
     // Is it already shown?
     if (std::binary_search(shownActivities.cbegin(), shownActivities.cend(), activityInfo, InfoPtrComparator())) {
         return;
     }
 
     auto registeredPosition = Private::activityPosition(knownActivities, activityInfo->id());
 
     if (!registeredPosition) {
         qDebug() << "Got a request to show an unknown activity, ignoring";
         return;
     }
 
     const auto activityInfoPtr = *(registeredPosition.iterator);
 
     // In C++17, this would be:
     // const auto [iterator, index, found] = shownActivities.insert(...);
     const auto _result = shownActivities.insert(activityInfoPtr);
     // const auto iterator = std::get<0>(_result);
     const auto index = std::get<1>(_result);
 
     if (notifyClients) {
         q->beginInsertRows(QModelIndex(), index, index);
         q->endInsertRows();
     }
 }
 
 void ActivitiesModelPrivate::hideActivity(const QString &id)
 {
     auto position = Private::activityPosition(shownActivities, id);
 
     if (position) {
         q->beginRemoveRows(QModelIndex(), position.index, position.index);
         shownActivities.removeAt(position.index);
         q->endRemoveRows();
     }
 }
 
 // clang-format off
 #define CREATE_SIGNAL_EMITTER(What,Role)                                      \
     void ActivitiesModelPrivate::onActivity##What##Changed(const QString &)    \
     {                                                                          \
         Private::emitActivityUpdated(this, shownActivities, sender(), Role);   \
     }
 // clang-format on
 
 CREATE_SIGNAL_EMITTER(Name, Qt::DisplayRole)
 CREATE_SIGNAL_EMITTER(Description, ActivitiesModel::ActivityDescription)
 CREATE_SIGNAL_EMITTER(Icon, Qt::DecorationRole)
 
 #undef CREATE_SIGNAL_EMITTER
 
 void ActivitiesModelPrivate::onActivityStateChanged(Info::State state)
 {
     if (shownStates.empty()) {
         Private::emitActivityUpdated(this, shownActivities, sender(), ActivitiesModel::ActivityState);
 
     } else {
         auto info = findActivity(sender());
 
         if (!info) {
             return;
         }
 
         if (shownStates.contains(state)) {
             showActivity(info, true);
         } else {
             hideActivity(info->id());
         }
     }
 }
 
 void ActivitiesModel::setShownStates(const QList<Info::State> &states)
 {
     d->shownStates = states;
 
     d->replaceActivities(d->activities.activities());
 
     Q_EMIT shownStatesChanged(states);
 }
 
 QList<Info::State> ActivitiesModel::shownStates() const
 {
     return d->shownStates;
 }
 
 int ActivitiesModel::rowCount(const QModelIndex &parent) const
 {
     if (parent.isValid()) {
         return 0;
     }
 
     return d->shownActivities.size();
 }
 
 QVariant ActivitiesModel::data(const QModelIndex &index, int role) const
 {
     const int row = index.row();
     const auto &item = d->shownActivities.at(row);
 
     switch (role) {
     case Qt::DisplayRole:
     case ActivityName:
         return item->name();
 
     case ActivityId:
         return item->id();
 
     case ActivityState:
         return item->state();
 
     case Qt::DecorationRole:
     case ActivityIconSource: {
         const QString &icon = item->icon();
 
         // We need a default icon for activities
         return icon.isEmpty() ? QStringLiteral("activities") : icon;
     }
 
     case ActivityDescription:
         return item->description();
 
     case ActivityIsCurrent:
         return d->activities.currentActivity() == item->id();
 
     default:
         return QVariant();
     }
 }
 
 QVariant ActivitiesModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     Q_UNUSED(section);
     Q_UNUSED(orientation);
     Q_UNUSED(role);
 
     return QVariant();
 }
 
 ActivitiesModelPrivate::InfoPtr ActivitiesModelPrivate::findActivity(QObject *ptr) const
 {
     auto info = std::find_if(knownActivities.cbegin(), knownActivities.cend(), [ptr](const InfoPtr &info) {
         return ptr == info.get();
     });
 
     if (info == knownActivities.end()) {
         return nullptr;
     } else {
         return *info;
     }
 }
 
 } // namespace KActivities
 
 #include "moc_activitiesmodel.cpp"
 #include "moc_activitiesmodel_p.cpp"