X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FXGUI%2FXGUI_Workshop.cpp;h=5f7303a78a29de2cf1a78ba4bdb4661282c790ca;hb=f4f5e51326a1846df7684d7fbf5b8315b12a29de;hp=a66f445985eee738a49c90c4f3aa82fdfa00345f;hpb=3395e370f75b7e2322326dbf2cf99472b14be829;p=modules%2Fshaper.git

diff --git a/src/XGUI/XGUI_Workshop.cpp b/src/XGUI/XGUI_Workshop.cpp
old mode 100644
new mode 100755
index a66f44598..5f7303a78
--- a/src/XGUI/XGUI_Workshop.cpp
+++ b/src/XGUI/XGUI_Workshop.cpp
@@ -23,6 +23,7 @@
 #include <XGUI_HistoryMenu.h>
 #include <XGUI_QtEvents.h>
 
+#ifndef HAVE_SALOME
 #include <AppElements_Button.h>
 #include <AppElements_Command.h>
 #include <AppElements_MainMenu.h>
@@ -30,6 +31,7 @@
 #include <AppElements_MenuGroupPanel.h>
 #include <AppElements_Viewer.h>
 #include <AppElements_Workbench.h>
+#endif
 
 #include <ModelAPI_AttributeDocRef.h>
 #include <ModelAPI_AttributeIntArray.h>
@@ -62,6 +64,8 @@
 #include <ModuleBase_SelectionValidator.h>
 #include <ModuleBase_Tools.h>
 #include <ModuleBase_WidgetFactory.h>
+#include <ModuleBase_OperationFeature.h>
+#include <ModuleBase_OperationAction.h>
 
 #include <Config_Common.h>
 #include <Config_FeatureMessage.h>
@@ -76,6 +80,7 @@
 #include <QFileDialog>
 #include <QMessageBox>
 #include <QMdiSubWindow>
+#include <QMainWindow>
 #include <QPushButton>
 #include <QDockWidget>
 #include <QLayout>
@@ -99,6 +104,9 @@
 #include <dlfcn.h>
 #endif
 
+
+QString XGUI_Workshop::MOVE_TO_END_COMMAND = QObject::tr("Move to the end");
+
 //#define DEBUG_DELETE
 
 XGUI_Workshop::XGUI_Workshop(XGUI_SalomeConnector* theConnector)
@@ -110,26 +118,25 @@ XGUI_Workshop::XGUI_Workshop(XGUI_SalomeConnector* theConnector)
       myObjectBrowser(0),
       myDisplayer(0)
 {
-  myMainWindow = mySalomeConnector ? 0 : new AppElements_MainWindow();
+#ifndef HAVE_SALOME
+  myMainWindow = new AppElements_MainWindow();
 
-  if (myMainWindow) {
-    SUIT_ResourceMgr* aResMgr = ModuleBase_Preferences::resourceMgr();
-    bool aCloc = aResMgr->booleanValue("language", "locale", true);
-    if (aCloc)
-      QLocale::setDefault( QLocale::c() );
-    else 
-      QLocale::setDefault( QLocale::system() );
-  }
+  SUIT_ResourceMgr* aResMgr = ModuleBase_Preferences::resourceMgr();
+  bool aCloc = aResMgr->booleanValue("language", "locale", true);
+  if (aCloc)
+    QLocale::setDefault( QLocale::c() );
+  else 
+    QLocale::setDefault( QLocale::system() );
+#endif
 
   myDisplayer = new XGUI_Displayer(this);
 
   mySelector = new XGUI_SelectionMgr(this);
-  //connect(mySelector, SIGNAL(selectionChanged()), this, SLOT(updateModuleCommands()));
+  connect(mySelector, SIGNAL(selectionChanged()), this, SLOT(updateCommandStatus()));
 
   myOperationMgr = new XGUI_OperationMgr(this, 0);
   myActionsMgr = new XGUI_ActionsMgr(this);
   myErrorDlg = new XGUI_ErrorDialog(QApplication::desktop());
-  myErrorMgr = new XGUI_ErrorMgr(this);
   myContextMenuMgr = new XGUI_ContextMenuMgr(this);
   connect(myContextMenuMgr, SIGNAL(actionTriggered(const QString&, bool)), this,
           SLOT(onContextMenuCommand(const QString&, bool)));
@@ -143,6 +150,7 @@ XGUI_Workshop::XGUI_Workshop(XGUI_SalomeConnector* theConnector)
   ModuleBase_IWorkshop* aWorkshop = moduleConnector();
   myOperationMgr->setWorkshop(aWorkshop);
 
+  myErrorMgr = new XGUI_ErrorMgr(this, aWorkshop);
   myEventsListener = new XGUI_WorkshopListener(aWorkshop);
 
   connect(myOperationMgr, SIGNAL(operationStarted(ModuleBase_Operation*)), 
@@ -155,11 +163,11 @@ XGUI_Workshop::XGUI_Workshop(XGUI_SalomeConnector* theConnector)
           SLOT(onOperationCommitted(ModuleBase_Operation*)));
   connect(myOperationMgr, SIGNAL(operationAborted(ModuleBase_Operation*)), 
           SLOT(onOperationAborted(ModuleBase_Operation*)));
-  connect(myOperationMgr, SIGNAL(validationStateChanged(bool)), 
-          myErrorMgr, SLOT(onValidationStateChanged()));
 
-  if (myMainWindow)
-    connect(myMainWindow, SIGNAL(exitKeySequence()), SLOT(onExit()));
+#ifndef HAVE_SALOME
+  connect(myMainWindow, SIGNAL(exitKeySequence()), SLOT(onExit()));
+#endif
+
   connect(this, SIGNAL(errorOccurred(const QString&)), myErrorDlg, SLOT(addError(const QString&)));
   connect(myEventsListener, SIGNAL(errorOccurred(const QString&)),
           myErrorDlg, SLOT(addError(const QString&)));
@@ -200,10 +208,11 @@ void XGUI_Workshop::startApplication()
   // by Config_PropManger to restore user-defined path to plugins
   ModuleBase_Preferences::loadCustomProps();
   createModule();
-  if (myMainWindow) {
-    myMainWindow->show();
-    updateCommandStatus();
-  }
+
+#ifndef HAVE_SALOME
+  myMainWindow->show();
+  updateCommandStatus();
+#endif
   
   onNew();
 
@@ -219,18 +228,31 @@ void XGUI_Workshop::activateModule()
   connect(myDisplayer, SIGNAL(beforeObjectErase(ObjectPtr, AISObjectPtr)),
     myModule, SLOT(onBeforeObjectErase(ObjectPtr, AISObjectPtr)));
 
-  myActionsMgr->update();
+  updateCommandStatus();
 
+  // activate visualized objects in the viewer
+  XGUI_Displayer* aDisplayer = displayer();
+  QObjectPtrList aDisplayed = aDisplayer->displayedObjects();
+  QIntList aModes;
+  module()->activeSelectionModes(aModes);
+  aDisplayer->activateObjects(aModes, aDisplayed);
 }
 
 void XGUI_Workshop::deactivateModule()
 {
   myModule->deactivateSelectionFilters();
 
+  // remove internal displayer filter
+  displayer()->deactivateSelectionFilters();
+
   disconnect(myDisplayer, SIGNAL(objectDisplayed(ObjectPtr, AISObjectPtr)),
     myModule, SLOT(onObjectDisplayed(ObjectPtr, AISObjectPtr)));
   disconnect(myDisplayer, SIGNAL(beforeObjectErase(ObjectPtr, AISObjectPtr)),
     myModule, SLOT(onBeforeObjectErase(ObjectPtr, AISObjectPtr)));
+
+  XGUI_Displayer* aDisplayer = displayer();
+  QObjectPtrList aDisplayed = aDisplayer->displayedObjects();
+  aDisplayer->deactivateObjects(aDisplayed, true);
 }
 
 //******************************************************
