X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FXGUI%2FXGUI_Workshop.cpp;h=0a1b1570ca901a64d408103893edbf3050ec8f3b;hb=e65bf14e2ff3cf853884bf8998fadcece6e3b34c;hp=2dee78840129e9e41210d04fdb4d4d69062c1723;hpb=6fb5a58743556b877d64129002572de4116abd96;p=modules%2Fshaper.git

diff --git a/src/XGUI/XGUI_Workshop.cpp b/src/XGUI/XGUI_Workshop.cpp
index 2dee78840..0a1b1570c 100755
--- a/src/XGUI/XGUI_Workshop.cpp
+++ b/src/XGUI/XGUI_Workshop.cpp
@@ -21,19 +21,27 @@
 #include "XGUI_Workshop.h"
 
 #include "XGUI_ActionsMgr.h"
+#include "XGUI_ActiveControlMgr.h"
+#include "XGUI_ActiveControlSelector.h"
 #include "XGUI_MenuMgr.h"
 #include "XGUI_ColorDialog.h"
 #include "XGUI_DeflectionDialog.h"
+#include "XGUI_TransparencyWidget.h"
 #include "XGUI_ContextMenuMgr.h"
 #include "XGUI_Displayer.h"
 #include "XGUI_ErrorDialog.h"
 #include "XGUI_ErrorMgr.h"
+#include "XGUI_FacesPanel.h"
+#include "XGUI_FacesPanelSelector.h"
 #include "XGUI_ModuleConnector.h"
 #include "XGUI_ObjectsBrowser.h"
 #include "XGUI_OperationMgr.h"
 #include "XGUI_PropertyPanel.h"
+#include "XGUI_PropertyPanelSelector.h"
+#include "XGUI_PropertyDialog.h"
 #include "XGUI_SalomeConnector.h"
 #include "XGUI_Selection.h"
+#include "XGUI_SelectionActivate.h"
 #include "XGUI_SelectionMgr.h"
 #include "XGUI_Tools.h"
 #include "XGUI_ViewerProxy.h"
@@ -42,6 +50,7 @@
 #include <XGUI_HistoryMenu.h>
 #include <XGUI_QtEvents.h>
 #include <XGUI_DataModel.h>
+#include <XGUI_InspectionPanel.h>
 
 #ifndef HAVE_SALOME
 #include <AppElements_Button.h>
@@ -53,6 +62,8 @@
 #include <AppElements_Workbench.h>
 #endif
 
+#include <Config_XMLReader.h>
+
 #include <ModelAPI_AttributeDocRef.h>
 #include <ModelAPI_AttributeIntArray.h>
 #include <ModelAPI_AttributeDouble.h>
@@ -61,13 +72,13 @@
 #include <ModelAPI_Feature.h>
 #include <ModelAPI_Object.h>
 #include <ModelAPI_ResultBody.h>
+#include <ModelAPI_ResultCompSolid.h>
 #include <ModelAPI_ResultConstruction.h>
 #include <ModelAPI_ResultGroup.h>
 #include <ModelAPI_ResultParameter.h>
 #include <ModelAPI_ResultField.h>
 #include <ModelAPI_Session.h>
 #include <ModelAPI_Validator.h>
-#include <ModelAPI_ResultCompSolid.h>
 #include <ModelAPI_Tools.h>
 
 //#include <PartSetPlugin_Part.h>
@@ -91,6 +102,7 @@
 #include <ModuleBase_WidgetValidated.h>
 #include <ModuleBase_ModelWidget.h>
 #include <ModuleBase_ResultPrs.h>
+#include <ModuleBase_ActionIntParameter.h>
 
 #include <Config_Common.h>
 #include <Config_FeatureMessage.h>
@@ -130,8 +142,8 @@
 #ifdef TINSPECTOR
 #include <CDF_Session.hxx>
 #include <CDF_Application.hxx>
-#include <TInspector_Communicator.hxx>
-#include <VInspector_CallBack.hxx>
+#include <inspector/TInspector_Communicator.hxx>
+#include <inspector/VInspector_CallBack.hxx>
 static TInspector_Communicator* MyTCommunicator;
 static Handle(VInspector_CallBack) MyVCallBack;
 
@@ -148,18 +160,23 @@ static Handle(VInspector_CallBack) MyVCallBack;
 #include <dlfcn.h>
 #endif
 
+//#define DEBUG_WITH_MESSAGE_REPORT
+
 QString XGUI_Workshop::MOVE_TO_END_COMMAND = QObject::tr("Move to the end");
 
 //#define DEBUG_DELETE
 //#define DEBUG_FEATURE_NAME
 //#define DEBUG_CLEAN_HISTORY
 
+//******************************************************
 XGUI_Workshop::XGUI_Workshop(XGUI_SalomeConnector* theConnector)
     : QObject(),
       myCurrentDir(QString()),
       myModule(NULL),
       mySalomeConnector(theConnector),
       myPropertyPanel(0),
+      myInspectionPanel(0),
+      myFacesPanel(0),
       myObjectBrowser(0),
       myDisplayer(0)
       //myViewerSelMode(TopAbs_FACE)
@@ -170,6 +187,7 @@ XGUI_Workshop::XGUI_Workshop(XGUI_SalomeConnector* theConnector)
   ModuleBase_IWorkshop* aWorkshop = moduleConnector();
   // Has to be defined first in order to get errors and messages from other components
   myEventsListener = new XGUI_WorkshopListener(aWorkshop);
+  mySelectionActivate = new XGUI_SelectionActivate(aWorkshop);
 
   SUIT_ResourceMgr* aResMgr = ModuleBase_Preferences::resourceMgr();
 #ifndef HAVE_SALOME
@@ -209,6 +227,7 @@ XGUI_Workshop::XGUI_Workshop(XGUI_SalomeConnector* theConnector)
   connect(mySelector, SIGNAL(selectionChanged()), this, SLOT(updateCommandStatus()));
 
   myActionsMgr = new XGUI_ActionsMgr(this);
+  myActiveControlMgr = new XGUI_ActiveControlMgr(myModuleConnector);
   myMenuMgr = new XGUI_MenuMgr(this);
   myErrorDlg = new XGUI_ErrorDialog(QApplication::desktop());
   myContextMenuMgr = new XGUI_ContextMenuMgr(this);
@@ -293,7 +312,17 @@ void XGUI_Workshop::startApplication()
   Config_PropManager::registerProp("Plugins", "default_path", "Default Path",
                                    Config_Prop::Directory, "");
 
+  std::string aDir = Config_XMLReader::resourcesConfigFile();
+  Config_PropManager::registerProp("Plugins", "import_initial_path", "Import initial directory",
+                                   Config_Prop::Directory, aDir);
 
+#ifdef _DEBUG
+  Config_PropManager::registerProp("Plugins", "create_part_by_start", "Create Part by Start",
+    Config_Prop::Boolean, "false");
+
+  Config_PropManager::registerProp("Plugins", "show_hide_faces", "Show Hide Faces (on the right)",
+    Config_Prop::Boolean, "false");
+#endif
   registerValidators();
 
   // Calling of  loadCustomProps before activating module is required
@@ -313,11 +342,19 @@ void XGUI_Workshop::startApplication()
           SLOT(onTrihedronVisibilityChanged(bool)));
 
   emit applicationStarted();
+
+#ifdef _DEBUG
+  bool aNewPart = Config_PropManager::boolean("Plugins", "create_part_by_start");
+  if (aNewPart) {
+      module()->launchOperation("Part", false); // PartSetPlugin_Part::ID()
+  }
+#endif
 }
 
+//******************************************************
 void XGUI_Workshop::activateModule()
 {
-  myModule->activateSelectionFilters();
+  selectionActivate()->updateSelectionFilters();
 
   connect(myDisplayer, SIGNAL(objectDisplayed(ObjectPtr, AISObjectPtr)),
     myModule, SLOT(onObjectDisplayed(ObjectPtr, AISObjectPtr)));
@@ -333,12 +370,11 @@ void XGUI_Workshop::activateModule()
   myOperationMgr->activate();
 }
 
