SUIT_ShortcutMgr.h

Go to the documentation of this file.

// Copyright (C) 2007-2026  CEA, EDF, OPEN CASCADE
//
// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
 
#ifndef SUIT_SHORTCUTMGR_H
#define SUIT_SHORTCUTMGR_H
 
#include "SUIT.h"
 
#include <QObject>
#include <QString>
#include <QKeySequence>
#include <QStringList>
#include <QIcon>
#include <map>
#include <set>
#include <memory>
#include <utility>
#include <limits>
#include <functional>
 
class QAction;
class QtxAction;
class QJsonObject;
 
#if defined WIN32
#pragma warning( disable: 4251 )
#endif
 
// Define SHORTCUT_MGR_DBG to enable SUIT_ShortcutMgr debug logging.
// #define SHORTCUT_MGR_DBG
SUIT_EXPORT extern inline bool ShCutDbg() {
#ifdef SHORTCUT_MGR_DBG
  return true;
#else
  return false;
#endif
}
SUIT_EXPORT extern bool ShCutDbg(const QString& theString);
SUIT_EXPORT extern bool ShCutDbg(const char* theString);
 
 
class SUIT_EXPORT SUIT_ShortcutContainer
{
public:
  SUIT_ShortcutContainer();
 
  std::set<QString> getIDsOfInterferingModules(const QString& theModuleID) const;
 
  std::set<QString> getIDsOfAllModules() const;
 
  bool isEmpty() const;
 
  std::set<std::pair<QString, QString>> setShortcut(
    QString theModuleID,
    const QString& theInModuleActionID,
    const QKeySequence& theKeySequence,
    bool theOverride
  );
 
  std::set<std::pair<QString, QString>> getConflicts(
    QString theModuleID,
    const QString& theInModuleActionID,
    const QKeySequence& theKeySequence
  ) const;
 
  const QKeySequence& getKeySequence(QString theModuleID, const QString& theInModuleActionID) const;
 
  bool hasShortcut(QString theModuleID, const QString& theInModuleActionID) const;
 
  const std::map<QString, QKeySequence>& getModuleShortcutsInversed(const QString& theModuleID) const;
 
  const std::map<QString, QKeySequence> getModuleShortcutsInversed(const QString& theModuleID, const QString& theInModuleActionIDPrefix) const;
 
  std::map<QString, std::map<QString, std::pair<QKeySequence, QKeySequence>>> merge(
    const SUIT_ShortcutContainer& theOther,
    bool theOverride,
    bool theTreatAbsentIncomingAsDisabled = false
  );
 
  bool hasKeySequence(const QString& theModuleID, const QKeySequence& theKeySequence) const;
 
  QString toString() const;
 
private:
  std::map<QString, std::map<QKeySequence, QString>> myShortcuts;
 
  std::map<QString, std::map<QString, QKeySequence>> myShortcutsInversed;
};
 
 
class SUIT_ShortcutItemAssets;
 
 
class SUIT_EXPORT SUIT_ShortcutAssets : public std::enable_shared_from_this<SUIT_ShortcutAssets>
{
public:
  enum class Type
  {
    Module,
    Item // Folder, action or folder-action.
  };
 
 
  struct LangDependentAssets
  {
    static const QString PROP_ID_NAME;
    static const QString PROP_ID_TOOLTIP;
 
    bool fromJSON(const QJsonObject& theJsonObject);
    void toJSON(QJsonObject& oJsonObject) const;
 
    QString myName;
    QString myToolTip;
  };
 
 
  static const QString PROP_ID_LANG_DEPENDENT_ASSETS;
  static const QString PROP_ID_ICON_PATH;
  static const QString PROP_ID_CHILDREN;
 
protected:
  SUIT_ShortcutAssets(const QString& theModuleID);
 
public:
  virtual ~SUIT_ShortcutAssets() = 0;
 
  const std::map<QString, std::shared_ptr<SUIT_ShortcutItemAssets>>& children() const;
 
