X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FXGUI%2FXGUI_FacesPanel.cpp;h=ced3592a2b541c1a3aaa475149f27a79b295bf70;hb=4de8d53fef7532b6843d79c970f55ad46f98da62;hp=79f29907775c29e05db27a75db69c386dfd8d6ec;hpb=613e672654df0f1e6838fb55b384842ce534809a;p=modules%2Fshaper.git

diff --git a/src/XGUI/XGUI_FacesPanel.cpp b/src/XGUI/XGUI_FacesPanel.cpp
index 79f299077..ced3592a2 100644
--- a/src/XGUI/XGUI_FacesPanel.cpp
+++ b/src/XGUI/XGUI_FacesPanel.cpp
@@ -1,4 +1,4 @@
-// Copyright (C) 2014-2017  CEA/DEN, EDF R&D
+// Copyright (C) 2014-2024  CEA, EDF
 //
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
@@ -12,29 +12,41 @@
 //
 // You should have received a copy of the GNU Lesser General Public
 // License along with this library; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 //
-// See http://www.salome-platform.org/ or
-// email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
 
 #include "XGUI_FacesPanel.h"
+#include "XGUI_ObjectsBrowser.h"
+#include "XGUI_SelectionMgr.h"
+#include "XGUI_Selection.h"
+#include "XGUI_Tools.h"
+#include "XGUI_Workshop.h"
+#include "XGUI_Displayer.h"
+#include "XGUI_ViewerProxy.h"
 
+#include <ModuleBase_IModule.h>
+#include <ModuleBase_ISelection.h>
+#include <ModuleBase_IWorkshop.h>
+#include <ModuleBase_IViewer.h>
+#include <ModuleBase_ListView.h>
+#include <ModuleBase_ResultPrs.h>
+#include <ModuleBase_Tools.h>
+#include <ModuleBase_ViewerPrs.h>
+#include <ModuleBase_SelectionFilterType.h>
+
+#include <Config_PropManager.h>
 #include <Events_Loop.h>
-#include "GeomAlgoAPI_CompoundBuilder.h"
+#include <GeomAlgoAPI_CompoundBuilder.h>
+#include <GeomAPI_Shape.h>
 
 #include <ModelAPI_Events.h>
+#include <ModelAPI_AttributeSelectionList.h>
 
-#include <ModuleBase_ISelection.h>
-#include "ModuleBase_IWorkshop.h"
-#include "ModuleBase_ListView.h"
-#include "ModuleBase_ResultPrs.h"
-#include "ModuleBase_Tools.h"
-#include "ModuleBase_ViewerPrs.h"
-
-#include "XGUI_Displayer.h"
-#include "XGUI_Tools.h"
-#include "XGUI_Workshop.h"
+#include <ModuleBase_Operation.h>
+#include <ModuleBase_OperationFeature.h>
+#include <XGUI_OperationMgr.h>
 
 #include <QAction>
 #include <QCheckBox>
@@ -42,15 +54,59 @@
 #include <QGridLayout>
 #include <QListWidget>
 #include <QMainWindow>
+#include <QTimer>
+
+#ifdef WIN32
+#pragma warning(disable : 4189) // for skipping MAYBE_UNUSED on Win
+#endif
 
 static const int LayoutMargin = 3;
 
 //********************************************************************
