File indexing completed on 2024-06-23 04:42:34

 // SPDX-FileCopyrightText: 2021 Waqar Ahmed <waqar.17a@gmail.com>
 // SPDX-License-Identifier: LGPL-2.0-or-later
 
 #include "actionsmodel.h"
 
 #include <KLocalizedString>
 
 #include <QAction>
 #include <QMenu>
 
 #include <unordered_set>
 
 KalCommandBarModel::KalCommandBarModel(QObject *parent)
     : QAbstractTableModel(parent)
 {
 }
 
 void fillRows(QVector<KalCommandBarModel::Item> &rows, const QString &title, const QList<QAction *> &actions, std::unordered_set<QAction *> &uniqueActions)
 {
     for (const auto &action : actions) {
         // We don't want disabled actions
         if (!action->isEnabled()) {
             continue;
         }
 
         // Is this action actually a menu?
         if (auto menu = action->menu()) {
             auto menuActionList = menu->actions();
 
             // Empty? => Maybe the menu loads action on aboutToShow()?
             if (menuActionList.isEmpty()) {
                 Q_EMIT menu->aboutToShow();
                 menuActionList = menu->actions();
             }
 
             const QString menuTitle = menu->title();
             fillRows(rows, menuTitle, menuActionList, uniqueActions);
             continue;
         }
 
         if (uniqueActions.insert(action).second) {
             rows.push_back(KalCommandBarModel::Item{title, action, -1});
         }
     }
 }
 
 void KalCommandBarModel::refresh(const QVector<ActionGroup> &actionGroups)
 {
     int totalActions = std::accumulate(actionGroups.begin(), actionGroups.end(), 0, [](int a, const ActionGroup &ag) {
         return a + ag.actions.count();
     });
 
     QVector<Item> temp_rows;
     std::unordered_set<QAction *> uniqueActions;
     temp_rows.reserve(totalActions);
     int actionGroupIdx = 0;
     for (const auto &ag : actionGroups) {
         const auto &agActions = ag.actions;
         fillRows(temp_rows, ag.name, agActions, uniqueActions);
 
         actionGroupIdx++;
     }
 
     /**
      * For each action in last triggered actions,
      *  - Find it in the actions
      *  - Use the score variable to set its score
      *
      * Items in m_lastTriggered are stored in descending order
      * by their usage i.e., the first item in the vector is the most
      * recently invoked action.
      *
      * Here we traverse them in reverse order, i.e., from least recent to
      * most recent and then assign a score to them in a way that most recent
      * ends up having the highest score. Thus when proxy model does the sorting
      * later, most recent item will end up on the top
      */
     int score = 0;
     std::for_each(m_lastTriggered.crbegin(), m_lastTriggered.crend(), [&score, &temp_rows](const QString &act) {
         auto it = std::find_if(temp_rows.begin(), temp_rows.end(), [act](const KalCommandBarModel::Item &i) {
             return i.action->text() == act;
         });
         if (it != temp_rows.end()) {
             it->score = score++;
         }
     });
 
     beginResetModel();
     m_rows = std::move(temp_rows);
     endResetModel();
 }
 
 QVariant KalCommandBarModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid()) {
         return {};
     }
 
     const auto &entry = m_rows[index.row()];
     const int col = index.column();
 
     switch (role) {
     case Qt::DisplayRole:
         if (col == 0) {
             QString groupName = KLocalizedString::removeAcceleratorMarker(entry.groupName);
             QString actionText = KLocalizedString::removeAcceleratorMarker(entry.action->text());
             return QString(groupName + QStringLiteral(": ") + actionText);
         } else {
             return entry.action->shortcut().toString();
         }
     case ShortcutRole:
         return entry.action->shortcut().toString();
     case Qt::DecorationRole:
         if (col == 0) {
             return entry.action->icon().name();
         }
         break;
     case Qt::TextAlignmentRole:
         if (col == 0) {
             return Qt::AlignLeft;
         } else {
             return Qt::AlignRight;
         }
     case Qt::UserRole: {
         return QVariant::fromValue(entry.action);
     }
     case Role::Score:
         return entry.score;
     }
 
     return {};
 }
 
 void KalCommandBarModel::actionTriggered(const QString &name)
 {
     if (m_lastTriggered.size() == 6) {
         m_lastTriggered.pop_back();
     }
     m_lastTriggered.push_front(name);
 }
 
 QStringList KalCommandBarModel::lastUsedActions() const
 {
     return m_lastTriggered;
 }
 
 void KalCommandBarModel::setLastUsedActions(const QStringList &actionNames)
 {
     m_lastTriggered = actionNames;
 
     while (m_lastTriggered.size() > 6) {
         m_lastTriggered.pop_back();
     }
 }
 
 QHash<int, QByteArray> KalCommandBarModel::roleNames() const
 {
     auto roles = QAbstractTableModel::roleNames();
     roles[Qt::UserRole] = QByteArrayLiteral("action");
     roles[Score] = QByteArrayLiteral("score");
     roles[ShortcutRole] = QByteArrayLiteral("shortcut");
     return roles;
 }