  std::shared_ptr<SUIT_ShortcutItemAssets> findDescendantItem(const QString& theRelativeID) const;
 
  std::shared_ptr<SUIT_ShortcutItemAssets> descendantItem(const QString& theRelativeID, bool theIsAction = true);
 
  virtual int depth() const = 0;
  virtual SUIT_ShortcutAssets::Type type() const = 0;
 
private:
  bool fromJSONOwnProps(const QJsonObject& theJsonObject, const std::set<QString>& theLangs = {});
 
public:
  bool fromJSON(const QJsonObject& theJsonObject, bool theParseDescendants = true, const std::set<QString>& theLangs = {});
 
  bool fromJSON(const QJsonObject& theJsonObject, const QString& theRelativeID, const std::set<QString>& theLangs = {});
 
  void toJSON(QJsonObject& oJsonObject) const;
 
  virtual void merge(const SUIT_ShortcutAssets& theOther, bool theOverride);
 
  virtual void merge(SUIT_ShortcutAssets&& theOther, bool theOverride);
 
private:
  virtual bool fromJSONOtherProps(const QJsonObject& theJsonObject) { return false; };
 
  virtual void toJSONVirtual(QJsonObject& oJsonObject) const {};
 
public:
  void loadIcon(bool theReload = false);
 
  void forEachDescendant(const std::function<void(SUIT_ShortcutItemAssets&)>& theFunc) const;
 
  void forEachDescendant(const std::function<void(const SUIT_ShortcutItemAssets&)>& theFunc) const;
 
  void forEachDescendant(const std::function<void(std::shared_ptr<SUIT_ShortcutItemAssets>)>& theFunc) const;
 
  void forEachDescendant(const std::function<void(std::shared_ptr<const SUIT_ShortcutItemAssets>)>& theFunc) const;
 
  QString toString() const;
  virtual QString description() const = 0;
 
  QStringList getLangs() const;
  void clearAllLangsExcept(const QString& theLang);
 
  const LangDependentAssets* bestLangDependentAssets(QString theLang = QString()) const;
 
  virtual const QString& bestName(const QString& theLang = QString()) const = 0;
 
  virtual const QString& bestToolTip(const QString& theLang = QString()) const;
 
public:
  const QString myModuleID;
 
  std::map<QString, LangDependentAssets> myLangDependentAssets;
  QString myIconPath;
 
  QIcon myIcon;
 
private:
  // { IDLastToken, assets }.
  std::map<QString, std::shared_ptr<SUIT_ShortcutItemAssets>> myChildren;
};
 
 
class SUIT_EXPORT SUIT_ShortcutModuleAssets : public SUIT_ShortcutAssets
{
private:
  SUIT_ShortcutModuleAssets(const QString& theModuleID);
  SUIT_ShortcutModuleAssets(const SUIT_ShortcutModuleAssets&) = delete;
  SUIT_ShortcutModuleAssets& operator= (const SUIT_ShortcutModuleAssets&) = delete;
 
public:
  static std::shared_ptr<SUIT_ShortcutModuleAssets> create(const QString& theModuleID);
  ~SUIT_ShortcutModuleAssets() = default;
 
  int depth() const { return 0; };
  SUIT_ShortcutAssets::Type type() const { return SUIT_ShortcutAssets::Type::Module; };
 
  const QString& bestName(const QString& theLang = QString()) const;
 
  QString description() const;
};
 
 
class SUIT_EXPORT SUIT_ShortcutItemAssets : public SUIT_ShortcutAssets
{
  friend class SUIT_ShortcutAssets;
 
public:
  static void loadDefaultIcons();
  static const QString PROP_ID_IS_ACTION; // Absense of the key in JSON means myIsAction == true.
 
private:
  static QIcon DEFAUT_ICON_ACTION;
  static QIcon DEFAUT_ICON_FOLDER;
  static QIcon DEFAUT_ICON_FOLDER_ACTION;
 