-XGUI_FacesPanel::XGUI_FacesPanel(QWidget* theParent, ModuleBase_IWorkshop* theWorkshop)
-  : QDockWidget(theParent), myIsActive(false), myWorkshop(theWorkshop)
+void updateHiddenShapes(Handle(ModuleBase_ResultPrs) thePrs, const TopoDS_ListOfShape& theShapes)
+{
+  TopoDS_ListOfShape aAlreadyHidden = thePrs->hiddenSubShapes();
+  TopoDS_ListOfShape::Iterator aShPIt(theShapes);
+  for (; aShPIt.More(); aShPIt.Next()) {
+    if (aAlreadyHidden.Contains(aShPIt.Value()))
+      aAlreadyHidden.Remove(aShPIt.Value());
+  }
+  thePrs->setSubShapeHidden(aAlreadyHidden);
+}
+
+//********************************************************************
+void objectsMapFromPrs(ModuleBase_ViewerPrsPtr thePrs,
+  std::map<ObjectPtr, TopoDS_ListOfShape>& theObjectToShapes,
+  std::map<ObjectPtr, Handle(ModuleBase_ResultPrs) >& theObjectToPrs)
+{
+  ObjectPtr anObject = thePrs->object();
+  if (!anObject.get())
+    return;
+
+  // Process bodies
+  Handle(ModuleBase_ResultPrs) aResultPrs = Handle(ModuleBase_ResultPrs)::DownCast(
+    thePrs->interactive());
+  if (aResultPrs.IsNull())
+    return;
+
+  if (theObjectToShapes.find(anObject) != theObjectToShapes.end())
+    theObjectToShapes.at(anObject).Append(ModuleBase_Tools::getSelectedShape(thePrs));
+  else {
+    TopoDS_ListOfShape aListOfShapes;
+    aListOfShapes.Append(ModuleBase_Tools::getSelectedShape(thePrs));
+    theObjectToShapes[anObject] = aListOfShapes;
+    theObjectToPrs[anObject] = aResultPrs;
+  }
+}
+
+//********************************************************************
+XGUI_FacesPanel::XGUI_FacesPanel(QWidget* theParent, XGUI_Workshop* theWorkshop)
+  : QDockWidget(theParent), myWorkshop(theWorkshop), myIsActive(false), myLastItemIndex(0)
 {
   setWindowTitle(tr("Hide Faces"));
-  QAction* aViewAct = toggleViewAction();
+  setObjectName("Hide Faces");
+
+  MAYBE_UNUSED QAction* aViewAct = toggleViewAction();
   setStyleSheet("::title { position: relative; padding-left: 5px; text-align: left center }");
 
   QWidget* aContent = new QWidget(this);
@@ -59,8 +115,9 @@ XGUI_FacesPanel::XGUI_FacesPanel(QWidget* theParent, ModuleBase_IWorkshop* theWo
   setWidget(aContent);
 
   myHiddenOrTransparent = new QCheckBox(tr("Transparent"), aContent);
+  connect(myHiddenOrTransparent, SIGNAL(toggled(bool)), SLOT(onTransparencyChanged()));
+
   myListView = new ModuleBase_ListView(aContent, "", "Hidden/transparent faces in 3D view");
-  connect(myListView->getControl(), SIGNAL(itemSelectionChanged()), SLOT(onListSelection()));
   connect(myListView, SIGNAL(deleteActionClicked()), SLOT(onDeleteItem()));
 
   aMainLayout->addWidget(myHiddenOrTransparent, 0, 0);
@@ -68,28 +125,66 @@ XGUI_FacesPanel::XGUI_FacesPanel(QWidget* theParent, ModuleBase_IWorkshop* theWo
 
   myListView->getControl()->setFocusPolicy(Qt::StrongFocus);
   myListView->getControl()->viewport()->installEventFilter(this);
+
+  XGUI_Displayer* aDisplayer = myWorkshop->displayer();
+  connect(aDisplayer, SIGNAL(objectDisplayed(ObjectPtr, AISObjectPtr)),
+    SLOT(onObjectDisplay(ObjectPtr, AISObjectPtr)));
 }
 
 //********************************************************************
 void XGUI_FacesPanel::reset(const bool isToFlushRedisplay)
 {
-  // restore presentation state
-  bool isModified = false;
-  std::set<ObjectPtr> aRestoredObjects;
-  for (QMap<int, ModuleBase_ViewerPrsPtr>::const_iterator anIt = myItems.begin();
-    anIt != myItems.end(); anIt++) {
-    if (aRestoredObjects.find(anIt.value()->object()) == aRestoredObjects.end())
-      aRestoredObjects.insert(anIt.value()->object());
+  if (myLastItemIndex == 0) // do nothing because there was no activity in the pane after reset
+    return;
+
+  std::map<ObjectPtr, TopoDS_ListOfShape> anObjectToShapes;
+  std::map<ObjectPtr, Handle(ModuleBase_ResultPrs) > anObjectToPrs;
+  QMap<int, ModuleBase_ViewerPrsPtr >::const_iterator aIt;
+  for (aIt = myItems.cbegin(); aIt != myItems.cend(); aIt++) {
+    objectsMapFromPrs(aIt.value(), anObjectToShapes, anObjectToPrs);
+  }
+
+  std::set<ObjectPtr> aObjects;
+  TopoDS_ListOfShape anEmpty;
+  std::map<ObjectPtr, Handle(ModuleBase_ResultPrs)>::const_iterator aPrsIt;
+  for (aPrsIt = anObjectToPrs.cbegin(); aPrsIt != anObjectToPrs.cend(); aPrsIt++) {
+    aObjects.insert(aPrsIt->first);
+    aPrsIt->second->setSubShapeHidden(anEmpty);
   }
+
+  if (redisplayObjects(aObjects))
+    flushRedisplay();
+
   // clear internal containers
   myListView->getControl()->clear();
-  myLastItemIndex = 0;
   myItems.clear();
+  updateProcessedObjects(myItems, myItemObjects);
+  myLastItemIndex = 0; // it should be after redisplay as flag used in customize
+  myHiddenObjects.clear();
+}
 
-  isModified = redisplayObjects(aRestoredObjects, isToFlushRedisplay);
+//********************************************************************
+bool XGUI_FacesPanel::isEmpty() const
+{
+  return myItems.size() == 0;
+}
 
-  if (isToFlushRedisplay && isModified)
-    XGUI_Tools::workshop(myWorkshop)->displayer()->updateViewer();
+//********************************************************************
+void XGUI_FacesPanel::selectionModes(QIntList& theModes)
+{
+  theModes.append(TopAbs_FACE);
+}
+
+//********************************************************************
+void XGUI_FacesPanel::selectionFilters(SelectMgr_ListOfFilter& theSelectionFilters)
+{
+  ModuleBase_IModule* aModule = myWorkshop->module();
+  QIntList aModuleSelectionFilters = myWorkshop->module()->selectionFilters();
+
+  // The global filter makes problem for groups selection when any operation is launched
+  // theSelectionFilters.Append(aModule->selectionFilter(SF_GlobalFilter));
+  theSelectionFilters.Append(aModule->selectionFilter(SF_FilterInfinite));
+  theSelectionFilters.Append(aModule->selectionFilter(SF_ResultGroupNameFilter));
 }
 
 //********************************************************************
@@ -114,20 +209,33 @@ void XGUI_FacesPanel::setActivePanel(const bool theIsActive)
   ModuleBase_Tools::setShadowEffect(myListView->getControl(), theIsActive);
   myIsActive = theIsActive;
 
-  if (myIsActive)
-  {
+  if (myIsActive) {
     emit activated();
-    // selection should be activated after emit signal, that deactivates current widget(selection)
-    activateSelection(theIsActive);
+    // selection should be cleared after emit of signal to do not process selection change
+    // event by the previous selector
+    // the selection is cleared by activating selection control
+    myWorkshop->selector()->clearSelection();
   }
-  else
-  {
-    // selection should be activated after emit signal, that deactivates current widget(selection)
-    activateSelection(theIsActive);
+  else{
     emit deactivated();
+    myUndoList.clear();
   }
 }
 
+//********************************************************************
+bool XGUI_FacesPanel::useTransparency() const
+{
+  return myHiddenOrTransparent->isChecked();
+}
+
+//********************************************************************
+double XGUI_FacesPanel::transparency() const
+{
+  return useTransparency() ?
+    Config_PropManager::real("Visualization", "hidden_face_transparency") : 1;
+}
+
+
 //********************************************************************
 void XGUI_FacesPanel::restoreObjects(const std::set<ObjectPtr>& theHiddenObjects)
 {
@@ -143,17 +251,15 @@ void XGUI_FacesPanel::restoreObjects(const std::set<ObjectPtr>& theHiddenObjects
   }
 
   // remove from myItes container
-  for (std::set<int>::const_iterator aToBeRemovedIt = anIndicesToBeRemoved.begin();
-    aToBeRemovedIt != anIndicesToBeRemoved.end(); aToBeRemovedIt++)
-    myItems.remove(*aToBeRemovedIt);
-
-  myListView->removeItems(anIndicesToBeRemoved);
+  removeItems(anIndicesToBeRemoved);
+  if (!anIndicesToBeRemoved.empty()) // means that myItems has been changed
+    updateProcessedObjects(myItems, myItemObjects);
 
   // remove from container of hidden objects
   for (std::set<ObjectPtr>::const_iterator aHiddenIt = theHiddenObjects.begin();
     aHiddenIt != theHiddenObjects.end(); aHiddenIt++)
   {
-    if (myHiddenObjects.find(*aHiddenIt) != myHiddenObjects.end()) ///< found objects
+    if (myHiddenObjects.find(*aHiddenIt) != myHiddenObjects.end()) /// found objects
       myHiddenObjects.erase(*aHiddenIt);
   }
 }
@@ -176,129 +282,185 @@ bool XGUI_FacesPanel::processAction(ModuleBase_ActionType theActionType)
   }
 }
 
+
 //********************************************************************
 void XGUI_FacesPanel::processSelection()
 {
-  QList<ModuleBase_ViewerPrsPtr> aSelected = myWorkshop->selection()->getSelected(
-                                                       ModuleBase_ISelection::Viewer);
+  QList<ModuleBase_ViewerPrsPtr> aSelected =
+    myWorkshop->selector()->selection()->getSelected(ModuleBase_ISelection::Viewer);
+
+  if (aSelected.size() == 0)
+    return;
+
   bool isModified = false;
+  static Events_ID aDispEvent = Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY);
+
+  std::map<ObjectPtr, TopoDS_ListOfShape> anObjectToShapes;
+  std::map<ObjectPtr, Handle(ModuleBase_ResultPrs) > anObjectToPrs;
+  std::set<int> aToRemove;
+
   for (int i = 0; i < aSelected.size(); i++) {
     ModuleBase_ViewerPrsPtr aPrs = aSelected[i];
     ObjectPtr anObject = aPrs->object();
     if (!anObject.get())
       continue;
 
-    if (ModuleBase_Tools::getSelectedShape(aPrs).ShapeType() != TopAbs_FACE)
+    GeomShapePtr aShapePtr = aPrs->shape();
+    if (!aShapePtr.get() || !aShapePtr->isFace())
       continue;
 
-    myItems.insert(myLastItemIndex, aPrs);
-    myListView->addItem(generateName(aPrs), myLastItemIndex);
-    isModified = hideFace(myLastItemIndex) || isModified;
+    QString aItemName = XGUI_Tools::generateName(aPrs);
+    if (myListView->hasItem(aItemName))
+      continue;
 
+    objectsMapFromPrs(aPrs, anObjectToShapes, anObjectToPrs);
+
+    // The code is dedicated to remove already selected items if they are selected twice
+    // It can happen in case of groups selection
+    QMap<int, ModuleBase_ViewerPrsPtr>::const_iterator aIt;
+    for (aIt = myItems.cbegin(); aIt != myItems.cend(); aIt++) {
+      ModuleBase_ViewerPrsPtr aCurPrs = aIt.value();
+      ObjectPtr aObject = aCurPrs->object();
+      if (anObjectToShapes.find(aObject) != anObjectToShapes.end()) {
+        TopoDS_ListOfShape aShapes = anObjectToShapes[aObject];
+        GeomShapePtr aShapePtr = aCurPrs->shape();
+        if (aShapes.Contains(aShapePtr->impl<TopoDS_Shape>())) {
+          aToRemove.insert(aIt.key());
+        }
+      }
+    }
+
+    myItems.insert(myLastItemIndex, aPrs);
+    myListView->addItem(aItemName, myLastItemIndex);
+    // add in undo list
+    myUndoList.push_back(myLastItemIndex);
     myLastItemIndex++;
+    isModified = true;
+  }
+
+  // Hide fully hidden shapes
+  std::map<ObjectPtr, TopoDS_ListOfShape>::const_iterator anIt;
+  for (anIt = anObjectToShapes.begin(); anIt != anObjectToShapes.end(); anIt++) {
+    ObjectPtr anObject = anIt->first;
+    if (!anObject.get() || anObjectToPrs.find(anObject) == anObjectToPrs.end())
+      continue;
+    Handle(ModuleBase_ResultPrs) aResultPrs = anObjectToPrs.at(anObject);
+
+    if (!aResultPrs->hasSubShapeVisible(anIt->second)) { // redisplay
+      // erase object because it is entirely hidden
+      anObject->setDisplayed(false);
+      myHiddenObjects.insert(anObject);
+    }
+    ModelAPI_EventCreator::get()->sendUpdated(anObject, aDispEvent);
+  }
+
+  // Process selected presentations
+  double aTransp = transparency();
+  std::map<ObjectPtr, Handle(ModuleBase_ResultPrs)>::iterator aPrsIt;
+  for (aPrsIt = anObjectToPrs.begin(); aPrsIt != anObjectToPrs.end(); aPrsIt++) {
+    ObjectPtr anObject = aPrsIt->first;
+    Handle(ModuleBase_ResultPrs) aPrs = aPrsIt->second;
+    TopoDS_ListOfShape aAlreadyHidden = aPrs->hiddenSubShapes();
+    TopoDS_ListOfShape aListOfShapes = anObjectToShapes[anObject];
+    TopoDS_ListOfShape::Iterator aShapesIt(aListOfShapes);
+    for (; aShapesIt.More(); aShapesIt.Next()) {
+      if (!aAlreadyHidden.Contains(aShapesIt.Value()))
+        aAlreadyHidden.Append(aShapesIt.Value());
+    }
+    aPrs->setSubShapeHidden(aAlreadyHidden);
+    aPrs->setHiddenSubShapeTransparency(aTransp);
   }
 
-  if (isModified)
-    XGUI_Tools::workshop(myWorkshop)->displayer()->updateViewer();
+  // Remove duplicate items
+  removeItems(aToRemove);
+  myWorkshop->selector()->clearSelection();
+  if (isModified) {
+    updateProcessedObjects(myItems, myItemObjects);
+    flushRedisplay();
+  }
 }
 
 //********************************************************************
 bool XGUI_FacesPanel::processDelete()
 {
   //appendFirstSelectionInHistory();
-  QModelIndexList anIndices = myListView->getControl()->selectionModel()->selectedIndexes();
+  //QModelIndexList anIndices = myListView->getControl()->selectionModel()->selectedIndexes();
 
   std::set<int> aSelectedIds;
   myListView->getSelectedIndices(aSelectedIds);
   if (aSelectedIds.empty())
     return false;
 
-  bool isModified = false;
-  std::set<ObjectPtr> aRestoredObjects;
-  XGUI_Displayer* aDisplayer = XGUI_Tools::workshop(myWorkshop)->displayer();
-  for (std::set<int>::const_iterator anIt = aSelectedIds.begin(); anIt != aSelectedIds.end();
-       anIt++) {
+  std::set<ModuleBase_ViewerPrsPtr> aRestored;
+  std::set<int>::const_iterator anIt;
+  for (anIt = aSelectedIds.begin(); anIt != aSelectedIds.end(); anIt++) {
     ModuleBase_ViewerPrsPtr aPrs = myItems[*anIt];
-    if (aRestoredObjects.find(aPrs->object()) == aRestoredObjects.end())
-      aRestoredObjects.insert(aPrs->object());
-    myItems.remove(*anIt);
+    if (aRestored.find(aPrs) == aRestored.end()) {
+      aRestored.insert(aPrs);
+      myItems.remove(*anIt);
+    }
   }
-  myListView->removeSelectedItems();
+  std::map<ObjectPtr, TopoDS_ListOfShape> anObjectToShapes;
+  std::map<ObjectPtr, Handle(ModuleBase_ResultPrs) > anObjectToPrs;
 
-  isModified = redisplayObjects(aRestoredObjects, true) || isModified;
-  if (isModified)
-    XGUI_Tools::workshop(myWorkshop)->displayer()->updateViewer();
+  std::set<ModuleBase_ViewerPrsPtr>::const_iterator aIt;
+  for (aIt = aRestored.cbegin(); aIt != aRestored.cend(); aIt++) {
+    objectsMapFromPrs((*aIt), anObjectToShapes, anObjectToPrs);
+  }
 
-  // Restore selection
-  myListView->restoreSelection(anIndices);
-  //appendSelectionInHistory();
+  std::set<ObjectPtr> aRestoredObjects;
+  std::map<ObjectPtr, TopoDS_ListOfShape>::const_iterator aShapesIt;
+  for (aShapesIt = anObjectToShapes.begin(); aShapesIt != anObjectToShapes.end(); aShapesIt++) {
+    TopoDS_ListOfShape aShapes = aShapesIt->second;
+    aRestoredObjects.insert(aShapesIt->first);
+    Handle(ModuleBase_ResultPrs) aPrs = anObjectToPrs[aShapesIt->first];
+    TopoDS_ListOfShape aHiddenShapes = aPrs->hiddenSubShapes();
+    TopoDS_ListOfShape::Iterator aSubShapesIt(aShapes);
+    for (; aSubShapesIt.More(); aSubShapesIt.Next()) {
+      if (aHiddenShapes.Contains(aSubShapesIt.Value()))
+        aHiddenShapes.Remove(aSubShapesIt.Value());
+    }
+    aPrs->setSubShapeHidden(aHiddenShapes);
+  }
+  if (redisplayObjects(aRestoredObjects))
+    flushRedisplay();
+
+  myListView->removeSelectedItems();
   return true;
 }
 
 //********************************************************************
 bool XGUI_FacesPanel::redisplayObjects(
-  const std::set<std::shared_ptr<ModelAPI_Object> >& theObjects,
-  const bool isToFlushRedisplay)
+  const std::set<ObjectPtr >& theObjects)
 {
+  if (theObjects.empty())
+    return false;
+
   bool isModified = false;
-  XGUI_Displayer* aDisplayer = XGUI_Tools::workshop(myWorkshop)->displayer();
   static Events_ID aDispEvent = Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY);
-
   for (std::set<ObjectPtr>::const_iterator anIt = theObjects.begin(); anIt != theObjects.end();
        anIt++)
   {
     ObjectPtr anObject = *anIt;
-    if (!anObject->isDisplayed()) {
-      // if the object was hidden by this panel
-      if (myHiddenObjects.find(anObject) != myHiddenObjects.end())
-        myHiddenObjects.erase(anObject);
-      anObject->setDisplayed(true); // it means that the object is hidden by hide all faces
-      ModelAPI_EventCreator::get()->sendUpdated(anObject, aDispEvent);
-      isModified = true;
-      //isModified = aDisplayer->display(anObject, false) || isModified;
-    }
-    else {
-      ModelAPI_EventCreator::get()->sendUpdated(anObject, aDispEvent);
-      isModified = true;
-    }
+    if (!anObject->isDisplayed())
+      continue;
+    ModelAPI_EventCreator::get()->sendUpdated(anObject, aDispEvent);
+    isModified = true;
   }
-  if (isToFlushRedisplay)
-    Events_Loop::loop()->flush(aDispEvent);
   return isModified;
 }
 
 //********************************************************************