+//******************************************************
 void XGUI_Workshop::deactivateModule()
 {
-  myModule->deactivateSelectionFilters();
-
   // remove internal displayer filter
-  displayer()->deactivateSelectionFilters();
+  displayer()->deactivateSelectionFilters(false);
 
   disconnect(myDisplayer, SIGNAL(objectDisplayed(ObjectPtr, AISObjectPtr)),
     myModule, SLOT(onObjectDisplayed(ObjectPtr, AISObjectPtr)));
@@ -348,17 +384,10 @@ void XGUI_Workshop::deactivateModule()
   XGUI_Displayer* aDisplayer = displayer();
   QObjectPtrList aDisplayed = aDisplayer->displayedObjects();
   aDisplayer->deactivateObjects(aDisplayed, true);
-  Handle(AIS_InteractiveContext) aContext = viewer()->AISContext();
-  Handle(AIS_Trihedron) aTrihedron = Handle(AIS_Trihedron)::DownCast(aDisplayer->getTrihedron());
-  /// deactivate trihedron in selection modes
-  TColStd_ListOfInteger aTColModes;
-  aContext->ActivatedModes(aTrihedron, aTColModes);
-  TColStd_ListIteratorOfListOfInteger itr( aTColModes );
-  for (; itr.More(); itr.Next() ) {
-    Standard_Integer aMode = itr.Value();
-    aContext->Deactivate(aTrihedron, aMode);
-  }
+  selectionActivate()->deactivateTrihedronInSelectionModes();
+
 #ifdef BEFORE_TRIHEDRON_PATCH
+  //Handle(AIS_Trihedron) aTrihedron = Handle(AIS_Trihedron)::DownCast(aDisplayer->getTrihedron());
   /// Trihedron problem: objects stayed in the viewer, should be removed manually
   /// otherwise in SALOME happens crash by HideAll in the viewer
   aContext->Remove(aTrihedron->Position(), true);
@@ -397,14 +426,6 @@ void XGUI_Workshop::initMenu()
   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 native..."),
                                              tr("Export the current document into a native file"),
@@ -452,12 +473,6 @@ 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->disable();
-
   aCommand = aGroup->addFeature("OPEN_CMD", tr("Open..."), tr("Open a new document"),
                                 QIcon(":pictures/open.png"), QKeySequence::Open);
   aCommand->connectTo(this, SLOT(onOpen()));
@@ -473,6 +488,7 @@ void XGUI_Workshop::initMenu()
 }
 
 #ifndef HAVE_SALOME
+//******************************************************
 AppElements_Workbench* XGUI_Workshop::addWorkbench(const QString& theName)
 {
   AppElements_MainMenu* aMenuBar = myMainWindow->menuObject();
@@ -513,6 +529,21 @@ void XGUI_Workshop::onAcceptActionClicked()
   }
 }
 