@@ -238,48 +260,47 @@ void XGUI_Workshop::initMenu()
 {
   myContextMenuMgr->createActions();
 
-  if (isSalomeMode()) {
-    // Create only Undo, Redo commands
-    QAction* aAction = salomeConnector()->addDesktopCommand("UNDO_CMD", tr("Undo"),
-                                                         tr("Undo last command"),
-                                                         QIcon(":pictures/undo.png"),
-                                                         QKeySequence::Undo, false, "MEN_DESK_EDIT");
-    QString aToolBarTitle = tr( "INF_DESK_TOOLBAR_STANDARD" );
-    salomeConnector()->addActionInToolbar( aAction,aToolBarTitle  );
-
-    connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onUndo()));
-    addHistoryMenu(aAction, SIGNAL(updateUndoHistory(const QList<ActionInfo>&)), SLOT(onUndo(int)));
-
-    aAction = salomeConnector()->addDesktopCommand("REDO_CMD", tr("Redo"), tr("Redo last command"),
-                                                QIcon(":pictures/redo.png"), QKeySequence::Redo,
-                                                false, "MEN_DESK_EDIT");
-    salomeConnector()->addActionInToolbar( aAction, aToolBarTitle );
-
-    connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onRedo()));
-    addHistoryMenu(aAction, SIGNAL(updateRedoHistory(const QList<ActionInfo>&)), SLOT(onRedo(int)));
-
-    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");
-    salomeConnector()->addActionInToolbar( aAction, aToolBarTitle );
-
-    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");
+#ifdef HAVE_SALOME
+  // Create only Undo, Redo commands
+  QAction* aAction = salomeConnector()->addDesktopCommand("UNDO_CMD", tr("Undo"),
+                                                        tr("Undo last command"),
+                                                        QIcon(":pictures/undo.png"),
+                                                        QKeySequence::Undo, false, "MEN_DESK_EDIT");
+  QString aToolBarTitle = tr( "INF_DESK_TOOLBAR_STANDARD" );
+  salomeConnector()->addActionInToolbar( aAction,aToolBarTitle  );
+
+  connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onUndo()));
+  addHistoryMenu(aAction, SIGNAL(updateUndoHistory(const QList<ActionInfo>&)), SLOT(onUndo(int)));
+
+  aAction = salomeConnector()->addDesktopCommand("REDO_CMD", tr("Redo"), tr("Redo last command"),
+                                              QIcon(":pictures/redo.png"), QKeySequence::Redo,
+                                              false, "MEN_DESK_EDIT");
+  salomeConnector()->addActionInToolbar( aAction, aToolBarTitle );
+
+  connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onRedo()));
+  addHistoryMenu(aAction, SIGNAL(updateRedoHistory(const QList<ActionInfo>&)), SLOT(onRedo(int)));
+
+  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");
+  //salomeConnector()->addActionInToolbar( aAction, aToolBarTitle );
+
+  //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;
-  }
+#else
   // File commands group
   AppElements_MenuGroupPanel* aGroup = myMainWindow->menuObject()->generalPage();
 
@@ -290,6 +311,10 @@ void XGUI_Workshop::initMenu()
   aCommand->connectTo(this, SLOT(onSave()));
   //aCommand->disable();
 
+  aCommand = aGroup->addFeature("SAVEAS_CMD", tr("Save as..."), tr("Save the document into a file"),
+                                QIcon(":pictures/save.png"), QKeySequence());
+  aCommand->connectTo(this, SLOT(onSaveAs()));
+
   QString aUndoId = "UNDO_CMD";
   aCommand = aGroup->addFeature(aUndoId, tr("Undo"), tr("Undo last command"),
                                 QIcon(":pictures/undo.png"), QKeySequence::Undo);
@@ -308,23 +333,16 @@ void XGUI_Workshop::initMenu()
                  SIGNAL(updateRedoHistory(const QList<ActionInfo>&)),
                  SLOT(onRedo(int)));
 
-  aCommand = aGroup->addFeature("REBUILD_CMD", tr("Rebuild"), tr("Rebuild data objects"),
-    QIcon(":pictures/rebuild.png"), QKeySequence());
-  aCommand->connectTo(this, SLOT(onRebuild()));
+  //aCommand = aGroup->addFeature("REBUILD_CMD", tr("Rebuild"), tr("Rebuild data objects"),
+  //  QIcon(":pictures/rebuild.png"), QKeySequence());
+  //aCommand->connectTo(this, SLOT(onRebuild()));
 
-  aCommand = aGroup->addFeature("SAVEAS_CMD", tr("Save as..."), tr("Save the document into a file"),
-                                QIcon(":pictures/save.png"), QKeySequence());
-  aCommand->connectTo(this, SLOT(onSaveAs()));
   //aCommand->disable();
 
   aCommand = aGroup->addFeature("OPEN_CMD", tr("Open..."), tr("Open a new document"),
                                 QIcon(":pictures/open.png"), QKeySequence::Open);
   aCommand->connectTo(this, SLOT(onOpen()));
 
-  //aCommand = aGroup->addFeature("NEW_CMD", tr("New"), tr("Create a new document"),
-  //                              QIcon(":pictures/new.png"), QKeySequence::New);
-  //aCommand->connectTo(this, SLOT(onNew()));
-
   aCommand = aGroup->addFeature("PREF_CMD", tr("Preferences"), tr("Edit preferences"),
                                 QIcon(":pictures/preferences.png"), QKeySequence::Preferences);
   aCommand->connectTo(this, SLOT(onPreferences()));
@@ -332,25 +350,25 @@ void XGUI_Workshop::initMenu()
   aCommand = aGroup->addFeature("EXIT_CMD", tr("Exit"), tr("Exit application"),
                                 QIcon(":pictures/close.png"), QKeySequence::Close);
   aCommand->connectTo(this, SLOT(onExit()));
-  //FIXME: SBH's test action. Can be used for some GUI tests.
-//  #ifdef _DEBUG
-//    aCommand = aGroup->addFeature("TEST_CMD", "Test!", "Private debug button",
-//                                  QIcon(":pictures/close.png"), QKeySequence(), true);
-//    aCommand->connectTo(myMainWindow, SLOT(dockPythonConsole()));
-//  #endif
+#endif
 }
 
-//******************************************************
+#ifndef HAVE_SALOME
 AppElements_Workbench* XGUI_Workshop::addWorkbench(const QString& theName)
 {
   AppElements_MainMenu* aMenuBar = myMainWindow->menuObject();
   return aMenuBar->addWorkbench(theName);
 }
+#endif
 
 //******************************************************
 QMainWindow* XGUI_Workshop::desktop() const
 {
-  return isSalomeMode() ? salomeConnector()->desktop() : myMainWindow;
+#ifdef HAVE_SALOME
+  return salomeConnector()->desktop();
+#else
+  return myMainWindow;
+#endif
 }
 
 //******************************************************
@@ -361,39 +379,80 @@ void XGUI_Workshop::onStartWaiting()
   }
 }
 
+//******************************************************
+void XGUI_Workshop::onAcceptActionClicked()
+{
+  QAction* anAction = dynamic_cast<QAction*>(sender());
+  XGUI_OperationMgr* anOperationMgr = operationMgr();
+  if (anOperationMgr) {
+    ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>
+                                                    (anOperationMgr->currentOperation());
+    if (aFOperation) {
+      //if (errorMgr()->canProcessClick(anAction, aFOperation->feature()))
+      myOperationMgr->onCommitOperation();
+    }
+  }
+}
 
 //******************************************************
 void XGUI_Workshop::deactivateActiveObject(const ObjectPtr& theObject, const bool theUpdateViewer)
 {
   if (!myModule->canActivateSelection(theObject)) {
-    if (myDisplayer->isActive(theObject))
-      myDisplayer->deactivate(theObject, theUpdateViewer);
+    if (myDisplayer->isActive(theObject)) {
+      QObjectPtrList anObjects;
+      anObjects.append(theObject);
+      myDisplayer->deactivateObjects(anObjects, theUpdateViewer);
+    }
   }
 }
 
