src/XGUI/XGUI_Displayer.cpp

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D -->
   2
   3 // File:        XGUI_Displayer.cpp
   4 // Created:     20 Apr 2014
   5 // Author:      Natalia ERMOLAEVA
   6
   7 #include "XGUI_Displayer.h"
   8 #include "XGUI_Workshop.h"
   9 #include "XGUI_ViewerProxy.h"
  10 #include "XGUI_SelectionMgr.h"
  11 #include "XGUI_Selection.h"
  12 #include "XGUI_CustomPrs.h"
  13
  14 #include <AppElements_Viewer.h>
  15
  16 #include <ModelAPI_Document.h>
  17 #include <ModelAPI_Data.h>
  18 #include <ModelAPI_Object.h>
  19 #include <ModelAPI_Tools.h>
  20 #include <ModelAPI_AttributeIntArray.h>
  21 #include <ModelAPI_ResultCompSolid.h>
  22
  23 #include <ModuleBase_ResultPrs.h>
  24 #include <ModuleBase_Tools.h>
  25 #include <ModuleBase_IModule.h>
  26
  27 #include <GeomAPI_Shape.h>
  28 #include <GeomAPI_IPresentable.h>
  29 #include <GeomAPI_ICustomPrs.h>
  30
  31 #include <AIS_InteractiveContext.hxx>
  32 #include <AIS_LocalContext.hxx>
  33 #include <AIS_ListOfInteractive.hxx>
  34 #include <AIS_ListIteratorOfListOfInteractive.hxx>
  35 #include <AIS_DimensionSelectionMode.hxx>
  36 #include <AIS_Shape.hxx>
  37 #include <AIS_Dimension.hxx>
  38 #include <TColStd_ListIteratorOfListOfInteger.hxx>
  39 #include <SelectMgr_ListOfFilter.hxx>
  40 #include <SelectMgr_ListIteratorOfListOfFilter.hxx>
  41 #include <Prs3d_Drawer.hxx>
  42 #include <Prs3d_IsoAspect.hxx>
  43
  44 #include <StdSelect_ViewerSelector3d.hxx>
  45
  46 #include <TColStd_MapOfTransient.hxx>
  47 #include <TColStd_MapIteratorOfMapOfTransient.hxx>
  48
  49 #include <Events_Loop.h>
  50 #include <ModelAPI_Events.h>
  51
  52 #include <set>
  53
  54 const int MOUSE_SENSITIVITY_IN_PIXEL = 10;  ///< defines the local context mouse selection sensitivity
  55
  56 //#define DEBUG_ACTIVATE_OBJECTS
  57 //#define DEBUG_DEACTIVATE
  58 //#define DEBUG_ACTIVATE_AIS
  59 //#define DEBUG_DEACTIVATE_AIS
  60
  61 //#define DEBUG_DISPLAY
  62 //#define DEBUG_FEATURE_REDISPLAY
  63 //#define DEBUG_SELECTION_FILTERS
  64
  65 //#define DEBUG_COMPOSILID_DISPLAY
  66 // Workaround for bug #25637
  67 void displayedObjects(const Handle(AIS_InteractiveContext)& theAIS, AIS_ListOfInteractive& theList)
  68 {
  69   // Get from null point
  70   theAIS->DisplayedObjects(theList, true);
  71   if (theAIS->HasOpenedContext()) {
  72     // get from local context
  73     const Handle(AIS_LocalContext)& aLC = theAIS->LocalContext();
  74     TColStd_MapOfTransient aMap;
  75     int NbDisp = aLC->DisplayedObjects(aMap);
  76     TColStd_MapIteratorOfMapOfTransient aIt(aMap);
  77
  78     Handle(AIS_InteractiveObject) curIO;
  79     Handle(Standard_Transient) Tr;
  80     for(; aIt.More(); aIt.Next()){
  81       Tr = aIt.Key();
  82       curIO = *((Handle(AIS_InteractiveObject)*) &Tr);
  83       theList.Append(curIO);
  84     }
  85   }
  86 }
  87
  88 QString qIntListInfo(const QIntList& theValues, const QString& theSeparator = QString(", "))
  89 {
  90   QStringList anInfo;
  91   QIntList::const_iterator anIt = theValues.begin(), aLast = theValues.end();
  92   for (; anIt != aLast; anIt++) {
  93     anInfo.append(QString::number(*anIt));
  94   }
  95   return anInfo.join(theSeparator);
  96 }
  97
  98 XGUI_Displayer::XGUI_Displayer(XGUI_Workshop* theWorkshop)
  99   : myWorkshop(theWorkshop), myEnableUpdateViewer(true)
 100 {
 101   enableUpdateViewer(true);
 102   myCustomPrs = std::shared_ptr<GeomAPI_ICustomPrs>(new XGUI_CustomPrs());
 103 }
 104
 105 XGUI_Displayer::~XGUI_Displayer()
 106 {
 107 }
 108
 109 bool XGUI_Displayer::isVisible(ObjectPtr theObject) const
 110 {
 111   return myResult2AISObjectMap.contains(theObject);
 112 }
 113
 114 bool XGUI_Displayer::display(ObjectPtr theObject, bool theUpdateViewer)
 115 {
 116   bool aDisplayed = false;
 117   if (isVisible(theObject)) {
 118 #ifdef DEBUG_COMPOSILID_DISPLAY
 119     ResultCompSolidPtr aCompsolidResult = std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(theObject);
 120     if (aCompsolidResult.get()) {
 121       for(int i = 0; i < aCompsolidResult->numberOfSubs(); i++) {
 122         ResultPtr aSubResult = aCompsolidResult->subResult(i);
 123         if (aSubResult.get())
 124           redisplay(aSubResult, false);
 125       }
 126       if (theUpdateViewer)
 127         updateViewer();
 128     }
 129     else
 130 #endif
 131     aDisplayed = redisplay(theObject, theUpdateViewer);
 132   } else {
 133     AISObjectPtr anAIS;
 134     GeomPresentablePtr aPrs = std::dynamic_pointer_cast<GeomAPI_IPresentable>(theObject);
 135     bool isShading = false;
 136     if (aPrs.get() != NULL) {
 137       anAIS = aPrs->getAISObject(anAIS);
 138     } else {
 139       ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(theObject);
 140       if (aResult.get() != NULL) {
 141 #ifdef DEBUG_COMPOSILID_DISPLAY
 142         ResultCompSolidPtr aCompsolidResult = std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(theObject);
 143         if (aCompsolidResult.get()) {
 144           for(int i = 0; i < aCompsolidResult->numberOfSubs(); i++) {
 145             ResultPtr aSubResult = aCompsolidResult->subResult(i);
 146             if (aSubResult.get())
 147               display(aSubResult, false);
 148           }
 149           if (theUpdateViewer)
 150             updateViewer();
 151         }
 152         else {
 153 #endif
 154         std::shared_ptr<GeomAPI_Shape> aShapePtr = ModelAPI_Tools::shape(aResult);
 155         if (aShapePtr.get() != NULL) {
 156           anAIS = AISObjectPtr(new GeomAPI_AISObject());
 157           anAIS->setImpl(new Handle(AIS_InteractiveObject)(new ModuleBase_ResultPrs(aResult)));
 158           //anAIS->createShape(aShapePtr);
 159           isShading = true;
 160         }
 161 #ifdef DEBUG_COMPOSILID_DISPLAY
 162         } // close else
 163 #endif
 164       }
 165     }
 166     if (anAIS)
 167       aDisplayed = display(theObject, anAIS, isShading, theUpdateViewer);
 168   }
 169   return aDisplayed;
 170 }
 171
 172 bool canBeShaded(Handle(AIS_InteractiveObject) theAIS)
 173 {
 174   Handle(AIS_Shape) aShapePrs = Handle(AIS_Shape)::DownCast(theAIS);
 175   if (!aShapePrs.IsNull()) {
 176     TopoDS_Shape aShape = aShapePrs->Shape();
 177     if (aShape.IsNull())
 178       return false;
 179     TopAbs_ShapeEnum aType = aShape.ShapeType();
 180     if ((aType == TopAbs_VERTEX) || (aType == TopAbs_EDGE) || (aType == TopAbs_WIRE))
 181       return false;
 182     else {
 183       // Check that the presentation is not a sketch
 184       Handle(ModuleBase_ResultPrs) aPrs = Handle(ModuleBase_ResultPrs)::DownCast(theAIS);
 185       if (!aPrs.IsNull())
 186         return !aPrs->isSketchMode();
 187       return true;
 188     }
 189   }
 190   return false;
 191 }
 192
 193 bool XGUI_Displayer::display(ObjectPtr theObject, AISObjectPtr theAIS,
 194                              bool isShading, bool theUpdateViewer)
 195 {
 196   bool aDisplayed = false;
 197
 198   Handle(AIS_InteractiveContext) aContext = AISContext();
 199   if (aContext.IsNull())
 200     return aDisplayed;
 201
 202   Handle(AIS_InteractiveObject) anAISIO = theAIS->impl<Handle(AIS_InteractiveObject)>();
 203   if (!anAISIO.IsNull()) {
 204     appendResultObject(theObject, theAIS);
 205
 206     bool isCustomized = customizeObject(theObject);
 207
 208     int aDispMode = isShading? Shading : Wireframe;
 209     if (isShading)
 210       anAISIO->Attributes()->SetFaceBoundaryDraw( Standard_True );
 211     anAISIO->SetDisplayMode(aDispMode);
 212     aContext->Display(anAISIO, aDispMode, 0, false, true, AIS_DS_Displayed);
 213     aDisplayed = true;
 214
 215     emit objectDisplayed(theObject, theAIS);
 216     activate(anAISIO, myActiveSelectionModes, theUpdateViewer);
 217     // the fix from VPA for more suitable selection of sketcher lines
 218     if(anAISIO->Width() > 1) {
 219       for(int aModeIdx = 0; aModeIdx < myActiveSelectionModes.length(); ++aModeIdx) {
 220         aContext->SetSelectionSensitivity(anAISIO,
 221           myActiveSelectionModes.value(aModeIdx), anAISIO->Width() + 2);
 222       }
 223     }
 224   }
 225   if (theUpdateViewer)
 226     updateViewer();
 227
 228   return aDisplayed;
 229 }
 230
 231 bool XGUI_Displayer::erase(ObjectPtr theObject, const bool theUpdateViewer)
 232 {
 233   bool aErased = false;
 234   if (!isVisible(theObject))
 235     return aErased;
 236
 237   Handle(AIS_InteractiveContext) aContext = AISContext();
 238   if (aContext.IsNull())
 239     return aErased;
 240
 241   AISObjectPtr anObject = myResult2AISObjectMap[theObject];
 242   if (anObject) {
 243     Handle(AIS_InteractiveObject) anAIS = anObject->impl<Handle(AIS_InteractiveObject)>();
 244     if (!anAIS.IsNull()) {
 245       emit beforeObjectErase(theObject, anObject);
 246       aContext->Remove(anAIS, theUpdateViewer);
 247       aErased = true;
 248     }
 249   }
 250   myResult2AISObjectMap.remove(theObject);
 251
 252 #ifdef DEBUG_DISPLAY
 253   std::ostringstream aPtrStr;
 254   aPtrStr << theObject.get();
 255   qDebug(QString("erase object: %1").arg(aPtrStr.str().c_str()).toStdString().c_str());
 256   qDebug(getResult2AISObjectMapInfo().c_str());
 257 #endif
 258   return aErased;
 259 }
 260
 261 bool XGUI_Displayer::redisplay(ObjectPtr theObject, bool theUpdateViewer)
 262 {
 263   bool aRedisplayed = false;
 264   if (!isVisible(theObject))
 265     return aRedisplayed;
 266
 267   AISObjectPtr aAISObj = getAISObject(theObject);
 268   Handle(AIS_InteractiveObject) aAISIO = aAISObj->impl<Handle(AIS_InteractiveObject)>();
 269
 270   GeomPresentablePtr aPrs = std::dynamic_pointer_cast<GeomAPI_IPresentable>(theObject);
 271   if (aPrs) {
 272     AISObjectPtr aAIS_Obj = aPrs->getAISObject(aAISObj);
 273     if (!aAIS_Obj) {
 274       aRedisplayed = erase(theObject, theUpdateViewer);
 275       return aRedisplayed;
 276     }
 277     if (aAIS_Obj != aAISObj) {
 278       appendResultObject(theObject, aAIS_Obj);
 279     }
 280     aAISIO = aAIS_Obj->impl<Handle(AIS_InteractiveObject)>();
 281   }
 282
 283   Handle(AIS_InteractiveContext) aContext = AISContext();
 284   if (!aContext.IsNull() && !aAISIO.IsNull()) {
 285     // Check that the visualized shape is the same and the redisplay is not necessary
 286     // Redisplay of AIS object leads to this object selection compute and the selection
 287     // in the browser is lost
 288     // this check is not necessary anymore because the selection store/restore is realized
 289     // before and after the values modification.
 290     // Moreother, this check avoids customize and redisplay presentation if the presentable
 291     // parameter is changed.
 292     bool isEqualShapes = false;
 293     ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(theObject);
 294     if (aResult.get() != NULL) {
 295       Handle(AIS_Shape) aShapePrs = Handle(AIS_Shape)::DownCast(aAISIO);
 296       if (!aShapePrs.IsNull()) {
 297         std::shared_ptr<GeomAPI_Shape> aShapePtr = ModelAPI_Tools::shape(aResult);
 298         if (aShapePtr.get()) {
 299           const TopoDS_Shape& aOldShape = aShapePrs->Shape();
 300           if (!aOldShape.IsNull())
 301             isEqualShapes = aOldShape.IsEqual(aShapePtr->impl<TopoDS_Shape>());
 302         }
 303       }
 304     }
 305     // Customization of presentation
 306     bool isCustomized = customizeObject(theObject);
 307     #ifdef DEBUG_FEATURE_REDISPLAY
 308       qDebug(QString("Redisplay: %1, isEqualShapes=%2, isCustomized=%3").
 309         arg(!isEqualShapes || isCustomized).arg(isEqualShapes).arg(isCustomized).toStdString().c_str());
 310     #endif
 311     if (!isEqualShapes || isCustomized) {
 312       aContext->Redisplay(aAISIO, false);
 313       aRedisplayed = true;
 314       #ifdef DEBUG_FEATURE_REDISPLAY
 315         qDebug("  Redisplay happens");
 316       #endif
 317       if (theUpdateViewer)
 318         updateViewer();
 319     }
 320   }
 321   return aRedisplayed;
 322 }
 323
 324 void XGUI_Displayer::redisplayObjects()
 325 {
 326   // redisplay objects visualized in the viewer
 327   static Events_ID EVENT_DISP = Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY);
 328   static const ModelAPI_EventCreator* aECreator = ModelAPI_EventCreator::get();
 329   QObjectPtrList aDisplayed = myWorkshop->displayer()->displayedObjects();
 330   QObjectPtrList::const_iterator anIt = aDisplayed.begin(), aLast = aDisplayed.end();
 331   for (; anIt != aLast; anIt++) {
 332     aECreator->sendUpdated(*anIt, EVENT_DISP);
 333   }
 334   Events_Loop::loop()->flush(EVENT_DISP);
 335 }
 336
 337 void XGUI_Displayer::deactivate(ObjectPtr theObject, const bool theUpdateViewer)
 338 {
 339 #ifdef DEBUG_DEACTIVATE
 340   QString anInfoStr = ModuleBase_Tools::objectInfo(theObject);
 341   qDebug(QString("deactivate: myActiveSelectionModes[%1]: %2, objects = ").
 342     arg(myActiveSelectionModes.size()).arg(qIntListInfo(myActiveSelectionModes)).
 343     arg(anInfoStr).
 344     toStdString().c_str());
 345 #endif
 346   Handle(AIS_InteractiveContext) aContext = AISContext();
 347   if (!aContext.IsNull() && isVisible(theObject)) {
 348     AISObjectPtr anObj = myResult2AISObjectMap[theObject];
 349     Handle(AIS_InteractiveObject) anAIS = anObj->impl<Handle(AIS_InteractiveObject)>();
 350
 351     deactivateAIS(anAIS);
 352     // the selection from the previous activation modes should be cleared manually (#26172)
 353     aContext->LocalContext()->ClearOutdatedSelection(anAIS, true);
 354     if (theUpdateViewer)
 355       updateViewer();
 356   }
 357 }
 358
 359 void XGUI_Displayer::deactivateObjects(const QObjectPtrList& theObjList,
 360                                        const bool theUpdateViewer)
 361 {
 362   QObjectPtrList::const_iterator anIt = theObjList.begin(), aLast = theObjList.end();
 363   for (; anIt != aLast; anIt++) {
 364     deactivate(*anIt, false);
 365   }
 366   //VSV It seems that there is no necessity to update viewer on deactivation
 367   //if (theUpdateViewer)
 368   //  updateViewer();
 369 }
 370
 371 void XGUI_Displayer::getModesOfActivation(ObjectPtr theObject, QIntList& theModes)
 372 {
 373   Handle(AIS_InteractiveContext) aContext = AISContext();
 374   if (aContext.IsNull() || !isVisible(theObject))
 375     return;
 376
 377   AISObjectPtr aAISObj = getAISObject(theObject);
 378
 379   if (aAISObj.get() != NULL) {
 380     Handle(AIS_InteractiveObject) anAISIO = aAISObj->impl<Handle(AIS_InteractiveObject)>();
 381     TColStd_ListOfInteger aTColModes;
 382     aContext->ActivatedModes(anAISIO, aTColModes);
 383     TColStd_ListIteratorOfListOfInteger itr( aTColModes );
 384     for (; itr.More(); itr.Next() ) {
 385       theModes.append(itr.Value());
 386     }
 387   }
 388 }
 389
 390 void XGUI_Displayer::activateObjects(const QIntList& theModes, const QObjectPtrList& theObjList,
 391                                      const bool theUpdateViewer)
 392 {
 393   // Convert shape types to selection types
 394   QIntList aModes;
 395   foreach(int aType, theModes) {
 396     if (aType >= TopAbs_SHAPE)
 397       aModes.append(aType);
 398     else
 399       aModes.append(AIS_Shape::SelectionMode((TopAbs_ShapeEnum)aType));
 400   }
 401
 402 #ifdef DEBUG_ACTIVATE_OBJECTS
 403   QStringList anInfo;
 404   QObjectPtrList::const_iterator anIt = theObjList.begin(), aLast = theObjList.end();
 405   for (; anIt != aLast; ++anIt) {
 406     anInfo.append(ModuleBase_Tools::objectInfo((*anIt)));
 407   }
 408   QString anInfoStr = anInfo.join(", ");
 409
 410   qDebug(QString("activateObjects: aModes[%1] = %2, myActiveSelectionModes[%3] = %4, objects = %5").
 411     arg(aModes.size()).arg(qIntListInfo(aModes)).
 412     arg(myActiveSelectionModes.size()).arg(qIntListInfo(myActiveSelectionModes)).
 413     arg(anInfoStr).
 414     toStdString().c_str());
 415 #endif
 416   // In order to avoid doblications of selection modes
 417   QIntList aNewModes;
 418   foreach (int aMode, aModes) {
 419     if (!aNewModes.contains(aMode))
 420       aNewModes.append(aMode);
 421   }
 422   myActiveSelectionModes = aNewModes;
 423   Handle(AIS_InteractiveContext) aContext = AISContext();
 424   // Open local context if there is no one
 425   if (aContext.IsNull() || !aContext->HasOpenedContext())
 426     return;
 427
 428   //aContext->UseDisplayedObjects();
 429   //myUseExternalObjects = true;
 430
 431   Handle(AIS_InteractiveObject) anAISIO;
 432   AIS_ListOfInteractive aPrsList;
 433   if (theObjList.isEmpty())
 434     return;
 435   else {
 436     foreach(ObjectPtr aObj, theObjList) {
 437       if (myResult2AISObjectMap.contains(aObj))
 438         aPrsList.Append(myResult2AISObjectMap[aObj]->impl<Handle(AIS_InteractiveObject)>());
 439     }
 440   }
 441
 442   AIS_ListIteratorOfListOfInteractive aLIt(aPrsList);
 443   bool isActivationChanged = false;
 444   for(aLIt.Initialize(aPrsList); aLIt.More(); aLIt.Next()){
 445     anAISIO = aLIt.Value();
 446     if (activate(anAISIO, myActiveSelectionModes, false))
 447       isActivationChanged = true;
 448   }
 449   // VSV It seems that there is no necessity to update viewer on activation
 450   //if (theUpdateViewer && isActivationChanged)
 451   //  updateViewer();
 452 }
 453
 454 bool XGUI_Displayer::isActive(ObjectPtr theObject) const
 455 {
 456   Handle(AIS_InteractiveContext) aContext = AISContext();
 457   if (aContext.IsNull() || !isVisible(theObject))
 458     return false;
 459
 460   AISObjectPtr anObj = myResult2AISObjectMap[theObject];
 461   Handle(AIS_InteractiveObject) anAIS = anObj->impl<Handle(AIS_InteractiveObject)>();
 462
 463   TColStd_ListOfInteger aModes;
 464   aContext->ActivatedModes(anAIS, aModes);
 465   return aModes.Extent() > 0;
 466 }
 467 void XGUI_Displayer::setSelected(const  QList<ModuleBase_ViewerPrs>& theValues, bool theUpdateViewer)
 468 {
 469   Handle(AIS_InteractiveContext) aContext = AISContext();
 470   if (aContext.IsNull())
 471     return;
 472   if (aContext->HasOpenedContext()) {
 473     aContext->UnhilightSelected();
 474     aContext->ClearSelected();
 475     foreach (ModuleBase_ViewerPrs aPrs, theValues) {
 476       const TopoDS_Shape& aShape = aPrs.shape();
 477       if (!aShape.IsNull()) {
 478         aContext->AddOrRemoveSelected(aShape, false);
 479       } else {
 480         ObjectPtr anObject = aPrs.object();
 481         ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObject);
 482         if (aResult.get() && isVisible(aResult)) {
 483           AISObjectPtr anObj = myResult2AISObjectMap[aResult];
 484           Handle(AIS_InteractiveObject) anAIS = anObj->impl<Handle(AIS_InteractiveObject)>();
 485           if (!anAIS.IsNull()) {
 486             // The methods are replaced in order to provide multi-selection, e.g. restore selection
 487             // by activating multi selector widget. It also gives an advantage that the multi
 488             // selection in OB gives multi-selection in the viewer
 489             //aContext->SetSelected(anAIS, false);
 490             // The selection in the context was cleared, so the method sets the objects are selected
 491             aContext->AddOrRemoveSelected(anAIS, false);
 492           }
 493         }
 494       }
 495     }
 496   } else {
 497     aContext->UnhilightCurrents();
 498     aContext->ClearCurrents();
 499     foreach (ModuleBase_ViewerPrs aPrs, theValues) {
 500       ObjectPtr anObject = aPrs.object();
 501       ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObject);
 502       if (aResult.get() && isVisible(aResult)) {
 503         AISObjectPtr anObj = myResult2AISObjectMap[aResult];
 504         Handle(AIS_InteractiveObject) anAIS = anObj->impl<Handle(AIS_InteractiveObject)>();
 505         if (!anAIS.IsNull())
 506           aContext->SetCurrentObject(anAIS, false);
 507       }
 508     }
 509   }
 510   if (theUpdateViewer)
 511     updateViewer();
 512 }
 513
 514 void XGUI_Displayer::clearSelected()
 515 {
 516   Handle(AIS_InteractiveContext) aContext = AISContext();
 517   if (!aContext.IsNull()) {
 518     aContext->UnhilightCurrents(false);
 519     aContext->ClearSelected();
 520   }
 521 }
 522
 523 bool XGUI_Displayer::eraseAll(const bool theUpdateViewer)
 524 {
 525   bool aErased = false;
 526   Handle(AIS_InteractiveContext) aContext = AISContext();
 527   if (!aContext.IsNull()) {
 528     foreach (ObjectPtr aObj, myResult2AISObjectMap.keys()) {
 529       AISObjectPtr aAISObj = myResult2AISObjectMap[aObj];
 530       // erase an object
 531       Handle(AIS_InteractiveObject) anIO = aAISObj->impl<Handle(AIS_InteractiveObject)>();
 532       if (!anIO.IsNull()) {
 533         emit beforeObjectErase(aObj, aAISObj);
 534         aContext->Remove(anIO, false);
 535         aErased = true;
 536       }
 537     }
 538     if (theUpdateViewer)
 539       updateViewer();
 540   }
 541   myResult2AISObjectMap.clear();
 542 #ifdef DEBUG_DISPLAY
 543   qDebug("eraseAll");
 544   qDebug(getResult2AISObjectMapInfo().c_str());
 545 #endif
 546   return aErased;
 547 }
 548
 549 void XGUI_Displayer::deactivateTrihedron() const
 550 {
 551   Handle(AIS_InteractiveContext) aContext = myWorkshop->viewer()->AISContext();
 552   if (!aContext.IsNull()) {
 553     AIS_ListOfInteractive aList;
 554     aContext->DisplayedObjects(aList, true);
 555     AIS_ListIteratorOfListOfInteractive aIt;
 556     for (aIt.Initialize(aList); aIt.More(); aIt.Next()) {
 557       Handle(AIS_Trihedron) aTrihedron = Handle(AIS_Trihedron)::DownCast(aIt.Value());
 558       if (!aTrihedron.IsNull()) {
 559         aContext->Deactivate(aTrihedron);
 560       }
 561     }
 562   }
 563 }
 564
 565 void XGUI_Displayer::openLocalContext()
 566 {
 567   Handle(AIS_InteractiveContext) aContext = myWorkshop->viewer()->AISContext();
 568   // Open local context if there is no one
 569   if (!aContext.IsNull() && !aContext->HasOpenedContext()) {
 570     // Preserve selected objects
 571     //AIS_ListOfInteractive aAisList;
 572     //for (aContext->InitCurrent(); aContext->MoreCurrent(); aContext->NextCurrent())
 573     //  aAisList.Append(aContext->Current());
 574
 575     // get the filters from the global context and append them to the local context
 576     // a list of filters in the global context is not cleared and should be cleared here
 577     SelectMgr_ListOfFilter aFilters;
 578     aFilters.Assign(aContext->Filters());
 579     // it is important to remove the filters in the global context, because there is a code
 580     // in the closeLocalContex, which restore the global context filters
 581     aContext->RemoveFilters();
 582
 583     //aContext->ClearCurrents();
 584     aContext->OpenLocalContext();
 585     deactivateTrihedron();
 586     //aContext->NotUseDisplayedObjects();
 587
 588     //myUseExternalObjects = false;
 589
 590     SelectMgr_ListIteratorOfListOfFilter aIt(aFilters);
 591     for (;aIt.More(); aIt.Next()) {
 592       aContext->AddFilter(aIt.Value());
 593     }
 594     // Restore selection
 595     //AIS_ListIteratorOfListOfInteractive aIt2(aAisList);
 596     //for(; aIt2.More(); aIt2.Next()) {
 597     //  aContext->SetSelected(aIt2.Value(), false);
 598     //}
 599   }
 600 }
 601
 602 void XGUI_Displayer::closeLocalContexts(const bool theUpdateViewer)
 603 {
 604   Handle(AIS_InteractiveContext) aContext = AISContext();
 605   if (!aContext.IsNull() && aContext->HasOpenedContext()) {
 606     // Preserve selected objects
 607     //AIS_ListOfInteractive aAisList;
 608     //for (aContext->InitSelected(); aContext->MoreSelected(); aContext->NextSelected())
 609     //  aAisList.Append(aContext->SelectedInteractive());
 610
 611     // get the filters from the local context and append them to the global context
 612     // a list of filters in the local context is cleared
 613     SelectMgr_ListOfFilter aFilters;
 614     aFilters.Assign(aContext->Filters());
 615
 616     //aContext->ClearSelected();
 617     aContext->CloseAllContexts(false);
 618
 619     // From the moment when the AIS_DS_Displayed flag is used in the Display of AIS object,
 620     // this code is obsolete. It is temporaty commented and should be removed after
 621     // the test campaign.
 622     // Redisplay all object if they were displayed in localContext
 623     /*Handle(AIS_InteractiveObject) aAISIO;
 624     foreach (AISObjectPtr aAIS, myResult2AISObjectMap) {
 625       aAISIO = aAIS->impl<Handle(AIS_InteractiveObject)>();
 626       if (aContext->DisplayStatus(aAISIO) != AIS_DS_Displayed) {
 627         aContext->Display(aAISIO, false);
 628         aContext->SetDisplayMode(aAISIO, Shading, false);
 629       }
 630     }*/
 631
 632     // Append the filters from the local selection in the global selection context
 633     SelectMgr_ListIteratorOfListOfFilter aIt(aFilters);
 634     for (;aIt.More(); aIt.Next()) {
 635       Handle(SelectMgr_Filter) aFilter = aIt.Value();
 636       aContext->AddFilter(aFilter);
 637     }
 638
 639     if (theUpdateViewer)
 640       updateViewer();
 641     //myUseExternalObjects = false;
 642
 643     // Restore selection
 644     //AIS_ListIteratorOfListOfInteractive aIt2(aAisList);
 645     //for(; aIt2.More(); aIt2.Next()) {
 646     //  if (aContext->IsDisplayed(aIt2.Value()))
 647     //    aContext->SetCurrentObject(aIt2.Value(), false);
 648     //}
 649   }
 650 }
 651
 652 AISObjectPtr XGUI_Displayer::getAISObject(ObjectPtr theObject) const
 653 {
 654   AISObjectPtr anIO;
 655   if (myResult2AISObjectMap.contains(theObject))
 656     anIO = myResult2AISObjectMap[theObject];
 657   return anIO;
 658 }
 659
 660 ObjectPtr XGUI_Displayer::getObject(const AISObjectPtr& theIO) const
 661 {
 662   Handle(AIS_InteractiveObject) aRefAIS = theIO->impl<Handle(AIS_InteractiveObject)>();
 663   return getObject(aRefAIS);
 664 }
 665
 666 ObjectPtr XGUI_Displayer::getObject(const Handle(AIS_InteractiveObject)& theIO) const
 667 {
 668   ObjectPtr anObject;
 669   foreach (ObjectPtr anObj, myResult2AISObjectMap.keys()) {
 670     AISObjectPtr aAIS = myResult2AISObjectMap[anObj];
 671     Handle(AIS_InteractiveObject) anAIS = aAIS->impl<Handle(AIS_InteractiveObject)>();
 672     if (anAIS == theIO)
 673       anObject = anObj;
 674     if (anObject.get())
 675       break;
 676   }
 677   if (!anObject.get()) {
 678     std::shared_ptr<GeomAPI_AISObject> anAISObj = AISObjectPtr(new GeomAPI_AISObject());
 679     if (!theIO.IsNull()) {
 680       anAISObj->setImpl(new Handle(AIS_InteractiveObject)(theIO));
 681     }
 682     anObject = myWorkshop->module()->findPresentedObject(anAISObj);
 683   }
 684   return anObject;
 685 }
 686
 687 bool XGUI_Displayer::enableUpdateViewer(const bool isEnabled)
 688 {
 689   bool aWasEnabled = myEnableUpdateViewer;
 690
 691   myEnableUpdateViewer = isEnabled;
 692
 693   return aWasEnabled;
 694 }
 695
 696 void XGUI_Displayer::updateViewer() const
 697 {
 698   static int ai = 0;
 699   Handle(AIS_InteractiveContext) aContext = AISContext();
 700   if (!aContext.IsNull() && myEnableUpdateViewer) {
 701     myWorkshop->viewer()->Zfitall();
 702     aContext->UpdateCurrentViewer();
 703   }
 704 }
 705
 706 void XGUI_Displayer::activateAIS(const Handle(AIS_InteractiveObject)& theIO,
 707                                  const int theMode, const bool theUpdateViewer) const
 708 {
 709   Handle(AIS_InteractiveContext) aContext = myWorkshop->viewer()->AISContext();
 710   if (!aContext.IsNull()) {
 711     aContext->Activate(theIO, theMode, theUpdateViewer);
 712
 713 #ifdef DEBUG_ACTIVATE_AIS
 714     ObjectPtr anObject = getObject(theIO);
 715     anInfo.append(ModuleBase_Tools::objectInfo((*anIt)));
 716     qDebug(QString("activateAIS: theMode = %1, object = %2").arg(theMode).arg(anInfo).toStdString().c_str());
 717 #endif
 718   }
 719 }
 720
 721 void XGUI_Displayer::deactivateAIS(const Handle(AIS_InteractiveObject)& theIO, const int theMode) const
 722 {
 723   Handle(AIS_InteractiveContext) aContext = myWorkshop->viewer()->AISContext();
 724   if (!aContext.IsNull()) {
 725     if (theMode == -1)
 726       aContext->Deactivate(theIO);
 727     else
 728       aContext->Deactivate(theIO, theMode);
 729
 730 #ifdef DEBUG_DEACTIVATE_AIS
 731     ObjectPtr anObject = getObject(theIO);
 732     anInfo.append(ModuleBase_Tools::objectInfo((*anIt)));
 733     qDebug(QString("deactivateAIS: theMode = %1, object = %2").arg(theMode).arg(anInfo).toStdString().c_str());
 734 #endif
 735   }
 736 }
 737
 738 Handle(AIS_InteractiveContext) XGUI_Displayer::AISContext() const
 739 {
 740   Handle(AIS_InteractiveContext) aContext = myWorkshop->viewer()->AISContext();
 741   if (!aContext.IsNull() && !aContext->HasOpenedContext()) {
 742     aContext->OpenLocalContext();
 743     deactivateTrihedron();
 744     aContext->DefaultDrawer()->VIsoAspect()->SetNumber(0);
 745     aContext->DefaultDrawer()->UIsoAspect()->SetNumber(0);
 746   }
 747   return aContext;
 748 }
 749
 750 Handle(SelectMgr_AndFilter) XGUI_Displayer::GetFilter()
 751 {
 752   Handle(AIS_InteractiveContext) aContext = AISContext();
 753   if (!aContext.IsNull() && myAndFilter.IsNull()) {
 754     myAndFilter = new SelectMgr_AndFilter();
 755     aContext->AddFilter(myAndFilter);
 756   }
 757   return myAndFilter;
 758 }
 759
 760 bool XGUI_Displayer::displayAIS(AISObjectPtr theAIS, const bool toActivateInSelectionModes,
 761                                 bool theUpdateViewer)
 762 {
 763   bool aDisplayed = false;
 764   Handle(AIS_InteractiveContext) aContext = AISContext();
 765   Handle(AIS_InteractiveObject) anAISIO = theAIS->impl<Handle(AIS_InteractiveObject)>();
 766   if (!aContext.IsNull() && !anAISIO.IsNull()) {
 767     aContext->Display(anAISIO, 0/*wireframe*/, 0, theUpdateViewer, true, AIS_DS_Displayed);
 768     aDisplayed = true;
 769     aContext->Deactivate(anAISIO);
 770     aContext->Load(anAISIO);
 771     if (toActivateInSelectionModes) {
 772       if (aContext->HasOpenedContext()) {
 773         if (myActiveSelectionModes.size() == 0)
 774           activateAIS(anAISIO, 0, theUpdateViewer);
 775         else {
 776           foreach(int aMode, myActiveSelectionModes) {
 777             activateAIS(anAISIO, aMode, theUpdateViewer);
 778           }
 779         }
 780       }
 781     }
 782   }
 783   return aDisplayed;
 784 }
 785
 786 bool XGUI_Displayer::eraseAIS(AISObjectPtr theAIS, const bool theUpdateViewer)
 787 {
 788   bool aErased = false;
 789   Handle(AIS_InteractiveContext) aContext = AISContext();
 790   if (!aContext.IsNull()) {
 791     Handle(AIS_InteractiveObject) anAISIO = theAIS->impl<Handle(AIS_InteractiveObject)>();
 792     if (!anAISIO.IsNull() && aContext->IsDisplayed(anAISIO)) {
 793       aContext->Remove(anAISIO, theUpdateViewer);
 794       aErased = true;
 795     }
 796   }
 797   return aErased;
 798 }
 799
 800
 801 void XGUI_Displayer::setDisplayMode(ObjectPtr theObject, DisplayMode theMode, bool theUpdateViewer)
 802 {
 803   if (theMode == NoMode)
 804     return;
 805
 806   Handle(AIS_InteractiveContext) aContext = AISContext();
 807   if (aContext.IsNull())
 808     return;
 809
 810   AISObjectPtr aAISObj = getAISObject(theObject);
 811   if (!aAISObj)
 812     return;
 813
 814   Handle(AIS_InteractiveObject) aAISIO = aAISObj->impl<Handle(AIS_InteractiveObject)>();
 815   aContext->SetDisplayMode(aAISIO, theMode, false);
 816   // Redisplay in order to update new mode because it could be not computed before
 817   if (theUpdateViewer)
 818     updateViewer();
 819 }
 820
 821 XGUI_Displayer::DisplayMode XGUI_Displayer::displayMode(ObjectPtr theObject) const
 822 {
 823   Handle(AIS_InteractiveContext) aContext = AISContext();
 824   if (aContext.IsNull())
 825     return NoMode;
 826
 827   AISObjectPtr aAISObj = getAISObject(theObject);
 828   if (!aAISObj)
 829     return NoMode;
 830
 831   Handle(AIS_InteractiveObject) aAISIO = aAISObj->impl<Handle(AIS_InteractiveObject)>();
 832   return (XGUI_Displayer::DisplayMode) aAISIO->DisplayMode();
 833 }
 834
 835 void XGUI_Displayer::deactivateSelectionFilters()
 836 {
 837   Handle(AIS_InteractiveContext) aContext = AISContext();
 838   if (!myAndFilter.IsNull()) {
 839     bool aFound = false;
 840     if (!aContext.IsNull()) {
 841       const SelectMgr_ListOfFilter& aFilters = aContext->Filters();
 842       SelectMgr_ListIteratorOfListOfFilter anIt(aFilters);
 843       for (; anIt.More() && !aFound; anIt.Next()) {
 844         Handle(SelectMgr_Filter) aFilter = anIt.Value();
 845         aFound = aFilter == myAndFilter;
 846       }
 847       if (aFound)
 848         aContext->RemoveFilter(myAndFilter);
 849     }
 850     myAndFilter.Nullify();
 851   }
 852 }
 853
 854 void XGUI_Displayer::addSelectionFilter(const Handle(SelectMgr_Filter)& theFilter)
 855 {
 856   Handle(AIS_InteractiveContext) aContext = AISContext();
 857   if (aContext.IsNull() || hasSelectionFilter(theFilter))
 858     return;
 859
 860   Handle(SelectMgr_CompositionFilter) aCompositeFilter = GetFilter();
 861   if (!aCompositeFilter.IsNull()) {
 862     aCompositeFilter->Add(theFilter);
 863 #ifdef DEBUG_SELECTION_FILTERS
 864     int aCount = aCompositeFilter->StoredFilters().Extent();
 865     qDebug(QString("addSelectionFilter: filters.count() = %1").arg(aCount).toStdString().c_str());
 866 #endif
 867   }
 868 }
 869
 870 void XGUI_Displayer::removeSelectionFilter(const Handle(SelectMgr_Filter)& theFilter)
 871 {
 872   Handle(AIS_InteractiveContext) aContext = AISContext();
 873   if (aContext.IsNull())
 874     return;
 875
 876   Handle(SelectMgr_AndFilter) aCompositeFilter = GetFilter();
 877   if (!aCompositeFilter.IsNull() && aCompositeFilter->IsIn(theFilter)) {
 878     aCompositeFilter->Remove(theFilter);
 879 #ifdef DEBUG_SELECTION_FILTERS
 880     int aCount = aCompositeFilter->StoredFilters().Extent();
 881     qDebug(QString("removeSelectionFilter: filters.count() = %1").arg(aCount).toStdString().c_str());
 882 #endif
 883   }
 884 }
 885
 886 bool XGUI_Displayer::hasSelectionFilter(const Handle(SelectMgr_Filter)& theFilter)
 887 {
 888   bool aFilterFound = false;
 889
 890   Handle(AIS_InteractiveContext) aContext = AISContext();
 891   if (aContext.IsNull())
 892     return aFilterFound;
 893   const SelectMgr_ListOfFilter& aFilters = aContext->Filters();
 894   SelectMgr_ListIteratorOfListOfFilter aIt(aFilters);
 895   for (; aIt.More() && !aFilterFound; aIt.Next()) {
 896     if (theFilter.Access() == aIt.Value().Access())
 897       aFilterFound = true;
 898   }
 899   Handle(SelectMgr_CompositionFilter) aCompositeFilter = GetFilter();
 900   if (!aCompositeFilter.IsNull()) {
 901     const SelectMgr_ListOfFilter& aStoredFilters = aCompositeFilter->StoredFilters();
 902     for (aIt.Initialize(aStoredFilters); aIt.More() && !aFilterFound; aIt.Next()) {
 903       if (theFilter.Access() == aIt.Value().Access())
 904         aFilterFound = true;
 905     }
 906   }
 907   return aFilterFound;
 908 }
 909
 910 void XGUI_Displayer::removeFilters()
 911 {
 912   Handle(AIS_InteractiveContext) aContext = AISContext();
 913   if (aContext.IsNull())
 914     return;
 915
 916   Handle(SelectMgr_CompositionFilter) aCompositeFilter = GetFilter();
 917   if (!aCompositeFilter.IsNull())
 918     aCompositeFilter->Clear();
 919 }
 920
 921 void XGUI_Displayer::showOnly(const QObjectPtrList& theList)
 922 {
 923   QObjectPtrList aDispList = myResult2AISObjectMap.keys();
 924   foreach(ObjectPtr aObj, aDispList) {
 925     if (!theList.contains(aObj))
 926       erase(aObj, false);
 927   }
 928   foreach(ObjectPtr aObj, theList) {
 929     if (!isVisible(aObj))
 930       display(aObj, false);
 931   }
 932   updateViewer();
 933 }
 934
 935 bool XGUI_Displayer::canBeShaded(ObjectPtr theObject) const
 936 {
 937   if (!isVisible(theObject))
 938     return false;
 939
 940   AISObjectPtr aAISObj = getAISObject(theObject);
 941   if (aAISObj.get() == NULL)
 942     return false;
 943
 944   Handle(AIS_InteractiveObject) anAIS = aAISObj->impl<Handle(AIS_InteractiveObject)>();
 945   return ::canBeShaded(anAIS);
 946 }
 947
 948 bool XGUI_Displayer::activate(const Handle(AIS_InteractiveObject)& theIO,
 949                               const QIntList& theModes,
 950                               const bool theUpdateViewer) const
 951 {
 952   Handle(AIS_InteractiveContext) aContext = AISContext();
 953   if (aContext.IsNull() || theIO.IsNull())
 954     return false;
 955
 956   bool isActivationChanged = false;
 957   // deactivate object in all modes, which are not in the list of activation
 958   // It seems that after the IO deactivation the selected state of the IO's owners
 959   // is modified in OCC(version: 6.8.0) and the selection of the object later is lost.
 960   // By this reason, the number of the IO deactivate is decreased and the object is deactivated
 961   // only if there is a difference in the current modes and the parameters modes.
 962   // If the selection problem happens again, it is possible to write a test scenario and create
 963   // a bug. The bug steps are the following:
 964   // Create two IO, activate them in 5 modes, select the first IO, deactivate 3 modes for both,
 965   // with clicked SHIFT select the second object. The result is the selection of the first IO is lost.
 966   TColStd_ListOfInteger aTColModes;
 967   aContext->ActivatedModes(theIO, aTColModes);
 968   TColStd_ListIteratorOfListOfInteger itr( aTColModes );
 969   QIntList aModesActivatedForIO;
 970   bool isDeactivated = false;
 971   for (; itr.More(); itr.Next() ) {
 972     Standard_Integer aMode = itr.Value();
 973     if (!theModes.contains(aMode)) {
 974       deactivateAIS(theIO, aMode);
 975       isDeactivated = true;
 976     }
 977     else {
 978       aModesActivatedForIO.append(aMode);
 979     }
 980   }
 981   if (isDeactivated) {
 982     // the selection from the previous activation modes should be cleared manually (#26172)
 983     theIO->ClearSelected();
 984     aContext->LocalContext()->ClearOutdatedSelection(theIO, true);
 985     // For performance issues
 986     //if (theUpdateViewer)
 987     //  updateViewer();
 988     isActivationChanged = true;
 989   }
 990
 991   // loading the interactive object allowing the decomposition
 992   if (aTColModes.IsEmpty()) {
 993     aContext->Load(theIO, -1, true);
 994   }
 995
 996   // trihedron AIS check should be after the AIS loading.
 997   // If it is not loaded, it is steel selectable in the viewer.
 998   Handle(AIS_Trihedron) aTrihedron = Handle(AIS_Trihedron)::DownCast(theIO);
 999   if (aTrihedron.IsNull()) {
1000       //aContext->Load(anAISIO, -1, true);
1001       // In order to clear active modes list
1002     if (theModes.size() == 0) {
1003       //aContext->Load(anAISIO, 0, true);
1004       activateAIS(theIO, 0, theUpdateViewer);
1005     } else {
1006       foreach(int aMode, theModes) {
1007         //aContext->Load(anAISIO, aMode, true);
1008         if (!aModesActivatedForIO.contains(aMode)) {
1009           activateAIS(theIO, aMode, theUpdateViewer);
1010           isActivationChanged = true;
1011         }
1012       }
1013     }
1014   }
1015   return isActivationChanged;
1016 }
1017
1018 bool XGUI_Displayer::customizeObject(ObjectPtr theObject)
1019 {
1020   AISObjectPtr anAISObj = getAISObject(theObject);
1021   // correct the result's color it it has the attribute
1022   ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(theObject);
1023
1024   // Customization of presentation
1025   GeomCustomPrsPtr aCustomPrs;
1026   FeaturePtr aFeature = ModelAPI_Feature::feature(theObject);
1027   if (aFeature.get() != NULL) {
1028     GeomCustomPrsPtr aCustPrs = std::dynamic_pointer_cast<GeomAPI_ICustomPrs>(aFeature);
1029     if (aCustPrs.get() != NULL)
1030       aCustomPrs = aCustPrs;
1031   }
1032   if (aCustomPrs.get() == NULL) {
1033     GeomPresentablePtr aPrs = std::dynamic_pointer_cast<GeomAPI_IPresentable>(theObject);
1034     // we ignore presentable not customized objects
1035     if (aPrs.get() == NULL)
1036       aCustomPrs = myCustomPrs;
1037   }
1038   bool isCustomized = aCustomPrs.get() &&
1039                       aCustomPrs->customisePresentation(aResult, anAISObj, myCustomPrs);
1040   return isCustomized;
1041 }
1042
1043
1044 QColor XGUI_Displayer::setObjectColor(ObjectPtr theObject, const QColor& theColor, bool theUpdateViewer)
1045 {
1046   if (!isVisible(theObject))
1047     return Qt::black;
1048
1049   AISObjectPtr anAISObj = getAISObject(theObject);
1050   int aR, aG, aB;
1051   anAISObj->getColor(aR, aG, aB);
1052   anAISObj->setColor(theColor.red(), theColor.green(), theColor.blue());
1053   if (theUpdateViewer)
1054     updateViewer();
1055   return QColor(aR, aG, aB);
1056 }
1057
1058 void XGUI_Displayer::appendResultObject(ObjectPtr theObject, AISObjectPtr theAIS)
1059 {
1060   myResult2AISObjectMap[theObject] = theAIS;
1061
1062 #ifdef DEBUG_DISPLAY
1063   std::ostringstream aPtrStr;
1064   aPtrStr << theObject.get();
1065   qDebug(QString("display object: %1").arg(aPtrStr.str().c_str()).toStdString().c_str());
1066   qDebug(getResult2AISObjectMapInfo().c_str());
1067 #endif
1068 }
1069
1070 std::string XGUI_Displayer::getResult2AISObjectMapInfo() const
1071 {
1072   QStringList aContent;
1073   foreach (ObjectPtr aObj, myResult2AISObjectMap.keys()) {
1074     AISObjectPtr aAISObj = myResult2AISObjectMap[aObj];
1075     std::ostringstream aPtrStr;
1076     aPtrStr << "aObj = " << aObj.get() << ":";
1077     aPtrStr << "anAIS = " << aAISObj.get() << ":";
1078     aPtrStr << "[" << ModuleBase_Tools::objectInfo(aObj).toStdString().c_str() << "]";
1079
1080     aContent.append(aPtrStr.str().c_str());
1081   }
1082   return QString("myResult2AISObjectMap: size = %1\n%2\n").arg(myResult2AISObjectMap.size()).
1083                                             arg(aContent.join("\n")).toStdString().c_str();
1084 }