+//******************************************************
+void XGUI_Workshop::onAcceptPlusActionClicked()
+{
+  QAction* anAction = dynamic_cast<QAction*>(sender());
+  XGUI_OperationMgr* anOperationMgr = operationMgr();
+  if (anOperationMgr) {
+    ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>
+                                                    (anOperationMgr->currentOperation());
+    if (aFOperation) {
+      if (myOperationMgr->commitOperation())
+        module()->launchOperation(aFOperation->id(), false);
+    }
+  }
+}
+
 //******************************************************
 void XGUI_Workshop::onPreviewActionClicked()
 {
@@ -532,7 +563,7 @@ void XGUI_Workshop::onPreviewActionClicked()
 void XGUI_Workshop::deactivateActiveObject(const ObjectPtr& theObject, const bool theUpdateViewer)
 {
   if (!myModule->canActivateSelection(theObject)) {
-    if (myDisplayer->isActive(theObject)) {
+    if (selectionActivate()->isActive(theObject)) {
       QObjectPtrList anObjects;
       anObjects.append(theObject);
       myDisplayer->deactivateObjects(anObjects, theUpdateViewer);
@@ -558,6 +589,7 @@ bool XGUI_Workshop::isFeatureOfNested(const FeaturePtr& theFeature)
   return aHasNested;
 }
 
+//******************************************************
 void XGUI_Workshop::fillPropertyPanel(ModuleBase_Operation* theOperation)
 {
   ModuleBase_OperationFeature* aFOperation =
@@ -565,7 +597,7 @@ void XGUI_Workshop::fillPropertyPanel(ModuleBase_Operation* theOperation)
   if (!aFOperation)
     return;
 
-  showPropertyPanel();
+  showPanel(myPropertyPanel);
   myPropertyPanel->cleanContent();
 
   QList<ModuleBase_ModelWidget*> aWidgets;
@@ -580,13 +612,15 @@ void XGUI_Workshop::fillPropertyPanel(ModuleBase_Operation* theOperation)
   FeaturePtr aFeature = aFOperation->feature();
   std::string aFeatureKind = aFeature->getKind();
   foreach (ModuleBase_ModelWidget* aWidget, aWidgets) {
-    if (!aWidget->attributeID().empty() && !aFeature->attribute(aWidget->attributeID()).get()) {
-      std::string anErrorMsg = "The feature '%1' has no attribute '%2' used by widget '%3'.";
-      Events_InfoMessage("XGUI_Workshop", anErrorMsg)
-        .arg(aFeatureKind).arg(aWidget->attributeID())
-        .arg(aWidget->metaObject()->className()).send();
-      myPropertyPanel->cleanContent();
-      return;
+    if (aWidget->usesAttribute()) {
+      if (!aWidget->attributeID().empty() && !aFeature->attribute(aWidget->attributeID()).get()) {
+        std::string anErrorMsg = "The feature '%1' has no attribute '%2' used by widget '%3'.";
+        Events_InfoMessage("XGUI_Workshop", anErrorMsg)
+          .arg(aFeatureKind).arg(aWidget->attributeID())
+          .arg(aWidget->metaObject()->className()).send();
+        myPropertyPanel->cleanContent();
+        return;
+      }
     }
   }
   // for performance purpose, flush should be done after all controls are filled
@@ -600,8 +634,6 @@ void XGUI_Workshop::fillPropertyPanel(ModuleBase_Operation* theOperation)
       aWidget->restoreValue();
     aWidget->enableFocusProcessing();
   }
-  ModuleBase_Tools::flushUpdated(aFeature);
-
   // update visible state of Preview button
   std::shared_ptr<Config_FeatureMessage> aFeatureInfo;
 #ifdef HAVE_SALOME
@@ -630,6 +662,10 @@ void XGUI_Workshop::fillPropertyPanel(ModuleBase_Operation* theOperation)
                   new Events_Message(Events_Loop::eventByName(EVENT_PREVIEW_BLOCKED)));
     Events_Loop::loop()->send(aMsg);
   }
+  // if update happens after preview is blocked, it does nothing when blocked
+  // it improves performance for valid objects on feature start
+  ModuleBase_Tools::flushUpdated(aFeature);
+
   myPropertyPanel->setModelWidgets(aWidgets);
   aFOperation->setPropertyPanel(myPropertyPanel);
 
@@ -647,6 +683,7 @@ void XGUI_Workshop::fillPropertyPanel(ModuleBase_Operation* theOperation)
   myErrorMgr->setPropertyPanel(myPropertyPanel);
 }
 
+//******************************************************
 void XGUI_Workshop::connectToPropertyPanel(const bool isToConnect)
 {
   XGUI_PropertyPanel* aPropertyPanel = propertyPanel();
@@ -682,7 +719,6 @@ void XGUI_Workshop::onOperationResumed(ModuleBase_Operation* theOperation)
   myModule->operationResumed(theOperation);
 }
 
-
 //******************************************************
 void XGUI_Workshop::onOperationStopped(ModuleBase_Operation* theOperation)
 {
@@ -696,7 +732,7 @@ void XGUI_Workshop::onOperationStopped(ModuleBase_Operation* theOperation)
   ModuleBase_ISelection* aSel = mySelector->selection();
   QObjectPtrList aObj = aSel->selectedPresentations();
   //!< No need for property panel
-  hidePropertyPanel();
+  hidePanel(myPropertyPanel);
   myPropertyPanel->cleanContent();
 
   connectToPropertyPanel(false);
@@ -707,14 +743,14 @@ void XGUI_Workshop::onOperationStopped(ModuleBase_Operation* theOperation)
   QObjectPtrList anObjects;
   FeaturePtr aFeature = aFOperation->feature();
   if (aFeature.get()) { // feature may be not created (plugin load fail)
-    if (myDisplayer->isVisible(aFeature) && !myDisplayer->isActive(aFeature))
+    if (myDisplayer->isVisible(aFeature) && !selectionActivate()->isActive(aFeature))
       anObjects.append(aFeature);
     std::list<ResultPtr> aResults;
     ModelAPI_Tools::allResults(aFeature, aResults);
     std::list<ResultPtr>::const_iterator aIt;
     for (aIt = aResults.begin(); aIt != aResults.end(); ++aIt) {
       ResultPtr anObject = *aIt;
-      if (myDisplayer->isVisible(anObject) && !myDisplayer->isActive(anObject)) {
+      if (myDisplayer->isVisible(anObject) && !selectionActivate()->isActive(anObject)) {
         anObjects.append(anObject);
       }
     }
@@ -722,17 +758,19 @@ void XGUI_Workshop::onOperationStopped(ModuleBase_Operation* theOperation)
   activateObjectsSelection(anObjects);
 }
 
-
+//******************************************************
 void XGUI_Workshop::onOperationCommitted(ModuleBase_Operation* theOperation)
 {
   myModule->operationCommitted(theOperation);
 }
 
+//******************************************************
 void XGUI_Workshop::onOperationAborted(ModuleBase_Operation* theOperation)
 {
   myModule->operationAborted(theOperation);
 }
 
+//******************************************************
 void XGUI_Workshop::setGrantedFeatures(ModuleBase_Operation* theOperation)
 {
   ModuleBase_OperationFeature* aFOperation =
@@ -776,6 +814,12 @@ void XGUI_Workshop::saveDocument(const QString& theName, std::list<std::string>&
   QApplication::restoreOverrideCursor();
 }
 
+//******************************************************
+bool XGUI_Workshop::abortAllOperations()
+{
+  return myOperationMgr->abortAllOperations();
+}
+
 //******************************************************
 void XGUI_Workshop::operationStarted(ModuleBase_Operation* theOperation)
 {
@@ -791,7 +835,7 @@ void XGUI_Workshop::operationStarted(ModuleBase_Operation* theOperation)
 //******************************************************
 void XGUI_Workshop::onOpen()
 {
-  if(!myOperationMgr->abortAllOperations())
+  if(!abortAllOperations())
     return;
   //save current file before close if modified
   SessionPtr aSession = ModelAPI_Session::get();
@@ -845,6 +889,22 @@ void XGUI_Workshop::openDirectory(const QString& theDirectory)
 #ifndef HAVE_SALOME
   myMainWindow->setCurrentDir(myCurrentDir, true);
 #endif
+
+#ifdef _DEBUG
+  bool aNewPart = Config_PropManager::boolean("Plugins", "create_part_by_start");
+  if (aNewPart) {
+
+    DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
+    int aSize = aRootDoc->size(ModelAPI_ResultPart::group());
+    if (aSize > 0 ) {
+      ObjectPtr aObject = aRootDoc->object(ModelAPI_ResultPart::group(), 0);
+      ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aObject);
+      if (aPart.get())
+        aPart->activate();
+    }
+  }
+#endif
+
   QApplication::restoreOverrideCursor();
 }
 
@@ -976,85 +1036,80 @@ bool XGUI_Workshop::onSaveAs()
 //******************************************************
 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 operations
-    /// when sketch operation is active, this condition is false and
-    /// the sketch operation is not aborted
-    operationMgr()->onAbortOperation();
-  }
-  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();
-  updateCommandStatus();
+  processUndoRedo(ActionUndo, theTimes);
+  myObjectBrowser->updateAllIndexes(1);
 }
 
 //******************************************************
 void XGUI_Workshop::onRedo(int theTimes)
 {
+  processUndoRedo(ActionRedo, theTimes);
+  myObjectBrowser->updateAllIndexes(1);
+}
+
+//******************************************************
+void XGUI_Workshop::processUndoRedo(const ModuleBase_ActionType theActionType, int theTimes)
+{
+  ModuleBase_ModelWidget* anActiveWidget = myOperationMgr->activeWidget();
+  if (anActiveWidget) {
+    ActionIntParamPtr aParam(new ModuleBase_ActionIntParameter(theTimes));
+    if (anActiveWidget->processAction(theActionType, aParam))
+      return;
+  }
   // the viewer update should be blocked in order to avoid the features blinking. For the created
   // feature a results are created, the flush of the created signal caused the viewer redisplay for
   // each created result. After a redisplay signal is flushed. So, the viewer update is blocked
   // until redo of all possible objects happens
   bool isUpdateEnabled = myDisplayer->enableUpdateViewer(false);
 
-  objectBrowser()->treeView()->setCurrentIndex(QModelIndex());
   SessionPtr aMgr = ModelAPI_Session::get();
-  std::list<std::string> aRedoList = aMgr->redoList();
   if (aMgr->isOperation()) {
+    XGUI_OperationMgr* aOpMgr = operationMgr();
     /// this is important for nested operations
     /// when sketch operation is active, this condition is false and
     /// the sketch operation is not aborted
-    operationMgr()->onAbortOperation();
+    if (aOpMgr->canStopOperation(aOpMgr->currentOperation()))
+      aOpMgr->abortOperation(aOpMgr->currentOperation());
+    else
+    {
+      myDisplayer->enableUpdateViewer(isUpdateEnabled);
+      return;
+    }
   }
-  std::list<std::string>::const_iterator aIt = aRedoList.cbegin();
-  for (int i = 0; (i < theTimes) && (aIt != aRedoList.cend()); ++i, ++aIt) {
-    aMgr->redo();
+  objectBrowser()->treeView()->setCurrentIndex(QModelIndex());
+  std::list<std::string> anActionList = theActionType == ActionUndo ? aMgr->undoList()
+    : aMgr->redoList();
+  std::list<std::string>::const_iterator aIt = anActionList.cbegin();
+  for (int i = 0; (i < theTimes) && (aIt != anActionList.cend()); ++i, ++aIt) {
+    if (theActionType == ActionUndo)
+      aMgr->undo();
+    else
+      aMgr->redo();
+
     if (QString((*aIt).c_str()) == MOVE_TO_END_COMMAND)
       myObjectBrowser->rebuildDataTree();
   }
   operationMgr()->updateApplyOfOperations();
+  facesPanel()->reset(true);
   updateCommandStatus();
 
   // unblock the viewer update functionality and make update on purpose
   myDisplayer->enableUpdateViewer(isUpdateEnabled);
   myDisplayer->updateViewer();
+  // Clear messages in status bar from previous operations if exists
+  setStatusBarMessage("");
 }
 
-//******************************************************
-//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::onWidgetStateChanged(int thePreviousState)
 {
-  ModuleBase_ModelWidget* anActiveWidget = 0;
-  ModuleBase_Operation* anOperation = myOperationMgr->currentOperation();
-  if (anOperation) {
-    ModuleBase_IPropertyPanel* aPanel = anOperation->propertyPanel();
-    if (aPanel)
-      anActiveWidget = aPanel->activeWidget();
-  }
+  ModuleBase_ModelWidget* anActiveWidget = myOperationMgr->activeWidget();
+  //ModuleBase_Operation* anOperation = myOperationMgr->currentOperation();
+  //if (anOperation) {
+  //  ModuleBase_IPropertyPanel* aPanel = anOperation->propertyPanel();
+  //  if (aPanel)
+  //    anActiveWidget = aPanel->activeWidget();
+  //}
   if (anActiveWidget)
     operationMgr()->onValidateOperation();
 
@@ -1083,11 +1138,13 @@ void XGUI_Workshop::onValuesChanged()
   }
 }
 
+//******************************************************
 void XGUI_Workshop::onWidgetObjectUpdated()
 {
   operationMgr()->onValidateOperation();
 }
 
+//******************************************************
 ModuleBase_IModule* XGUI_Workshop::loadModule(const QString& theModule)
 {
   QString libName = QString::fromStdString(library(theModule.toStdString()));
@@ -1183,10 +1240,24 @@ void XGUI_Workshop::updateCommandStatus()
   if (aMgr->hasModuleDocument()) {
     foreach(QAction* aCmd, aCommands) {
       QString aId = aCmd->data().toString();
-      if (aId == "UNDO_CMD")
-        aCmd->setEnabled(myModule->canUndo());
-      else if (aId == "REDO_CMD")
-        aCmd->setEnabled(myModule->canRedo());
+      if (aId == "UNDO_CMD") {
+        bool isActionEnabled = false;
+        // if ultimate is true -> using result of operation only, or using OR combination
+        ModuleBase_ModelWidget* anActiveWidget = myOperationMgr->activeWidget();
+        if (anActiveWidget && anActiveWidget->canProcessAction(ActionUndo, isActionEnabled))
+          aCmd->setEnabled(isActionEnabled);
+        else
+          aCmd->setEnabled(myModule->canUndo());
+      }
+      else if (aId == "REDO_CMD") {
+        bool isActionEnabled = false;
+        // if ultimate is true -> using result of operation only, or using OR combination
+        ModuleBase_ModelWidget* anActiveWidget = myOperationMgr->activeWidget();
+        if (anActiveWidget && anActiveWidget->canProcessAction(ActionRedo, isActionEnabled))
+          aCmd->setEnabled(isActionEnabled);
+        else
+          aCmd->setEnabled(myModule->canRedo());
+      }
       else
         // Enable all commands
         aCmd->setEnabled(true);
@@ -1207,14 +1278,24 @@ void XGUI_Workshop::updateCommandStatus()
   emit commandStatusUpdated();
 }
 
+//******************************************************
 void XGUI_Workshop::updateHistory()
 {
-  std::list<std::string> aUndoList = ModelAPI_Session::get()->undoList();
-  QList<ActionInfo> aUndoRes = processHistoryList(aUndoList);
-  emit updateUndoHistory(aUndoRes);
+  bool isActionEnabled = false;
+  ModuleBase_ModelWidget* anActiveWidget = myOperationMgr->activeWidget();
+  QList<ActionInfo> aUndoRes;
+  QList<ActionInfo> aRedoRes;
+  if (anActiveWidget && anActiveWidget->canProcessAction(ActionUndo, isActionEnabled)) {
+    aUndoRes = anActiveWidget->actionsList(ActionUndo);
+    aRedoRes = anActiveWidget->actionsList(ActionRedo);
+  } else {
+    std::list<std::string> aUndoList = ModelAPI_Session::get()->undoList();
+    aUndoRes = processHistoryList(aUndoList);
 
-  std::list<std::string> aRedoList = ModelAPI_Session::get()->redoList();
-  QList<ActionInfo> aRedoRes = processHistoryList(aRedoList);
+    std::list<std::string> aRedoList = ModelAPI_Session::get()->redoList();
+    aRedoRes = processHistoryList(aRedoList);
+  }
+  emit updateUndoHistory(aUndoRes);
   emit updateRedoHistory(aRedoRes);
 }
 
@@ -1248,19 +1329,66 @@ void XGUI_Workshop::createDockWidgets()
   QDockWidget* aObjDock = createObjectBrowser(aDesktop);
   aDesktop->addDockWidget(Qt::LeftDockWidgetArea, aObjDock);
   myPropertyPanel = new XGUI_PropertyPanel(aDesktop, myOperationMgr);
+  myActiveControlMgr->addSelector(new XGUI_PropertyPanelSelector(myPropertyPanel));
+
   myPropertyPanel->setupActions(myActionsMgr);
   myPropertyPanel->setAllowedAreas(Qt::LeftDockWidgetArea |
                                    Qt::RightDockWidgetArea |
                                    Qt::BottomDockWidgetArea);
   aDesktop->addDockWidget(Qt::LeftDockWidgetArea, myPropertyPanel);
-  hidePropertyPanel();  ///<! Invisible by default
+  hidePanel(myPropertyPanel);  ///<! Invisible by default
+
+  myFacesPanel = new XGUI_FacesPanel(aDesktop, myModuleConnector);
+  myActiveControlMgr->addSelector(new XGUI_FacesPanelSelector(myFacesPanel));
+  myFacesPanel->setAllowedAreas(Qt::LeftDockWidgetArea |
+                                Qt::RightDockWidgetArea |
+                                Qt::BottomDockWidgetArea);
+  connect(myFacesPanel, SIGNAL(closed()), myFacesPanel, SLOT(onClosed()));
+
+  myInspectionPanel = new XGUI_InspectionPanel(aDesktop, mySelector);
+  myInspectionPanel->setAllowedAreas(Qt::LeftDockWidgetArea |
+    Qt::RightDockWidgetArea);
+  aDesktop->addDockWidget(Qt::RightDockWidgetArea, myInspectionPanel);
+
+  aDesktop->addDockWidget(
+#ifdef HAVE_SALOME
+    Qt::RightDockWidgetArea,
+#else
+    Qt::LeftDockWidgetArea,
+#endif
+    myFacesPanel);
+  hidePanel(myFacesPanel);  ///<! Invisible by default
+
+#ifdef _DEBUG
+  bool aShowOnTheRight = Config_PropManager::boolean("Plugins", "show_hide_faces");
+  if (aShowOnTheRight) {
+    aDesktop->addDockWidget(Qt::RightDockWidgetArea, myFacesPanel);
+    showPanel(myFacesPanel);
+  }
+#endif
   hideObjectBrowser();
+
+#ifndef HAVE_SALOME
+#ifdef _DEBUG
+  if (!aShowOnTheRight)
+  {
+#endif // _DEBUG
+  aDesktop->tabifyDockWidget(myFacesPanel, aObjDock);
+#ifdef _DEBUG
+  }
+#endif // _DEBUG
+
+#endif // HAVE_SALOME
+
   aDesktop->tabifyDockWidget(aObjDock, myPropertyPanel);
   myPropertyPanel->installEventFilter(myOperationMgr);
 
   QAction* aOkAct = myActionsMgr->operationStateAction(XGUI_ActionsMgr::Accept);
   connect(aOkAct, SIGNAL(triggered()), this, SLOT(onAcceptActionClicked()));
 
+  QAction* aOkContAct = myActionsMgr->operationStateAction(XGUI_ActionsMgr::AcceptPlus);
+  connect(aOkContAct, SIGNAL(triggered()), this, SLOT(onAcceptPlusActionClicked()));
+
   QAction* aCancelAct = myActionsMgr->operationStateAction(XGUI_ActionsMgr::Abort);
   connect(aCancelAct, SIGNAL(triggered()), myOperationMgr, SLOT(onAbortOperation()));
 
@@ -1274,28 +1402,32 @@ void XGUI_Workshop::createDockWidgets()
 }
 
 //******************************************************
-void XGUI_Workshop::showPropertyPanel()
+void XGUI_Workshop::showPanel(QDockWidget* theDockWidget)
 {
-  QAction* aViewAct = myPropertyPanel->toggleViewAction();
-  ///<! Restore ability to close panel from the window's menu
-  aViewAct->setEnabled(true);
-  myPropertyPanel->show();
-  myPropertyPanel->raise();
+  if (theDockWidget == myPropertyPanel) {
+    QAction* aViewAct = myPropertyPanel->toggleViewAction();
+    ///<! Restore ability to close panel from the window's menu
+    aViewAct->setEnabled(true);
+  }
+  theDockWidget->show();
+  theDockWidget->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::setFocus(myPropertyPanel, "XGUI_Workshop::showPropertyPanel()");
+  ModuleBase_Tools::setFocus(theDockWidget, "XGUI_Workshop::showPanel()");
 }
 
 //******************************************************
-void XGUI_Workshop::hidePropertyPanel()
+void XGUI_Workshop::hidePanel(QDockWidget* theDockWidget)
 {
-  QAction* aViewAct = myPropertyPanel->toggleViewAction();
-  ///<! Do not allow to show empty property panel
-  aViewAct->setEnabled(false);
-  myPropertyPanel->hide();
+  if (theDockWidget && theDockWidget == myPropertyPanel) {
+    QAction* aViewAct = theDockWidget->toggleViewAction();
+    ///<! Do not allow to show empty property panel
+    aViewAct->setEnabled(false);
+  }
+  theDockWidget->hide();
 
   // the property panel is active window of the desktop, when it is
   // hidden, it is undefined which window becomes active. By this reason
@@ -1305,7 +1437,7 @@ void XGUI_Workshop::hidePropertyPanel()
   // are processed by this console. For example Undo actions.
   // It is possible that this code is to be moved to SHAPER package
   QMainWindow* aDesktop = desktop();
-  ModuleBase_Tools::setFocus(aDesktop, "XGUI_Workshop::showPropertyPanel()");
+  ModuleBase_Tools::setFocus(aDesktop, "XGUI_Workshop::hidePanel()");
 }
 
 //******************************************************
@@ -1348,6 +1480,10 @@ void XGUI_Workshop::onContextMenuCommand(const QString& theId, bool isChecked)
     changeColor(aObjects);
   else if (theId == "DEFLECTION_CMD")
     changeDeflection(aObjects);
+#ifdef USE_TRANSPARENCY
+  else if (theId == "TRANSPARENCY_CMD")
+    changeTransparency(aObjects);
+#endif
   else if (theId == "SHOW_CMD") {
     showObjects(aObjects, true);
     mySelector->updateSelectionBy(ModuleBase_ISelection::Browser);
@@ -1378,12 +1514,24 @@ void XGUI_Workshop::onContextMenuCommand(const QString& theId, bool isChecked)
     viewer()->eraseAll();
 #endif
     updateCommandStatus();
+    // Necessary for update icons in ObjectBrowser on Linux
+    myObjectBrowser->updateAllIndexes();
   } else if (theId == "SELECT_VERTEX_CMD") {
     setViewerSelectionMode(TopAbs_VERTEX);
   } else if (theId == "SELECT_EDGE_CMD") {
     setViewerSelectionMode(TopAbs_EDGE);
   } else if (theId == "SELECT_FACE_CMD") {
     setViewerSelectionMode(TopAbs_FACE);
+  } else if (theId == "INSERT_FOLDER_CMD") {
+    insertFeatureFolder();
+  } else if (theId == "ADD_TO_FOLDER_BEFORE_CMD") {
+    insertToFolder(true);
+  } else if (theId == "ADD_TO_FOLDER_AFTER_CMD") {
+    insertToFolder(false);
+  } else if (theId == "ADD_OUT_FOLDER_BEFORE_CMD") {
+    moveOutFolder(true);
+  } else if (theId == "ADD_OUT_FOLDER_AFTER_CMD") {
+    moveOutFolder(false);
   } else if (theId == "SELECT_RESULT_CMD") {
     //setViewerSelectionMode(-1);
     //IMP: an attempt to use result selection with other selection modes
@@ -1409,6 +1557,13 @@ void XGUI_Workshop::onContextMenuCommand(const QString& theId, bool isChecked)
         if (!aContext.IsNull())
           aParameters.Append(aContext);
 
+#ifdef DEBUG_WITH_MESSAGE_REPORT
+        Handle(Message_Report) aContextReport = aContext->GetReport();
+        aContext->SetReportActive (Standard_True);
+        aContextReport->SetLimit (1000);
+        if (!aContextReport.IsNull())
+          aParameters.Append(aContextReport);
+#endif
         MyVCallBack = new VInspector_CallBack();
         myDisplayer->setCallBack(MyVCallBack);
         #ifndef HAVE_SALOME
@@ -1418,12 +1573,26 @@ void XGUI_Workshop::onContextMenuCommand(const QString& theId, bool isChecked)
         #endif
         aParameters.Append(MyVCallBack);
 
+        MyTCommunicator->RegisterPlugin("TKDFBrowser");
+        MyTCommunicator->RegisterPlugin("TKShapeView");
+        MyTCommunicator->RegisterPlugin("TKVInspector");
+#ifdef DEBUG_WITH_MESSAGE_REPORT
+        MyTCommunicator->RegisterPlugin("TKMessageView");
+#endif
         MyTCommunicator->RegisterPlugin("SMBrowser"); // custom plugin to view ModelAPI
+        //MyTCommunicator->RegisterPlugin("TKSMBrowser"); // custom plugin to view ModelAPI
 
         MyTCommunicator->Init(aParameters);
-        MyTCommunicator->Activate("SMBrowser"); // to have button in TInspector
+        MyTCommunicator->Activate("TKSMBrowser"); // to have button in TInspector
+#ifndef DEBUG_WITH_MESSAGE_REPORT
         MyTCommunicator->Activate("TKVInspector"); // to have filled callback by model
+#endif
         MyTCommunicator->Activate("TKDFBrowser");
+
+#ifdef DEBUG_WITH_MESSAGE_REPORT
+        MyTCommunicator->Activate("TKMessageView"); // temporary
+        MyTCommunicator->Activate("TKVInspector"); // to have filled callback by model
+#endif
       }
       MyTCommunicator->SetVisible(true);
     }
@@ -1442,7 +1611,7 @@ void XGUI_Workshop::setViewerSelectionMode(int theMode)
     else
       myViewerSelMode.append(theMode);
   }
-  activateObjectsSelection(myDisplayer->displayedObjects());
+  selectionActivate()->updateSelectionModes();
 }
 
 //**************************************************************
@@ -1452,7 +1621,59 @@ void XGUI_Workshop::activateObjectsSelection(const QObjectPtrList& theList)
   module()->activeSelectionModes(aModes);
   if (aModes.isEmpty() && (myViewerSelMode.length() > 0))
     aModes.append(myViewerSelMode);
-  myDisplayer->activateObjects(aModes, theList);
+  selectionActivate()->activateObjects(aModes, theList);
+}
+
+//**************************************************************
+bool XGUI_Workshop::prepareForDisplay(const std::set<ObjectPtr>& theObjects) const
+{
+  if (facesPanel()->isEmpty())
+    return true;
+
+  // generate container of objects taking into account sub elments of compsolid
+  std::set<ObjectPtr> anAllProcessedObjects;
+  for (std::set<ObjectPtr>::const_iterator anObjectsIt = theObjects.begin();
+    anObjectsIt != theObjects.end(); anObjectsIt++) {
+    ObjectPtr anObject = *anObjectsIt;
+    ResultCompSolidPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(anObject);
+    if (aCompRes.get()) {
+      if (aCompRes->numberOfSubs(true) == 0)
+        anAllProcessedObjects.insert(anObject);
+      else {
+        for (int i = 0; i < aCompRes->numberOfSubs(true); i++) {
+          ResultPtr aSubRes = aCompRes->subResult(i, true);
+          anAllProcessedObjects.insert(aCompRes->subResult(i, true));
+        }
+      }
+    }
+    else
+      anAllProcessedObjects.insert(anObject);
+  }
+
+  // find hidden objects in faces panel
+  std::set<ObjectPtr> aHiddenObjects;
+  QStringList aHiddenObjectNames;
+  for (std::set<ObjectPtr>::const_iterator anObjectsIt = anAllProcessedObjects.begin();
+       anObjectsIt != anAllProcessedObjects.end(); anObjectsIt++) {
+    if (!facesPanel()->isObjectHiddenByPanel(*anObjectsIt))
+      continue;
+    aHiddenObjects.insert(*anObjectsIt);
+    aHiddenObjectNames.append((*anObjectsIt)->data()->name().c_str());
+  }
+  if (aHiddenObjects.empty()) // in parameter objects there are no hidden objects in hide face
+    return true;
+
+  int anAnswer = QMessageBox::question(
+        desktop(), tr("Show object"),
+        tr("'%1'\n are hidden by %2:\nRemove objects from the panel to be displayed?")
+        .arg(aHiddenObjectNames.join(", ")).arg(facesPanel()->windowTitle()),
+        QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
+
+  bool aToBeDisplayed = anAnswer == QMessageBox::Yes;
+  if (aToBeDisplayed)
+    facesPanel()->restoreObjects(aHiddenObjects);
+
+  return aToBeDisplayed;
 }
 
 //**************************************************************
@@ -1466,7 +1687,7 @@ void XGUI_Workshop::deleteObjects()
   }
 
   QObjectPtrList anObjects = mySelector->selection()->selectedObjects();