+//******************************************************
+bool XGUI_Workshop::isFeatureOfNested(const FeaturePtr& theFeature)
+{
+  bool aHasNested = false;
+  std::string aFeatureKind = theFeature->getKind();
+#ifdef HAVE_SALOME
+    XGUI_SalomeConnector* aSalomeConnector = salomeConnector();
+    if (aSalomeConnector->isFeatureOfNested(actionsMgr()->action(aFeatureKind.c_str())))
+      aHasNested = true;
+#else 
+    AppElements_MainMenu* aMenuBar = mainWindow()->menuObject();
+    AppElements_Command* aCommand = aMenuBar->feature(aFeatureKind.c_str());
+    if (aCommand && aCommand->button()->additionalButtonWidget())
+      aHasNested = true;
+#endif
+  return aHasNested;
+}
+
 //******************************************************
 void XGUI_Workshop::onOperationStarted(ModuleBase_Operation* theOperation)
 {
-  setNestedFeatures(theOperation);
+  setGrantedFeatures(theOperation);
 
-  if (theOperation->getDescription()->hasXmlRepresentation()) {  //!< No need for property panel
-    setPropertyPanel(theOperation);
+  ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>
+                                                                               (theOperation);
+  if (!aFOperation)
+    return;
+
+  if (aFOperation->getDescription()->hasXmlRepresentation()) {  //!< No need for property panel
+    setPropertyPanel(aFOperation);
     // filling the operation values by the current selection
-    // if the operation can be commited after the controls filling, the method perform should
+    // if the operation can be committed after the controls filling, the method perform should
     // be stopped. Otherwise unnecessary presentations can be shown(e.g. operation prs in sketch)
-    if (!theOperation->isEditOperation()) {
-      theOperation->activateByPreselection();
-      if (operationMgr()->currentOperation() != theOperation)
+    if (!aFOperation->isEditOperation()) {
+      aFOperation->activateByPreselection();
+      if (operationMgr()->currentOperation() != aFOperation)
         return;
     }
   }
   updateCommandStatus();
 
-  myModule->onOperationStarted(theOperation);
+  connectToPropertyPanel(true);
+  myModule->operationStarted(aFOperation);
 
   // the objects of the current operation should be deactivated
   QObjectPtrList anObjects;
-  FeaturePtr aFeature = theOperation->feature();
+  FeaturePtr aFeature = aFOperation->feature();
   anObjects.append(aFeature);
   std::list<ResultPtr> aResults = aFeature->results();
   std::list<ResultPtr>::const_iterator aIt;
@@ -410,41 +469,51 @@ void XGUI_Workshop::onOperationStarted(ModuleBase_Operation* theOperation)
 //******************************************************
 void XGUI_Workshop::onOperationResumed(ModuleBase_Operation* theOperation)
 {
-  setNestedFeatures(theOperation);
+  setGrantedFeatures(theOperation);
 
   if (theOperation->getDescription()->hasXmlRepresentation()) {  //!< No need for property panel
     setPropertyPanel(theOperation);
+    connectToPropertyPanel(true);
   }
   updateCommandStatus();
 
-  myModule->onOperationResumed(theOperation);
+  myModule->operationResumed(theOperation);
 }
 
 
 //******************************************************
 void XGUI_Workshop::onOperationStopped(ModuleBase_Operation* theOperation)
 {
+  updateCommandStatus();
+
+  ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>
+                                                                        (theOperation);
+  if (!aFOperation)
+    return;
+
   ModuleBase_ISelection* aSel = mySelector->selection();
   QObjectPtrList aObj = aSel->selectedPresentations();
   //!< No need for property panel
-  updateCommandStatus();
   hidePropertyPanel();
   myPropertyPanel->cleanContent();
 
-  myModule->onOperationStopped(theOperation);
+  connectToPropertyPanel(false);
+  myModule->operationStopped(aFOperation);
 
   // the deactivated objects of the current operation should be activated back.
   // They were deactivated on operation start or an object redisplay
   QObjectPtrList anObjects;
-  FeaturePtr aFeature = theOperation->feature();
-  if (myDisplayer->isVisible(aFeature) && !myDisplayer->isActive(aFeature))
-    anObjects.append(aFeature);
-  std::list<ResultPtr> aResults = aFeature->results();
-  std::list<ResultPtr>::const_iterator aIt;
-  for (aIt = aResults.begin(); aIt != aResults.end(); ++aIt) {
-    ResultPtr anObject = *aIt;
-    if (myDisplayer->isVisible(anObject) && !myDisplayer->isActive(anObject)) {
-      anObjects.append(anObject);
+  FeaturePtr aFeature = aFOperation->feature();
+  if (aFeature.get()) { // feature may be not created (plugin load fail)
+    if (myDisplayer->isVisible(aFeature) && !myDisplayer->isActive(aFeature))
+      anObjects.append(aFeature);
+    std::list<ResultPtr> aResults = aFeature->results();
+    std::list<ResultPtr>::const_iterator aIt;
+    for (aIt = aResults.begin(); aIt != aResults.end(); ++aIt) {
+      ResultPtr anObject = *aIt;
+      if (myDisplayer->isVisible(anObject) && !myDisplayer->isActive(anObject)) {
+        anObjects.append(anObject);
+      }
     }
   }
   QIntList aModes;
@@ -455,43 +524,71 @@ void XGUI_Workshop::onOperationStopped(ModuleBase_Operation* theOperation)
 
 void XGUI_Workshop::onOperationCommitted(ModuleBase_Operation* theOperation)
 {
-  myModule->onOperationCommitted(theOperation);
+  myModule->operationCommitted(theOperation);
 }
 
 void XGUI_Workshop::onOperationAborted(ModuleBase_Operation* theOperation)
 {
-  myModule->onOperationAborted(theOperation);
+  myModule->operationAborted(theOperation);
 }
 
-void XGUI_Workshop::setNestedFeatures(ModuleBase_Operation* theOperation)
+void XGUI_Workshop::setGrantedFeatures(ModuleBase_Operation* theOperation)
 {
-  if (this->isSalomeMode()) 
-    theOperation->setNestedFeatures(mySalomeConnector->nestedActions(theOperation->id()));
-  else 
-    theOperation->setNestedFeatures(myActionsMgr->nestedCommands(theOperation->id()));
+  ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>(theOperation);
+  if (!aFOperation)
+    return;
+
+  QStringList aGrantedIds;
+  if (isSalomeMode())
+    aGrantedIds = mySalomeConnector->nestedActions(theOperation->id());
+  else
+    aGrantedIds = myActionsMgr->nestedCommands(theOperation->id());
+
+  ModuleBase_IModule* aModule = module();
+  if (aModule)
+    aModule->grantedOperationIds(theOperation, aGrantedIds);
+
+  aFOperation->setGrantedOperationIds(aGrantedIds);
 }
 
 void XGUI_Workshop::setPropertyPanel(ModuleBase_Operation* theOperation)
 {
+  ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>(theOperation);
+  if (!aFOperation)
+    return;
+
   showPropertyPanel();
-  QString aXmlRepr = theOperation->getDescription()->xmlRepresentation();
-  ModuleBase_WidgetFactory aFactory = ModuleBase_WidgetFactory(aXmlRepr.toStdString(),
-                                                                myModuleConnector);
+  QString aXmlRepr = aFOperation->getDescription()->xmlRepresentation();
+  ModuleBase_WidgetFactory aFactory(aXmlRepr.toStdString(), myModuleConnector);
 
   myPropertyPanel->cleanContent();
   aFactory.createWidget(myPropertyPanel->contentWidget());
 
   QList<ModuleBase_ModelWidget*> aWidgets = aFactory.getModelWidgets();
+
+  // check compatibility of feature and widgets
+  FeaturePtr aFeature = aFOperation->feature();
   foreach (ModuleBase_ModelWidget* aWidget, aWidgets) {
-    bool isStoreValue = !theOperation->isEditOperation() &&
+    if (!aWidget->attributeID().empty() && !aFeature->attribute(aWidget->attributeID()).get()) {
+      std::string anErrorMsg = "The feature '" + aFeature->getKind() + "' has no attribute '"
+          + aWidget->attributeID() + "' used by widget '"
+          + aWidget->metaObject()->className() + "'.";
+      Events_Error::send(anErrorMsg);
+      myPropertyPanel->cleanContent();
+      return;
+    }
+  }
+
+  foreach (ModuleBase_ModelWidget* aWidget, aWidgets) {
+    bool isStoreValue = !aFOperation->isEditOperation() &&
                         !aWidget->getDefaultValue().empty() &&
                         !aWidget->isComputedDefault();
-    aWidget->setFeature(theOperation->feature(), isStoreValue);
+    aWidget->setFeature(aFOperation->feature(), isStoreValue);
     aWidget->enableFocusProcessing();
   }
-  
+
   myPropertyPanel->setModelWidgets(aWidgets);
-  theOperation->setPropertyPanel(myPropertyPanel);
+  aFOperation->setPropertyPanel(myPropertyPanel);
 
   myModule->propertyPanelDefined(theOperation);
 
@@ -500,6 +597,23 @@ void XGUI_Workshop::setPropertyPanel(ModuleBase_Operation* theOperation)
   myErrorMgr->setPropertyPanel(myPropertyPanel);
 }
 
+void XGUI_Workshop::connectToPropertyPanel(const bool isToConnect)
+{
+  XGUI_PropertyPanel* aPropertyPanel = propertyPanel();
+  if (aPropertyPanel) {
+    const QList<ModuleBase_ModelWidget*>& aWidgets = aPropertyPanel->modelWidgets();
+    foreach (ModuleBase_ModelWidget* aWidget, aWidgets) {
+       myModule->connectToPropertyPanel(aWidget, isToConnect);
+      if (isToConnect) {
+        connect(aWidget, SIGNAL(valueStateChanged(int)), this, SLOT(onWidgetStateChanged(int)));
+      }
+      else {
+        disconnect(aWidget, SIGNAL(valueStateChanged(int)), this, SLOT(onWidgetStateChanged(int)));
+      }
+    }
+  }
+}
+
 /*
  * Saves document with given name.
  */
@@ -511,29 +625,48 @@ void XGUI_Workshop::saveDocument(const QString& theName, std::list<std::string>&
   QApplication::restoreOverrideCursor();
 }
 
-bool XGUI_Workshop::isActiveOperationAborted()
+bool XGUI_Workshop::abortAllOperations()
 {
   return myOperationMgr->abortAllOperations();
 }
 
 //******************************************************
-void XGUI_Workshop::onExit()
+void XGUI_Workshop::onOpen()
 {
-  SessionPtr aMgr = ModelAPI_Session::get();
-  if (aMgr->isModified()) {
+  if(!abortAllOperations())
+    return;
+  //save current file before close if modified
+  SessionPtr aSession = ModelAPI_Session::get();
+  if (aSession->isModified()) {
+    //TODO(sbh): re-launch the app?
     int anAnswer = QMessageBox::question(
-        myMainWindow, tr("Save current file"), tr("The document is modified, save before exit?"),
+        desktop(), tr("Save current file"),
+        tr("The document is modified, save before opening another?"),
         QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel, QMessageBox::Cancel);
     if (anAnswer == QMessageBox::Save) {
-      bool saved = onSave();
-      if (!saved) {
-        return;
-      }
+      onSave();
     } else if (anAnswer == QMessageBox::Cancel) {
       return;
     }
+    myCurrentDir = "";
   }
-  qApp->exit();
+
+  //show file dialog, check if readable and open
+  myCurrentDir = QFileDialog::getExistingDirectory(desktop(), tr("Select directory"));
+  if (myCurrentDir.isEmpty())
+    return;
+  QFileInfo aFileInfo(myCurrentDir);
+  if (!aFileInfo.exists() || !aFileInfo.isReadable()) {
+    QMessageBox::critical(desktop(), tr("Warning"), tr("Unable to open the file."));
+    myCurrentDir = "";
+    return;
+  }
+  QApplication::setOverrideCursor(Qt::WaitCursor);
+  aSession->closeAll();
+  aSession->load(myCurrentDir.toLatin1().constData());
+  myObjectBrowser->rebuildDataTree();
+  updateCommandStatus();
+  QApplication::restoreOverrideCursor();
 }
 
 //******************************************************
@@ -546,60 +679,62 @@ void XGUI_Workshop::onNew()
   }
   myViewerProxy->connectToViewer();
   showObjectBrowser();
-  if (!isSalomeMode()) {
-    myMainWindow->showPythonConsole();
-    QMdiSubWindow* aWnd = myMainWindow->viewer()->createView();
-    aWnd->showMaximized();
-    updateCommandStatus();
-  }
+#ifndef HAVE_SALOME
+  myMainWindow->showPythonConsole();
+  QMdiSubWindow* aWnd = myMainWindow->viewer()->createView();
+  aWnd->showMaximized();
+  updateCommandStatus();
+#endif
   myContextMenuMgr->connectViewer();
   QApplication::restoreOverrideCursor();
 }
 
+#ifndef HAVE_SALOME
 //******************************************************
-void XGUI_Workshop::onOpen()
+void XGUI_Workshop::onExit()
 {
-  if(!isActiveOperationAborted())
-    return;
-  //save current file before close if modified
-  SessionPtr aSession = ModelAPI_Session::get();
-  if (aSession->isModified()) {
-    //TODO(sbh): re-launch the app?
+  SessionPtr aMgr = ModelAPI_Session::get();
+  if (aMgr->isModified()) {
     int anAnswer = QMessageBox::question(
-        myMainWindow, tr("Save current file"),
-        tr("The document is modified, save before opening another?"),
+        myMainWindow, tr("Save current file"), tr("The document is modified, save before exit?"),
         QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel, QMessageBox::Cancel);
     if (anAnswer == QMessageBox::Save) {
-      onSave();
+      bool saved = onSave();
+      if (!saved) {
+        return;
+      }
     } else if (anAnswer == QMessageBox::Cancel) {
       return;
     }
-    myCurrentDir = "";
   }
+  qApp->exit();
+}
 
-  //show file dialog, check if readable and open
-  myCurrentDir = QFileDialog::getExistingDirectory(mainWindow(), tr("Select directory"));
-  if (myCurrentDir.isEmpty())
-    return;
-  QFileInfo aFileInfo(myCurrentDir);
-  if (!aFileInfo.exists() || !aFileInfo.isReadable()) {
-    QMessageBox::critical(myMainWindow, tr("Warning"), tr("Unable to open the file."));
-    myCurrentDir = "";
-    return;
+//******************************************************
+void XGUI_Workshop::onPreferences()
+{
+  ModuleBase_Prefs aModif;
+  ModuleBase_Preferences::editPreferences(aModif);
+  if (aModif.size() > 0) {
+    QString aSection;
+    foreach (ModuleBase_Pref aPref, aModif)
+    {
+      aSection = aPref.first;
+      if (aSection == ModuleBase_Preferences::VIEWER_SECTION) {
+        myMainWindow->viewer()->updateFromResources();
+      } else if (aSection == ModuleBase_Preferences::MENU_SECTION) {
+        myMainWindow->menuObject()->updateFromResources();
+      }
+    }
+    displayer()->redisplayObjects();
   }
-  QApplication::setOverrideCursor(Qt::WaitCursor);
-  aSession->closeAll();
-  aSession->load(myCurrentDir.toLatin1().constData());
-  myObjectBrowser->rebuildDataTree();
-  //displayAllResults();
-  updateCommandStatus();
-  QApplication::restoreOverrideCursor();
 }
+#endif
 
 //******************************************************
 bool XGUI_Workshop::onSave()
 {
-  if(!isActiveOperationAborted())
+  if(!abortAllOperations())
     return false;
   if (myCurrentDir.isEmpty()) {
     return onSaveAs();
@@ -607,17 +742,18 @@ bool XGUI_Workshop::onSave()
   std::list<std::string> aFiles;
   saveDocument(myCurrentDir, aFiles);
   updateCommandStatus();
-  if (!isSalomeMode())
+#ifndef HAVE_SALOME
     myMainWindow->setModifiedState(false);
+#endif
   return true;
 }
 
 //******************************************************
 bool XGUI_Workshop::onSaveAs()
 {
-  if(!isActiveOperationAborted())
+  if(!abortAllOperations())
     return false;
-  QFileDialog dialog(mainWindow());
+  QFileDialog dialog(desktop());
   dialog.setWindowTitle(tr("Select directory to save files..."));
   dialog.setFileMode(QFileDialog::Directory);
   dialog.setFilter(tr("Directories (*)"));
@@ -632,7 +768,7 @@ bool XGUI_Workshop::onSaveAs()
   QDir aDir(aTempDir);
   if (aDir.exists() && !aDir.entryInfoList(QDir::NoDotAndDotDot | QDir::AllEntries).isEmpty()) {
     int answer = QMessageBox::question(
-        myMainWindow,
+        desktop(),
         //: Title of the dialog which asks user if he wants to save study in existing non-empty folder
         tr("Save"),
         tr("The directory already contains some files, save anyway?"),
@@ -642,10 +778,10 @@ bool XGUI_Workshop::onSaveAs()
     }
   }
   myCurrentDir = aTempDir;
-  if (!isSalomeMode()) {
+#ifndef HAVE_SALOME
     myMainWindow->setCurrentDir(myCurrentDir, false);
     myMainWindow->setModifiedState(false);
-  }
+#endif
   return onSave();
 }
 
@@ -654,14 +790,18 @@ void XGUI_Workshop::onUndo(int theTimes)
 {
   objectBrowser()->treeView()->setCurrentIndex(QModelIndex());
   SessionPtr aMgr = ModelAPI_Session::get();
+  std::list<std::string> aUndoList = aMgr->undoList();
   if (aMgr->isOperation()) {
-    /// this is important for nested operrations
-    /// when sketch opeation is active, this condition is false and 
+    /// this is important for nested operations
+    /// when sketch operation is active, this condition is false and
     /// the sketch operation is not aborted
     operationMgr()->onAbortOperation();
   }
-  for (int i = 0; i < theTimes; ++i) {
+  std::list<std::string>::const_iterator aIt = aUndoList.cbegin();
+  for (int i = 0; (i < theTimes) && (aIt != aUndoList.cend()); ++i, ++aIt) {
     aMgr->undo();
+    if (QString((*aIt).c_str()) == MOVE_TO_END_COMMAND)
+      myObjectBrowser->rebuildDataTree();
   }
 
   operationMgr()->updateApplyOfOperations();
@@ -679,14 +819,18 @@ void XGUI_Workshop::onRedo(int theTimes)
 
   objectBrowser()->treeView()->setCurrentIndex(QModelIndex());
   SessionPtr aMgr = ModelAPI_Session::get();
+  std::list<std::string> aRedoList = aMgr->redoList();
   if (aMgr->isOperation()) {
-    /// this is important for nested operrations
-    /// when sketch opeation is active, this condition is false and 
+    /// this is important for nested operations
+    /// when sketch operation is active, this condition is false and
     /// the sketch operation is not aborted
     operationMgr()->onAbortOperation();
   }
-  for (int i = 0; i < theTimes; ++i) {
+  std::list<std::string>::const_iterator aIt = aRedoList.cbegin();
+  for (int i = 0; (i < theTimes) && (aIt != aRedoList.cend()); ++i, ++aIt) {
     aMgr->redo();
+    if (QString((*aIt).c_str()) == MOVE_TO_END_COMMAND)
+      myObjectBrowser->rebuildDataTree();
   }
   operationMgr()->updateApplyOfOperations();
   updateCommandStatus();
@@ -697,44 +841,38 @@ void XGUI_Workshop::onRedo(int theTimes)
 }
 
 //******************************************************
-void XGUI_Workshop::onRebuild()
-{
-  SessionPtr aMgr = ModelAPI_Session::get();
-  bool aWasOperation = aMgr->isOperation(); // keep this value
-  if (!aWasOperation) {
-    aMgr->startOperation("Rebuild");
-  }
-  static const Events_ID aRebuildEvent = Events_Loop::loop()->eventByName("Rebuild");
-  Events_Loop::loop()->send(std::shared_ptr<Events_Message>(
-    new Events_Message(aRebuildEvent, this)));
-  if (!aWasOperation) {
-    aMgr->finishOperation();
-  }
-  updateCommandStatus();
-}
+//void XGUI_Workshop::onRebuild()
+//{
+//  SessionPtr aMgr = ModelAPI_Session::get();
+//  bool aWasOperation = aMgr->isOperation(); // keep this value
+//  if (!aWasOperation) {
+//    aMgr->startOperation("Rebuild");
+//  }
+//  static const Events_ID aRebuildEvent = Events_Loop::loop()->eventByName("Rebuild");
+//  Events_Loop::loop()->send(std::shared_ptr<Events_Message>(
+//    new Events_Message(aRebuildEvent, this)));
+//  if (!aWasOperation) {
+//    aMgr->finishOperation();
+//  }
+//  updateCommandStatus();
+//}
 
 //******************************************************
-void XGUI_Workshop::onPreferences()
+void XGUI_Workshop::onWidgetStateChanged(int thePreviousState)
 {
-  ModuleBase_Prefs aModif;
-  ModuleBase_Preferences::editPreferences(aModif);
-  if (aModif.size() > 0) {
-    QString aSection;
-    foreach (ModuleBase_Pref aPref, aModif)
-    {
-      aSection = aPref.first;
-      if (aSection == ModuleBase_Preferences::VIEWER_SECTION) {
-        if (!isSalomeMode())
-          myMainWindow->viewer()->updateFromResources();
-      } else if (aSection == ModuleBase_Preferences::MENU_SECTION) {
-        if (!isSalomeMode())
-          myMainWindow->menuObject()->updateFromResources();
-      }
-    }
+  ModuleBase_ModelWidget* anActiveWidget = 0;
+  ModuleBase_Operation* anOperation = myOperationMgr->currentOperation();
+  if (anOperation) {
+    ModuleBase_IPropertyPanel* aPanel = anOperation->propertyPanel();
+    if (aPanel)
+      anActiveWidget = aPanel->activeWidget();
   }
+  if (anActiveWidget)
+    operationMgr()->onValidateOperation();
+
+  myModule->widgetStateChanged(thePreviousState);
 }
 
-//******************************************************
 ModuleBase_IModule* XGUI_Workshop::loadModule(const QString& theModule)
 {
   QString libName = QString::fromStdString(library(theModule.toStdString()));
@@ -784,7 +922,7 @@ ModuleBase_IModule* XGUI_Workshop::loadModule(const QString& theModule)
   ModuleBase_IModule* aModule = crtInst ? crtInst(myModuleConnector) : 0;
 
   if (!err.isEmpty()) {
-    if (mainWindow()) {
+    if (desktop()) {
       Events_Error::send(err.toStdString());
     } else {
       qWarning(qPrintable(err));
@@ -816,13 +954,13 @@ bool XGUI_Workshop::createModule()
 void XGUI_Workshop::updateCommandStatus()
 {
   QList<QAction*> aCommands;
-  if (isSalomeMode()) {  // update commands in SALOME mode
+#ifdef HAVE_SALOME
     aCommands = salomeConnector()->commandList();
-  } else {
+#else
     AppElements_MainMenu* aMenuBar = myMainWindow->menuObject();
     foreach (AppElements_Command* aCmd, aMenuBar->features())
       aCommands.append(aCmd);
-  }
+#endif
   SessionPtr aMgr = ModelAPI_Session::get();
   if (aMgr->hasModuleDocument()) {
     foreach(QAction* aCmd, aCommands) {
@@ -847,7 +985,7 @@ void XGUI_Workshop::updateCommandStatus()
         aCmd->setEnabled(false);
     }
   }
-  myActionsMgr->update();
+  myActionsMgr->updateCommandsStatus();
   emit commandStatusUpdated();
 }
 
@@ -871,9 +1009,6 @@ QDockWidget* XGUI_Workshop::createObjectBrowser(QWidget* theParent)
   aObjDock->setStyleSheet(
       "::title { position: relative; padding-left: 5px; text-align: left center }");
   myObjectBrowser = new XGUI_ObjectsBrowser(aObjDock);
-#ifdef ModuleDataModel
-  myObjectBrowser->setDataModel(myModule->dataModel());
-#endif
   myModule->customizeObjectBrowser(myObjectBrowser);
   aObjDock->setWidget(myObjectBrowser);
 
@@ -888,10 +1023,10 @@ QDockWidget* XGUI_Workshop::createObjectBrowser(QWidget* theParent)
  */
 void XGUI_Workshop::createDockWidgets()
 {
-  QMainWindow* aDesktop = isSalomeMode() ? salomeConnector()->desktop() : myMainWindow;
+  QMainWindow* aDesktop = desktop();
   QDockWidget* aObjDock = createObjectBrowser(aDesktop);
   aDesktop->addDockWidget(Qt::LeftDockWidgetArea, aObjDock);
-  myPropertyPanel = new XGUI_PropertyPanel(aDesktop);
+  myPropertyPanel = new XGUI_PropertyPanel(aDesktop, myOperationMgr);
   myPropertyPanel->setupActions(myActionsMgr);
   myPropertyPanel->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea | Qt::BottomDockWidgetArea);
   aDesktop->addDockWidget(Qt::LeftDockWidgetArea, myPropertyPanel);
@@ -901,14 +1036,15 @@ void XGUI_Workshop::createDockWidgets()
   myPropertyPanel->installEventFilter(myOperationMgr);
 
   QAction* aOkAct = myActionsMgr->operationStateAction(XGUI_ActionsMgr::Accept);
-  connect(aOkAct, SIGNAL(triggered()), myOperationMgr, SLOT(onCommitOperation()));
+  connect(aOkAct, SIGNAL(triggered()), this, SLOT(onAcceptActionClicked()));
+
   QAction* aCancelAct = myActionsMgr->operationStateAction(XGUI_ActionsMgr::Abort);
   connect(aCancelAct, SIGNAL(triggered()), myOperationMgr, SLOT(onAbortOperation()));
-  connect(myPropertyPanel, SIGNAL(noMoreWidgets()), myModule, SLOT(onNoMoreWidgets()));
   connect(myPropertyPanel, SIGNAL(keyReleased(QKeyEvent*)),
           myOperationMgr,  SLOT(onKeyReleased(QKeyEvent*)));
-  connect(myOperationMgr,  SIGNAL(validationStateChanged(bool)),
-          aOkAct,          SLOT(setEnabled(bool)));
+
+  connect(myPropertyPanel, SIGNAL(enterClicked()),
+          myOperationMgr,  SLOT(onProcessEnter()));
 }
 
 //******************************************************
@@ -919,6 +1055,13 @@ void XGUI_Workshop::showPropertyPanel()
   aViewAct->setEnabled(true);
   myPropertyPanel->show();
   myPropertyPanel->raise();
+
+  // The next code is necessary to made the property panel the active window
+  // in order to operation manager could process key events of the panel.
+  // otherwise they are ignored. It happens only if the same(activateWindow) is
+  // not happened by property panel activation(e.g. resume operation of Sketch)
+  ModuleBase_Tools::activateWindow(myPropertyPanel, "XGUI_Workshop::showPropertyPanel()");
+  ModuleBase_Tools::setFocus(myPropertyPanel, "XGUI_Workshop::showPropertyPanel()");
 }
 
 //******************************************************
@@ -928,6 +1071,17 @@ void XGUI_Workshop::hidePropertyPanel()
   ///<! Do not allow to show empty property panel
   aViewAct->setEnabled(false);
   myPropertyPanel->hide();
+
+  // the property panel is active window of the desktop, when it is
+  // hidden, it is undefined which window becomes active. By this reason
+  // it is defined to perform the desktop as the active window.
+  // in SALOME mode, workstack made the PyConsole the active window,
+  // set the focus on it. As a result, shortcuts of the application, like
+  // are processed by this console. For example Undo actions.
+  // It is possible that this code is to be moved to NewGeom package
+  QMainWindow* aDesktop = desktop();
+  ModuleBase_Tools::activateWindow(aDesktop, "XGUI_Workshop::hidePropertyPanel()");
+  ModuleBase_Tools::setFocus(aDesktop, "XGUI_Workshop::showPropertyPanel()");
 }
 
 //******************************************************
@@ -976,8 +1130,10 @@ void XGUI_Workshop::onContextMenuCommand(const QString& theId, bool isChecked)
     setDisplayMode(aObjects, XGUI_Displayer::Wireframe);
   else if (theId == "HIDEALL_CMD") {
     QObjectPtrList aList = myDisplayer->displayedObjects();
-    foreach (ObjectPtr aObj, aList)
-      aObj->setDisplayed(false);
+    foreach (ObjectPtr aObj, aList) {
+      if (module()->canEraseObject(aObj))
+        aObj->setDisplayed(false);
+    }
     Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
   }
 }
@@ -992,14 +1148,14 @@ void XGUI_Workshop::deleteObjects()
     return;
   }
 
-  if (!isActiveOperationAborted())
-    return;
   QObjectPtrList anObjects = mySelector->selection()->selectedObjects();
+  if (!abortAllOperations())
+    return;
   // It is necessary to clear selection in order to avoid selection changed event during
-  // deleteion and negative consequences connected with processing of already deleted items
+  // deletion and negative consequences connected with processing of already deleted items
   mySelector->clearSelection();
   // check whether the object can be deleted. There should not be parts which are not loaded
-  if (!XGUI_Tools::canRemoveOrRename(myMainWindow, anObjects))
+  if (!XGUI_Tools::canRemoveOrRename(desktop(), anObjects))
     return;
 
   bool hasResult = false;
@@ -1020,39 +1176,23 @@ void XGUI_Workshop::deleteObjects()
     aObjectNames << QString::fromStdString(aObj->data()->name());
   }
   aDescription = aDescription.arg(aObjectNames.join(", "));
+  ModuleBase_OperationAction* anOpAction = new ModuleBase_OperationAction(aDescription, module());
 
-  SessionPtr aMgr = ModelAPI_Session::get();
-  aMgr->startOperation(aDescription.toStdString());
-  // 2. close the documents of the removed parts if the result part is in a list of selected objects
-  // this is performed in the RemoveFeature of Part object.
-  /*foreach (ObjectPtr aObj, anObjects)
-  {
-    ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aObj);
-    if (aPart) {
-      DocumentPtr aDoc = aObj->document();
-      if (aDoc == aMgr->activeDocument()) {
-        aDoc->close();
-      }
-    }
-  }*/
+  operationMgr()->startOperation(anOpAction);
   // 3. delete objects
-  QMainWindow* aDesktop = isSalomeMode() ? salomeConnector()->desktop() : myMainWindow;
   std::set<FeaturePtr> anIgnoredFeatures;
-  if (deleteFeatures(anObjects, anIgnoredFeatures, aDesktop, true)) {
-    myDisplayer->updateViewer();
-    aMgr->finishOperation();
-    operationMgr()->updateApplyOfOperations();
-    updateCommandStatus();
+  if (deleteFeatures(anObjects, anIgnoredFeatures, desktop(), true)) {
+    operationMgr()->commitOperation();
   }
   else {
-    aMgr->abortOperation();
+    operationMgr()->abortOperation(operationMgr()->currentOperation());
   }
 }
 
 //**************************************************************
 void XGUI_Workshop::moveObjects()
 {
-  if (!isActiveOperationAborted())
+  if (!abortAllOperations())
     return;
 
   SessionPtr aMgr = ModelAPI_Session::get();
@@ -1062,8 +1202,14 @@ void XGUI_Workshop::moveObjects()
   aMgr->startOperation(aDescription.toStdString());
 
   QObjectPtrList anObjects = mySelector->selection()->selectedObjects();
-  DocumentPtr anActiveDocument = aMgr->activeDocument();
+  // It is necessary to clear selection in order to avoid selection changed event during
+  // moving and negative consequences connected with processing of already moved items
+  mySelector->clearSelection();
+  // check whether the object can be moved. There should not be parts which are not loaded
+  if (!XGUI_Tools::canRemoveOrRename(desktop(), anObjects))
+    return;
 
+  DocumentPtr anActiveDocument = aMgr->activeDocument();
   FeaturePtr aCurrentFeature = anActiveDocument->currentFeature(true);
   foreach (ObjectPtr aObject, anObjects) {
     if (!myModule->canApplyAction(aObject, anActionId))
@@ -1097,57 +1243,92 @@ bool XGUI_Workshop::deleteFeatures(const QObjectPtrList& theList,
   // 1. find all referenced features
   std::set<FeaturePtr> aDirectRefFeatures, aIndirectRefFeatures;
   foreach (ObjectPtr aDeletedObj, theList) {
-    XGUI_Tools::refsToFeatureInAllDocuments(aDeletedObj, aDeletedObj, aDirectRefFeatures, aIndirectRefFeatures);
+    std::set<FeaturePtr> alreadyProcessed;
+    XGUI_Tools::refsToFeatureInAllDocuments(
+      aDeletedObj, aDeletedObj, aDirectRefFeatures, aIndirectRefFeatures, alreadyProcessed);
     std::set<FeaturePtr> aDifference;
     std::set_difference(aIndirectRefFeatures.begin(), aIndirectRefFeatures.end(), 
                         aDirectRefFeatures.begin(), aDirectRefFeatures.end(), 
                         std::inserter(aDifference, aDifference.begin()));
     aIndirectRefFeatures = aDifference;
   }
+
+  bool doDeleteReferences = true;
+
   // 2. warn about the references remove, break the delete operation if the user chose it
   if (theAskAboutDeleteReferences && !aDirectRefFeatures.empty()) {
     QStringList aDirectRefNames;
-    foreach(const FeaturePtr& aFeature, aDirectRefFeatures)
+    foreach (const FeaturePtr& aFeature, aDirectRefFeatures)
       aDirectRefNames.append(aFeature->name().c_str());
     QString aDirectNames = aDirectRefNames.join(", ");
 
     QStringList aIndirectRefNames;
-    foreach(const FeaturePtr& aFeature, aIndirectRefFeatures)
+    foreach (const FeaturePtr& aFeature, aIndirectRefFeatures)
       aIndirectRefNames.append(aFeature->name().c_str());
     QString aIndirectNames = aIndirectRefNames.join(", ");
 
-    QMessageBox::StandardButton aRes = QMessageBox::warning(
-        theParent, tr("Delete features"),
-        QString(tr("Selected features are used in the following features: %1.\
- These features will be deleted.\n%2Would you like to continue?")).arg(aDirectNames)
-            .arg(aIndirectNames.isEmpty() ? QString() : QString("Also these features will be deleted: %1.\n").arg(aIndirectNames)),
-        QMessageBox::No | QMessageBox::Yes, QMessageBox::No);
-    if (aRes != QMessageBox::Yes)
+    bool canReplaceParameters = true;
+    foreach (ObjectPtr aObj, theList) {
+      FeaturePtr aFeature = ModelAPI_Feature::feature(aObj);
+      if (!std::dynamic_pointer_cast<ModelAPI_ResultParameter>(aFeature->firstResult()).get()) { // the feature is not a parameter
+        canReplaceParameters = false;
+        break;
+      }
+    }
+
+    QMessageBox aMessageBox(theParent);
+    aMessageBox.setWindowTitle(tr("Delete features"));
+    aMessageBox.setIcon(QMessageBox::Warning);
+    aMessageBox.setStandardButtons(QMessageBox::No | QMessageBox::Yes);
+    aMessageBox.setDefaultButton(QMessageBox::No);
+
+    QString aText;
+    if (canReplaceParameters) {
+      aText = QString(tr("Selected parameters are used in the following features: %1.\nThese features will be deleted.\n%2Or parameters could be replaced by their values.\nWould you like to continue?"))
+          .arg(aDirectNames).arg(aIndirectNames.isEmpty() ? QString() : QString(tr("(Also these features will be deleted: %1)\n")).arg(aIndirectNames));
+      QPushButton *aReplaceButton = aMessageBox.addButton(tr("Replace"), QMessageBox::ActionRole);
+    } else {
+      aText = QString(tr("Selected features are used in the following features: %1.\nThese features will be deleted.\n%2Would you like to continue?"))
+          .arg(aDirectNames).arg(aIndirectNames.isEmpty() ? QString() : QString(tr("Also these features will be deleted: %1.\n")).arg(aIndirectNames));
+    }
+    aMessageBox.setText(aText);
+    aMessageBox.exec();
+    QMessageBox::ButtonRole aButtonRole = aMessageBox.buttonRole(aMessageBox.clickedButton());
+
+    if (aButtonRole == QMessageBox::NoRole)
       return false;
+
+    if (aButtonRole == QMessageBox::ActionRole) {
+      foreach (ObjectPtr aObj, theList)
+        ModelAPI_ReplaceParameterMessage::send(aObj, this);
+      doDeleteReferences = false;
+    }
   }
 
   // 3. remove referenced features
-  std::set<FeaturePtr> aFeaturesToDelete = aDirectRefFeatures;
-  aFeaturesToDelete.insert(aIndirectRefFeatures.begin(), aIndirectRefFeatures.end());
-  std::set<FeaturePtr>::const_iterator anIt = aFeaturesToDelete.begin(),
-                                       aLast = aFeaturesToDelete.end();
+  if (doDeleteReferences) {
+    std::set<FeaturePtr> aFeaturesToDelete = aDirectRefFeatures;
+    aFeaturesToDelete.insert(aIndirectRefFeatures.begin(), aIndirectRefFeatures.end());
+    std::set<FeaturePtr>::const_iterator anIt = aFeaturesToDelete.begin(),
+                                         aLast = aFeaturesToDelete.end();
 #ifdef DEBUG_DELETE
-  QStringList anInfo;
+    QStringList anInfo;
 #endif
-  for (; anIt != aLast; anIt++) {
-    FeaturePtr aFeature = (*anIt);
-    DocumentPtr aDoc = aFeature->document();
-    if (theIgnoredFeatures.find(aFeature) == theIgnoredFeatures.end()) {
-      aDoc->removeFeature(aFeature);
+    for (; anIt != aLast; anIt++) {
+      FeaturePtr aFeature = (*anIt);
+      DocumentPtr aDoc = aFeature->document();
+      if (theIgnoredFeatures.find(aFeature) == theIgnoredFeatures.end()) {
+        aDoc->removeFeature(aFeature);
 #ifdef DEBUG_DELETE
-      anInfo.append(ModuleBase_Tools::objectInfo(aFeature).toStdString().c_str());
+        anInfo.append(ModuleBase_Tools::objectInfo(aFeature).toStdString().c_str());
 #endif
+      }
     }
-  }
 #ifdef DEBUG_DELETE
-  qDebug(QString("remove references:%1").arg(anInfo.join("; ")).toStdString().c_str());
-  anInfo.clear();
+    qDebug(QString("remove references:%1").arg(anInfo.join("; ")).toStdString().c_str());
+    anInfo.clear();
 #endif
+  }
 
   QString anActionId = "DELETE_CMD";
   QString anId = QString::fromStdString(anActionId.toStdString().c_str());
@@ -1203,6 +1384,32 @@ bool hasResults(QObjectPtrList theObjects, const std::set<std::string>& theTypes
   return isFoundResultType;
 }
 
+//**************************************************************
+// Returns the list of all features for theDocument and all features of
+// all nested parts.
+std::list<FeaturePtr> allFeatures(const DocumentPtr& theDocument)
+{
+  std::list<FeaturePtr> aResultList;
+  std::list<FeaturePtr> anAllFeatures = theDocument->allFeatures();
+  foreach (const FeaturePtr& aFeature, anAllFeatures) {
+    // The order of appending features of the part and the part itself is important
+
+    // Append features from a part feature
+    foreach (const ResultPtr& aResult, aFeature->results()) {
+      ResultPartPtr aResultPart =
+          std::dynamic_pointer_cast<ModelAPI_ResultPart>(aResult);
+      if (aResultPart.get() && aResultPart->partDoc().get()) {
+        // Recursion
+        std::list<FeaturePtr> anAllFeatures = allFeatures(aResultPart->partDoc());
+        aResultList.insert(aResultList.end(), anAllFeatures.begin(), anAllFeatures.end());
+      }
+    }
+
+    aResultList.push_back(aFeature);
+  }
+  return aResultList;
+}
+
 //**************************************************************
 // Returns the list of features placed between theObject and the current feature
 // in the same document. Excludes theObject, includes the current feature.
@@ -1210,14 +1417,14 @@ std::list<FeaturePtr> toCurrentFeatures(const ObjectPtr& theObject)
 {
   std::list<FeaturePtr> aResult;
   DocumentPtr aDocument = theObject->document();
-  std::list<FeaturePtr> anAllFeatures = aDocument->allFeatures();
+  std::list<FeaturePtr> anAllFeatures = allFeatures(aDocument);
   // find the object iterator
   std::list<FeaturePtr>::iterator aObjectIt = std::find(anAllFeatures.begin(), anAllFeatures.end(), theObject);
-  if (aObjectIt == anAllFeatures.end()) 
+  if (aObjectIt == anAllFeatures.end())
     return aResult;
   // find the current feature iterator
   std::list<FeaturePtr>::iterator aCurrentIt = std::find(anAllFeatures.begin(), anAllFeatures.end(), aDocument->currentFeature(true));
-  if (aCurrentIt == anAllFeatures.end()) 
+  if (aCurrentIt == anAllFeatures.end())
     return aResult;
   // check the right order
   if (std::distance(aObjectIt, anAllFeatures.end()) <= std::distance(aCurrentIt, anAllFeatures.end()))
@@ -1236,8 +1443,12 @@ bool XGUI_Workshop::canMoveFeature()
   QObjectPtrList aObjects = mySelector->selection()->selectedObjects();
   QObjectPtrList aValidatedObjects;
   foreach (ObjectPtr aObject, aObjects) {
-    if (myModule->canApplyAction(aObject, anActionId))
-      aValidatedObjects.append(aObject);
+    if (!myModule->canApplyAction(aObject, anActionId))
+      continue;
+    // To be moved feature should be in active document
+    if (aObject->document() != ModelAPI_Session::get()->activeDocument())
+      continue;
+    aValidatedObjects.append(aObject);
   }
   if (aValidatedObjects.size() != aObjects.size())
     aObjects = aValidatedObjects;
@@ -1266,7 +1477,7 @@ bool XGUI_Workshop::canMoveFeature()
         std::set_intersection(aRefFeatures.begin(), aRefFeatures.end(),
                               aPlacedFeatures.begin(), aPlacedFeatures.end(),
                               std::inserter(aIntersectionFeatures, aIntersectionFeatures.begin()));
-        // 4. Return false if any reference feature is placed before curent feature
+        // 4. Return false if any reference feature is placed before current feature
         if (!aIntersectionFeatures.empty())
           aCanMove = false;
       }
@@ -1304,7 +1515,7 @@ bool XGUI_Workshop::canChangeColor() const
   return hasResults(aObjects, aTypes);
 }
 
-void setColor(ResultPtr theResult, std::vector<int>& theColor)
+void setColor(ResultPtr theResult, const std::vector<int>& theColor)
 {
   if (!theResult.get())
     return;
@@ -1323,6 +1534,7 @@ void setColor(ResultPtr theResult, std::vector<int>& theColor)
 //**************************************************************
 void XGUI_Workshop::changeColor(const QObjectPtrList& theObjects)
 {
+
   AttributeIntArrayPtr aColorAttr;
   // 1. find the current color of the object. This is a color of AIS presentation
   // The objects are iterated until a first valid color is found 
@@ -1349,8 +1561,10 @@ void XGUI_Workshop::changeColor(const QObjectPtrList& theObjects)
   if (aColor.size() != 3)
     return;
 
+  if (!abortAllOperations())
+  return; 
   // 2. show the dialog to change the value
-  XGUI_ColorDialog* aDlg = new XGUI_ColorDialog(mainWindow());
+  XGUI_ColorDialog* aDlg = new XGUI_ColorDialog(desktop());
   aDlg->setColor(aColor);
   aDlg->move(QCursor::pos());
   bool isDone = aDlg->exec() == QDialog::Accepted;
@@ -1361,11 +1575,8 @@ void XGUI_Workshop::changeColor(const QObjectPtrList& theObjects)
 
   // 3. abort the previous operation and start a new one
   SessionPtr aMgr = ModelAPI_Session::get();
-  bool aWasOperation = aMgr->isOperation(); // keep this value
-  if (!aWasOperation) {
-    QString aDescription = contextMenuMgr()->action("COLOR_CMD")->text();
-    aMgr->startOperation(aDescription.toStdString());
-  }
+  QString aDescription = contextMenuMgr()->action("COLOR_CMD")->text();
+  aMgr->startOperation(aDescription.toStdString());
 
   // 4. set the value to all results
   std::vector<int> aColorResult = aDlg->getColor();
@@ -1374,14 +1585,14 @@ void XGUI_Workshop::changeColor(const QObjectPtrList& theObjects)
     if (aResult.get() != NULL) {
       ResultCompSolidPtr aCompsolidResult = std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(aResult);
       if (aCompsolidResult.get() != NULL) { // change colors for all sub-solids
-        for(int i = 0; i < aCompsolidResult->numberOfSubs(); i++)
-          setColor(aCompsolidResult->subResult(i), aColorResult);
+        for(int i = 0; i < aCompsolidResult->numberOfSubs(); i++) {
+          setColor(aCompsolidResult->subResult(i), !isRandomColor ? aColorResult : aDlg->getRandomColor());
+        }
       }
-      setColor(aResult, aColorResult);
+      setColor(aResult, !isRandomColor ? aColorResult : aDlg->getRandomColor());
     }
   }
-  if (!aWasOperation)
-    aMgr->finishOperation();
+  aMgr->finishOperation();
   updateCommandStatus();
 }
 
@@ -1413,8 +1624,10 @@ void XGUI_Workshop::showOnlyObjects(const QObjectPtrList& theList)
 {
   // Hide all displayed objects
   QObjectPtrList aList = myDisplayer->displayedObjects();
-  foreach (ObjectPtr aObj, aList)
-    aObj->setDisplayed(false);
+  foreach (ObjectPtr aObj, aList) {
+    if (module()->canEraseObject(aObj))
+      aObj->setDisplayed(false);
+  }
 
   // Show only objects from the list
   foreach (ObjectPtr aObj, theList) {
@@ -1442,20 +1655,6 @@ void XGUI_Workshop::registerValidators() const
   ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
 }
 
-//**************************************************************
-/*void XGUI_Workshop::displayAllResults()
-{
-  SessionPtr aMgr = ModelAPI_Session::get();
-  DocumentPtr aRootDoc = aMgr->moduleDocument();
-  displayDocumentResults(aRootDoc);
-  for (int i = 0; i < aRootDoc->size(ModelAPI_ResultPart::group()); i++) {
-    ObjectPtr aObject = aRootDoc->object(ModelAPI_ResultPart::group(), i);
-    ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aObject);
-    displayDocumentResults(aPart->partDoc());
-  }
-  myDisplayer->updateViewer();
-}*/
-
 //**************************************************************
 void XGUI_Workshop::displayDocumentResults(DocumentPtr theDoc)
 {
@@ -1504,6 +1703,8 @@ void XGUI_Workshop::closeDocument()
   myDisplayer->eraseAll();
   objectBrowser()->clearContent();
 
+  module()->closeDocument();
+
   SessionPtr aMgr = ModelAPI_Session::get();
   aMgr->closeAll();
 }
@@ -1530,9 +1731,9 @@ QList<ActionInfo> XGUI_Workshop::processHistoryList(const std::list<std::string>
   std::list<std::string>::const_iterator it = theList.cbegin();
   for (; it != theList.cend(); it++) {
     QString anId = QString::fromStdString(*it);
-    bool isEditing = anId.endsWith(ModuleBase_Operation::EditSuffix());
+    bool isEditing = anId.endsWith(ModuleBase_OperationFeature::EditSuffix());
     if (isEditing) {
-      anId.chop(ModuleBase_Operation::EditSuffix().size());
+      anId.chop(ModuleBase_OperationFeature::EditSuffix().size());
     }
     ActionInfo anInfo;
     QAction* aContextMenuAct = myContextMenuMgr->actionByName(anId);
@@ -1548,3 +1749,29 @@ QList<ActionInfo> XGUI_Workshop::processHistoryList(const std::list<std::string>
   }
   return aResult;
 }
+
+void XGUI_Workshop::synchronizeViewer()
+{
+  SessionPtr aMgr = ModelAPI_Session::get();
+  DocumentPtr aDoc = aMgr->activeDocument();
+
+  synchronizeGroupInViewer(aDoc, ModelAPI_ResultConstruction::group(), false);
+  synchronizeGroupInViewer(aDoc, ModelAPI_ResultBody::group(), false);
+  synchronizeGroupInViewer(aDoc, ModelAPI_ResultPart::group(), false);
+  synchronizeGroupInViewer(aDoc, ModelAPI_ResultGroup::group(), false);
+}
+
+void XGUI_Workshop::synchronizeGroupInViewer(const DocumentPtr& theDoc, 
+                                             const std::string& theGroup, 
+                                             bool theUpdateViewer)
+{
+  ObjectPtr aObj;
+  int aSize = theDoc->size(theGroup);
+  for (int i = 0; i < aSize; i++) {
+    aObj = theDoc->object(theGroup, i);
+    if (aObj->isDisplayed())
+      myDisplayer->display(aObj, false);
+  }
+  if (theUpdateViewer)
+    myDisplayer->updateViewer();
+}