  SUIT_ShortcutItemAssets(std::shared_ptr<SUIT_ShortcutModuleAssets> theModule, const QString& theIDLastToken, bool theIsAction = true);
 
  SUIT_ShortcutItemAssets(std::shared_ptr<SUIT_ShortcutItemAssets> theParentItem, const QString& theIDLastToken, bool theIsAction = true);
  SUIT_ShortcutItemAssets(const SUIT_ShortcutItemAssets&) = delete;
  SUIT_ShortcutItemAssets& operator= (const SUIT_ShortcutItemAssets&) = delete;
  static std::shared_ptr<SUIT_ShortcutItemAssets> create(std::shared_ptr<SUIT_ShortcutAssets> theParentItemOrModule, const QString& theIDLastToken, bool theIsAction = true);
 
 public:
  ~SUIT_ShortcutItemAssets() = default;
 
  int depth() const;
  SUIT_ShortcutAssets::Type type() const { return SUIT_ShortcutAssets::Type::Item; };
 
  void merge(const SUIT_ShortcutItemAssets& theOther, bool theOverride);
 
  virtual void merge(SUIT_ShortcutItemAssets&& theOther, bool theOverride);
 
private:
  bool fromJSONOtherProps(const QJsonObject& theJsonObject);
  void toJSONVirtual(QJsonObject& oJsonObject) const;
 
public:
  const QString& bestName(const QString& theLang = QString()) const;
 
  const QString& bestPath(const QString theLang = QString()) const;
 
  QString description() const;
 
  bool isAction() const;
  bool isFolder() const;
  std::shared_ptr<SUIT_ShortcutAssets> parent() const;
  std::shared_ptr<SUIT_ShortcutModuleAssets> module() const;
 
  QString actionID() const;
 
  const QIcon& icon() const;
 
private:
  std::weak_ptr<SUIT_ShortcutAssets> myParent;
 
  bool myIsAction;
 
public:
  const QString myIDLastToken;
  const QString myInModuleID; // Composed as <depth_1_item.myIDLastToken>/...<depth_N_item.myIDLastToken>.../<this->myIDLastToken>. Synonym for inModuleActionID.
 
private:
  const int myDepth;
 
  mutable std::map<QString, QString> myBestPaths;
};
 
 
class SUIT_EXPORT SUIT_ShortcutMgr: public QObject
{
  Q_OBJECT
 
private:
  SUIT_ShortcutMgr();
  SUIT_ShortcutMgr(const SUIT_ShortcutMgr&) = delete;
  SUIT_ShortcutMgr& operator=(const SUIT_ShortcutMgr&) = delete;
 
protected:
  virtual ~SUIT_ShortcutMgr();
 
public:
  static const QString ROOT_MODULE_ID;
 
  static void Init();
 
  static SUIT_ShortcutMgr* get();
 
  static bool isKeySequenceValid(const QKeySequence& theKeySequence);
 
  static std::pair<bool, QKeySequence> toKeySequenceIfValid(const QString& theKeySequenceString);
 
  static bool isModuleIDValid(const QString& theModuleID);
 
  static bool isInModuleIDTokenValid(const QString& theInModuleIDToken);
 
  static bool isInModuleIDTokenMeta(const QString& theInModuleIDToken);
 
  static bool isInModuleActionIDValid(const QString& theInModuleActionID);
 
  static bool isInModuleMetaActionID(const QString& theInModuleActionID);
 
  static std::pair<QString, QString> splitIntoModuleIDAndInModuleID(const QString& theActionID);
 
  static QStringList splitIntoTokens(const QString& theRelativeID);
 
  static QString joinIntoRelativeID(const QStringList& theTokens);
 
  static bool isActionIDValid(const QString& theActionID);
 
  static QString makeActionID(const QString& theModuleID, const QString& theInModuleActionID);
 
  static void fillContainerFromPreferences(SUIT_ShortcutContainer& theContainer, bool theDefaultOnly);
 
