X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FXGUI%2FXGUI_Displayer.cpp;h=0ebba5866f740bcac44bf6e9adbf8788fe1bc970;hb=9ef2d81a8b97eee85d6506d95f2481fe7fae1e56;hp=ed92f3845cff22d8ee9102b37f0be743486da20c;hpb=09360d321e48c3749afa582c0958a28ea7bf9200;p=modules%2Fshaper.git

diff --git a/src/XGUI/XGUI_Displayer.cpp b/src/XGUI/XGUI_Displayer.cpp
index ed92f3845..0ebba5866 100644
--- a/src/XGUI/XGUI_Displayer.cpp
+++ b/src/XGUI/XGUI_Displayer.cpp
@@ -6,11 +6,13 @@
 #include "XGUI_Viewer.h"
 #include "XGUI_Workshop.h"
 #include "XGUI_ViewerProxy.h"
-#include "ModuleBase_Tools.h"
 
 #include <ModelAPI_Document.h>
 #include <ModelAPI_Data.h>
 #include <ModelAPI_Object.h>
+#include <ModelAPI_Tools.h>
+
+#include <ModuleBase_ResultPrs.h>
 
 #include <GeomAPI_Shape.h>
 #include <GeomAPI_IPresentable.h>
@@ -20,25 +22,28 @@
 #include <AIS_ListOfInteractive.hxx>
 #include <AIS_ListIteratorOfListOfInteractive.hxx>
 #include <AIS_DimensionSelectionMode.hxx>
-
 #include <AIS_Shape.hxx>
+#include <AIS_Dimension.hxx>
+#include <TColStd_ListIteratorOfListOfInteger.hxx>
+#include <SelectMgr_ListOfFilter.hxx>
+#include <SelectMgr_ListIteratorOfListOfFilter.hxx>
 
 #include <set>
 
-const int MOUSE_SENSITIVITY_IN_PIXEL = 10; ///< defines the local context mouse selection sensitivity
+const int MOUSE_SENSITIVITY_IN_PIXEL = 10;  ///< defines the local context mouse selection sensitivity
 
 XGUI_Displayer::XGUI_Displayer(XGUI_Workshop* theWorkshop)
+  : myUseExternalObjects(false), myWorkshop(theWorkshop)
 {
-  myWorkshop = theWorkshop;
 }
 
 XGUI_Displayer::~XGUI_Displayer()
 {
 }
 
-bool XGUI_Displayer::isVisible(ObjectPtr theObject)
+bool XGUI_Displayer::isVisible(ObjectPtr theObject) const
 {
-  return myResult2AISObjectMap.find(theObject) != myResult2AISObjectMap.end();
+  return myResult2AISObjectMap.contains(theObject);
 }
 
 void XGUI_Displayer::display(ObjectPtr theObject, bool isUpdateViewer)
@@ -46,177 +51,187 @@ void XGUI_Displayer::display(ObjectPtr theObject, bool isUpdateViewer)
   if (isVisible(theObject)) {
     redisplay(theObject, isUpdateViewer);
   } else {
-    boost::shared_ptr<GeomAPI_AISObject> anAIS;
+    AISObjectPtr anAIS;
 
-    GeomPresentablePtr aPrs = boost::dynamic_pointer_cast<GeomAPI_IPresentable>(theObject);
+    GeomPresentablePtr aPrs = std::dynamic_pointer_cast<GeomAPI_IPresentable>(theObject);
+    bool isShading = false;
     if (aPrs) {
-      anAIS = aPrs->getAISObject(boost::shared_ptr<GeomAPI_AISObject>());
+      anAIS = aPrs->getAISObject(AISObjectPtr());
     } else {
-      ResultPtr aResult = boost::dynamic_pointer_cast<ModelAPI_Result>(theObject);
+      ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(theObject);
       if (aResult) {
-        boost::shared_ptr<GeomAPI_Shape> aShapePtr = ModuleBase_Tools::shape(aResult);
+        std::shared_ptr<GeomAPI_Shape> aShapePtr = ModelAPI_Tools::shape(aResult);
         if (aShapePtr) {
-          anAIS = boost::shared_ptr<GeomAPI_AISObject>(new GeomAPI_AISObject());
-          anAIS->createShape(aShapePtr);
+          anAIS = AISObjectPtr(new GeomAPI_AISObject());
+          anAIS->setImpl(new Handle(AIS_InteractiveObject)(new ModuleBase_ResultPrs(aResult)));
+          //anAIS->createShape(aShapePtr);
+          isShading = true;
         }
       }
     }
     if (anAIS)
-      display(theObject, anAIS, isUpdateViewer);
+      display(theObject, anAIS, isShading, isUpdateViewer);
   }
 }
 
