X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FXGUI%2FXGUI_Workshop.cpp;h=fa583caead741b96b4c821e5adfb8c5a49a147cb;hb=dc158ea248a9bbd70675887f494388c93e1b3b4d;hp=8c76c2fd11cf18d84788e79300b9b76ea9b50242;hpb=0b7e04043b8541228f1a0d27392e761a83dbc2dc;p=modules%2Fshaper.git

diff --git a/src/XGUI/XGUI_Workshop.cpp b/src/XGUI/XGUI_Workshop.cpp
index 8c76c2fd1..fa583caea 100644
--- a/src/XGUI/XGUI_Workshop.cpp
+++ b/src/XGUI/XGUI_Workshop.cpp
@@ -1,29 +1,32 @@
-#include "ModuleBase_IModule.h"
-#include "XGUI_Constants.h"
-#include "XGUI_Command.h"
-#include "XGUI_MainMenu.h"
-#include "XGUI_MainWindow.h"
-#include "XGUI_MenuGroupPanel.h"
+// Copyright (C) 2014-20xx CEA/DEN, EDF R&D -->
+
+//#include "XGUI_Constants.h"
 #include "XGUI_Tools.h"
-#include "XGUI_Workbench.h"
 #include "XGUI_Workshop.h"
-#include "XGUI_Viewer.h"
 #include "XGUI_SelectionMgr.h"
 #include "XGUI_Selection.h"
 #include "XGUI_ObjectsBrowser.h"
 #include "XGUI_Displayer.h"
 #include "XGUI_OperationMgr.h"
 #include "XGUI_SalomeConnector.h"
-#include "XGUI_SalomeViewer.h"
 #include "XGUI_ActionsMgr.h"
 #include "XGUI_ErrorDialog.h"
 #include "XGUI_ViewerProxy.h"
 #include "XGUI_PropertyPanel.h"
 #include "XGUI_ContextMenuMgr.h"
 #include "XGUI_ModuleConnector.h"
-#include "XGUI_Preferences.h"
 #include <XGUI_QtEvents.h>
 
+#include <AppElements_Workbench.h>
+#include <AppElements_Viewer.h>
+#include <AppElements_Command.h>
+#include <AppElements_MainMenu.h>
+#include <AppElements_MainWindow.h>
+#include <AppElements_MenuGroupPanel.h>
+
+#include <ModuleBase_IModule.h>
+#include <ModuleBase_Preferences.h>
+
 #include <ModelAPI_Events.h>
 #include <ModelAPI_Session.h>
 #include <ModelAPI_Feature.h>
@@ -34,7 +37,7 @@
 #include <ModelAPI_ResultConstruction.h>
 #include <ModelAPI_ResultBody.h>
 
-#include <PartSetPlugin_Part.h>
+//#include <PartSetPlugin_Part.h>
 
 #include <Events_Loop.h>
 #include <Events_Error.h>
@@ -44,12 +47,17 @@
 #include <ModuleBase_Operation.h>
 #include <ModuleBase_OperationDescription.h>
 #include <ModuleBase_SelectionValidator.h>
-#include "ModuleBase_WidgetFactory.h"
+#include <ModuleBase_WidgetFactory.h>
+#include <ModuleBase_Tools.h>
+#include <ModuleBase_IViewer.h>
+#include<ModuleBase_FilterFactory.h>
 
 #include <Config_Common.h>
 #include <Config_FeatureMessage.h>
 #include <Config_PointerMessage.h>
 #include <Config_ModuleReader.h>
+#include <Config_PropManager.h>
+#include <Config_SelectionFilterMessage.h>
 
 #include <QApplication>
 #include <QFileDialog>
@@ -74,12 +82,41 @@
 
 QMap<QString, QString> XGUI_Workshop::myIcons;
 
-QString XGUI_Workshop::featureIcon(const std::string& theId)
+
+QIcon XGUI_Workshop::featureIcon(const FeaturePtr& theFeature)
 {
-  QString aId(theId.c_str());
-  if (myIcons.contains(aId))
-    return myIcons[aId];
-  return QString();
+  QIcon anIcon;
+
+  std::string aKind = theFeature->getKind();
+  QString aId(aKind.c_str());
+  if (!myIcons.contains(aId))
+    return anIcon;
+
+  QString anIconString = myIcons[aId];
+
+  ModelAPI_ExecState aState = theFeature->data()->execState();
+  switch(aState) {
+    case ModelAPI_StateDone:
+    case ModelAPI_StateNothing: {
+      anIcon = QIcon(anIconString);
+    }
+    break;
+    case ModelAPI_StateMustBeUpdated: {
+      anIcon = ModuleBase_Tools::lighter(anIconString);
+    }
+    break;
+    case ModelAPI_StateExecFailed: {
+      anIcon = ModuleBase_Tools::composite(":pictures/exec_state_failed.png", anIconString);
+    }
+    break;
+    case ModelAPI_StateInvalidArgument: {
+      anIcon = ModuleBase_Tools::composite(":pictures/exec_state_invalid_parameters.png",
+                                           anIconString);
+    }
+    break;
+    default: break;  
+  }
+  return anIcon;  
 }
 
 XGUI_Workshop::XGUI_Workshop(XGUI_SalomeConnector* theConnector)
@@ -93,7 +130,7 @@ XGUI_Workshop::XGUI_Workshop(XGUI_SalomeConnector* theConnector)
       myUpdatePrefs(false),
       myPartActivating(false)
 {
-  myMainWindow = mySalomeConnector ? 0 : new XGUI_MainWindow();
+  myMainWindow = mySalomeConnector ? 0 : new AppElements_MainWindow();
 
   myDisplayer = new XGUI_Displayer(this);
 
@@ -108,18 +145,22 @@ XGUI_Workshop::XGUI_Workshop(XGUI_SalomeConnector* theConnector)
           SLOT(onContextMenuCommand(const QString&, bool)));
 
   myViewerProxy = new XGUI_ViewerProxy(this);
-  connect(myViewerProxy, SIGNAL(selectionChanged()), this, SLOT(updateCommandsOnViewSelection()));
+  connect(myViewerProxy, SIGNAL(selectionChanged()),
+          myActionsMgr,  SLOT(updateOnViewSelection()));
 
   myModuleConnector = new XGUI_ModuleConnector(this);
 
-  connect(myOperationMgr, SIGNAL(operationStarted()), SLOT(onOperationStarted()));
-  connect(myOperationMgr, SIGNAL(operationResumed()), SLOT(onOperationStarted()));
+  connect(myOperationMgr, SIGNAL(operationStarted(ModuleBase_Operation*)), 
+          SLOT(onOperationStarted(ModuleBase_Operation*)));
+  connect(myOperationMgr, SIGNAL(operationResumed(ModuleBase_Operation*)),
+          SLOT(onOperationResumed(ModuleBase_Operation*)));
   connect(myOperationMgr, SIGNAL(operationStopped(ModuleBase_Operation*)),
           SLOT(onOperationStopped(ModuleBase_Operation*)));