  static void fillContainerFromPreferences(SUIT_ShortcutContainer& theContainer, bool theDefaultOnly, const QString& theSectionNamePrefix);
 
  static std::pair<std::shared_ptr<SUIT_ShortcutModuleAssets>, std::shared_ptr<SUIT_ShortcutItemAssets>>
  getActionAssetsFromResources(const QString& theActionID, const std::set<QString>& theLangs = {});
 
  static QString currentLang();
 
 
  void registerAction(const QString& theActionID, QAction* theAction);
 
  void registerAction(QtxAction* theAction);
 
  std::set<QAction*> getActions(const QString& theModuleID, const QString& theInModuleActionID) const;
 
  std::pair<QString, QString> getModuleIDAndInModuleID(const QAction* theAction) const;
 
  bool hasAction(const QAction* theAction) const;
 
  QString getActionID(const QAction* theAction) const;
 
  void setActionsOfModuleEnabled(const QString& theModuleID, const bool theEnable = true) const;
 
  [[deprecated("Use setActionsOfModuleEnabled(const QString&, bool) instead.")]]
  void setSectionEnabled(const QString& theInModuleActionIDPrefix, bool theEnable = true) const;
 
  void setActionsWithPrefixInIDEnabled(const QString& theInModuleActionIDPrefix, bool theEnable = true) const;
 
  void rebindActionsToKeySequences() const;
 
  [[deprecated("Use rebindActionsToKeySequences() instead.")]]
  void updateShortcuts() const;
 
  std::set<std::pair<QString, QString>> setShortcut(const QString& theActionID, const QKeySequence& theKeySequence, bool theOverride = false);
  std::set<std::pair<QString, QString>> setShortcut(const QString& theModuleID, const QString& theInModuleActionID, const QKeySequence& theKeySequence, bool theOverride = false);
 
  const SUIT_ShortcutContainer& getShortcutContainer() const;
 
  void mergeShortcutContainer(const SUIT_ShortcutContainer& theContainer, bool theOverride = true, bool theTreatAbsentIncomingAsDisabled = false, bool theSaveToPreferences = true);
 
  const QKeySequence& getKeySequence(const QString& theModuleID, const QString& theInModuleActionID) const;
 
  const std::map<QString, QKeySequence>& getModuleShortcutsInversed(const QString& theModuleID) const;
 
  std::set<QString> getShortcutModuleIDs() const;
 
  std::set<QString> getIDsOfInterferingModules(const QString& theModuleID) const;
 
  std::shared_ptr<const SUIT_ShortcutModuleAssets> getModuleAssets(const QString& theModuleID) const;
  const std::map<QString, std::shared_ptr<SUIT_ShortcutModuleAssets>>& getModuleAssets() const { return myModuleAssets; }
 
  QString getModuleName(const QString& theModuleID, const QString& theLang = "") const;
 
  std::shared_ptr<const SUIT_ShortcutItemAssets> getActionAssets(const QString& theModuleID, const QString& theInModuleActionID, bool theTryToCreateRuntimeAssetsIfAbsent = true) const;
 
  std::shared_ptr<const SUIT_ShortcutItemAssets> getActionAssets(const QString& theActionID, bool theTryToCreateRuntimeAssetsIfAbsent = true) const;
 
  std::shared_ptr<const SUIT_ShortcutItemAssets> createRuntimeActionAssets(const QString& theModuleID, const QString& theInModuleActionID) const;
 
  QString getActionName(const QString& theModuleID, const QString& theInModuleActionID, const QString& theLang = "") const;
 
  QtxAction* createAction(QObject* theParent, QObject* theReceiver, const char* theReceiverSlot, const QString& theActionID, const bool theIsToggle = false) const;
 
private slots:
  void onActionDestroyed(QObject* theObject);
 
  void onAnonymousActionDestroyed(QObject* theObject);
 
private:
  virtual bool eventFilter(QObject* theObject, QEvent* theEvent);
 