-bool XGUI_FacesPanel::hideFace(const int theIndex)
+void XGUI_FacesPanel::updateProcessedObjects(QMap<int, ModuleBase_ViewerPrsPtr> theItems,
+                                             std::set<ObjectPtr>& theObjects)
 {
-  XGUI_Displayer* aDisplayer = XGUI_Tools::workshop(myWorkshop)->displayer();
-
-  if (!myItems.contains(theIndex))
-    return false;
-
-  ModuleBase_ViewerPrsPtr aPrs = myItems[theIndex];
-
-  AISObjectPtr aAISObj = aDisplayer->getAISObject(aPrs->object());
-  if (aAISObj.get() == NULL)
-    return false;
-  Handle(ModuleBase_ResultPrs) aResultPrs = Handle(ModuleBase_ResultPrs)::DownCast(
-    aAISObj->impl<Handle(AIS_InteractiveObject)>());
-  if (aResultPrs.IsNull())
-    return false;
-  // set shape hidden to check whether the presentation should be erased from the viewer
-  bool isModified = false;
-  if (aResultPrs->hasSubShapeVisible(ModuleBase_Tools::getSelectedShape(aPrs)))
-    isModified = aDisplayer->redisplay(aPrs->object(), false) || isModified;
-  else
-  {
-    ObjectPtr anObject = aPrs->object();
-    myHiddenObjects.insert(anObject);
-    static Events_ID aDispEvent = Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY);
-    anObject->setDisplayed(false);
-    isModified = aDisplayer->erase(anObject, false) || isModified;
-    ModelAPI_EventCreator::get()->sendUpdated(anObject, aDispEvent);
-    Events_Loop::loop()->flush(aDispEvent);
+  theObjects.clear();
+  for (QMap<int, ModuleBase_ViewerPrsPtr>::const_iterator anIt = theItems.begin();
+       anIt != theItems.end(); anIt++) {
+    ModuleBase_ViewerPrsPtr aPrs = anIt.value();
+    if (theObjects.find(aPrs->object()) == theObjects.end())
+      theObjects.insert(aPrs->object());
   }
-  return isModified;
 }
 
 //********************************************************************