-  if (!myOperationMgr->abortAllOperations())
+  if (!abortAllOperations())
     return;
 
   bool hasResult = false;
@@ -1474,9 +1695,10 @@ void XGUI_Workshop::deleteObjects()
   bool hasParameter = false;
   bool hasCompositeOwner = false;
   bool hasResultInHistory = false;
+  bool hasFolder = false;
   ModuleBase_Tools::checkObjects(anObjects, hasResult, hasFeature, hasParameter, hasCompositeOwner,
-                                 hasResultInHistory);
-  if (!(hasFeature || hasParameter))
+                                 hasResultInHistory, hasFolder);
+  if (!(hasFeature || hasParameter || hasFolder))
     return;
 
   // delete objects
@@ -1485,6 +1707,9 @@ void XGUI_Workshop::deleteObjects()
   ModuleBase_Tools::convertToFeatures(anObjects, aFeatures);
   ModelAPI_Tools::findAllReferences(aFeatures, aReferences);
 
+  std::set<FolderPtr> aFolders;
+  ModuleBase_Tools::convertToFolders(anObjects, aFolders);
+
   bool aDone = false;
   QString aDescription = contextMenuMgr()->action("DELETE_CMD")->text() + " %1";
   aDescription = aDescription.arg(XGUI_Tools::unionOfObjectNames(anObjects, ", "));
