]> SALOME platform Git repositories - modules/gui.git/blob - src/SUIT/SUIT_FindActionDialog.cxx
Salome HOME
[bos #40644][CEA](2024-T1) Feature search.
[modules/gui.git] / src / SUIT / SUIT_FindActionDialog.cxx
1 // Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19
20 #include "SUIT_FindActionDialog.h"
21
22 #include <QAction>
23 #include <QWidget>
24 #include <QLayout>
25 #include <QList>
26 #include <QMap>
27 #include <QApplication>
28
29 #include <QCollator>
30
31 #include <QCheckBox>
32 #include <QLineEdit>
33 #include <QBrush>
34 #include <QColor>
35 #include <QHeaderView>
36 #include <QKeyEvent>
37
38 #include <algorithm>
39 #include <limits>
40
41
42 SUIT_FindActionDialog::SUIT_FindActionDialog(QWidget* theParent)
43 : QDialog(theParent)
44 {
45   setMinimumWidth(500);
46   setWindowTitle(tr("Find action"));
47   QVBoxLayout* layout = new QVBoxLayout(this);
48
49   myQueryLineEdit = new QLineEdit(this);
50   layout->addWidget(myQueryLineEdit);
51   myQueryLineEdit->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
52   setFocusProxy(myQueryLineEdit);
53
54   QHBoxLayout* searchOptionsLayout = new QHBoxLayout(this);
55   layout->addLayout(searchOptionsLayout);
56   myIncludeUnavailableActionsCB = new QCheckBox(tr("Unavailable actions"), this);
57   myIncludeUnavailableActionsCB->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
58   myIncludeUnavailableActionsCB->setCheckState(Qt::CheckState::Checked);
59   myActionSearcher.includeDisabledActions(true);
60   myIncludeInactiveModulesCB = new QCheckBox(tr("Inactive modules"), this);
61   myIncludeInactiveModulesCB->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
62   myIncludeInactiveModulesCB->setCheckState(Qt::CheckState::Unchecked);
63   searchOptionsLayout->addWidget(myIncludeUnavailableActionsCB);
64   searchOptionsLayout->addWidget(myIncludeInactiveModulesCB);
65
66   myFoundActionsTree = new SUIT_FoundActionTree(this);
67   layout->addWidget(myFoundActionsTree);
68
69   connect(myQueryLineEdit, SIGNAL(textChanged(const QString&)), this, SLOT(onQueryChanged(const QString&)));
70   connect(myIncludeUnavailableActionsCB, SIGNAL(stateChanged(int)), this, SLOT(onSearchOptionUnavailableActionsChanged(int)));
71   connect(myIncludeInactiveModulesCB, SIGNAL(stateChanged(int)), this, SLOT(onSearchOptionInactiveModulesChanged(int)));
72
73   myQueryLineEdit->installEventFilter(myFoundActionsTree);
74 }
75
76 void SUIT_FindActionDialog::setActiveModuleID(const QString& theModuleID)
77 {
78   myActiveModuleID = theModuleID;
79   if(myActionSearcher.setIncludedModuleIDs(std::set<QString>({SUIT_ShortcutMgr::ROOT_MODULE_ID, myActiveModuleID})))
80     updateUI();
81 }
82
83 void SUIT_FindActionDialog::onQueryChanged(const QString& theQuery)
84 {
85   if (myActionSearcher.setQuery(theQuery))
86     updateUI();
87 }
88
89 void SUIT_FindActionDialog::onSearchOptionUnavailableActionsChanged(int theState)
90 {
91   if (myActionSearcher.includeDisabledActions(theState == Qt::CheckState::Checked))
92     updateUI();
93 }
94
95 void SUIT_FindActionDialog::onSearchOptionInactiveModulesChanged(int theState)
96 {
97   bool resultsChanged = false;
98   if (theState == Qt::CheckState::Checked) {
99     myIncludeUnavailableActionsCB->setDisabled(true);
100     myIncludeUnavailableActionsCB->setCheckState(Qt::CheckState::Checked);
101     resultsChanged = myActionSearcher.setIncludedModuleIDs(SUIT_ShortcutMgr::get()->getShortcutContainer().getIDsOfAllModules());
102   }
103   else {
104     myIncludeUnavailableActionsCB->setDisabled(false);
105     resultsChanged = myActionSearcher.setIncludedModuleIDs(std::set<QString>({SUIT_ShortcutMgr::ROOT_MODULE_ID, myActiveModuleID}));
106   }
107
108   if (resultsChanged)
109     updateUI();
110 }
111
112 void SUIT_FindActionDialog::updateUI()
113 {
114   myFoundActionsTree->updateItems(myActionSearcher.getSearchResults());
115 }
116
117
118
119 SUIT_FoundActionTree::SUIT_FoundActionTree(SUIT_FindActionDialog* theParent)
120 : QTreeWidget(theParent)
121 {
122   setColumnCount(2);
123   setSelectionMode(QAbstractItemView::SingleSelection);
124   setSortingEnabled(false);
125   header()->setSectionResizeMode(QHeaderView::Interactive);
126   {
127     QMap<int, QString> labelMap;
128     labelMap[SUIT_FoundActionTree::ElementIdx::Name]    = SUIT_FindActionDialog::tr("Action");
129     labelMap[SUIT_FoundActionTree::ElementIdx::ToolTip] = SUIT_FindActionDialog::tr("Description");
130     setHeaderLabels(labelMap.values());
131   }
132   setExpandsOnDoubleClick(false); // Implemented manually.
133   setSizeAdjustPolicy(QAbstractScrollArea::AdjustToContents);
134   setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
135
136   setColumnWidth(SUIT_FoundActionTree::ElementIdx::Name, 120);
137   setColumnWidth(SUIT_FoundActionTree::ElementIdx::Name, 250);
138   setMinimumHeight(300);
139
140   setWindowFlags(windowFlags() | Qt::FramelessWindowHint);
141
142   mySortKey = SUIT_FoundActionTree::SortKey::MatchMetrics;
143   mySortOrder = SUIT_FoundActionTree::SortOrder::Ascending;
144
145   connect(this, SIGNAL(itemDoubleClicked(QTreeWidgetItem*, int)), this, SLOT(onItemExecuted(QTreeWidgetItem*, int)));
146 }
147
148 /*! \brief Compensates lack of std::distance(), which is introduced in C++17.
149 \returns -1, if theIt does not belong to the  */
150 template <class Container>
151 size_t indexOf(
152   const Container& theContainer,
153   const typename Container::iterator& theIt
154 ) {
155   auto it = theContainer.begin();
156   size_t distance = 0;
157   while (it != theContainer.end()) {
158     if (it == theIt)
159       return distance;
160
161     it++;
162     distance++;
163   }
164   return -1;
165 }
166
167 void SUIT_FoundActionTree::updateItems(const std::map<QString, std::map<QString, SUIT_ActionSearcher::AssetsAndSearchData>>& theAssets)
168 {
169   std::set<QString> shownModuleIDs; // To sort module-items by their IDs.
170
171   // Remove shown module items, if updated search results have no matching actions from these modules.
172   for (int moduleIdx = 0; moduleIdx < topLevelItemCount(); ) {
173     SUIT_FoundActionTreeModule* moduleItem = static_cast<SUIT_FoundActionTreeModule*>(topLevelItem(moduleIdx));
174     myModuleItemExpansionStates[moduleItem->myModuleID] = moduleItem->isExpanded();
175
176     const auto itUpdatedAssetsOfShownModule = theAssets.find(moduleItem->myModuleID);
177     if (itUpdatedAssetsOfShownModule == theAssets.end()) {
178       delete takeTopLevelItem(moduleIdx);
179       continue;
180     }
181
182     if (itUpdatedAssetsOfShownModule->second.empty()) {
183       delete takeTopLevelItem(moduleIdx);
184       continue;
185     }
186
187     shownModuleIDs.emplace(moduleItem->myModuleID);
188     moduleIdx++;
189   }
190
191   const auto shortcutMgr = SUIT_ShortcutMgr::get();
192   const QString lang = SUIT_ShortcutMgr::getLang();
193
194   SUIT_FoundActionTreeAction* preselectedActionItem = nullptr;
195
196   for (const auto& moduleIDAndAssets : theAssets) {
197     const QString& moduleID = moduleIDAndAssets.first;
198     const auto& moduleAssets = moduleIDAndAssets.second;
199     if (moduleAssets.empty())
200       continue;
201
202     const auto moduleItemAndIdx = findModuleItem(moduleID);
203     SUIT_FoundActionTreeModule* moduleItem = moduleItemAndIdx.first;
204     if (!moduleItem) {
205       moduleItem = new SUIT_FoundActionTreeModule(moduleID);
206       moduleItem->setAssetsAndSearchData(SUIT_ActionSearcher::AssetsAndSearchData(shortcutMgr->getModuleAssets(moduleID)), lang);
207
208       const auto emplaceRes = shownModuleIDs.emplace(moduleID);
209       insertTopLevelItem(indexOf(shownModuleIDs, emplaceRes.first), moduleItem);
210
211       moduleItem->setFlags(Qt::ItemIsEnabled);
212
213       const auto itExpansionState = myModuleItemExpansionStates.find(moduleID);
214       if (itExpansionState == myModuleItemExpansionStates.end())
215         moduleItem->setExpanded(true); // Make module item expanded at first appearance.
216       else
217         moduleItem->setExpanded(itExpansionState->second);
218     }
219     else /* if the tree has the module-item */ {
220       const auto actionItems = moduleItem->takeChildren();
221       for (const auto actionItem : actionItems) {
222         delete actionItem;
223       }
224     }
225
226     // Fill module item with action items.
227     auto sortedActionItems = createActionSetWithComparator();
228     for (const auto& actionIDAndAssets : moduleAssets) {
229       const QString& inModuleActionID = actionIDAndAssets.first;
230       const SUIT_ActionSearcher::AssetsAndSearchData& assetsAndSearchData = actionIDAndAssets.second;
231
232       auto actionItem = SUIT_FoundActionTreeAction::create(moduleID, inModuleActionID);
233       if (!actionItem) {
234         ShCutDbg("SUIT_FoundActionTree can't create child item for action ID = \"" + SUIT_ShortcutMgr::makeActionID(moduleID, inModuleActionID) + "\".");
235         continue;
236       }
237
238       actionItem->setAssetsAndSearchData(assetsAndSearchData, lang);
239       sortedActionItems.emplace(actionItem);
240     }
241
242     SUIT_FoundActionTreeAction* preselectedActionItemCand = nullptr;
243     for (const auto actionItem : sortedActionItems) {
244       moduleItem->addChild(actionItem);
245
246       // Consider first ranked available action in the module (if user did not collapsed it) as a candidate for preselected action.
247       if (!preselectedActionItemCand && moduleItem->isExpanded() && actionItem->isEnabledBufferedValue())
248         preselectedActionItemCand = actionItem;
249     }
250
251     if (preselectedActionItem) {
252       if (preselectedActionItemCand) {
253         if (preselectedActionItemCand->matchMetrics() < preselectedActionItem->matchMetrics())
254           preselectedActionItem = preselectedActionItemCand;
255       }
256     }
257     else
258       preselectedActionItem = preselectedActionItemCand;
259   }
260
261   if (preselectedActionItem)
262     setCurrentItem(preselectedActionItem);
263 }
264
265 void SUIT_FoundActionTree::sort(SUIT_FoundActionTree::SortKey theKey, SUIT_FoundActionTree::SortOrder theOrder)
266 {
267   if (theKey == mySortKey && theOrder == mySortOrder)
268     return;
269
270   mySortKey == theKey;
271   mySortOrder = theOrder;
272
273   for (int moduleIdx = 0; moduleIdx < topLevelItemCount(); moduleIdx++) {
274     const auto moduleItem = static_cast<SUIT_FoundActionTreeModule*>(topLevelItem(moduleIdx));
275
276     auto sortedActionItems = createActionSetWithComparator();
277     for (int childIdx = 0; childIdx < moduleItem->childCount(); childIdx++) {
278       SUIT_FoundActionTreeAction* const actionItem = static_cast<SUIT_FoundActionTreeAction*>(moduleItem->child(childIdx));
279       sortedActionItems.emplace(actionItem);
280     }
281
282     moduleItem->takeChildren();
283
284     for (const auto actionItem : sortedActionItems) {
285       moduleItem->addChild(actionItem);
286     }
287   }
288 }
289
290 void SUIT_FoundActionTree::keyPressEvent(QKeyEvent* theEvent)
291 {
292   const auto key = theEvent->key();
293   const auto selectedItem = currentItem();
294   if ((key == Qt::Key_Enter || key == Qt::Key_Return) && selectedItem)
295     onItemExecuted(selectedItem, SUIT_FoundActionTree::ElementIdx::Name);
296   else
297     QTreeWidget::keyPressEvent(theEvent);
298 }
299
300 bool SUIT_FoundActionTree::eventFilter(QObject* theQObject, QEvent* theEvent)
301 {
302   if (theEvent->type() == QEvent::KeyPress) {
303     QKeyEvent* const keyEvent = static_cast<QKeyEvent*>(theEvent);
304     const auto key = keyEvent->key();
305
306     if (key == Qt::Key_Enter || key == Qt::Key_Return || key == Qt::Key_Up || key == Qt::Key_Down) {
307       keyPressEvent(keyEvent);
308       return true;
309     }
310   }
311
312   return false;
313 }
314
315 std::pair<SUIT_FoundActionTreeModule*, int> SUIT_FoundActionTree::findModuleItem(const QString& theModuleID) const
316 {
317   for (int moduleIdx = 0; moduleIdx < topLevelItemCount(); moduleIdx++) {
318     SUIT_FoundActionTreeModule* moduleItem = static_cast<SUIT_FoundActionTreeModule*>(topLevelItem(moduleIdx));
319     if (moduleItem->myModuleID == theModuleID)
320       return std::pair<SUIT_FoundActionTreeModule*, int>(moduleItem, moduleIdx);
321   }
322   return std::pair<SUIT_FoundActionTreeModule*, int>(nullptr, -1);
323 }
324
325 template <typename Float>
326 bool approximatelyEqual(Float a, Float b, Float relativeTol = std::numeric_limits<Float>::epsilon())
327 {
328     return std::abs(a - b) <= ( (std::abs(a) < std::abs(b) ? std::abs(b) : std::abs(a)) * relativeTol);
329 }
330
331 std::set<SUIT_FoundActionTreeAction*, std::function<bool(SUIT_FoundActionTreeAction*, SUIT_FoundActionTreeAction*)>> SUIT_FoundActionTree::createActionSetWithComparator() const
332 {
333   QList<std::pair<SUIT_FoundActionTree::SortKey, SUIT_FoundActionTree::SortOrder>> sortSchema = SUIT_FoundActionTree::DEFAULT_SORT_SCHEMA;
334   {
335     for (auto itSameKey = sortSchema.begin(); itSameKey != sortSchema.end(); itSameKey++) {
336       if (itSameKey->first == mySortKey) {
337         sortSchema.erase(itSameKey);
338         break;
339       }
340     }
341     sortSchema.push_front(std::pair<SUIT_FoundActionTree::SortKey, SUIT_FoundActionTree::SortOrder>(mySortKey, mySortOrder));
342   }
343
344   static const QCollator collator;
345   const std::function<bool(SUIT_FoundActionTreeAction*, SUIT_FoundActionTreeAction*)> comparator =
346   [sortSchema, &collator](const SUIT_FoundActionTreeAction* theItemA, const SUIT_FoundActionTreeAction* theItemB) {
347     for (const auto& keyAndOrder : sortSchema) {
348       const QVariant fieldOfA = theItemA->getValue(keyAndOrder.first);
349       const QVariant fieldOfB = theItemB->getValue(keyAndOrder.first);
350
351       bool* const fieldOfAIsDouble = new bool(false);
352       bool* const fieldOfBIsDouble = new bool(false);
353       const double matchMetricsA = fieldOfA.toDouble(fieldOfAIsDouble);
354       const double matchMetricsB = fieldOfB.toDouble(fieldOfBIsDouble);
355       if (*fieldOfAIsDouble && *fieldOfBIsDouble) {
356         if (!approximatelyEqual(matchMetricsA, matchMetricsB)) {
357           const double res = matchMetricsA - matchMetricsB;
358           return keyAndOrder.second == SUIT_FoundActionTree::SortOrder::Ascending ? res < 0 : res > 0;
359         }
360       }
361       else {
362         const int res = collator.compare(fieldOfA.toString(), fieldOfB.toString());
363         if (res != 0)
364           return keyAndOrder.second == SUIT_FoundActionTree::SortOrder::Ascending ? res < 0 : res > 0;
365       }
366     }
367     return false;
368   };
369
370   return std::set<SUIT_FoundActionTreeAction*, std::function<bool(SUIT_FoundActionTreeAction*, SUIT_FoundActionTreeAction*)>>(comparator);
371 }
372
373 void SUIT_FoundActionTree::onItemExecuted(QTreeWidgetItem* theItem, int theColIdx)
374 {
375   SUIT_FoundActionTreeItem* const item = static_cast<SUIT_FoundActionTreeItem*>(theItem);
376   if (item->type() == SUIT_FoundActionTreeItem::Type::Action) {
377     SUIT_FoundActionTreeAction* const actionItem = static_cast<SUIT_FoundActionTreeAction*>(theItem);
378     if (actionItem->trigger())
379       static_cast<SUIT_FindActionDialog*>(parentWidget())->accept();
380   }
381   else /* if (item->type() == SUIT_FoundActionTreeItem::Type::Module) */ {
382     item->setExpanded(!item->isExpanded());
383   }
384 }
385
386 /*static*/ const QList<std::pair<SUIT_FoundActionTree::SortKey, SUIT_FoundActionTree::SortOrder>> SUIT_FoundActionTree::DEFAULT_SORT_SCHEMA =
387 {
388   {SUIT_FoundActionTree::SortKey::MatchMetrics, SUIT_FoundActionTree::SortOrder::Ascending},
389   {SUIT_FoundActionTree::SortKey::Name, SUIT_FoundActionTree::SortOrder::Ascending},
390   {SUIT_FoundActionTree::SortKey::ToolTip, SUIT_FoundActionTree::SortOrder::Ascending},
391   {SUIT_FoundActionTree::SortKey::ID, SUIT_FoundActionTree::SortOrder::Ascending}
392 };
393
394
395 SUIT_FoundActionTreeItem::SUIT_FoundActionTreeItem(const QString& theModuleID)
396 : QTreeWidgetItem(), myModuleID(theModuleID)
397 { }
398
399 QString SUIT_FoundActionTreeItem::name() const
400 {
401   return text(SUIT_FoundActionTree::ElementIdx::Name);
402 }
403
404 QString SUIT_FoundActionTreeItem::toolTip() const
405 {
406   return text(SUIT_FoundActionTree::ElementIdx::ToolTip);
407 }
408
409
410 SUIT_FoundActionTreeModule::SUIT_FoundActionTreeModule(const QString& theModuleID)
411 : SUIT_FoundActionTreeItem(theModuleID)
412 {
413   QFont f = font(SUIT_FoundActionTree::ElementIdx::Name);
414   f.setBold(true);
415   setFont(SUIT_FoundActionTree::ElementIdx::Name, f);
416   setText(SUIT_FoundActionTree::ElementIdx::Name, theModuleID);
417 }
418
419 void SUIT_FoundActionTreeModule::setAssetsAndSearchData(const SUIT_ActionSearcher::AssetsAndSearchData& theAssetsAndSD, const QString& theLang)
420 {
421   if (!theAssetsAndSD.myAssets)
422     return;
423
424   setIcon(SUIT_FoundActionTree::ElementIdx::Name, theAssetsAndSD.myAssets->myIcon);
425
426   const auto& ldaMap = theAssetsAndSD.myAssets->myLangDependentAssets;
427   if (ldaMap.empty()) {
428     setText(SUIT_FoundActionTree::ElementIdx::Name, myModuleID);
429     return;
430   }
431
432   auto itLDA = ldaMap.find(theLang);
433   if (itLDA == ldaMap.end())
434     itLDA = ldaMap.begin();
435
436   const SUIT_ActionAssets::LangDependentAssets& lda = itLDA->second;
437   const QString& name = lda.myName.isEmpty() ? myModuleID : lda.myName;
438   setText(SUIT_FoundActionTree::ElementIdx::Name, name);
439 }
440
441 QVariant SUIT_FoundActionTreeModule::getValue(SUIT_FoundActionTree::SortKey theKey) const
442 {
443   switch (theKey) {
444     case SUIT_FoundActionTree::SortKey::MatchMetrics:
445       return double(0);
446     case SUIT_FoundActionTree::SortKey::ID:
447       return myModuleID;
448     case SUIT_FoundActionTree::SortKey::Name:
449       return name();
450     case SUIT_FoundActionTree::SortKey::ToolTip:
451       return toolTip();
452     default:
453       return QString();
454   }
455 }
456
457 bool SUIT_FoundActionTreeModule::isEnabled() const
458 {
459   return true;
460 }
461
462
463 SUIT_FoundActionTreeAction::SUIT_FoundActionTreeAction(const QString& theModuleID, const QString& theInModuleActionID)
464 : SUIT_FoundActionTreeItem(theModuleID), myInModuleActionID(theInModuleActionID),
465   myMatchMetrics(std::numeric_limits<double>::infinity()), myIsEnabledBufferedValue(false)
466 {
467   setText(SUIT_FoundActionTree::ElementIdx::Name, theInModuleActionID);
468 }
469
470 /*static*/ SUIT_FoundActionTreeAction* SUIT_FoundActionTreeAction::create(const QString& theModuleID, const QString& theInModuleActionID)
471 {
472   if (theInModuleActionID.isEmpty()) {
473     ShCutDbg("SUIT_FoundActionTreeItem: attempt to create item with empty action ID.");
474     return nullptr;
475   }
476
477   return new SUIT_FoundActionTreeAction(theModuleID, theInModuleActionID);
478 }
479
480 void SUIT_FoundActionTreeAction::setAssetsAndSearchData(const SUIT_ActionSearcher::AssetsAndSearchData& theAssetsAndSD, const QString& theLang)
481 {
482   if (!theAssetsAndSD.myAssets)
483     return;
484
485   setIcon(SUIT_FoundActionTree::ElementIdx::Name, theAssetsAndSD.myAssets->myIcon);
486
487   const auto& ldaMap = theAssetsAndSD.myAssets->myLangDependentAssets;
488   if (ldaMap.empty()) {
489     setText(SUIT_FoundActionTree::ElementIdx::Name, myInModuleActionID);
490     return;
491   }
492
493   auto itLDA = ldaMap.find(theLang);
494   if (itLDA == ldaMap.end())
495     itLDA = ldaMap.begin();
496
497   const SUIT_ActionAssets::LangDependentAssets& lda = itLDA->second;
498   const QString& name = lda.myName.isEmpty() ? myInModuleActionID : lda.myName;
499   setText(SUIT_FoundActionTree::ElementIdx::Name, name);
500
501   setText(SUIT_FoundActionTree::ElementIdx::ToolTip, lda.myToolTip);
502
503   if (isEnabled()) {
504     setToolTip(
505       SUIT_FoundActionTree::ElementIdx::Name,
506       SUIT_FoundActionTree::tr("Double click to start")
507     );
508
509     setToolTip(
510       SUIT_FoundActionTree::ElementIdx::ToolTip,
511       SUIT_FoundActionTree::tr("Double click to start")
512     );
513   }
514   else {
515     static const QBrush greyedOutBrush = QBrush(Qt::gray);
516     setForeground(SUIT_FoundActionTree::ElementIdx::Name,    greyedOutBrush);
517     setForeground(SUIT_FoundActionTree::ElementIdx::ToolTip, greyedOutBrush);
518   }
519
520   myMatchMetrics = theAssetsAndSD.matchMetrics();
521 }
522
523 QVariant SUIT_FoundActionTreeAction::getValue(SUIT_FoundActionTree::SortKey theKey) const
524 {
525   switch (theKey) {
526     case SUIT_FoundActionTree::SortKey::MatchMetrics:
527       return myMatchMetrics;
528     case SUIT_FoundActionTree::SortKey::ID:
529       return myInModuleActionID;
530     case SUIT_FoundActionTree::SortKey::Name:
531       return name();
532     case SUIT_FoundActionTree::SortKey::ToolTip:
533       return toolTip();
534     default:
535       return QString();
536   }
537 }
538
539 bool SUIT_FoundActionTreeAction::isEnabled() const
540 {
541   const auto& actions = SUIT_ShortcutMgr::get()->getActions(myModuleID, myInModuleActionID);
542   myIsEnabledBufferedValue = std::find_if(actions.begin(), actions.end(), [](const QAction* const theAction){ return theAction->isEnabled(); }) != actions.end();
543   return myIsEnabledBufferedValue;
544 }
545
546 bool SUIT_FoundActionTreeAction::trigger() const
547 {
548   bool res = false;
549   const auto& actions = SUIT_ShortcutMgr::get()->getActions(myModuleID, myInModuleActionID);
550   for (const auto& action : actions) {
551     if (action->isEnabled()) {
552       action->trigger();
553       res = true;
554     }
555   }
556   return res;
557 }