@@ -309,88 +471,115 @@ void XGUI_FacesPanel::closeEvent(QCloseEvent* theEvent)
 }
 
 //********************************************************************
-void XGUI_FacesPanel::activateSelection(bool toActivate)
+void XGUI_FacesPanel::onDeleteItem()
 {
-  QIntList aShapeTypes;
-  aShapeTypes.append(TopAbs_FACE);
-
-  if (toActivate) {
-    myWorkshop->activateSubShapesSelection(aShapeTypes);
-  } else {
-    myWorkshop->deactivateSubShapesSelection();
-  }
-  if (toActivate)
-    activateSelectionFilters();
-  else
-    deactivateSelectionFilters();
+  processDelete();
 }
 
 //********************************************************************
-QString XGUI_FacesPanel::generateName(const ModuleBase_ViewerPrsPtr& thePrs)
+void XGUI_FacesPanel::onTransparencyChanged()
 {
-  if (!thePrs.get() || !thePrs->object().get())
-    return "Undefined";
-
-  GeomShapePtr aContext;
-  ObjectPtr anObject = thePrs->object();
-  ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObject);
-  if (aResult.get())
-    aContext = aResult->shape();
-  else {
-    // TODO if there is this case
+  std::map<ObjectPtr, TopoDS_ListOfShape> anObjectToShapes;
+  std::map<ObjectPtr, Handle(ModuleBase_ResultPrs) > anObjectToPrs;
+  QMap<int, ModuleBase_ViewerPrsPtr >::const_iterator aIt;
+  for (aIt = myItems.cbegin(); aIt != myItems.cend(); aIt++) {
+    objectsMapFromPrs(aIt.value(), anObjectToShapes, anObjectToPrs);
   }
 
-  QString aName = anObject->data()->name().c_str();
-  if (aContext.get()) {
-    GeomShapePtr aSubShape(new GeomAPI_Shape());
-    aSubShape->setImpl(new TopoDS_Shape(ModuleBase_Tools::getSelectedShape(thePrs)));
-    if (!aSubShape->isEqual(aContext))
-      aName += QString("_%1").arg(GeomAlgoAPI_CompoundBuilder::id(aContext, aSubShape));
+  double aTransp = Config_PropManager::real("Visualization", "hidden_face_transparency");
+  std::set<ObjectPtr> aObjects;
+  std::map<ObjectPtr, Handle(ModuleBase_ResultPrs)>::const_iterator aPrsIt;
+  for (aPrsIt = anObjectToPrs.cbegin(); aPrsIt != anObjectToPrs.cend(); aPrsIt++) {
+    aObjects.insert(aPrsIt->first);
+    aPrsIt->second->setHiddenSubShapeTransparency(useTransparency()? aTransp : 1);
   }
-  return aName;
+  if (redisplayObjects(aObjects))
+    flushRedisplay();
 }
 
 //********************************************************************
-bool XGUI_FacesPanel::customizeObject(const ObjectPtr& theObject, const bool isDisplayed)
+void XGUI_FacesPanel::onClosed()
 {
-  if (isDisplayed && myItems.isEmpty())
-    return false;
-
-  XGUI_Displayer* aDisplayer = XGUI_Tools::workshop(myWorkshop)->displayer();
+  setActivePanel(false);
+  reset(true);
+}
 
-  AISObjectPtr aAISObj = aDisplayer->getAISObject(theObject);
-  if (aAISObj.get() == NULL)
-    return false;
-  Handle(ModuleBase_ResultPrs) aResultPrs = Handle(ModuleBase_ResultPrs)::DownCast(
-    aAISObj->impl<Handle(AIS_InteractiveObject)>());
-  if (aResultPrs.IsNull())
-    return false;
+//********************************************************************
 
-  // if the object is displayed, the hidden faces are collected and set to the presentation
-  bool isModified = false;
-  NCollection_List<TopoDS_Shape> aHiddenSubShapes;
-  for (QMap<int, ModuleBase_ViewerPrsPtr>::const_iterator anIt = myItems.begin();
-    anIt != myItems.end(); anIt++) {
-    ModuleBase_ViewerPrsPtr aPrs = anIt.value();
-    if (aPrs.get() && aPrs->object() != theObject)
-      continue;
-    TopoDS_Shape aShape = ModuleBase_Tools::getSelectedShape(aPrs);
-    if (!aHiddenSubShapes.Contains(aShape))
-      aHiddenSubShapes.Append(aShape);
-  }
-  isModified = aResultPrs->setSubShapeHidden(aHiddenSubShapes);
+void XGUI_FacesPanel::processUndo()
+{
+ if(!myUndoList.size())
+   return;
 
-  return isModified;
+ myListView->selectIndices({myUndoList.back()});
+ processDelete();
+ myUndoList.pop_back();
 }
 
 //********************************************************************
-void XGUI_FacesPanel::onDeleteItem()
+void XGUI_FacesPanel::flushRedisplay() const
 {
-  processDelete();
+  Events_Loop::loop()->flush(Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY));
+  // Necessary for update visibility icons in ObjectBrowser
+  XGUI_ObjectsBrowser* anObjectBrowser = myWorkshop->objectBrowser();
+  if (anObjectBrowser)
+    anObjectBrowser->updateAllIndexes();
+  myWorkshop->viewer()->update();
 }
 