+  connect(myOperationMgr, SIGNAL(operationCommitted(ModuleBase_Operation*)), 
+          SLOT(onOperationCommitted(ModuleBase_Operation*)));
+  connect(myOperationMgr, SIGNAL(operationAborted(ModuleBase_Operation*)), 
+          SLOT(onOperationAborted(ModuleBase_Operation*)));
   connect(myMainWindow, SIGNAL(exitKeySequence()), SLOT(onExit()));
-  connect(myOperationMgr, SIGNAL(operationStarted()), myActionsMgr, SLOT(update()));
-  connect(myOperationMgr, SIGNAL(operationStopped(ModuleBase_Operation*)), myActionsMgr,
-          SLOT(update()));
   connect(this, SIGNAL(errorOccurred(const QString&)), myErrorDlg, SLOT(addError(const QString&)));
 }
 
@@ -133,12 +174,14 @@ XGUI_Workshop::~XGUI_Workshop(void)
 void XGUI_Workshop::startApplication()
 {
   initMenu();
+
+  Config_PropManager::registerProp("Plugins", "default_path", "Default Path",
+                                   Config_Prop::Directory, "");
+
   //Initialize event listening
   Events_Loop* aLoop = Events_Loop::loop();
   aLoop->registerListener(this, Events_Error::errorID());  //!< Listening application errors.
-  //TODO(sbh): Implement static method to extract event id [SEID]
-  aLoop->registerListener(this, Events_Loop::eventByName(EVENT_FEATURE_LOADED));
-  // TODO Is it good to use non standard event within workshop?
+  aLoop->registerListener(this, Events_Loop::eventByName(Config_FeatureMessage::GUI_EVENT()));
   aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OPERATION_LAUNCHED));
   aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
   aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_CREATED));
@@ -149,14 +192,19 @@ void XGUI_Workshop::startApplication()
   aLoop->registerListener(this, Events_Loop::eventByName("CurrentDocumentChanged"));
   aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_TOSHOW));
   aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_TOHIDE));
+  aLoop->registerListener(this, Events_Loop::eventByName(EVENT_SELFILTER_LOADED));
 
   registerValidators();
+
+  // Calling of  loadCustomProps before activating module is required
+  // by Config_PropManger to restore user-defined path to plugins
+  ModuleBase_Preferences::loadCustomProps();
   activateModule();
   if (myMainWindow) {
     myMainWindow->show();
     updateCommandStatus();
   }
-  XGUI_Preferences::loadCustomProps();
+  
   onNew();
 }
 
@@ -167,22 +215,39 @@ void XGUI_Workshop::initMenu()
 
   if (isSalomeMode()) {
     // Create only Undo, Redo commands
-    QAction* aAction = salomeConnector()->addEditCommand("UNDO_CMD", tr("Undo"),
+    QAction* aAction = salomeConnector()->addDesktopCommand("UNDO_CMD", tr("Undo"),
                                                          tr("Undo last command"),
                                                          QIcon(":pictures/undo.png"),
-                                                         QKeySequence::Undo, false);
+                                                         QKeySequence::Undo, false, "MEN_DESK_EDIT");
     connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onUndo()));
-    aAction = salomeConnector()->addEditCommand("REDO_CMD", tr("Redo"), tr("Redo last command"),
+    aAction = salomeConnector()->addDesktopCommand("REDO_CMD", tr("Redo"), tr("Redo last command"),
                                                 QIcon(":pictures/redo.png"), QKeySequence::Redo,
-                                                false);
+                                                false, "MEN_DESK_EDIT");
     connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onRedo()));
-    salomeConnector()->addEditMenuSeparator();
+    salomeConnector()->addDesktopMenuSeparator("MEN_DESK_EDIT");
+    aAction = salomeConnector()->addDesktopCommand("REBUILD_CMD", tr("Rebuild"), tr("Rebuild data objects"),
+                                                QIcon(":pictures/rebuild.png"), QKeySequence(),
+                                                false, "MEN_DESK_EDIT");
+    connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onRebuild()));
+    salomeConnector()->addDesktopMenuSeparator("MEN_DESK_EDIT");
+
+    aAction = salomeConnector()->addDesktopCommand("SAVEAS_CMD", tr("Export NewGeom..."), tr("Export the current document into a NewGeom file"),
+                                                QIcon(), QKeySequence(),
+                                                false, "MEN_DESK_FILE");
+    connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onSaveAs()));
+
+    aAction = salomeConnector()->addDesktopCommand("OPEN_CMD", tr("Import NewGeom..."), tr("Import a NewGeom file"),
+                                                QIcon(), QKeySequence(),
+                                                false, "MEN_DESK_FILE");
+    connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onOpen()));
+    salomeConnector()->addDesktopMenuSeparator("MEN_DESK_FILE");
+
     return;
   }
   // File commands group
-  XGUI_MenuGroupPanel* aGroup = myMainWindow->menuObject()->generalPage();
+  AppElements_MenuGroupPanel* aGroup = myMainWindow->menuObject()->generalPage();
 
-  XGUI_Command* aCommand;
+  AppElements_Command* aCommand;
 
   aCommand = aGroup->addFeature("SAVE_CMD", tr("Save..."), tr("Save the document"),
                                 QIcon(":pictures/save.png"), QKeySequence::Save);
@@ -230,14 +295,14 @@ void XGUI_Workshop::initMenu()
 }
 
 //******************************************************
-XGUI_Workbench* XGUI_Workshop::addWorkbench(const QString& theName)
+AppElements_Workbench* XGUI_Workshop::addWorkbench(const QString& theName)
 {
-  XGUI_MainMenu* aMenuBar = myMainWindow->menuObject();
+  AppElements_MainMenu* aMenuBar = myMainWindow->menuObject();
   return aMenuBar->addWorkbench(theName);
 }
 
 //******************************************************