@@ -1503,6 +1728,18 @@ void XGUI_Workshop::deleteObjects()
       aFeatures.insert(aFeatureRefsToDelete.begin(), aFeatureRefsToDelete.end());
     aDone = ModelAPI_Tools::removeFeatures(aFeatures, false);
   }
+  if (aFolders.size() > 0) {
+    std::set<FolderPtr>::const_iterator anIt = aFolders.begin(),
+                                         aLast = aFolders.end();
+    for (; anIt != aLast; anIt++) {
+      FolderPtr aFolder = *anIt;
+      if (aFolder.get()) {
+        DocumentPtr aDoc = aFolder->document();
+        aDoc->removeFolder(aFolder);
+      }
+    }
+  }
+
   if (aDone)
     operationMgr()->commitOperation();
   else
@@ -1533,7 +1770,7 @@ void addRefsToFeature(const FeaturePtr& theFeature,
 //**************************************************************
 void XGUI_Workshop::cleanHistory()
 {
-  if (!myOperationMgr->abortAllOperations())
+  if (!abortAllOperations())
     return;
 
   QObjectPtrList anObjects = mySelector->selection()->selectedObjects();
@@ -1659,7 +1896,7 @@ void XGUI_Workshop::cleanHistory()
 //**************************************************************
 void XGUI_Workshop::moveObjects()
 {
-  if (!myOperationMgr->abortAllOperations())
+  if (!abortAllOperations())
     return;
 
   SessionPtr aMgr = ModelAPI_Session::get();
@@ -1695,13 +1932,13 @@ void XGUI_Workshop::moveObjects()
 //**************************************************************
 bool XGUI_Workshop::deleteFeatures(const QObjectPtrList& theObjects)
 {
-  std::map<FeaturePtr, std::set<FeaturePtr> > aReferences;
   std::set<FeaturePtr> aFeatures;
   ModuleBase_Tools::convertToFeatures(theObjects, aFeatures);
 
   return ModelAPI_Tools::removeFeaturesAndReferences(aFeatures);
 }
 
+//******************************************************
 bool hasResults(QObjectPtrList theObjects, const std::set<std::string>& theTypes)
 {
   bool isFoundResultType = false;
@@ -1775,6 +2012,7 @@ std::list<FeaturePtr> toCurrentFeatures(const ObjectPtr& theObject)
   return std::list<FeaturePtr>(aObjectIt, aCurrentIt);
 }
 
+//******************************************************
 bool XGUI_Workshop::canMoveFeature()
 {
   QString anActionId = "MOVE_CMD";
@@ -1797,6 +2035,17 @@ bool XGUI_Workshop::canMoveFeature()
   QObjectPtrList::const_iterator anIt = aObjects.begin(), aLast = aObjects.end();
   for (; anIt != aLast && aCanMove; anIt++) {
     ObjectPtr aObject = *anIt;
+    if (!aObject.get() || !aObject->data().get() || !aObject->data()->isValid()) {
+      aCanMove = false;
+      break;
+    }
+    FeaturePtr aFeat = std::dynamic_pointer_cast<ModelAPI_Feature>(aObject);
+    // only groups can be moved to the end for now (#2451)
+    if (aFeat.get() && aFeat->getKind() != "Group") {
+      aCanMove = false;
+      break;
+    }
+
     // 1. Get features placed between selected and current in the document
     std::list<FeaturePtr> aFeaturesBetween = toCurrentFeatures(aObject);
     // if aFeaturesBetween is empty it means wrong order or aObject is the current feature
@@ -1841,19 +2090,28 @@ bool XGUI_Workshop::canBeShaded(const ObjectPtr& theObject) const
 }
 
 //**************************************************************
-bool XGUI_Workshop::canChangeColor() const
+bool XGUI_Workshop::canChangeProperty(const QString& theActionName) const
 {
-  QObjectPtrList aObjects = mySelector->selection()->selectedObjects();
+  if (theActionName == "COLOR_CMD" ||
+      theActionName == "DEFLECTION_CMD"
+#ifdef USE_TRANSPARENCY
+      || theActionName == "TRANSPARENCY_CMD"
+#endif
+      ) {
+    QObjectPtrList aObjects = mySelector->selection()->selectedObjects();
 
-  std::set<std::string> aTypes;
-  aTypes.insert(ModelAPI_ResultGroup::group());
-  aTypes.insert(ModelAPI_ResultConstruction::group());
-  aTypes.insert(ModelAPI_ResultBody::group());
-  aTypes.insert(ModelAPI_ResultPart::group());
+    std::set<std::string> aTypes;
+    aTypes.insert(ModelAPI_ResultGroup::group());
+    aTypes.insert(ModelAPI_ResultConstruction::group());
+    aTypes.insert(ModelAPI_ResultBody::group());
+    aTypes.insert(ModelAPI_ResultPart::group());
 
-  return hasResults(aObjects, aTypes);
+    return hasResults(aObjects, aTypes);
+  }
+  return false;
 }
 
+//******************************************************
 void setColor(ResultPtr theResult, const std::vector<int>& theColor)
 {
   if (!theResult.get())
@@ -1900,7 +2158,7 @@ void XGUI_Workshop::changeColor(const QObjectPtrList& theObjects)
   if (aColor.size() != 3)
     return;
 
-  if (!myOperationMgr->abortAllOperations())
+  if (!abortAllOperations())
   return;
   // 2. show the dialog to change the value
   XGUI_ColorDialog* aDlg = new XGUI_ColorDialog(desktop());
@@ -1938,19 +2196,6 @@ void XGUI_Workshop::changeColor(const QObjectPtrList& theObjects)
 }
 
 //**************************************************************
-bool XGUI_Workshop::canChangeDeflection() const
-{
-  QObjectPtrList aObjects = mySelector->selection()->selectedObjects();
-
-  std::set<std::string> aTypes;
-  aTypes.insert(ModelAPI_ResultGroup::group());
-  aTypes.insert(ModelAPI_ResultConstruction::group());
-  aTypes.insert(ModelAPI_ResultBody::group());
-  aTypes.insert(ModelAPI_ResultPart::group());
-
-  return hasResults(aObjects, aTypes);
-}
-
 void setDeflection(ResultPtr theResult, const double theDeflection)
 {
   if (!theResult.get())
@@ -1961,13 +2206,41 @@ void setDeflection(ResultPtr theResult, const double theDeflection)
     aDeflectionAttr->setValue(theDeflection);
 }
 
+//**************************************************************
+void setTransparency(ResultPtr theResult, double theTransparency)
+{
+  if (!theResult.get())
+    return;
+
+  AttributeDoublePtr anAttribute = theResult->data()->real(ModelAPI_Result::TRANSPARENCY_ID());
+  if (anAttribute.get() != NULL)
+    anAttribute->setValue(theTransparency);
+}
+
+//**************************************************************
+void setTransparency(double theTransparency, const QObjectPtrList& theObjects)
+{
+  foreach(ObjectPtr anObj, theObjects) {
+    ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObj);
+    if (aResult.get() != NULL) {
+      ResultCompSolidPtr aCompsolidResult =
+        std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(aResult);
+      if (aCompsolidResult.get() != NULL) { // change property for all sub-solids
+        for(int i = 0; i < aCompsolidResult->numberOfSubs(); i++) {
+          setTransparency(aCompsolidResult->subResult(i), theTransparency);
+        }
+      }
+      setTransparency(aResult, theTransparency);
+    }
+  }
+}
 
 //**************************************************************
 void XGUI_Workshop::changeDeflection(const QObjectPtrList& theObjects)
 {
   AttributeDoublePtr aDoubleAttr;
-  // 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
+  // 1. find the current property of the object. This is a property of AIS presentation
+  // The objects are iterated until a first valid property is found
   double aDeflection = -1;
   foreach(ObjectPtr anObject, theObjects) {
     ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObject);
@@ -1975,9 +2248,9 @@ void XGUI_Workshop::changeDeflection(const QObjectPtrList& theObjects)
       aDeflection = XGUI_CustomPrs::getResultDeflection(aResult);
     }
     else {
-      // TODO: remove the obtaining a color from the AIS object
+      // TODO: remove the obtaining a property from the AIS object
       // this does not happen never because:
-      // 1. The color can be changed only on results
+      // 1. The property can be changed only on results
       // 2. The result can be not visualized in the viewer(e.g. Origin Construction)
       AISObjectPtr anAISObj = myDisplayer->getAISObject(anObject);
       if (anAISObj.get()) {
@@ -1990,7 +2263,7 @@ void XGUI_Workshop::changeDeflection(const QObjectPtrList& theObjects)
   if (aDeflection < 0)
     return;
 
-  if (!myOperationMgr->abortAllOperations())
+  if (!abortAllOperations())
   return;
   // 2. show the dialog to change the value
   XGUI_DeflectionDialog* aDlg = new XGUI_DeflectionDialog(desktop());
@@ -2012,7 +2285,7 @@ void XGUI_Workshop::changeDeflection(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
+      if (aCompsolidResult.get() != NULL) { // change property for all sub-solids
         for(int i = 0; i < aCompsolidResult->numberOfSubs(); i++) {
           setDeflection(aCompsolidResult->subResult(i), aDeflection);
         }
@@ -2024,17 +2297,113 @@ void XGUI_Workshop::changeDeflection(const QObjectPtrList& theObjects)
   updateCommandStatus();
 }
 
+//**************************************************************
+void XGUI_Workshop::changeTransparency(const QObjectPtrList& theObjects)
+{
+  AttributeDoublePtr aDoubleAttr;
+  // 1. find the current property of the object. This is a property of AIS presentation
+  // The objects are iterated until a first valid property is found
+  double aCurrentValue = -1;
+  foreach(ObjectPtr anObject, theObjects) {
+    ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObject);
+    if (aResult.get()) {
+      aCurrentValue = XGUI_CustomPrs::getResultTransparency(aResult);
+    }
+    else {
+      // TODO: remove the obtaining a property from the AIS object
+      // this does not happen never because:
+      // 1. The property can be changed only on results
+      // 2. The result can be not visualized in the viewer(e.g. Origin Construction)
+      AISObjectPtr anAISObj = myDisplayer->getAISObject(anObject);
+      if (anAISObj.get()) {
+        aCurrentValue = anAISObj->getDeflection();
+      }
+    }
+    if (aCurrentValue > 0)
+      break;
+  }
+  if (aCurrentValue < 0)
+    return;
+
+  if (!abortAllOperations())
+  return;
+
+  // 2. show the dialog to change the value
+  XGUI_PropertyDialog* aDlg = new XGUI_PropertyDialog(desktop());
+  aDlg->setWindowTitle("Transparency");
+  XGUI_TransparencyWidget* aTransparencyWidget = new XGUI_TransparencyWidget(aDlg);
+  connect(aTransparencyWidget, SIGNAL(transparencyValueChanged()),
+          this, SLOT(onTransparencyValueChanged()));
+  connect(aTransparencyWidget, SIGNAL(previewStateChanged()),
+          this, SLOT(onPreviewStateChanged()));
+  aDlg->setContent(aTransparencyWidget);
+  aTransparencyWidget->setValue(aCurrentValue);
+
+  // 3. abort the previous operation and start a new one
+  SessionPtr aMgr = ModelAPI_Session::get();
+  QString aDescription = contextMenuMgr()->action("TRANSPARENCY_CMD")->text();
+  aMgr->startOperation(aDescription.toStdString());
+
+  aDlg->move(QCursor::pos());
+  bool isDone = aDlg->exec() == QDialog::Accepted;
+  if (!isDone)
+    return;
+
+  // 4. set the value to all results
+  aCurrentValue = aTransparencyWidget->getValue();
+  setTransparency(aCurrentValue, theObjects);
+
+  aMgr->finishOperation();
+  updateCommandStatus();
+}
+
+//**************************************************************
+void XGUI_Workshop::onTransparencyValueChanged()
+{
+  XGUI_TransparencyWidget* aTransparencyWidget = (XGUI_TransparencyWidget*)sender();
+  if (!aTransparencyWidget || !aTransparencyWidget->isPreviewNeeded())
+    return;
+
+  QObjectPtrList anObjects = mySelector->selection()->selectedObjects();
+  setTransparency(aTransparencyWidget->getValue(), anObjects);
+  Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
+}
+
+//**************************************************************
+void XGUI_Workshop::onPreviewStateChanged()
+{
+  XGUI_TransparencyWidget* aTransparencyWidget = (XGUI_TransparencyWidget*)sender();
+  if (!aTransparencyWidget || !aTransparencyWidget->isPreviewNeeded())
+    return;
+
+  QObjectPtrList anObjects = mySelector->selection()->selectedObjects();
+  setTransparency(aTransparencyWidget->getValue(), anObjects);
+  Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
+}
+
 //**************************************************************
 #define SET_DISPLAY_GROUP(aGroupName, aDisplay) \
 for (int i = 0; i < aDoc->size(aGroupName); i++) { \
   aDoc->object(aGroupName, i)->setDisplayed(aDisplay); \
 }
+
+//******************************************************
 void XGUI_Workshop::showObjects(const QObjectPtrList& theList, bool isVisible)
 {
+  if (isVisible) {
+    std::set<ObjectPtr> anObjects;
+    foreach (ObjectPtr aObj, theList) {
+      anObjects.insert(aObj);
+    }
+    if (!prepareForDisplay(anObjects))
+      return;
+  }
+
   foreach (ObjectPtr aObj, theList) {
     aObj->setDisplayed(isVisible);
   }
   Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
+  myObjectBrowser->updateAllIndexes();
 }
 
 //**************************************************************
@@ -2046,19 +2415,32 @@ void XGUI_Workshop::showOnlyObjects(const QObjectPtrList& theList)
     if (module()->canEraseObject(aObj))
       aObj->setDisplayed(false);
   }
+  //Do not use eraseAll if you didn't send Redisplay event:
+  //all objects are erased from viewer, but considered as displayed in displayer
+  // Problem in bug 2218
   Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
 #ifdef HAVE_SALOME
     //issue #2159 Hide all incomplete behavior
     viewer()->eraseAll();
 #endif
 
+  std::set<ObjectPtr> anObjects;
+  foreach (ObjectPtr aObj, theList) {
+    anObjects.insert(aObj);
+  }
+
+  if (!prepareForDisplay(anObjects))
+    return;
+
   // Show only objects from the list
   foreach (ObjectPtr aObj, theList) {
     aObj->setDisplayed(true);
   }
   Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
-}
 
+  // Necessary for update icons in ObjectBrowser on Linux
+  myObjectBrowser->updateAllIndexes();
+}
 
 //**************************************************************
 void XGUI_Workshop::registerValidators() const
@@ -2116,6 +2498,9 @@ void XGUI_Workshop::closeDocument()
   objectBrowser()->clearContent();
 
   module()->closeDocument();
+  // we need to clear viewer (with created filters) to do not have problems in 2nd SALOME study
+  module()->clearViewer();
+
 
   // data model need not process the document's signals about objects modifications as
   // the document is closed
@@ -2127,6 +2512,7 @@ void XGUI_Workshop::closeDocument()
   //objectBrowser()->dataModel()->blockEventsProcessing(isBlocked);
 }
 
+//******************************************************
 void XGUI_Workshop::addHistoryMenu(QObject* theObject, const char* theSignal, const char* theSlot)
 {
   XGUI_HistoryMenu* aMenu = NULL;
@@ -2143,6 +2529,7 @@ void XGUI_Workshop::addHistoryMenu(QObject* theObject, const char* theSignal, co
   connect(aMenu, SIGNAL(actionSelected(int)), this, theSlot);
 }
 
+//******************************************************
 QList<ActionInfo> XGUI_Workshop::processHistoryList(const std::list<std::string>& theList) const
 {
   QList<ActionInfo> aResult;
@@ -2168,6 +2555,7 @@ QList<ActionInfo> XGUI_Workshop::processHistoryList(const std::list<std::string>
   return aResult;
 }
 
+//******************************************************
 void XGUI_Workshop::setStatusBarMessage(const QString& theMessage)
 {
 #ifdef HAVE_SALOME
@@ -2177,6 +2565,8 @@ void XGUI_Workshop::setStatusBarMessage(const QString& theMessage)
 #endif
 }
 
+#ifdef HAVE_SALOME
+//******************************************************
 void XGUI_Workshop::synchronizeViewer()
 {
   SessionPtr aMgr = ModelAPI_Session::get();
@@ -2192,6 +2582,7 @@ void XGUI_Workshop::synchronizeViewer()
   }
 }
 
+//******************************************************
 void XGUI_Workshop::synchronizeGroupInViewer(const DocumentPtr& theDoc,
                                              const std::string& theGroup,
                                              bool theUpdateViewer)
@@ -2212,11 +2603,14 @@ void XGUI_Workshop::synchronizeGroupInViewer(const DocumentPtr& theDoc,
   if (theUpdateViewer)
     myDisplayer->updateViewer();
 }
+#endif
 
+//******************************************************
 void XGUI_Workshop::highlightResults(const QObjectPtrList& theObjects)
 {
   FeaturePtr aFeature;
   QObjectPtrList aSelList = theObjects;
+  QObjectPtrList aNewSel;
   bool aHasHidden = false;
   foreach(ObjectPtr aObj, theObjects) {
     aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObj);
@@ -2227,6 +2621,7 @@ void XGUI_Workshop::highlightResults(const QObjectPtrList& theObjects)
       for(aIt = aResults.cbegin(); aIt != aResults.cend(); aIt++) {
         aHasHidden |= (*aIt)->isConcealed();
         aSelList.append(*aIt);
+        aNewSel.append(*aIt);
       }
     }
   }
@@ -2235,16 +2630,19 @@ void XGUI_Workshop::highlightResults(const QObjectPtrList& theObjects)
     bool aBlocked = objectBrowser()->blockSignals(true);
     objectBrowser()->setObjectsSelected(aSelList);
     objectBrowser()->blockSignals(aBlocked);
+    objectBrowser()->ensureVisible(aNewSel.first());
   }
   if (aHasHidden)
     QMessageBox::information(desktop(), tr("Find results"),
                              tr("Results not found"), QMessageBox::Ok);
 }
 