+
 //********************************************************************
-void XGUI_FacesPanel::onClosed()
+void XGUI_FacesPanel::onObjectDisplay(ObjectPtr theObject, AISObjectPtr theAIS)
 {
-  reset(true);
+  bool aContains = false;
+  QMap<int, ModuleBase_ViewerPrsPtr>::iterator aIt;
+  for (aIt = myItems.begin(); aIt != myItems.end(); aIt++) {
+    ModuleBase_ViewerPrsPtr aPrs = aIt.value();
+    if (aPrs->object() == theObject) {
+      aContains = true;
+      break;
+    }
+  }
+  if (aContains) {
+    std::map<ObjectPtr, TopoDS_ListOfShape> aObjectToShapes;
+    std::map<ObjectPtr, Handle(ModuleBase_ResultPrs)> aObjectToPrs;
+    std::set<ObjectPtr> aObjects;
+    std::set<int> aIdsToRem;
+
+    TopoDS_ListOfShape aHideShapes;
+    std::map<ObjectPtr, TopoDS_ListOfShape>::const_iterator aSIt;
+    for (aIt = myItems.begin(); aIt != myItems.end(); aIt++) {
+      ModuleBase_ViewerPrsPtr aPrs = aIt.value();
+      if (aPrs->object() == theObject) {
+        TopoDS_Shape aShape = aPrs->shape()->impl<TopoDS_Shape>();
+        if (!aShape.IsNull())
+          aHideShapes.Append(aShape);
+        aPrs->setInteractive(theAIS->impl<Handle(AIS_InteractiveObject)>());
+      }
+    }
+    double aTransp = transparency();
+    if (aHideShapes.Size() > 0) {
+      Handle(ModuleBase_ResultPrs) aResultPrs = Handle(ModuleBase_ResultPrs)::DownCast(
+        theAIS->impl<Handle(AIS_InteractiveObject)>());
+      if (!aResultPrs.IsNull()) {
+        aResultPrs->setSubShapeHidden(aHideShapes);
+        aResultPrs->setHiddenSubShapeTransparency(aTransp);
+        aObjects.insert(theObject);
+      }
+    }
+    removeItems(aIdsToRem);
+    myWorkshop->selector()->clearSelection();
+    if (redisplayObjects(aObjects))
+      QTimer::singleShot(50, this, SLOT(flushRedisplay()));
+  }
+}
+
+void XGUI_FacesPanel::removeItems(std::set<int> theIds)
+{
+  if (theIds.empty())
+    return;
+  myListView->removeItems(theIds);
+  std::set<int>::const_iterator aRIt;
+  for (aRIt = theIds.begin(); aRIt != theIds.end(); aRIt++)
+    myItems.remove(*aRIt);
 }