  std::set<std::pair<QString, QString>> setShortcutNoIDChecks(const QString& theModuleID, const QString& theInModuleActionID, const QKeySequence& theKeySequence, bool theOverride);
 
  void setShortcutsFromPreferences();
 
  static void saveShortcutsToPreferences(const std::map<QString, std::map<QString, QKeySequence>>& theShortcutsInversed);
 
  static void saveShortcutsToPreferences(const std::map<QString, std::map<QString, std::pair<QKeySequence, QKeySequence>>>& theShortcutsInversed);
 
  void setAssetsFromResources(QString theLanguage = QString());
 
  void registerAnonymousShortcut(QAction* const theAction);
  void enableAnonymousShortcutsClashingWith(const QString& theModuleID, const bool theEnable) const;
  void enableAnonymousShortcutsClashingWith(const QKeySequence& theKeySequence, bool theEnable) const;
  QString anonymousShortcutsToString() const;
 
private:
  static SUIT_ShortcutMgr* myShortcutMgr;
 
  std::map<QString, std::map<QString, std::set<QAction*>>> myActions;
 
  std::map<QAction*, std::pair<QString, QString>> myActionIDs; // To maintain uniqueness of actions and effectively retrieve IDs of registered actions.
 
  SUIT_ShortcutContainer myShortcutContainer;
 
  /* nb!
  Sets of moduleIDs and inModuleActionIDs are equal for myActions and myActionIDs.
  Sets of moduleIDs and inModuleActionIDs may NOT be equal for myActions and myShortcutContainer.
  */
 
  mutable std::map<QString, std::shared_ptr<SUIT_ShortcutModuleAssets>> myModuleAssets;
 
  bool myAssetsLoaded;
 
  mutable std::set<QString> myActiveModuleIDs;
 
  std::map<QAction*, QKeySequence> myAnonymousShortcuts;
 
  std::map<QKeySequence, std::set<QAction*>> myAnonymousShortcutsInverse;
};
 
 
class SUIT_EXPORT SUIT_ShortcutHistorian
{
public:
  static const std::vector<QString> SECTION_PREFIX_EVOLUTION;
 
private:
  class SUIT_EXPORT AIDSMutation
  {
  public:
    static const QString PROP_ID_MUTATIONS;
    static const QString PROP_ID_PREFIX_OLD;
    static const QString PROP_ID_PREFIX_NEW;
    static const QString PROP_ID_OLD_TO_NEW_ACTION_ID_MAP;
 
    static bool isPairOfNewAndOldActionIDsValid(const QString& theSectionPrefixNew, const QString& theSectionPrefixOld);
 
    AIDSMutation(const QString& theSectionPrefixNew, const QString& theSectionPrefixOld);
    AIDSMutation(const QJsonObject& theJsonObject, const bool theParseMap = true);
 
    const QString& getSectionPrefixOld() const { return mySectionPrefixOld; };
    const QString& getSectionPrefixNew() const { return mySectionPrefixNew; };
    const std::map<QString, QString>& getNewToOldActionIDMap() const { return myNewToOldActionIDMap; };
    const std::map<QString, QString>& getOldToNewActionIDMap() const { return myOldToNewActionIDMap; };
 
    bool isConcurrent(const AIDSMutation& theOther) const;
 
    bool merge(const AIDSMutation& theOther);
 
  private:
    QString mySectionPrefixOld;
 
    QString mySectionPrefixNew;
 
    std::map<QString, QString> myNewToOldActionIDMap;
 
    std::map<QString, QString> myOldToNewActionIDMap;
  };
 
public:
  SUIT_ShortcutHistorian();
 
  bool doOldShortcutPreferencesExist() const;
 
  QString getActionID(const QString& theOldActionID, const QString& theOldSectionPrefix) const;
 
  std::pair<bool, QKeySequence> getOldUserDefinedKeySequence(const QString& theActionID) const;
 
  const SUIT_ShortcutContainer& getContainerWithOldShortcuts() const { return myShortcutContainer; };
 