-void XGUI_Workshop::processEvent(const boost::shared_ptr<Events_Message>& theMessage)
+void XGUI_Workshop::processEvent(const std::shared_ptr<Events_Message>& theMessage)
 {
   if (QApplication::instance()->thread() != QThread::currentThread()) {
     #ifdef _DEBUG
@@ -250,9 +315,9 @@ void XGUI_Workshop::processEvent(const boost::shared_ptr<Events_Message>& theMes
   }
 
   //A message to start feature creation received.
-  if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_FEATURE_LOADED)) {
-    boost::shared_ptr<Config_FeatureMessage> aFeatureMsg =
-       boost::dynamic_pointer_cast<Config_FeatureMessage>(theMessage);
+  if (theMessage->eventID() == Events_Loop::loop()->eventByName(Config_FeatureMessage::GUI_EVENT())) {
+    std::shared_ptr<Config_FeatureMessage> aFeatureMsg =
+       std::dynamic_pointer_cast<Config_FeatureMessage>(theMessage);
     if (!aFeatureMsg->isInternal()) {
       addFeature(aFeatureMsg);
     }
@@ -260,8 +325,8 @@ void XGUI_Workshop::processEvent(const boost::shared_ptr<Events_Message>& theMes
 
   // Process creation of Part
   else if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_OBJECT_CREATED)) {
-    boost::shared_ptr<ModelAPI_ObjectUpdatedMessage> aUpdMsg =
-        boost::dynamic_pointer_cast<ModelAPI_ObjectUpdatedMessage>(theMessage);
+    std::shared_ptr<ModelAPI_ObjectUpdatedMessage> aUpdMsg =
+        std::dynamic_pointer_cast<ModelAPI_ObjectUpdatedMessage>(theMessage);
     onFeatureCreatedMsg(aUpdMsg);
     if (myUpdatePrefs) {
       if (mySalomeConnector)
@@ -275,22 +340,22 @@ void XGUI_Workshop::processEvent(const boost::shared_ptr<Events_Message>& theMes
 
   // Redisplay feature
   else if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY)) {
-    boost::shared_ptr<ModelAPI_ObjectUpdatedMessage> aUpdMsg =
-        boost::dynamic_pointer_cast<ModelAPI_ObjectUpdatedMessage>(theMessage);
+    std::shared_ptr<ModelAPI_ObjectUpdatedMessage> aUpdMsg =
+        std::dynamic_pointer_cast<ModelAPI_ObjectUpdatedMessage>(theMessage);
     onFeatureRedisplayMsg(aUpdMsg);
   }
 
   //Update property panel on corresponding message. If there is no current operation (no
   //property panel), or received message has different feature to the current - do nothing.
   else if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_OBJECT_UPDATED)) {
-    boost::shared_ptr<ModelAPI_ObjectUpdatedMessage> anUpdateMsg =
-        boost::dynamic_pointer_cast<ModelAPI_ObjectUpdatedMessage>(theMessage);
+    std::shared_ptr<ModelAPI_ObjectUpdatedMessage> anUpdateMsg =
+        std::dynamic_pointer_cast<ModelAPI_ObjectUpdatedMessage>(theMessage);
     onFeatureUpdatedMsg(anUpdateMsg);
   }
 
   else if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_OBJECT_DELETED)) {
-    boost::shared_ptr<ModelAPI_ObjectDeletedMessage> aDelMsg =
-        boost::dynamic_pointer_cast<ModelAPI_ObjectDeletedMessage>(theMessage);
+    std::shared_ptr<ModelAPI_ObjectDeletedMessage> aDelMsg =
+        std::dynamic_pointer_cast<ModelAPI_ObjectDeletedMessage>(theMessage);
     onObjectDeletedMsg(aDelMsg);
   }
 
