src/XGUI/XGUI_MenuMgr.cpp

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
   2
   3 // File:        XGUI_MenuMgr.cpp
   4 // Created:     13 Apr 2016
   5 // Author:      Natalia ERMOLAEVA
   6
   7 #include <XGUI_MenuMgr.h>
   8 #include <XGUI_Workshop.h>
   9 #include <XGUI_ActionsMgr.h>
  10 #include <XGUI_OperationMgr.h>
  11 #include <XGUI_MenuWorkbench.h>
  12 #include <XGUI_MenuGroup.h>
  13
  14 #include <Events_Loop.h>
  15 #include <Config_FeatureMessage.h>
  16 #include <Config_Keywords.h>
  17
  18 #ifndef HAVE_SALOME
  19 #include <AppElements_Workbench.h>
  20 #include <AppElements_Command.h>
  21 #include <AppElements_MainMenu.h>
  22 #include <AppElements_MainWindow.h>
  23 #include <AppElements_MenuGroupPanel.h>
  24 #include <AppElements_Button.h>
  25 #else
  26 #include <XGUI_SalomeConnector.h>
  27 #endif
  28
  29 #include <ModuleBase_IModule.h>
  30
  31 #include <QObject>
  32 #include <QAction>
  33 #include <QDebug>
  34
  35 XGUI_MenuMgr::XGUI_MenuMgr(XGUI_Workshop* theWorkshop)
  36 : myWorkshop(theWorkshop)
  37 {
  38   Events_Loop* aLoop = Events_Loop::loop();
  39
  40   aLoop->registerListener(this, Events_Loop::eventByName(Config_FeatureMessage::GUI_EVENT()));
  41 }
  42
  43 void XGUI_MenuMgr::processEvent(const std::shared_ptr<Events_Message>& theMessage)
  44 {
  45   //A message to start feature creation received.
  46   if (theMessage->eventID() ==
  47       Events_Loop::loop()->eventByName(Config_FeatureMessage::GUI_EVENT())) {
  48     std::shared_ptr<Config_FeatureMessage> aFeatureMsg =
  49        std::dynamic_pointer_cast<Config_FeatureMessage>(theMessage);
  50     if (!aFeatureMsg->isInternal()) {
  51       addFeature(aFeatureMsg);
  52     }
  53   }
  54 }
  55
  56 void XGUI_MenuMgr::addFeature(const std::shared_ptr<Config_FeatureMessage>& theMessage)
  57 {
  58   if (!theMessage) {
  59 #ifdef _DEBUG
  60     qDebug() << "XGUI_WorkshopListener::addFeature: NULL message.";
  61 #endif
  62     return;
  63   }
  64 #ifdef HAVE_SALOME
  65   std::shared_ptr<XGUI_MenuWorkbench> aWorkbench = findWorkbench(theMessage->workbenchId());
  66   std::shared_ptr<XGUI_MenuGroup> aGroup = aWorkbench->findGroup(theMessage->groupId());
  67   aGroup->setFeatureInfo(theMessage);
  68 #else
  69   ActionInfo aFeatureInfo;
  70   aFeatureInfo.initFrom(theMessage);
  71
  72   QString aWchName = QString::fromStdString(theMessage->workbenchId());
  73   QStringList aNestedFeatures =
  74       QString::fromStdString(theMessage->nestedFeatures()).split(" ", QString::SkipEmptyParts);
  75   QList<QAction*> aNestedActList;
  76   bool isColumnButton = !aNestedFeatures.isEmpty();
  77   if (isColumnButton) {
  78     QString aNestedActions = QString::fromStdString(theMessage->actionsWhenNested());
  79     XGUI_OperationMgr* anOperationMgr = myWorkshop->operationMgr();
  80     XGUI_ActionsMgr* anActionsMgr = myWorkshop->actionsMgr();
  81     if (aNestedActions.contains(FEATURE_WHEN_NESTED_ACCEPT)) {
  82       QAction* anAction = anActionsMgr->operationStateAction(XGUI_ActionsMgr::AcceptAll);
  83       QObject::connect(anAction, SIGNAL(triggered()), anOperationMgr, SLOT(commitAllOperations()));
  84       aNestedActList << anAction;
  85     }
  86     if (aNestedActions.contains(FEATURE_WHEN_NESTED_ABORT)) {
  87       QAction* anAction = anActionsMgr->operationStateAction(XGUI_ActionsMgr::AbortAll);
  88       QObject::connect(anAction, SIGNAL(triggered()), anOperationMgr, SLOT(abortAllOperations()));
  89       aNestedActList << anAction;
  90     }
  91   }
  92
  93   //Find or create Workbench
  94   AppElements_MainMenu* aMenuBar = myWorkshop->mainWindow()->menuObject();
  95   AppElements_Workbench* aPage = aMenuBar->findWorkbench(aWchName);
  96   if (!aPage) {
  97     aPage = myWorkshop->addWorkbench(aWchName);
  98   }
  99   //Find or create Group
 100   QString aGroupName = QString::fromStdString(theMessage->groupId());
 101   AppElements_MenuGroupPanel* aGroup = aPage->findGroup(aGroupName);
 102   if (!aGroup) {
 103     aGroup = aPage->addGroup(aGroupName);
 104   }
 105   // Check if hotkey sequence is already defined:
 106   XGUI_ActionsMgr* anActionsMgr = myWorkshop->actionsMgr();
 107   QKeySequence aHotKey = anActionsMgr->registerShortcut(aFeatureInfo.shortcut);
 108   if(aHotKey != aFeatureInfo.shortcut) {
 109     aFeatureInfo.shortcut = aHotKey;
 110   }
 111   AppElements_Command* aCommand = aGroup->addFeature(theMessage);
 112   // Enrich created button with accept/abort buttons if necessary
 113   AppElements_Button* aButton = aCommand->button();
 114   if (aButton->isColumnButton()) {
 115     aButton->setAdditionalButtons(aNestedActList);
 116   }
 117   myWorkshop->actionsMgr()->addCommand(aCommand);
 118   myWorkshop->module()->actionCreated(aCommand);
 119 #endif
 120 }
 121
 122 std::shared_ptr<XGUI_MenuWorkbench> XGUI_MenuMgr::findWorkbench(const std::string& theWorkbenchName)
 123 {
 124   std::list< std::shared_ptr<XGUI_MenuWorkbench> >::const_iterator anIt = myWorkbenches.begin(),
 125                                                                    aLast = myWorkbenches.end();
 126   std::shared_ptr<XGUI_MenuWorkbench> aResultWorkbench;
 127   for (; anIt != aLast && !aResultWorkbench; anIt++) {
 128     std::shared_ptr<XGUI_MenuWorkbench> aWorkbench = *anIt;
 129     if (aWorkbench->getName() == theWorkbenchName)
 130       aResultWorkbench = aWorkbench;
 131   }
 132   if (!aResultWorkbench) {
 133     aResultWorkbench =
 134       std::shared_ptr<XGUI_MenuWorkbench>(new XGUI_MenuWorkbench(theWorkbenchName));
 135     myWorkbenches.push_back(aResultWorkbench);
 136   }
 137   return aResultWorkbench;
 138 }
 139
 140 void XGUI_MenuMgr::createFeatureActions()
 141 {
 142 #ifdef HAVE_SALOME
 143   std::list< std::shared_ptr<XGUI_MenuWorkbench> >::const_iterator anIt = myWorkbenches.begin(),
 144                                                                    aLast = myWorkbenches.end();
 145   XGUI_SalomeConnector* aSalomeConnector = myWorkshop->salomeConnector();
 146   for (; anIt != aLast; anIt++) {
 147     std::shared_ptr<XGUI_MenuWorkbench> aWorkbench = *anIt;
 148     std::string aWchName = aWorkbench->getName();
 149     const std::list<std::shared_ptr<XGUI_MenuGroup> >& aGroups = aWorkbench->groups();
 150     std::list<std::shared_ptr<XGUI_MenuGroup> >::const_iterator aGIt = aGroups.begin(),
 151                                                                 aGLast = aGroups.end();
 152     for (; aGIt != aGLast; aGIt++) {
 153       const std::shared_ptr<XGUI_MenuGroup> aGroup = *aGIt;
 154       std::string aGName = aGroup->getName();
 155       const std::list<std::shared_ptr<Config_FeatureMessage> >& aFeaturesInfo =
 156         aGroup->featuresInfo();
 157       std::list<std::shared_ptr<Config_FeatureMessage> >::const_iterator aFIt =
 158         aFeaturesInfo.begin(), aFLast = aFeaturesInfo.end();
 159       int aFSize = aFeaturesInfo.size();
 160       for(int i = 0; aFIt != aFLast; aFIt++, i++) {
 161         std::shared_ptr<Config_FeatureMessage> aMessage = *aFIt;
 162         bool aUseSeparator = i == aFSize-1;
 163         QAction* aAction = buildAction(aMessage, aWchName, aUseSeparator);
 164
 165         aSalomeConnector->setFeatureInfo(QString::fromStdString(aMessage->id()), aMessage);
 166         myWorkshop->actionsMgr()->addCommand(aAction);
 167         myWorkshop->module()->actionCreated(aAction);
 168       }
 169     }
 170   }
 171 #endif
 172 }
 173
 174 QAction* XGUI_MenuMgr::buildAction(const std::shared_ptr<Config_FeatureMessage>& theMessage,
 175                                    const std::string& theWchName, const bool aUseSeparator) const
 176 {
 177   QAction* anAction = 0;
 178
 179 #ifdef HAVE_SALOME
 180   XGUI_SalomeConnector* aSalomeConnector = myWorkshop->salomeConnector();
 181
 182   ActionInfo aFeatureInfo;
 183   aFeatureInfo.initFrom(theMessage);
 184   QStringList aNestedFeatures =
 185       QString::fromStdString(theMessage->nestedFeatures()).split(" ", QString::SkipEmptyParts);
 186   QList<QAction*> aNestedActList;
 187   if (!aNestedFeatures.isEmpty()) {
 188     QString aNestedActions = QString::fromStdString(theMessage->actionsWhenNested());
 189     XGUI_OperationMgr* anOperationMgr = myWorkshop->operationMgr();
 190     XGUI_ActionsMgr* anActionsMgr = myWorkshop->actionsMgr();
 191     if (aNestedActions.contains(FEATURE_WHEN_NESTED_ACCEPT)) {
 192       QAction* anAction = anActionsMgr->operationStateAction(XGUI_ActionsMgr::AcceptAll);
 193       QObject::connect(anAction, SIGNAL(triggered()), anOperationMgr, SLOT(commitAllOperations()));
 194       aNestedActList << anAction;
 195     }
 196     if (aNestedActions.contains(FEATURE_WHEN_NESTED_ABORT)) {
 197       QAction* anAction = anActionsMgr->operationStateAction(XGUI_ActionsMgr::AbortAll);
 198       QObject::connect(anAction, SIGNAL(triggered()), anOperationMgr, SLOT(abortAllOperations()));
 199       aNestedActList << anAction;
 200     }
 201     anAction = aSalomeConnector->addFeatureOfNested(theWchName.c_str(), aFeatureInfo,
 202                                                     aNestedActList);
 203   }
 204   else {
 205     anAction = aSalomeConnector->addFeature(theWchName.c_str(), aFeatureInfo, aUseSeparator);
 206   }
 207 #endif
 208   return anAction;
 209 }