+//******************************************************
 void XGUI_Workshop::highlightFeature(const QObjectPtrList& theObjects)
 {
   ResultPtr aResult;
   QObjectPtrList aSelList = theObjects;
+  QObjectPtrList aNewSel;
   FeaturePtr aFeature;
   foreach(ObjectPtr aObj, theObjects) {
     aResult = std::dynamic_pointer_cast<ModelAPI_Result>(aObj);
@@ -2252,6 +2650,7 @@ void XGUI_Workshop::highlightFeature(const QObjectPtrList& theObjects)
       aFeature = ModelAPI_Feature::feature(aResult);
       if (aFeature.get()) {
         aSelList.append(aFeature);
+        aNewSel.append(aFeature);
       }
     }
   }
@@ -2260,5 +2659,79 @@ void XGUI_Workshop::highlightFeature(const QObjectPtrList& theObjects)
     bool aBlocked = objectBrowser()->blockSignals(true);
     objectBrowser()->setObjectsSelected(aSelList);
     objectBrowser()->blockSignals(aBlocked);
+    objectBrowser()->ensureVisible(aNewSel.first());
   }
 }
+
+void XGUI_Workshop::insertFeatureFolder()
+{
+  QObjectPtrList aObjects = mySelector->selection()->selectedObjects();
+  if (aObjects.isEmpty())
+    return;
+  ObjectPtr aObj = aObjects.first();
+  FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObj);
+  if (aFeature.get() == NULL)
+    return;
+  SessionPtr aMgr = ModelAPI_Session::get();
+  DocumentPtr aDoc = aMgr->activeDocument();
+
+  QString aDescription = contextMenuMgr()->action("INSERT_FOLDER_CMD")->text();
+
+  aMgr->startOperation(aDescription.toStdString());
+  aDoc->addFolder(aFeature);
+  aMgr->finishOperation();
+
+  updateCommandStatus();
+}
+
+
+void XGUI_Workshop::insertToFolder(bool isBefore)
+{
+  std::list<FeaturePtr> aFeatures = mySelector->getSelectedFeatures();
+  if (aFeatures.empty())
+    return;
+
+  SessionPtr aMgr = ModelAPI_Session::get();
+  DocumentPtr aDoc = aMgr->activeDocument();
+
+  FolderPtr aFolder = isBefore? aDoc->findFolderAbove(aFeatures):
+                                aDoc->findFolderBelow(aFeatures);
+  if (!aFolder.get())
+    return;
+
+  QString aDescription = contextMenuMgr()->action(
+    isBefore ? "ADD_TO_FOLDER_BEFORE_CMD" : "ADD_TO_FOLDER_AFTER_CMD")->text();
+
+  QMap<ObjectPtr, bool> aStates = myObjectBrowser->getFoldersState(aDoc);
+
+  aMgr->startOperation(aDescription.toStdString());
+  aDoc->moveToFolder(aFeatures, aFolder);
+  aMgr->finishOperation();
+
+  myObjectBrowser->setFoldersState(aStates);
+
+  updateCommandStatus();
+}
+
+void XGUI_Workshop::moveOutFolder(bool isBefore)
+{
+  std::list<FeaturePtr> aFeatures = mySelector->getSelectedFeatures();
+  if (aFeatures.empty())
+    return;
+
+  SessionPtr aMgr = ModelAPI_Session::get();
+  DocumentPtr aDoc = aMgr->activeDocument();
+
+  QString aDescription = contextMenuMgr()->action(
+    isBefore ? "ADD_OUT_FOLDER_BEFORE_CMD" : "ADD_OUT_FOLDER_AFTER_CMD")->text();
+
+  QMap<ObjectPtr, bool> aStates = myObjectBrowser->getFoldersState(aDoc);
+
+  aMgr->startOperation(aDescription.toStdString());
+  aDoc->removeFromFolder(aFeatures, isBefore);
+  aMgr->finishOperation();
+
+  myObjectBrowser->setFoldersState(aStates);
+
+  updateCommandStatus();
+}