@@ -302,10 +367,10 @@ void XGUI_Workshop::processEvent(const boost::shared_ptr<Events_Message>& theMes
   }
 
   else if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_OBJECT_TOSHOW)) {
-    boost::shared_ptr<ModelAPI_ObjectUpdatedMessage> anUpdateMsg =
-        boost::dynamic_pointer_cast<ModelAPI_ObjectUpdatedMessage>(theMessage);
+    std::shared_ptr<ModelAPI_ObjectUpdatedMessage> anUpdateMsg =
+        std::dynamic_pointer_cast<ModelAPI_ObjectUpdatedMessage>(theMessage);
     const std::set<ObjectPtr>& aObjList = anUpdateMsg->objects();
-    QList<ObjectPtr> aList;
+    QObjectPtrList aList;
     std::set<ObjectPtr>::const_iterator aIt;
     for (aIt = aObjList.cbegin(); aIt != aObjList.cend(); ++aIt)
       aList.append(*aIt);
@@ -313,10 +378,10 @@ void XGUI_Workshop::processEvent(const boost::shared_ptr<Events_Message>& theMes
   }
 
   else if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_OBJECT_TOHIDE)) {
-    boost::shared_ptr<ModelAPI_ObjectUpdatedMessage> anUpdateMsg =
-        boost::dynamic_pointer_cast<ModelAPI_ObjectUpdatedMessage>(theMessage);
+    std::shared_ptr<ModelAPI_ObjectUpdatedMessage> anUpdateMsg =
+        std::dynamic_pointer_cast<ModelAPI_ObjectUpdatedMessage>(theMessage);
     const std::set<ObjectPtr>& aObjList = anUpdateMsg->objects();
-    QList<ObjectPtr> aList;
+    QObjectPtrList aList;
     std::set<ObjectPtr>::const_iterator aIt;
     for (aIt = aObjList.cbegin(); aIt != aObjList.cend(); ++aIt)
       aList.append(*aIt);
@@ -325,8 +390,8 @@ void XGUI_Workshop::processEvent(const boost::shared_ptr<Events_Message>& theMes
 
   //An operation passed by message. Start it, process and commit.
   else if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_OPERATION_LAUNCHED)) {
-    boost::shared_ptr<Config_PointerMessage> aPartSetMsg =
-        boost::dynamic_pointer_cast<Config_PointerMessage>(theMessage);
+    std::shared_ptr<Config_PointerMessage> aPartSetMsg =
+        std::dynamic_pointer_cast<Config_PointerMessage>(theMessage);
     //myPropertyPanel->cleanContent();
     ModuleBase_Operation* anOperation = (ModuleBase_Operation*) aPartSetMsg->pointer();
 
@@ -339,10 +404,10 @@ void XGUI_Workshop::processEvent(const boost::shared_ptr<Events_Message>& theMes
     }
   }
   else if (theMessage->eventID() == Events_Loop::loop()->eventByName("CurrentDocumentChanged")) {
+    myActionsMgr->update();
     // Find and Activate active part
     if (myPartActivating)
       return;
-    myActionsMgr->update();
     SessionPtr aMgr = ModelAPI_Session::get();
     DocumentPtr aActiveDoc = aMgr->activeDocument();
     DocumentPtr aDoc = aMgr->moduleDocument();
@@ -352,7 +417,7 @@ void XGUI_Workshop::processEvent(const boost::shared_ptr<Events_Message>& theMes
     }
     std::string aGrpName = ModelAPI_ResultPart::group();
     for (int i = 0; i < aDoc->size(aGrpName); i++) {
-      ResultPartPtr aPart = boost::dynamic_pointer_cast<ModelAPI_ResultPart>(aDoc->object(aGrpName, i));
+      ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aDoc->object(aGrpName, i));
       if (aPart->partDoc() == aActiveDoc) {
         activatePart(aPart); // Activate a part which corresponds to active Doc
         return;
@@ -361,9 +426,23 @@ void XGUI_Workshop::processEvent(const boost::shared_ptr<Events_Message>& theMes
     // If not found then activate global document
     activatePart(ResultPartPtr()); 
 
-  } else {
+  }
+  else if (theMessage->eventID() == Events_Loop::eventByName(EVENT_SELFILTER_LOADED)) {
+    std::shared_ptr<Config_SelectionFilterMessage> aMsg = 
+      std::dynamic_pointer_cast<Config_SelectionFilterMessage>(theMessage);
+    if (aMsg) {
+      ModuleBase_FilterFactory* aFactory = moduleConnector()->selectionFilters();
+      if (!aMsg->attributeId().empty()) {
+        aFactory->assignFilter(aMsg->selectionFilterId(), aMsg->featureId(), aMsg->attributeId(),
+                               aMsg->parameters());
+      }
+    }
+  }
+
+  
+  else {
     //Show error dialog if error message received.
-    boost::shared_ptr<Events_Error> anAppError = boost::dynamic_pointer_cast<Events_Error>(theMessage);
+    std::shared_ptr<Events_Error> anAppError = std::dynamic_pointer_cast<Events_Error>(theMessage);
     if (anAppError) {
       emit errorOccurred(QString::fromLatin1(anAppError->description()));
     }
@@ -385,7 +464,7 @@ void XGUI_Workshop::onStartWaiting()
 }
 
 //******************************************************
-void XGUI_Workshop::onFeatureUpdatedMsg(const boost::shared_ptr<ModelAPI_ObjectUpdatedMessage>& theMsg)
+void XGUI_Workshop::onFeatureUpdatedMsg(const std::shared_ptr<ModelAPI_ObjectUpdatedMessage>& theMsg)
 {
   std::set<ObjectPtr> aFeatures = theMsg->objects();
   if (myOperationMgr->hasOperation()) {
@@ -405,28 +484,32 @@ void XGUI_Workshop::onFeatureUpdatedMsg(const boost::shared_ptr<ModelAPI_ObjectU
 }
 
 //******************************************************
-void XGUI_Workshop::onFeatureRedisplayMsg(const boost::shared_ptr<ModelAPI_ObjectUpdatedMessage>& theMsg)
+void XGUI_Workshop::onFeatureRedisplayMsg(const std::shared_ptr<ModelAPI_ObjectUpdatedMessage>& theMsg)
 {
   std::set<ObjectPtr> aObjects = theMsg->objects();
   std::set<ObjectPtr>::const_iterator aIt;
   for (aIt = aObjects.begin(); aIt != aObjects.end(); ++aIt) {
     ObjectPtr aObj = (*aIt);
-    if (!aObj->data() || !aObj->data()->isValid() || aObj->document()->isConcealed(aObj))
+    bool aHide = !aObj->data() || !aObj->data()->isValid();
+    if (!aHide) { // check that this is not hidden result
+      ResultPtr aRes = std::dynamic_pointer_cast<ModelAPI_Result>(aObj);
+      aHide = aRes && aRes->isConcealed();
+    }
+    if (aHide)
       myDisplayer->erase(aObj, false);
     else {
       if (myDisplayer->isVisible(aObj))  {
         myDisplayer->display(aObj, false);  // In order to update presentation
         if (myOperationMgr->hasOperation()) {
           ModuleBase_Operation* aOperation = myOperationMgr->currentOperation();
-          if (!aOperation->hasObject(aObj))
-            if (!myDisplayer->isActive(aObj))
-              myDisplayer->activate(aObj);
+          if (aOperation->hasObject(aObj) && myDisplayer->isActive(aObj))
+            myDisplayer->deactivate(aObj);
         }
       } else {
         if (myOperationMgr->hasOperation()) {
           ModuleBase_Operation* aOperation = myOperationMgr->currentOperation();
           // Display only current operation results if operation has preview
-          if (aOperation->hasObject(aObj) && aOperation->hasPreview()) {
+          if (aOperation->hasObject(aObj)/* && aOperation->hasPreview()*/) {
             myDisplayer->display(aObj, false);
             // Deactivate object of current operation from selection
             if (myDisplayer->isActive(aObj))
@@ -440,7 +523,7 @@ void XGUI_Workshop::onFeatureRedisplayMsg(const boost::shared_ptr<ModelAPI_Objec
 }
 
 //******************************************************
-void XGUI_Workshop::onFeatureCreatedMsg(const boost::shared_ptr<ModelAPI_ObjectUpdatedMessage>& theMsg)
+void XGUI_Workshop::onFeatureCreatedMsg(const std::shared_ptr<ModelAPI_ObjectUpdatedMessage>& theMsg)
 {
   std::set<ObjectPtr> aObjects = theMsg->objects();
 
@@ -448,15 +531,14 @@ void XGUI_Workshop::onFeatureCreatedMsg(const boost::shared_ptr<ModelAPI_ObjectU
   bool aHasPart = false;
   bool isDisplayed = false;
   for (aIt = aObjects.begin(); aIt != aObjects.end(); ++aIt) {
-    ResultPartPtr aPart = boost::dynamic_pointer_cast<ModelAPI_ResultPart>(*aIt);
+    ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(*aIt);
     if (aPart) {
       aHasPart = true;
       // If a feature is created from the aplication's python console  
       // it doesn't stored in the operation mgr and doesn't displayed
     } else if (myOperationMgr->hasOperation()) {
       ModuleBase_Operation* aOperation = myOperationMgr->currentOperation();
-      if (!(*aIt)->document()->isConcealed(*aIt) &&
-          aOperation->hasObject(*aIt)) {  // Display only current operation results
+      if (aOperation->hasObject(*aIt)) {  // Display only current operation results
         myDisplayer->display(*aIt, false);
         isDisplayed = true;
       }
@@ -472,7 +554,7 @@ void XGUI_Workshop::onFeatureCreatedMsg(const boost::shared_ptr<ModelAPI_ObjectU
 }
 
 //******************************************************
-void XGUI_Workshop::onObjectDeletedMsg(const boost::shared_ptr<ModelAPI_ObjectDeletedMessage>& theMsg)
+void XGUI_Workshop::onObjectDeletedMsg(const std::shared_ptr<ModelAPI_ObjectDeletedMessage>& theMsg)
 {
   if (myObjectBrowser)
     myObjectBrowser->processEvent(theMsg);
@@ -480,50 +562,34 @@ void XGUI_Workshop::onObjectDeletedMsg(const boost::shared_ptr<ModelAPI_ObjectDe
 }
 
 //******************************************************
-void XGUI_Workshop::onOperationStarted()
+void XGUI_Workshop::onOperationStarted(ModuleBase_Operation* theOperation)
 {
-  ModuleBase_Operation* aOperation = myOperationMgr->currentOperation();
-  if (this->isSalomeMode()) 
-    aOperation->setNestedFeatures(mySalomeConnector->nestedActions(aOperation->id()));
-  else 
-    aOperation->setNestedFeatures(myActionsMgr->nestedCommands(aOperation->id()));
-  
-  if (aOperation->getDescription()->hasXmlRepresentation()) {  //!< No need for property panel
-    connectWithOperation(aOperation);
-
-    showPropertyPanel();
-    QString aXmlRepr = aOperation->getDescription()->xmlRepresentation();
-    ModuleBase_WidgetFactory aFactory = ModuleBase_WidgetFactory(aXmlRepr.toStdString(),
-                                                                 myModuleConnector);
-
-    myPropertyPanel->cleanContent();
-    aFactory.createWidget(myPropertyPanel->contentWidget());
-
-    QList<ModuleBase_ModelWidget*> aWidgets = aFactory.getModelWidgets();
-    QList<ModuleBase_ModelWidget*>::const_iterator anIt = aWidgets.begin(), aLast = aWidgets.end();
-    ModuleBase_ModelWidget* aWidget;
-    for (; anIt != aLast; anIt++) {
-      aWidget = *anIt;
-      aWidget->setFeature(aOperation->feature());
-      aWidget->enableFocusProcessing();
-      QObject::connect(aWidget, SIGNAL(valuesChanged()), this, SLOT(onWidgetValuesChanged()));
-      // Init default values
-      if (!aOperation->isEditOperation() && !aWidget->isComputedDefault()) {
-        aWidget->storeValue();
-      }
-    }
+  setNestedFeatures(theOperation);
 
-    myPropertyPanel->setModelWidgets(aWidgets);
-    myPropertyPanel->onActivateNextWidget(NULL);
-    // Widget activation (from the previous method) may commit the current operation
-    // if pre-selection is enougth for it. So we shouldn't update prop panel's title
-    if(myOperationMgr->isCurrentOperation(aOperation)) {
-      myPropertyPanel->setWindowTitle(aOperation->getDescription()->description());
-    }
+  if (theOperation->getDescription()->hasXmlRepresentation()) {  //!< No need for property panel
+    connectWithOperation(theOperation);
+    setPropertyPanel(theOperation);
   }
   updateCommandStatus();
+
+  myModule->operationStarted(theOperation);
 }
 
+//******************************************************
+void XGUI_Workshop::onOperationResumed(ModuleBase_Operation* theOperation)
+{
+  setNestedFeatures(theOperation);
+
+  if (theOperation->getDescription()->hasXmlRepresentation()) {  //!< No need for property panel
+    connectWithOperation(theOperation);
+    setPropertyPanel(theOperation);
+  }
+  updateCommandStatus();
+
+  myModule->operationResumed(theOperation);
+}
+
+
 //******************************************************
 void XGUI_Workshop::onOperationStopped(ModuleBase_Operation* theOperation)
 {
@@ -531,13 +597,72 @@ void XGUI_Workshop::onOperationStopped(ModuleBase_Operation* theOperation)
   updateCommandStatus();
   hidePropertyPanel();
   myPropertyPanel->cleanContent();
+
+  // Activate objects created by current operation
+  FeaturePtr aFeature = theOperation->feature();
+  myDisplayer->activate(aFeature);
+  const std::list<ResultPtr>& aResults = aFeature->results();
+  std::list<ResultPtr>::const_iterator aIt;
+  for (aIt = aResults.cbegin(); aIt != aResults.cend(); ++aIt) {
+    myDisplayer->activate(*aIt);
+  }
+  myModule->operationStopped(theOperation);
+}
+
+
+void XGUI_Workshop::onOperationCommitted(ModuleBase_Operation* theOperation)
+{
+  myModule->operationCommitted(theOperation);
+}
+
+void XGUI_Workshop::onOperationAborted(ModuleBase_Operation* theOperation)
+{
+  myModule->operationAborted(theOperation);
+}
+
+void XGUI_Workshop::setNestedFeatures(ModuleBase_Operation* theOperation)
+{
+  if (this->isSalomeMode()) 
+    theOperation->setNestedFeatures(mySalomeConnector->nestedActions(theOperation->id()));
+  else 
+    theOperation->setNestedFeatures(myActionsMgr->nestedCommands(theOperation->id()));
+}
+
+void XGUI_Workshop::setPropertyPanel(ModuleBase_Operation* theOperation)
+{
+  showPropertyPanel();
+  QString aXmlRepr = theOperation->getDescription()->xmlRepresentation();
+  ModuleBase_WidgetFactory aFactory = ModuleBase_WidgetFactory(aXmlRepr.toStdString(),
+                                                                myModuleConnector);
+
+  myPropertyPanel->cleanContent();
+  aFactory.createWidget(myPropertyPanel->contentWidget());
+  ModuleBase_Tools::zeroMargins(myPropertyPanel->contentWidget());
+
+  QList<ModuleBase_ModelWidget*> aWidgets = aFactory.getModelWidgets();
+  foreach (ModuleBase_ModelWidget* aWidget, aWidgets) {
+    aWidget->setFeature(theOperation->feature());
+    aWidget->enableFocusProcessing();
+    QObject::connect(aWidget, SIGNAL(valuesChanged()), this, SLOT(onWidgetValuesChanged()));
+    // Init default values
+    if (!theOperation->isEditOperation() && !aWidget->isComputedDefault()) {
+      aWidget->storeValue();
+    }
+  }
+  
+  myPropertyPanel->setModelWidgets(aWidgets);
+  theOperation->setPropertyPanel(myPropertyPanel);
+
+  myModule->propertyPanelDefined(theOperation);
+
+  myPropertyPanel->setWindowTitle(theOperation->getDescription()->description());
 }
 
 bool XGUI_Workshop::event(QEvent * theEvent)
 {
   PostponeMessageQtEvent* aPostponedEv = dynamic_cast<PostponeMessageQtEvent*>(theEvent);
   if (aPostponedEv) {
-    boost::shared_ptr<Events_Message> aEventPtr = aPostponedEv->postponedMessage();
+    std::shared_ptr<Events_Message> aEventPtr = aPostponedEv->postponedMessage();
     processEvent(aEventPtr);
     return true;
   }
@@ -547,7 +672,7 @@ bool XGUI_Workshop::event(QEvent * theEvent)
 /*
  *
  */
-void XGUI_Workshop::addFeature(const boost::shared_ptr<Config_FeatureMessage>& theMessage)
+void XGUI_Workshop::addFeature(const std::shared_ptr<Config_FeatureMessage>& theMessage)
 {
   if (!theMessage) {
 #ifdef _DEBUG
@@ -571,18 +696,20 @@ void XGUI_Workshop::addFeature(const boost::shared_ptr<Config_FeatureMessage>& t
                                                      QKeySequence(),
                                                      isUsePropPanel);
     salomeConnector()->setNestedActions(aFeatureId, aNestedFeatures.split(" ", QString::SkipEmptyParts));
+    salomeConnector()->setDocumentKind(aFeatureId, QString::fromStdString(theMessage->documentKind()));
+
     myActionsMgr->addCommand(aAction);
-    myModule->featureCreated(aAction);
+    myModule->actionCreated(aAction);
   } else {
 
-    XGUI_MainMenu* aMenuBar = myMainWindow->menuObject();
-    XGUI_Workbench* aPage = aMenuBar->findWorkbench(aWchName);
+    AppElements_MainMenu* aMenuBar = myMainWindow->menuObject();
+    AppElements_Workbench* aPage = aMenuBar->findWorkbench(aWchName);
     if (!aPage) {
       aPage = addWorkbench(aWchName);
     }
     //Find or create Group
     QString aGroupName = QString::fromStdString(theMessage->groupId());
-    XGUI_MenuGroupPanel* aGroup = aPage->findGroup(aGroupName);
+    AppElements_MenuGroupPanel* aGroup = aPage->findGroup(aGroupName);
     if (!aGroup) {
       aGroup = aPage->addGroup(aGroupName);
     }
@@ -591,7 +718,7 @@ void XGUI_Workshop::addFeature(const boost::shared_ptr<Config_FeatureMessage>& t
     QKeySequence aHotKey = myActionsMgr->registerShortcut(
         QString::fromStdString(theMessage->keysequence()));
     // Create feature...
-    XGUI_Command* aCommand = aGroup->addFeature(aFeatureId,
+    AppElements_Command* aCommand = aGroup->addFeature(aFeatureId,
                                                 QString::fromStdString(theMessage->text()),
                                                 QString::fromStdString(theMessage->tooltip()),
                                                 QIcon(theMessage->icon().c_str()),
@@ -600,7 +727,7 @@ void XGUI_Workshop::addFeature(const boost::shared_ptr<Config_FeatureMessage>& t
                                                 isUsePropPanel);
     aCommand->setNestedCommands(aNestedFeatures.split(" ", QString::SkipEmptyParts));
     myActionsMgr->addCommand(aCommand);
-    myModule->featureCreated(aCommand);
+    myModule->actionCreated(aCommand);
   }
 }
 
@@ -615,7 +742,7 @@ void XGUI_Workshop::connectWithOperation(ModuleBase_Operation* theOperation)
   if (isSalomeMode()) {
     aCommand = salomeConnector()->command(theOperation->getDescription()->operationId());
   } else {
-    XGUI_MainMenu* aMenu = myMainWindow->menuObject();
+    AppElements_MainMenu* aMenu = myMainWindow->menuObject();
     FeaturePtr aFeature = theOperation->feature();
     if(aFeature)
       aCommand = aMenu->feature(QString::fromStdString(aFeature->getKind()));
@@ -700,7 +827,7 @@ void XGUI_Workshop::onOpen()
     } else if (anAnswer == QMessageBox::Cancel) {
       return;
     }
-    aSession->moduleDocument()->close();
+    aSession->closeAll();
     myCurrentDir = "";
   }
 
@@ -733,7 +860,8 @@ bool XGUI_Workshop::onSave()
   std::list<std::string> aFiles;
   saveDocument(myCurrentDir, aFiles);
   updateCommandStatus();
-  myMainWindow->setModifiedState(false);
+  if (!isSalomeMode())
+    myMainWindow->setModifiedState(false);
   return true;
 }
 
@@ -804,7 +932,7 @@ void XGUI_Workshop::onRebuild()
     aMgr->startOperation();
   }
   static const Events_ID aRebuildEvent = Events_Loop::loop()->eventByName("Rebuild");
-  Events_Loop::loop()->send(boost::shared_ptr<Events_Message>(
+  Events_Loop::loop()->send(std::shared_ptr<Events_Message>(
     new Events_Message(aRebuildEvent, this)));
   if (!aWasOperation) {
     aMgr->finishOperation();
@@ -814,17 +942,17 @@ void XGUI_Workshop::onRebuild()
 //******************************************************
 void XGUI_Workshop::onPreferences()
 {
-  XGUI_Prefs aModif;
-  XGUI_Preferences::editPreferences(aModif);
+  ModuleBase_Prefs aModif;
+  ModuleBase_Preferences::editPreferences(aModif);
   if (aModif.size() > 0) {
     QString aSection;
-    foreach (XGUI_Pref aPref, aModif)
+    foreach (ModuleBase_Pref aPref, aModif)
     {
       aSection = aPref.first;
-      if (aSection == XGUI_Preferences::VIEWER_SECTION) {
+      if (aSection == ModuleBase_Preferences::VIEWER_SECTION) {
         if (!isSalomeMode())
           myMainWindow->viewer()->updateFromResources();
-      } else if (aSection == XGUI_Preferences::MENU_SECTION) {
+      } else if (aSection == ModuleBase_Preferences::MENU_SECTION) {
         if (!isSalomeMode())
           myMainWindow->menuObject()->updateFromResources();
       }
@@ -879,7 +1007,7 @@ ModuleBase_IModule* XGUI_Workshop::loadModule(const QString& theModule)
   }
 #endif
 
-  ModuleBase_IModule* aModule = crtInst ? crtInst(this) : 0;
+  ModuleBase_IModule* aModule = crtInst ? crtInst(myModuleConnector) : 0;
 
   if (!err.isEmpty()) {
     if (mainWindow()) {
@@ -911,14 +1039,13 @@ void XGUI_Workshop::updateCommandStatus()
   if (isSalomeMode()) {  // update commands in SALOME mode
     aCommands = salomeConnector()->commandList();
   } else {
-    XGUI_MainMenu* aMenuBar = myMainWindow->menuObject();
-    foreach (XGUI_Command* aCmd, aMenuBar->features())
+    AppElements_MainMenu* aMenuBar = myMainWindow->menuObject();
+    foreach (AppElements_Command* aCmd, aMenuBar->features())
       aCommands.append(aCmd);
   }
   SessionPtr aMgr = ModelAPI_Session::get();
   if (aMgr->hasModuleDocument()) {
-    QAction* aUndoCmd;
-    QAction* aRedoCmd;
+    QAction *aUndoCmd, *aRedoCmd;
     foreach(QAction* aCmd, aCommands) {
       QString aId = aCmd->data().toString();
       if (aId == "UNDO_CMD")
@@ -929,8 +1056,8 @@ void XGUI_Workshop::updateCommandStatus()
         // Enable all commands
         aCmd->setEnabled(true);
     }
-    aUndoCmd->setEnabled(aMgr->canUndo());
-    aRedoCmd->setEnabled(aMgr->canRedo());
+    aUndoCmd->setEnabled(aMgr->canUndo() && !aMgr->isOperation());
+    aRedoCmd->setEnabled(aMgr->canRedo() && !aMgr->isOperation());
   } else {
     foreach(QAction* aCmd, aCommands) {
       QString aId = aCmd->data().toString();
@@ -943,22 +1070,7 @@ void XGUI_Workshop::updateCommandStatus()
     }
   }
   myActionsMgr->update();
-}
-
-//******************************************************
-QList<QAction*> XGUI_Workshop::getModuleCommands() const
-{
-  QList<QAction*> aCommands;
-  if (isSalomeMode()) {  // update commands in SALOME mode
-    aCommands = salomeConnector()->commandList();
-  } else {
-    XGUI_MainMenu* aMenuBar = myMainWindow->menuObject();
-    foreach(XGUI_Command* aCmd, aMenuBar->features())
-    {
-      aCommands.append(aCmd);
-    }
-  }
-  return aCommands;
+  emit commandStatusUpdated();
 }
 
 //******************************************************
@@ -990,21 +1102,21 @@ void XGUI_Workshop::createDockWidgets()
   aDesktop->addDockWidget(Qt::LeftDockWidgetArea, aObjDock);
   myPropertyPanel = new XGUI_PropertyPanel(aDesktop);
   myPropertyPanel->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea | Qt::BottomDockWidgetArea);
+
+  connect(myPropertyPanel, SIGNAL(noMoreWidgets()), myModule, SLOT(onNoMoreWidgets()));
+
   aDesktop->addDockWidget(Qt::LeftDockWidgetArea, myPropertyPanel);
   hidePropertyPanel();  //<! Invisible by default
   hideObjectBrowser();
   aDesktop->tabifyDockWidget(aObjDock, myPropertyPanel);
+  myPropertyPanel->installEventFilter(myOperationMgr);
 
-  QPushButton* aOkBtn = myPropertyPanel->findChild<QPushButton*>(XGUI::PROP_PANEL_OK);
+  QPushButton* aOkBtn = myPropertyPanel->findChild<QPushButton*>(PROP_PANEL_OK);
   connect(aOkBtn, SIGNAL(clicked()), myOperationMgr, SLOT(onCommitOperation()));
-  QPushButton* aCancelBtn = myPropertyPanel->findChild<QPushButton*>(XGUI::PROP_PANEL_CANCEL);
+  QPushButton* aCancelBtn = myPropertyPanel->findChild<QPushButton*>(PROP_PANEL_CANCEL);
   connect(aCancelBtn, SIGNAL(clicked()), myOperationMgr, SLOT(onAbortOperation()));
   connect(myPropertyPanel, SIGNAL(keyReleased(QKeyEvent*)), myOperationMgr,
           SLOT(onKeyReleased(QKeyEvent*)));
-  connect(myPropertyPanel, SIGNAL(widgetActivated(ModuleBase_ModelWidget*)), myOperationMgr,
-          SLOT(onWidgetActivated(ModuleBase_ModelWidget*)));
-  connect(myOperationMgr, SIGNAL(activateNextWidget(ModuleBase_ModelWidget*)), myPropertyPanel,
-          SLOT(onActivateNextWidget(ModuleBase_ModelWidget*)));
   connect(myOperationMgr, SIGNAL(operationValidated(bool)), myPropertyPanel,
           SLOT(setAcceptEnabled(bool)));
 
@@ -1057,7 +1169,7 @@ void XGUI_Workshop::changeCurrentDocument(ObjectPtr theObj)
 {
   SessionPtr aMgr = ModelAPI_Session::get();
   if (theObj) {
-    ResultPartPtr aPart = boost::dynamic_pointer_cast<ModelAPI_ResultPart>(theObj);
+    ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(theObj);
     if (aPart) {
       DocumentPtr aPartDoc = aPart->partDoc();
       if (aPartDoc) {
@@ -1076,7 +1188,7 @@ void XGUI_Workshop::salomeViewerSelectionChanged()
 }
 
 //**************************************************************
-XGUI_SalomeViewer* XGUI_Workshop::salomeViewer() const
+ModuleBase_IViewer* XGUI_Workshop::salomeViewer() const
 {
   return mySalomeConnector->viewer();
 }
@@ -1084,9 +1196,9 @@ XGUI_SalomeViewer* XGUI_Workshop::salomeViewer() const
 //**************************************************************
 void XGUI_Workshop::onContextMenuCommand(const QString& theId, bool isChecked)
 {
-  QList<ObjectPtr> aObjects = mySelector->selection()->selectedObjects();
+  QObjectPtrList aObjects = mySelector->selection()->selectedObjects();
   if ((theId == "ACTIVATE_PART_CMD") && (aObjects.size() > 0)) {
-    ResultPartPtr aPart = boost::dynamic_pointer_cast<ModelAPI_ResultPart>(aObjects.first());
+    ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aObjects.first());
     activatePart(aPart);
   } else if (theId == "DEACTIVATE_PART_CMD")
     activatePart(ResultPartPtr());
@@ -1104,6 +1216,11 @@ void XGUI_Workshop::onContextMenuCommand(const QString& theId, bool isChecked)
     setDisplayMode(aObjects, XGUI_Displayer::Wireframe);
   else if (theId == "HIDEALL_CMD")
     myDisplayer->eraseAll();
+  else if (theId == "EDIT_CMD") {
+    FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObjects.first());
+    if (aFeature)
+      myModule->editFeature(aFeature);
+  }
 }
 
 //**************************************************************
@@ -1113,15 +1230,12 @@ void XGUI_Workshop::onWidgetValuesChanged()
   FeaturePtr aFeature = anOperation->feature();
 
   ModuleBase_ModelWidget* aSenderWidget = dynamic_cast<ModuleBase_ModelWidget*>(sender());
-  //if (aCustom)
-  //  aCustom->storeValue(aFeature);
 
   const QList<ModuleBase_ModelWidget*>& aWidgets = myPropertyPanel->modelWidgets();
   QList<ModuleBase_ModelWidget*>::const_iterator anIt = aWidgets.begin(), aLast = aWidgets.end();
   for (; anIt != aLast; anIt++) {
     ModuleBase_ModelWidget* aCustom = *anIt;
-    if (aCustom && (/*!aCustom->isInitialized(aFeature) ||*/aCustom == aSenderWidget)) {
-      //aCustom->storeValue(aFeature);
+    if (aCustom && (aCustom == aSenderWidget)) {
       aCustom->storeValue();
     }
   }
@@ -1147,14 +1261,14 @@ void XGUI_Workshop::activateLastPart()
   DocumentPtr aDoc = aMgr->moduleDocument();
   std::string aGrpName = ModelAPI_ResultPart::group();
   ObjectPtr aLastPart = aDoc->object(aGrpName, aDoc->size(aGrpName) - 1);
-  ResultPartPtr aPart = boost::dynamic_pointer_cast<ModelAPI_ResultPart>(aLastPart);
+  ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aLastPart);
   if (aPart) {
     activatePart(aPart);
   }
 }
 
 //**************************************************************
-void XGUI_Workshop::deleteObjects(const QList<ObjectPtr>& theList)
+void XGUI_Workshop::deleteObjects(const QObjectPtrList& theList)
 {
   QMainWindow* aDesktop = isSalomeMode() ? salomeConnector()->desktop() : myMainWindow;
   QMessageBox::StandardButton aRes = QMessageBox::warning(
@@ -1166,7 +1280,7 @@ void XGUI_Workshop::deleteObjects(const QList<ObjectPtr>& theList)
     aMgr->startOperation();
     foreach (ObjectPtr aObj, theList)
     {
-      ResultPartPtr aPart = boost::dynamic_pointer_cast<ModelAPI_ResultPart>(aObj);
+      ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aObj);
       if (aPart) {
         DocumentPtr aDoc = aPart->document();
         if (aDoc == aMgr->activeDocument()) {
@@ -1174,7 +1288,7 @@ void XGUI_Workshop::deleteObjects(const QList<ObjectPtr>& theList)
         }
         //aMgr->moduleDocument()->removeFeature(aPart->owner());
       } else {
-        FeaturePtr aFeature = boost::dynamic_pointer_cast<ModelAPI_Feature>(aObj);
+        FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObj);
         if (aFeature)
           aObj->document()->removeFeature(aFeature);
       }
@@ -1185,70 +1299,26 @@ void XGUI_Workshop::deleteObjects(const QList<ObjectPtr>& theList)
 }
 
 //**************************************************************
-void XGUI_Workshop::showObjects(const QList<ObjectPtr>& theList, bool isVisible)
+void XGUI_Workshop::showObjects(const QObjectPtrList& theList, bool isVisible)
 {
   foreach (ObjectPtr aObj, theList)
   {
-    ResultPtr aRes = boost::dynamic_pointer_cast<ModelAPI_Result>(aObj);
-    if (aRes) {
-      if (isVisible) {
-        myDisplayer->display(aRes, false);
-      } else {
-        myDisplayer->erase(aRes, false);
-      }
+    if (isVisible) {
+      myDisplayer->display(aObj, false);
+    } else {
+      myDisplayer->erase(aObj, false);
     }
   }
   myDisplayer->updateViewer();
 }
 
 //**************************************************************
-void XGUI_Workshop::showOnlyObjects(const QList<ObjectPtr>& theList)
+void XGUI_Workshop::showOnlyObjects(const QObjectPtrList& theList)
 {
-  myDisplayer->eraseAll(false);
-  showObjects(theList, true);
+  myDisplayer->showOnly(theList);
 }
 
 
-//**************************************************************
-void XGUI_Workshop::updateCommandsOnViewSelection()
-{
-  XGUI_Selection* aSelection = mySelector->selection();
-  if (aSelection->getSelected().size() == 0)
-    return;
-
-  // Restrict validators to manage only nested (child) features
-  // of the current feature i.e. if current feature is Sketch -
-  // Sketch Features & Constraints can be validated.
-  QStringList aNestedIds;
-  if(myOperationMgr->hasOperation()) {
-    FeaturePtr aFeature = myOperationMgr->currentOperation()->feature();
-    if(aFeature) {
-      aNestedIds << myActionsMgr->nestedCommands(QString::fromStdString(aFeature->getKind()));
-    }
-  }
-  SessionPtr aMgr = ModelAPI_Session::get();
-  ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
-  QList<QAction*> aActions = getModuleCommands();
-  foreach(QAction* aAction, aActions) {
-    QString aId = aAction->data().toString();
-    if(!aNestedIds.contains(aId))
-      continue;
-    std::list<ModelAPI_Validator*> aValidators;
-    std::list<std::list<std::string> > anArguments;
-    aFactory->validators(aId.toStdString(), aValidators, anArguments);
-    std::list<ModelAPI_Validator*>::iterator aValidator = aValidators.begin();
-    for (; aValidator != aValidators.end(); aValidator++) {
-      if (*aValidator) {
-        const ModuleBase_SelectionValidator* aSelValidator =
-            dynamic_cast<const ModuleBase_SelectionValidator*>(*aValidator);
-        if (aSelValidator) {
-          aAction->setEnabled(aSelValidator->isValid(aSelection));
-        }
-      }
-    }
-  }
-}
-
 //**************************************************************
 void XGUI_Workshop::registerValidators() const
 {
@@ -1264,7 +1334,7 @@ void XGUI_Workshop::displayAllResults()
   displayDocumentResults(aRootDoc);
   for (int i = 0; i < aRootDoc->size(ModelAPI_ResultPart::group()); i++) {
     ObjectPtr aObject = aRootDoc->object(ModelAPI_ResultPart::group(), i);
-    ResultPartPtr aPart = boost::dynamic_pointer_cast<ModelAPI_ResultPart>(aObject);
+    ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aObject);
     displayDocumentResults(aPart->partDoc());
   }
   myDisplayer->updateViewer();
@@ -1287,7 +1357,7 @@ void XGUI_Workshop::displayGroupResults(DocumentPtr theDoc, std::string theGroup
 }
 
 //**************************************************************
-void XGUI_Workshop::setDisplayMode(const QList<ObjectPtr>& theList, int theMode)
+void XGUI_Workshop::setDisplayMode(const QObjectPtrList& theList, int theMode)
 {
   foreach(ObjectPtr aObj, theList) {
     myDisplayer->setDisplayMode(aObj, (XGUI_Displayer::DisplayMode)theMode, false);
@@ -1295,3 +1365,15 @@ void XGUI_Workshop::setDisplayMode(const QList<ObjectPtr>& theList, int theMode)
   if (theList.size() > 0)
     myDisplayer->updateViewer();
 }
+
+//**************************************************************
+void XGUI_Workshop::closeDocument()
+{
+  myDisplayer->closeLocalContexts();
+  myDisplayer->eraseAll();
+  objectBrowser()->clearContent();
+
+  SessionPtr aMgr = ModelAPI_Session::get();
+  aMgr->closeAll();
+  objectBrowser()->clearContent();
+}