-void XGUI_Displayer::display(ObjectPtr theObject,
-                             boost::shared_ptr<GeomAPI_AISObject> theAIS, bool isUpdateViewer)
+void XGUI_Displayer::display(ObjectPtr theObject, AISObjectPtr theAIS, 
+                             bool isShading, bool isUpdateViewer)
 {
   Handle(AIS_InteractiveContext) aContext = AISContext();
+  if (aContext.IsNull())
+    return;
 
   Handle(AIS_InteractiveObject) anAISIO = theAIS->impl<Handle(AIS_InteractiveObject)>();
   if (!anAISIO.IsNull()) {
     myResult2AISObjectMap[theObject] = theAIS;
-    aContext->Display(anAISIO, isUpdateViewer);
+    aContext->Display(anAISIO, false);
+    aContext->SetDisplayMode(anAISIO, isShading? Shading : Wireframe, isUpdateViewer);
+    if (aContext->HasOpenedContext()) {
+      if (myUseExternalObjects) {
+        if (myActiveSelectionModes.size() == 0)
+          aContext->Activate(anAISIO);
+        else {
+          foreach(int aMode, myActiveSelectionModes) {
+            aContext->Activate(anAISIO, aMode);
+          }
+        }
+      }
+    }
   }
 }
 
-
-
 void XGUI_Displayer::erase(ObjectPtr theObject, const bool isUpdateViewer)
 {
-  if (!isVisible(theObject)) return;
+  if (!isVisible(theObject))
+    return;
 
   Handle(AIS_InteractiveContext) aContext = AISContext();
-  boost::shared_ptr<GeomAPI_AISObject> anObject = myResult2AISObjectMap[theObject];
-  if (anObject)  {
+  if (aContext.IsNull())
+    return;
+  AISObjectPtr anObject = myResult2AISObjectMap[theObject];
+  if (anObject) {
     Handle(AIS_InteractiveObject) anAIS = anObject->impl<Handle(AIS_InteractiveObject)>();
     if (!anAIS.IsNull()) {
-      aContext->Erase(anAIS, isUpdateViewer);
+      aContext->Remove(anAIS, isUpdateViewer);
     }
   }
-  myResult2AISObjectMap.erase(theObject);
+  myResult2AISObjectMap.remove(theObject);
 }
 
-
-/*bool XGUI_Displayer::redisplay(ObjectPtr theObject,
-                               boost::shared_ptr<GeomAPI_AISObject> theAIS,
-                               const bool isUpdateViewer)
-{
-  bool isCreated = false;
-  Handle(AIS_InteractiveObject) anAIS = 
-    theAIS ? theAIS->impl<Handle(AIS_InteractiveObject)>() : Handle(AIS_InteractiveObject)();
-  Handle(AIS_InteractiveContext) aContext = AISContext();
-  // Open local context if there is no one
-  if (!aContext->HasOpenedContext()) {
-    aContext->ClearCurrents(false);
-    aContext->OpenLocalContext(false /use displayed objects/, true /allow shape decomposition/);
-    // set mouse sensitivity
-    //aContext->SetSensitivityMode(StdSelect_SM_WINDOW);
-    //aContext->SetPixelTolerance(MOUSE_SENSITIVITY_IN_PIXEL);
-  }
-  // display or redisplay presentation
-  boost::shared_ptr<GeomAPI_AISObject> anObj = myResult2AISObjectMap[theObject];
-  if (isVisible(theObject) && anObj && !anObj->empty()) {
-    aContext->Redisplay(anAIS, isUpdateViewer);
-    //aContext->RecomputeSelectionOnly(anAIS);
-  }
-  else {
-    myResult2AISObjectMap[theObject] = theAIS;
-    aContext->Display(anAIS, isUpdateViewer);
-    isCreated = true;
-  }
-  return isCreated;
-}*/
-
 void XGUI_Displayer::redisplay(ObjectPtr theObject, bool isUpdateViewer)
 {
   if (!isVisible(theObject))
     return;
 
-  boost::shared_ptr<GeomAPI_AISObject> aAISObj = getAISObject(theObject);
-  GeomPresentablePtr aPrs = boost::dynamic_pointer_cast<GeomAPI_IPresentable>(theObject);
+  AISObjectPtr aAISObj = getAISObject(theObject);
+  Handle(AIS_InteractiveObject) aAISIO = aAISObj->impl<Handle(AIS_InteractiveObject)>();
+
+  GeomPresentablePtr aPrs = std::dynamic_pointer_cast<GeomAPI_IPresentable>(theObject);
   if (aPrs) {
-    boost::shared_ptr<GeomAPI_AISObject> aAIS_Obj = aPrs->getAISObject(aAISObj);
-    if (aAISObj && !aAIS_Obj) {
+    AISObjectPtr aAIS_Obj = aPrs->getAISObject(aAISObj);
+    if (!aAIS_Obj) {
       erase(theObject, isUpdateViewer);
       return;
     }
-    Handle(AIS_InteractiveObject) aAISIO = aAIS_Obj->impl<Handle(AIS_InteractiveObject)>();
-    AISContext()->Redisplay(aAISIO, isUpdateViewer);
-  } else {
-    ResultPtr aResult = boost::dynamic_pointer_cast<ModelAPI_Result>(theObject);
-    if (aResult) {
-      boost::shared_ptr<GeomAPI_Shape> aShapePtr = ModuleBase_Tools::shape(aResult);
-      if (aShapePtr) {
-        Handle(AIS_Shape) aAISShape = Handle(AIS_Shape)::DownCast(aAISObj->impl<Handle(AIS_InteractiveObject)>());
-        if (!aAISShape.IsNull()) {
-          aAISShape->Set(aShapePtr->impl<TopoDS_Shape>());
-          AISContext()->Redisplay(aAISShape, isUpdateViewer);
-        }
-      }
+    if (aAIS_Obj != aAISObj) {
+      myResult2AISObjectMap[theObject] = aAIS_Obj;
     }
+    aAISIO = aAIS_Obj->impl<Handle(AIS_InteractiveObject)>();
+  }
+
+  if (!aAISIO.IsNull()) {
+    Handle(AIS_InteractiveContext) aContext = AISContext();
+    if (aContext.IsNull())
+      return;
+    aContext->Redisplay(aAISIO, isUpdateViewer);
   }
 }
 
-void XGUI_Displayer::activateInLocalContext(ObjectPtr theResult,
-                                         const std::list<int>& theModes, const bool isUpdateViewer)
+void XGUI_Displayer::deactivate(ObjectPtr theObject)
 {
-  Handle(AIS_InteractiveContext) aContext = AISContext();
-  // Open local context if there is no one
-  if (!aContext->HasOpenedContext()) {
-    aContext->ClearCurrents(false);
-    aContext->OpenLocalContext(false/*use displayed objects*/, true/*allow shape decomposition*/);
-  }
-/*  std::list<int>::const_iterator anIt;
-  for (anIt = theModes.begin(); anIt != theModes.end(); anIt++)
-    aContext->ActivateStandardMode((TopAbs_ShapeEnum)(*anIt));
-    */
-  // display or redisplay presentation
-  Handle(AIS_InteractiveObject) anAIS;
-  if (isVisible(theResult))
-  {
-    boost::shared_ptr<GeomAPI_AISObject> anObj = myResult2AISObjectMap[theResult];
-    if (anObj)
-      anAIS = anObj->impl<Handle(AIS_InteractiveObject)>();
-  }
+  if (isVisible(theObject)) {
+    Handle(AIS_InteractiveContext) aContext = AISContext();
+    if (aContext.IsNull())
+      return;
 
-  // Activate selection of objects from prs
-  if (!anAIS.IsNull()) {
-    aContext->Load(anAIS, -1, true/*allow decomposition*/);
+    AISObjectPtr anObj = myResult2AISObjectMap[theObject];
+    Handle(AIS_InteractiveObject) anAIS = anObj->impl<Handle(AIS_InteractiveObject)>();
     aContext->Deactivate(anAIS);
+  }
+}
 
-    std::list<int>::const_iterator anIt = theModes.begin(), aLast = theModes.end();
-    for (; anIt != aLast; anIt++)
-    {
-      aContext->Activate(anAIS, (*anIt));
+void XGUI_Displayer::activate(ObjectPtr theFeature)
+{
+  QIntList aModes;
+  activate(theFeature, aModes);
+}
+
+void XGUI_Displayer::activate(ObjectPtr theObject, const QIntList& theModes)
+{
+  if (isVisible(theObject)) {
+    Handle(AIS_InteractiveContext) aContext = AISContext();
+    if (aContext.IsNull())
+      return;
+
+    AISObjectPtr anObj = myResult2AISObjectMap[theObject];
+    Handle(AIS_InteractiveObject) anAIS = anObj->impl<Handle(AIS_InteractiveObject)>();
+    if (aContext->HasOpenedContext()) {
+      aContext->Load(anAIS, -1, true);
     }
+    if (theModes.size() > 0) {
+      foreach(int aMode, theModes) {
+        aContext->Activate(anAIS, aMode);
+      }
+    } else 
+      aContext->Activate(anAIS);
   }
+}
 
-  if (isUpdateViewer)
-    updateViewer();
+bool XGUI_Displayer::isActive(ObjectPtr theObject) const
+{
+  Handle(AIS_InteractiveContext) aContext = AISContext();
+  if (aContext.IsNull())
+    return false;
+  if (!isVisible(theObject))
+    return false;
+    
+  AISObjectPtr anObj = myResult2AISObjectMap[theObject];
+  Handle(AIS_InteractiveObject) anAIS = anObj->impl<Handle(AIS_InteractiveObject)>();
+
+  TColStd_ListOfInteger aModes;
+  aContext->ActivatedModes(anAIS, aModes);
+  return aModes.Extent() > 0;
 }
 
-void XGUI_Displayer::stopSelection(const QList<ObjectPtr>& theResults, const bool isStop,
+void XGUI_Displayer::stopSelection(const QObjectPtrList& theResults, const bool isStop,
                                    const bool isUpdateViewer)
 {
   Handle(AIS_InteractiveContext) aContext = AISContext();
+  if (aContext.IsNull())
+    return;
 
   Handle(AIS_Shape) anAIS;
-  QList<ObjectPtr>::const_iterator anIt = theResults.begin(), aLast = theResults.end();
+  QObjectPtrList::const_iterator anIt = theResults.begin(), aLast = theResults.end();
   ObjectPtr aFeature;
   for (; anIt != aLast; anIt++) {
     aFeature = *anIt;
     if (isVisible(aFeature))
-      anAIS = Handle(AIS_Shape)::DownCast(myResult2AISObjectMap[aFeature]->impl<Handle(AIS_InteractiveObject)>());
+      anAIS = Handle(AIS_Shape)::DownCast(
+          myResult2AISObjectMap[aFeature]->impl<Handle(AIS_InteractiveObject)>());
     if (anAIS.IsNull())
       continue;
 
     if (isStop) {
       QColor aColor(Qt::white);
-      anAIS->SetColor(Quantity_Color(aColor.red()/255., aColor.green()/255., aColor.blue()/255., Quantity_TOC_RGB));
+      anAIS->SetColor(
+          Quantity_Color(aColor.red() / 255., aColor.green() / 255., aColor.blue() / 255.,
+                         Quantity_TOC_RGB));
       anAIS->Redisplay();
-    }
-    else {
+    } else {
       QColor aColor(Qt::red);
-      anAIS->SetColor(Quantity_Color(aColor.red()/255., aColor.green()/255., aColor.blue()/255., Quantity_TOC_RGB));
+      anAIS->SetColor(
+          Quantity_Color(aColor.red() / 255., aColor.green() / 255., aColor.blue() / 255.,
+                         Quantity_TOC_RGB));
       anAIS->Redisplay();
     }
   }
@@ -224,7 +239,7 @@ void XGUI_Displayer::stopSelection(const QList<ObjectPtr>& theResults, const boo
     updateViewer();
 }
 
-void XGUI_Displayer::setSelected(const QList<ObjectPtr>& theResults, const bool isUpdateViewer)
+void XGUI_Displayer::setSelected(const QObjectPtrList& theResults, const bool isUpdateViewer)
 {
   Handle(AIS_InteractiveContext) aContext = AISContext();
   // we need to unhighligth objects manually in the current local context
@@ -234,15 +249,13 @@ void XGUI_Displayer::setSelected(const QList<ObjectPtr>& theResults, const bool
     aLocalContext->UnhilightLastDetected(myWorkshop->viewer()->activeView());
 
   aContext->ClearSelected();
-  foreach(ObjectPtr aResult, theResults) {
-    if (myResult2AISObjectMap.find(aResult) == myResult2AISObjectMap.end()) 
-      continue;
-
-    boost::shared_ptr<GeomAPI_AISObject> anObj = myResult2AISObjectMap[aResult];
-    if (anObj) {
+  foreach(ObjectPtr aResult, theResults)
+  {
+    if (isVisible(aResult)) {
+      AISObjectPtr anObj = myResult2AISObjectMap[aResult];
       Handle(AIS_InteractiveObject) anAIS = anObj->impl<Handle(AIS_InteractiveObject)>();
       if (!anAIS.IsNull())
-        aContext->AddOrRemoveSelected(anAIS, false);
+        aContext->SetSelected(anAIS, false);
     }
   }
   if (isUpdateViewer)
@@ -250,93 +263,153 @@ void XGUI_Displayer::setSelected(const QList<ObjectPtr>& theResults, const bool
 }
 
 
-/*void XGUI_Displayer::EraseAll(const bool isUpdateViewer)
+void XGUI_Displayer::clearSelected()
 {
-  Handle(AIS_InteractiveContext) ic = AISContext();
+  Handle(AIS_InteractiveContext) aContext = AISContext();
+  if (aContext) {
+    aContext->UnhilightCurrents(false);
+    aContext->ClearSelected();
+  }
+}
 
-  AIS_ListOfInteractive aList;
-  ic->DisplayedObjects(aList);
-  AIS_ListIteratorOfListOfInteractive anIter(aList);
-  for (; anIter.More(); anIter.Next()) {
-    if ((anIter.Value()->DynamicType() == STANDARD_TYPE(AIS_Trihedron)))
-      continue;
+void XGUI_Displayer::eraseAll(const bool isUpdateViewer)
+{
+  Handle(AIS_InteractiveContext) ic = AISContext();
+  if (ic.IsNull())
+    return;
 
-    // erase an object
-    Handle(AIS_InteractiveObject) anIO = anIter.Value();
-    ic->Erase(anIO, false);
-  }
-  myResult2AISObjectMap.clear();
-  if (isUpdateViewer)
-    updateViewer();
-}*/
+   foreach (AISObjectPtr aAISObj, myResult2AISObjectMap) {
+     // erase an object
+     Handle(AIS_InteractiveObject) anIO = aAISObj->impl<Handle(AIS_InteractiveObject)>();
+     if (!anIO.IsNull())
+       ic->Remove(anIO, false);
+   }
+   myResult2AISObjectMap.clear();
+   if (isUpdateViewer)
+     updateViewer();
+ }
 
 void XGUI_Displayer::eraseDeletedResults(const bool isUpdateViewer)
 {
   Handle(AIS_InteractiveContext) aContext = AISContext();
+  if (aContext.IsNull())
+    return;
 
-  ResultToAISMap::const_iterator aFIt = myResult2AISObjectMap.begin(),
-                                 aFLast = myResult2AISObjectMap.end();
-  std::list<ObjectPtr> aRemoved;
-  for (; aFIt != aFLast; aFIt++)
-  {
-    ObjectPtr aFeature = (*aFIt).first;
+  QObjectPtrList aRemoved;
+  foreach (ObjectPtr aFeature, myResult2AISObjectMap.keys()) {
     if (!aFeature || !aFeature->data() || !aFeature->data()->isValid()) {
-      boost::shared_ptr<GeomAPI_AISObject> anObj = (*aFIt).second;
-      if (!anObj) continue;
+      AISObjectPtr anObj = myResult2AISObjectMap[aFeature];
+      if (!anObj)
+        continue;
       Handle(AIS_InteractiveObject) anAIS = anObj->impl<Handle(AIS_InteractiveObject)>();
       if (!anAIS.IsNull()) {
-        aContext->Erase(anAIS, false);
-        aRemoved.push_back(aFeature);
+        aContext->Remove(anAIS, false);
+        aRemoved.append(aFeature);
       }
     }
   }
-  std::list<ObjectPtr>::const_iterator anIt = aRemoved.begin(),
-                                                                 aLast = aRemoved.end();
-  for (; anIt != aLast; anIt++) {
-    myResult2AISObjectMap.erase(myResult2AISObjectMap.find(*anIt));
+  foreach(ObjectPtr aObj, aRemoved) {
+    myResult2AISObjectMap.remove(aObj);
   }
 
   if (isUpdateViewer)
     updateViewer();
 }
 
+void XGUI_Displayer::openLocalContext()
+{
+  Handle(AIS_InteractiveContext) aContext = AISContext();
+  if (aContext.IsNull())
+    return;
+  // Open local context if there is no one
+  if (!aContext->HasOpenedContext()) {
+    // Preserve selected objects
+    //AIS_ListOfInteractive aAisList;
+    //for (aContext->InitCurrent(); aContext->MoreCurrent(); aContext->NextCurrent())
+    //  aAisList.Append(aContext->Current());
+
+    SelectMgr_ListOfFilter aFilters;
+    aFilters.Assign(aContext->Filters());
+
+    aContext->ClearCurrents();
+    aContext->OpenLocalContext();
+    aContext->NotUseDisplayedObjects();
+
+    myUseExternalObjects = false;
+    myActiveSelectionModes.clear();
+
+    SelectMgr_ListIteratorOfListOfFilter aIt(aFilters);
+    for (;aIt.More(); aIt.Next()) {
+      aContext->AddFilter(aIt.Value());
+    }
+    // Restore selection
+    //AIS_ListIteratorOfListOfInteractive aIt(aAisList);
+    //for(; aIt.More(); aIt.Next()) {
+    //  if (aContext->IsDisplayed(aIt.Value()))
+    //    aContext->SetSelected(aIt.Value(), false);
+    //}
+  }
+}
+
 void XGUI_Displayer::closeLocalContexts(const bool isUpdateViewer)
 {
-  closeAllContexts(true);
+  Handle(AIS_InteractiveContext) ic = AISContext();
+  if ( (!ic.IsNull()) && (ic->HasOpenedContext()) ) {
+    // Preserve selected objects
+    //AIS_ListOfInteractive aAisList;
+    //for (ic->InitSelected(); ic->MoreSelected(); ic->NextSelected())
+    //  aAisList.Append(ic->SelectedInteractive());
+
+    ic->ClearSelected();
+    ic->CloseAllContexts(false);
+
+    // Redisplay all object if they were displayed in localContext
+    Handle(AIS_InteractiveObject) aAISIO;
+    foreach (AISObjectPtr aAIS, myResult2AISObjectMap) {
+      aAISIO = aAIS->impl<Handle(AIS_InteractiveObject)>();
+      if (ic->DisplayStatus(aAISIO) != AIS_DS_Displayed) {
+        ic->Display(aAISIO, false);
+        ic->SetDisplayMode(aAISIO, Shading, false);
+      }
+    }
+    if (isUpdateViewer)
+      updateViewer();
+    myUseExternalObjects = false;
+    myActiveSelectionModes.clear();
+
+    // Restore selection
+    //AIS_ListIteratorOfListOfInteractive aIt(aAisList);
+    //for(; aIt.More(); aIt.Next()) {
+    //  if (ic->IsDisplayed(aIt.Value()))
+    //    ic->SetCurrentObject(aIt.Value(), false);
+    //}
+  }
 }
 
-boost::shared_ptr<GeomAPI_AISObject> XGUI_Displayer::getAISObject(ObjectPtr theObject) const
+AISObjectPtr XGUI_Displayer::getAISObject(ObjectPtr theObject) const
 {
-  boost::shared_ptr<GeomAPI_AISObject> anIO;
-  if (myResult2AISObjectMap.find(theObject) != myResult2AISObjectMap.end())
-    anIO = (myResult2AISObjectMap.find(theObject))->second;
+  AISObjectPtr anIO;
+  if (myResult2AISObjectMap.contains(theObject))
+    anIO = myResult2AISObjectMap[theObject];
   return anIO;
 }
 
-ObjectPtr XGUI_Displayer::getObject(Handle(AIS_InteractiveObject) theIO) const
+ObjectPtr XGUI_Displayer::getObject(const AISObjectPtr& theIO) const
 {
-  ObjectPtr aFeature;
-  ResultToAISMap::const_iterator aFIt = myResult2AISObjectMap.begin(),
-                                 aFLast = myResult2AISObjectMap.end();
-  for (; aFIt != aFLast && !aFeature; aFIt++) {
-    boost::shared_ptr<GeomAPI_AISObject> anObj = (*aFIt).second;
-    if (!anObj) continue;
-    Handle(AIS_InteractiveObject) anAIS = anObj->impl<Handle(AIS_InteractiveObject)>();
-    if (anAIS != theIO)
-      continue;
-    aFeature = (*aFIt).first;
-  }
-  return aFeature;
+  Handle(AIS_InteractiveObject) aRefAIS = theIO->impl<Handle(AIS_InteractiveObject)>();
+  return getObject(aRefAIS);
 }
 
-void XGUI_Displayer::closeAllContexts(const bool isUpdateViewer)
+ObjectPtr XGUI_Displayer::getObject(const Handle(AIS_InteractiveObject)& theIO) const
 {
-  Handle(AIS_InteractiveContext) ic = AISContext();
-  if (!ic.IsNull()) {
-    ic->CloseAllContexts(false);
-    if (isUpdateViewer)
-      updateViewer();
+  ObjectPtr aFeature;
+  foreach (ObjectPtr anObj, myResult2AISObjectMap.keys()) {
+    AISObjectPtr aAIS = myResult2AISObjectMap[anObj];
+    Handle(AIS_InteractiveObject) anAIS = aAIS->impl<Handle(AIS_InteractiveObject)>();
+    if (anAIS == theIO)
+      return anObj;
   }
+  return aFeature;
 }
 
 void XGUI_Displayer::updateViewer()
@@ -346,21 +419,32 @@ void XGUI_Displayer::updateViewer()
     ic->UpdateCurrentViewer();
 }
 
-Handle(AIS_InteractiveContext) XGUI_Displayer::AISContext() const 
-{ 
-  return myWorkshop->viewer()->AISContext(); 
+Handle(AIS_InteractiveContext) XGUI_Displayer::AISContext() const
+{
+  return myWorkshop->viewer()->AISContext();
 }
 
-
-void XGUI_Displayer::display(boost::shared_ptr<GeomAPI_AISObject> theAIS, bool isUpdate)
+void XGUI_Displayer::displayAIS(AISObjectPtr theAIS, bool isUpdate)
 {
   Handle(AIS_InteractiveContext) aContext = AISContext();
   Handle(AIS_InteractiveObject) anAISIO = theAIS->impl<Handle(AIS_InteractiveObject)>();
-  if (!anAISIO.IsNull())
+  if (!anAISIO.IsNull()) {
     aContext->Display(anAISIO, isUpdate);
+    if (aContext->HasOpenedContext()) {
+      if (myUseExternalObjects) {
+        if (myActiveSelectionModes.size() == 0)
+          aContext->Activate(anAISIO);
+        else {
+          foreach(int aMode, myActiveSelectionModes) {
+            aContext->Activate(anAISIO, aMode);
+          }
+        }
+      }
+    }
+  }
 }
 
-void XGUI_Displayer::erase(boost::shared_ptr<GeomAPI_AISObject> theAIS, const bool isUpdate)
+void XGUI_Displayer::eraseAIS(AISObjectPtr theAIS, const bool isUpdate)
 {
   Handle(AIS_InteractiveContext) aContext = AISContext();
   Handle(AIS_InteractiveObject) anAISIO = theAIS->impl<Handle(AIS_InteractiveObject)>();
@@ -369,3 +453,128 @@ void XGUI_Displayer::erase(boost::shared_ptr<GeomAPI_AISObject> theAIS, const bo
   }
 }
 
+void XGUI_Displayer::activateObjectsOutOfContext(const QIntList& theModes)
+{
+  Handle(AIS_InteractiveContext) aContext = AISContext();
+  // Open local context if there is no one
+  if (!aContext->HasOpenedContext()) 
+    return;
+
+  aContext->UseDisplayedObjects();
+  myUseExternalObjects = true;
+  myActiveSelectionModes = theModes;
+
+  //Deactivate trihedron which can be activated in local selector
+  AIS_ListOfInteractive aPrsList;
+  aContext->DisplayedObjects(aPrsList, true);
+
+  Handle(AIS_Trihedron) aTrihedron;
+  AIS_ListIteratorOfListOfInteractive aLIt(aPrsList);
+  for(; aLIt.More(); aLIt.Next()){
+    aTrihedron = Handle(AIS_Trihedron)::DownCast(aLIt.Value());
+    if (!aTrihedron.IsNull()) {
+      aContext->Deactivate(aTrihedron);
+      break;
+    }
+  }
+
+  Handle(AIS_InteractiveObject) anAISIO;
+  foreach (AISObjectPtr aAIS, myResult2AISObjectMap) {
+  anAISIO = aAIS->impl<Handle(AIS_InteractiveObject)>();
+    aContext->Load(anAISIO, -1, true);
+    if (theModes.size() == 0)
+      aContext->Activate(anAISIO);
+    else {
+      foreach(int aMode, theModes) {
+        aContext->Activate(anAISIO, aMode);
+      }
+    }
+  }
+}
+
+
+void XGUI_Displayer::deactivateObjectsOutOfContext()
+{
+  Handle(AIS_InteractiveContext) aContext = AISContext();
+  // Open local context if there is no one
+  if (!aContext->HasOpenedContext()) 
+    return;
+
+  aContext->NotUseDisplayedObjects();
+}
+
+
+void XGUI_Displayer::setDisplayMode(ObjectPtr theObject, DisplayMode theMode, bool toUpdate)
+{
+  if (theMode == NoMode)
+    return;
+
+  Handle(AIS_InteractiveContext) aContext = AISContext();
+  if (aContext.IsNull())
+    return;
+
+  AISObjectPtr aAISObj = getAISObject(theObject);
+  if (!aAISObj)
+    return;
+
+  Handle(AIS_InteractiveObject) aAISIO = aAISObj->impl<Handle(AIS_InteractiveObject)>();
+  aContext->SetDisplayMode(aAISIO, theMode, toUpdate);
+}
+
+void XGUI_Displayer::setSelectionModes(const QIntList& theModes)
+{
+  Handle(AIS_InteractiveContext) aContext = AISContext();
+  if (aContext.IsNull())
+    return;
+  if (!aContext->HasOpenedContext())
+    return;
+  // Clear previous mode
+  const TColStd_ListOfInteger& aModes = aContext->ActivatedStandardModes();
+  if (!aModes.IsEmpty()) {
+    TColStd_ListOfInteger aMModes;
+    aMModes.Assign(aModes);
+    TColStd_ListIteratorOfListOfInteger it(aMModes);
+    for(; it.More(); it.Next()) {
+      aContext->DeactivateStandardMode((TopAbs_ShapeEnum)it.Value());
+    }
+  }
+  foreach(int aMode, theModes) {
+    aContext->ActivateStandardMode((TopAbs_ShapeEnum)aMode);
+  }
+}
+
+XGUI_Displayer::DisplayMode XGUI_Displayer::displayMode(ObjectPtr theObject) const
+{
+  Handle(AIS_InteractiveContext) aContext = AISContext();
+  if (aContext.IsNull())
+    return NoMode;
+
+  AISObjectPtr aAISObj = getAISObject(theObject);
+  if (!aAISObj)
+    return NoMode;
+
+  Handle(AIS_InteractiveObject) aAISIO = aAISObj->impl<Handle(AIS_InteractiveObject)>();
+  return (XGUI_Displayer::DisplayMode) aAISIO->DisplayMode();
+}
+
+void XGUI_Displayer::addSelectionFilter(const Handle(SelectMgr_Filter)& theFilter)
+{
+  Handle(AIS_InteractiveContext) aContext = AISContext();
+  if (aContext.IsNull())
+    return;
+  const SelectMgr_ListOfFilter& aFilters = aContext->Filters();
+  SelectMgr_ListIteratorOfListOfFilter aIt(aFilters);
+  for (; aIt.More(); aIt.Next()) {
+    if (theFilter.Access() == aIt.Value().Access())
+      return;
+  }
+  aContext->AddFilter(theFilter);
+}
+
+void XGUI_Displayer::removeSelectionFilter(const Handle(SelectMgr_Filter)& theFilter)
+{
+  Handle(AIS_InteractiveContext) aContext = AISContext();
+  if (aContext.IsNull())
+    return;
+  aContext->RemoveFilter(theFilter);
+}