  void removeOldShortcutPreferences();
 
private:
  void parseMutations();
 
  std::pair<bool, QKeySequence> getKeySequenceFromSection(const QString& theActionID, const QString& theSectionPrefix) const;
 
private:
  std::list<std::pair<QString, SUIT_ShortcutHistorian::AIDSMutation>> myOldPrefixToMutationList;
 
  std::map<QString, SUIT_ShortcutContainer> myShortcutContainers;
 
  SUIT_ShortcutContainer myShortcutContainer;
};
 
 
namespace SUIT_tools {
  class SUIT_SentenceMatcher;
}
 
 
class SUIT_EXPORT SUIT_ActionSearcher
{
public:
  enum MatchField {
    ID,
    Name, // Also matches with path, composed as <depth_1_item.name>/...<depth_N_item.name>.../<actionItem.name>.
    ToolTip,
    KeySequence
  };
 
  class AssetsAndSearchData
  {
  public:
    AssetsAndSearchData(std::shared_ptr<const SUIT_ShortcutItemAssets> theAssets = nullptr, double theMatchMetrics = std::numeric_limits<double>::infinity());
 
    void setMatchMetrics(double theMatchMetrics);
    double matchMetrics() const { return myMatchMetrics; };
 
    std::shared_ptr<const SUIT_ShortcutItemAssets> myAssets;
 
    void toJSON(QJsonObject& oJsonObject) const;
    QString toString() const;
 
  private:
    double myMatchMetrics;
  };
 
 
  static double matchKeySequenceString(const QString& theQuery, const QString& theKeySequence);
 
  SUIT_ActionSearcher();
  SUIT_ActionSearcher(const SUIT_ActionSearcher&) = delete;
  SUIT_ActionSearcher& operator=(const SUIT_ActionSearcher&) = delete;
  virtual ~SUIT_ActionSearcher();
 
  bool setIncludedModuleIDs(std::set<QString> theIncludedModuleIDs, bool doNotUpdateResults = false);
 
  bool includeDisabledActions(bool theOn, bool doNotUpdateResults = false);
  inline bool areDisabledActionsIncluded() const {return myIncludeDisabledActions;};
 
  bool setFieldsToMatch(const std::set<SUIT_ActionSearcher::MatchField>& theFields, bool doNotUpdateResults = false);
 
  std::pair<bool, bool> setKeySequenceGetter(
    const std::function<QString(const QString&, const QString&)>& theKeySequenceGetter = std::function<QString(const QString&, const QString&)>(),
    bool doNotUpdateResults = false
  );
 
  bool setCaseSensitive(bool theOn, bool doNotUpdateResults = false);
 
  bool setQuery(const QString& theQuery);
  inline const QString& getQuery() const;
 
  const std::map<QString, std::map<QString, SUIT_ActionSearcher::AssetsAndSearchData>>& getSearchResults() const;
 
 
private:
  std::pair<bool, bool> filter();
 
  std::pair<bool, bool> filterResults();
 
  bool extendResults();
 
  double matchAction(const SUIT_ShortcutItemAssets& theAssets);
 
  QString toString() const;
 
 
  std::set<QString> myIncludedModuleIDs;
  bool myIncludeDisabledActions;
 
  std::set<SUIT_ActionSearcher::MatchField> myFieldsToMatch;
  ::SUIT_tools::SUIT_SentenceMatcher* myMatcher;
 
  /* getKeySequence(theModuleID, theInModuleActionID) */
  std::function<QString(const QString&, const QString&)> myKeySequenceGetter;
 
  /* { moduleID, {inModuleActionID, assetsAndSearchData}[] }[]. */
  std::map<QString, std::map<QString, SUIT_ActionSearcher::AssetsAndSearchData>> mySearchResults;
};
 
 
#if defined WIN32
#pragma warning( default: 4251 )
#endif
 
#endif //SUIT_SHORTCUTMGR_H