src/AIS/AIS_InteractiveContext.cxx

   1 // Created on: 1997-01-17
   2 // Created by: Robert COUBLANC
   3 // Copyright (c) 1997-1999 Matra Datavision
   4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   5 //
   6 // This file is part of Open CASCADE Technology software library.
   7 //
   8 // This library is free software; you can redistribute it and/or modify it under
   9 // the terms of the GNU Lesser General Public License version 2.1 as published
  10 // by the Free Software Foundation, with special exception defined in the file
  11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  12 // distribution for complete text of the license and disclaimer of any warranty.
  13 //
  14 // Alternatively, this file may be used under the terms of Open CASCADE
  15 // commercial license or contractual agreement.
  16
  17 // Modified by  XAB & Serguei Dec 97 (angle &deviation coeffts)
  18
  19 #include <AIS_ConnectedInteractive.hxx>
  20 #include <AIS_DataMapIteratorOfDataMapOfILC.hxx>
  21 #include <AIS_DataMapIteratorOfDataMapOfIOStatus.hxx>
  22 #include <AIS_GlobalStatus.hxx>
  23 #include <AIS_InteractiveContext.hxx>
  24 #include <AIS_InteractiveObject.hxx>
  25 #include <AIS_ListIteratorOfListOfInteractive.hxx>
  26 #include <AIS_LocalContext.hxx>
  27 #include <AIS_LocalStatus.hxx>
  28 #include <AIS_MapIteratorOfMapOfInteractive.hxx>
  29 #include <AIS_MultipleConnectedInteractive.hxx>
  30 #include <AIS_Selection.hxx>
  31 #include <AIS_Shape.hxx>
  32 #include <AIS_Trihedron.hxx>
  33 #include <Geom_Axis2Placement.hxx>
  34 #include <Graphic3d_AspectFillArea3d.hxx>
  35 #include <HLRBRep.hxx>
  36 #include <OSD_Environment.hxx>
  37 #include <Precision.hxx>
  38 #include <Prs3d_BasicAspect.hxx>
  39 #include <Prs3d_DatumAspect.hxx>
  40 #include <Prs3d_IsoAspect.hxx>
  41 #include <Prs3d_LineAspect.hxx>
  42 #include <Prs3d_PlaneAspect.hxx>
  43 #include <Prs3d_ShadingAspect.hxx>
  44 #include <PrsMgr_ModedPresentation.hxx>
  45 #include <PrsMgr_PresentableObject.hxx>
  46 #include <Quantity_Color.hxx>
  47 #include <SelectMgr_EntityOwner.hxx>
  48 #include <SelectMgr_Filter.hxx>
  49 #include <SelectMgr_OrFilter.hxx>
  50 #include <SelectMgr_SelectionManager.hxx>
  51 #include <Standard_Atomic.hxx>
  52 #include <Standard_Transient.hxx>
  53 #include <Standard_Type.hxx>
  54 #include <StdSelect_ViewerSelector3d.hxx>
  55 #include <TCollection_AsciiString.hxx>
  56 #include <TCollection_ExtendedString.hxx>
  57 #include <TColStd_ListIteratorOfListOfInteger.hxx>
  58 #include <TColStd_MapIteratorOfMapOfTransient.hxx>
  59 #include <TopLoc_Location.hxx>
  60 #include <TopoDS_Shape.hxx>
  61 #include <UnitsAPI.hxx>
  62 #include <V3d_View.hxx>
  63 #include <V3d_Viewer.hxx>
  64
  65 IMPLEMENT_STANDARD_RTTIEXT(AIS_InteractiveContext,MMgt_TShared)
  66
  67 //#include <AIS_DataMapIteratorOfDataMapOfInteractiveInteger.hxx>
  68 namespace
  69 {
  70   static volatile Standard_Integer THE_AIS_INDEX_SEL = 0;
  71   static volatile Standard_Integer THE_AIS_INDEX_CUR = 0;
  72
  73   static TCollection_AsciiString AIS_Context_NewSelName()
  74   {
  75     return TCollection_AsciiString ("AIS_SelContext_")
  76          + TCollection_AsciiString (Standard_Atomic_Increment (&THE_AIS_INDEX_SEL));
  77   }
  78
  79   static TCollection_AsciiString AIS_Context_NewCurName()
  80   {
  81     return TCollection_AsciiString ("AIS_CurContext_")
  82          + TCollection_AsciiString (Standard_Atomic_Increment (&THE_AIS_INDEX_CUR));
  83   }
  84
  85   typedef NCollection_DataMap<Handle(SelectMgr_SelectableObject), Handle(SelectMgr_IndexedMapOfOwner)> AIS_MapOfObjectOwners;
  86   typedef NCollection_DataMap<Handle(SelectMgr_SelectableObject), Handle(SelectMgr_IndexedMapOfOwner)>::Iterator AIS_MapIteratorOfMapOfObjectOwners;
  87 }
  88
  89 //=======================================================================
  90 //function : AIS_InteractiveContext
  91 //purpose  :
  92 //=======================================================================
  93
  94 AIS_InteractiveContext::AIS_InteractiveContext(const Handle(V3d_Viewer)& MainViewer):
  95 mgrSelector(new SelectMgr_SelectionManager()),
  96 myMainPM(new PrsMgr_PresentationManager3d(MainViewer->StructureManager())),
  97 myMainVwr(MainViewer),
  98 myMainSel(new StdSelect_ViewerSelector3d()),
  99 myWasLastMain(Standard_False),
 100 myCurrentTouched(Standard_False),
 101 mySelectedTouched(Standard_False),
 102 myToHilightSelected(Standard_True),
 103 myFilters(new SelectMgr_OrFilter()),
 104 myDefaultDrawer(new Prs3d_Drawer()),
 105 myDefaultColor(Quantity_NOC_GOLDENROD),
 106 myHilightColor(Quantity_NOC_CYAN1),
 107 mySelectionColor(Quantity_NOC_GRAY80),
 108 myPreselectionColor(Quantity_NOC_GREEN),
 109 mySubIntensity(Quantity_NOC_GRAY40),
 110 myDisplayMode(0),
 111 myCurLocalIndex(0),
 112 myAISCurDetected(0),
 113 myZDetectionFlag(0),
 114 myIsAutoActivateSelMode( Standard_True )
 115 {
 116   InitAttributes();
 117 }
 118
 119 void AIS_InteractiveContext::Delete() const
 120 {
 121   // clear the static current selection
 122   AIS_Selection::ClearCurrentSelection();
 123
 124   // to avoid an exception
 125   if (AIS_Selection::Find (mySelectionName.ToCString()))
 126   {
 127     AIS_Selection::Remove (mySelectionName.ToCString());
 128   }
 129
 130   // to avoid an exception
 131   if (AIS_Selection::Find (myCurrentName.ToCString()))
 132   {
 133     AIS_Selection::Remove (myCurrentName.ToCString());
 134   }
 135
 136   // let's remove one reference explicitly. this operation's supposed to
 137   // be performed when mgrSelector will be destroyed but anyway...
 138   const Handle(SelectMgr_ViewerSelector)& aSelector = myMainSel; // to avoid ambiguity
 139   mgrSelector->Remove (aSelector);
 140
 141   Handle(AIS_InteractiveContext) aNullContext;
 142   for (AIS_DataMapIteratorOfDataMapOfIOStatus anObjIter (myObjects); anObjIter.More(); anObjIter.Next())
 143   {
 144     Handle(AIS_InteractiveObject) anObj = anObjIter.Key();
 145     anObj->SetContext (aNullContext);
 146     for (anObj->Init(); anObj->More(); anObj->Next())
 147     {
 148       anObj->CurrentSelection()->UpdateBVHStatus (SelectMgr_TBU_Renew);
 149     }
 150   }
 151   MMgt_TShared::Delete();
 152 }
 153
 154 //=======================================================================
 155 //function : AIS_SelectionName
 156 //purpose  :
 157 //=======================================================================
 158 const TCollection_AsciiString& AIS_InteractiveContext::SelectionName() const
 159 {
 160   if(!HasOpenedContext())
 161     return mySelectionName;
 162   return myLocalContexts(myCurLocalIndex)->SelectionName();
 163
 164 }
 165
 166
 167
 168 //=======================================================================
 169 //function : UpdateCurrentViewer
 170 //purpose  :
 171 //=======================================================================
 172
 173 void AIS_InteractiveContext::UpdateCurrentViewer()
 174 {
 175   if (!myMainVwr.IsNull())
 176     myMainVwr->Update();
 177 }
 178
 179
 180 //=======================================================================
 181 //function : DomainOfMainViewer
 182 //purpose  :
 183 //=======================================================================
 184
 185 Standard_CString AIS_InteractiveContext::DomainOfMainViewer() const
 186 {
 187   return myMainVwr->Domain();
 188
 189 }
 190
 191 //=======================================================================
 192 //function : DisplayedObjects
 193 //purpose  :
 194 //=======================================================================
 195 void AIS_InteractiveContext::DisplayedObjects (AIS_ListOfInteractive& theListOfIO,
 196                                                const Standard_Boolean theOnlyFromNeutral) const
 197 {
 198   if (!HasOpenedContext()
 199    || theOnlyFromNeutral)
 200   {
 201     for (AIS_DataMapIteratorOfDataMapOfIOStatus anObjIter (myObjects); anObjIter.More(); anObjIter.Next())
 202     {
 203       if (anObjIter.Value()->GraphicStatus() == AIS_DS_Displayed)
 204       {
 205         theListOfIO.Append (anObjIter.Key());
 206       }
 207     }
 208     return;
 209   }
 210
 211   // neutral point
 212   TColStd_MapOfTransient aDispMap;
 213   for (AIS_DataMapIteratorOfDataMapOfIOStatus anObjIter (myObjects); anObjIter.More(); anObjIter.Next())
 214   {
 215     if (anObjIter.Value()->GraphicStatus() == AIS_DS_Displayed)
 216     {
 217       aDispMap.Add (anObjIter.Key());
 218     }
 219   }
 220
 221   // parse all local contexts...
 222   for (AIS_DataMapIteratorOfDataMapOfILC aCtxIter (myLocalContexts); aCtxIter.More(); aCtxIter.Next())
 223   {
 224     const Handle(AIS_LocalContext)& aLocCtx = aCtxIter.Value();
 225     aLocCtx->DisplayedObjects (aDispMap);
 226   }
 227
 228   Handle(AIS_InteractiveObject) anObj;
 229   for (TColStd_MapIteratorOfMapOfTransient aDispMapIter (aDispMap); aDispMapIter.More(); aDispMapIter.Next())
 230   {
 231     const Handle(Standard_Transient)& aTransient = aDispMapIter.Key();
 232     anObj = Handle(AIS_InteractiveObject)::DownCast (aTransient);
 233     theListOfIO.Append (anObj);
 234   }
 235 }
 236
 237 //=======================================================================
 238 //function : DisplayedObjects
 239 //purpose  :
 240 //=======================================================================
 241 void AIS_InteractiveContext::DisplayedObjects (const AIS_KindOfInteractive theKind,
 242                                                const Standard_Integer      theSign,
 243                                                AIS_ListOfInteractive&      theListOfIO,
 244                                                const Standard_Boolean /*OnlyFromNeutral*/) const
 245 {
 246   ObjectsByDisplayStatus (theKind, theSign, AIS_DS_Displayed, theListOfIO);
 247 }
 248
 249 //=======================================================================
 250 //function : ErasedObjects
 251 //purpose  :
 252 //=======================================================================
 253 void AIS_InteractiveContext::ErasedObjects (AIS_ListOfInteractive& theListOfIO) const
 254 {
 255   ObjectsByDisplayStatus (AIS_DS_Erased, theListOfIO);
 256 }
 257
 258 //=======================================================================
 259 //function : ErasedObjects
 260 //purpose  :
 261 //=======================================================================
 262 void AIS_InteractiveContext::ErasedObjects (const AIS_KindOfInteractive theKind,
 263                                             const Standard_Integer      theSign,
 264                                             AIS_ListOfInteractive&      theListOfIO) const
 265 {
 266   ObjectsByDisplayStatus (theKind, theSign, AIS_DS_Erased, theListOfIO);
 267 }
 268
 269 //=======================================================================
 270 //function : ObjectsByDisplayStatus
 271 //purpose  :
 272 //=======================================================================
 273 void AIS_InteractiveContext::ObjectsByDisplayStatus (const AIS_DisplayStatus theStatus,
 274                                                      AIS_ListOfInteractive&  theListOfIO) const
 275 {
 276   for (AIS_DataMapIteratorOfDataMapOfIOStatus anObjIter (myObjects); anObjIter.More(); anObjIter.Next())
 277   {
 278     if (anObjIter.Value()->GraphicStatus() == theStatus)
 279     {
 280       theListOfIO.Append (anObjIter.Key());
 281     }
 282   }
 283 }
 284
 285 //=======================================================================
 286 //function : ObjectsByDisplayStatus
 287 //purpose  :
 288 //=======================================================================
 289 void AIS_InteractiveContext::ObjectsByDisplayStatus (const AIS_KindOfInteractive theKind,
 290                                                      const Standard_Integer      theSign,
 291                                                      const AIS_DisplayStatus     theStatus,
 292                                                      AIS_ListOfInteractive&      theListOfIO) const
 293 {
 294   for (AIS_DataMapIteratorOfDataMapOfIOStatus anObjIter (myObjects); anObjIter.More(); anObjIter.Next())
 295   {
 296     if (theStatus != AIS_DS_None
 297      && anObjIter.Value()->GraphicStatus() != theStatus)
 298     {
 299       continue;
 300     }
 301     else if (anObjIter.Key()->Type() != theKind)
 302     {
 303       continue;
 304     }
 305
 306     if (theSign == -1
 307      || anObjIter.Key()->Signature() == theSign)
 308     {
 309       theListOfIO.Append (anObjIter.Key());
 310     }
 311   }
 312 }
 313
 314 //=======================================================================
 315 //function : ObjectsInside
 316 //purpose  :
 317 //=======================================================================
 318 void AIS_InteractiveContext::ObjectsInside (AIS_ListOfInteractive&      theListOfIO,
 319                                             const AIS_KindOfInteractive theKind,
 320                                             const Standard_Integer      theSign) const
 321 {
 322   if (theKind == AIS_KOI_None
 323    && theSign == -1)
 324   {
 325     for (AIS_DataMapIteratorOfDataMapOfIOStatus anObjIter (myObjects); anObjIter.More(); anObjIter.Next())
 326     {
 327       theListOfIO.Append (anObjIter.Key());
 328     }
 329     return;
 330   }
 331
 332   for (AIS_DataMapIteratorOfDataMapOfIOStatus anObjIter (myObjects); anObjIter.More(); anObjIter.Next())
 333   {
 334     if (anObjIter.Key()->Type() != theKind)
 335     {
 336       continue;
 337     }
 338
 339     if (theSign == -1
 340      || anObjIter.Key()->Signature() == theSign)
 341     {
 342       theListOfIO.Append (anObjIter.Key());
 343     }
 344   }
 345 }
 346
 347 //=======================================================================
 348 //function : ObjectsForView
 349 //purpose  :
 350 //=======================================================================
 351 void AIS_InteractiveContext::ObjectsForView (AIS_ListOfInteractive&  theListOfIO,
 352                                              const Handle(V3d_View)& theView,
 353                                              const Standard_Boolean  theIsVisibleInView,
 354                                              const AIS_DisplayStatus theStatus) const
 355 {
 356   Handle(Graphic3d_CView) aViewImpl = theView->View();
 357   const Standard_Integer  aViewId   = aViewImpl->Identification();
 358   for (AIS_DataMapIteratorOfDataMapOfIOStatus anObjIter (myObjects); anObjIter.More(); anObjIter.Next())
 359   {
 360     if (theStatus != AIS_DS_None
 361      && anObjIter.Value()->GraphicStatus() != theStatus)
 362     {
 363       theListOfIO.Append (anObjIter.Key());
 364       continue;
 365     }
 366
 367     Handle(Graphic3d_ViewAffinity) anAffinity = myMainVwr->StructureManager()->ObjectAffinity (anObjIter.Key());
 368     const Standard_Boolean isVisible = anAffinity->IsVisible (aViewId);
 369     if (isVisible == theIsVisibleInView)
 370     {
 371       theListOfIO.Append (anObjIter.Key());
 372     }
 373   }
 374 }
 375
 376 //=======================================================================
 377 //function : Display
 378 //purpose  :
 379 //=======================================================================
 380 void AIS_InteractiveContext::Display (const Handle(AIS_InteractiveObject)& theIObj,
 381                                       const Standard_Boolean               theToUpdateViewer)
 382 {
 383   if (theIObj.IsNull())
 384   {
 385     return;
 386   }
 387
 388   Standard_Integer aDispMode = 0, aHiMod = -1, aSelMode = -1;
 389   GetDefModes (theIObj, aDispMode, aHiMod, aSelMode);
 390
 391   Display (theIObj, aDispMode, myIsAutoActivateSelMode ? aSelMode : -1,
 392            theToUpdateViewer, theIObj->AcceptShapeDecomposition());
 393 }
 394
 395 //=======================================================================
 396 //function : SetViewAffinity
 397 //purpose  :
 398 //=======================================================================
 399 void AIS_InteractiveContext::SetViewAffinity (const Handle(AIS_InteractiveObject)& theIObj,
 400                                               const Handle(V3d_View)&              theView,
 401                                               const Standard_Boolean               theIsVisible)
 402 {
 403   if (theIObj.IsNull()
 404   || !myObjects.IsBound (theIObj))
 405   {
 406     return;
 407   }
 408
 409   Handle(Graphic3d_ViewAffinity) anAffinity = myMainVwr->StructureManager()->ObjectAffinity (theIObj);
 410   Handle(Graphic3d_CView) aViewImpl = theView->View();
 411   anAffinity->SetVisible (aViewImpl->Identification(), theIsVisible == Standard_True);
 412   if (theIsVisible)
 413   {
 414     theView->View()->ChangeHiddenObjects()->Remove (theIObj.get());
 415   }
 416   else
 417   {
 418     theView->View()->ChangeHiddenObjects()->Add (theIObj.get());
 419   }
 420 }
 421
 422 //=======================================================================
 423 //function : Display
 424 //purpose  :
 425 //=======================================================================
 426 void AIS_InteractiveContext::Display (const Handle(AIS_InteractiveObject)& theIObj,
 427                                       const Standard_Integer               theDispMode,
 428                                       const Standard_Integer               theSelectionMode,
 429                                       const Standard_Boolean               theToUpdateViewer,
 430                                       const Standard_Boolean               theToAllowDecomposition,
 431                                       const AIS_DisplayStatus              theDispStatus)
 432 {
 433   if (theIObj.IsNull())
 434   {
 435     return;
 436   }
 437
 438   if (theDispStatus == AIS_DS_Erased)
 439   {
 440     Erase  (theIObj, theToUpdateViewer);
 441     Load (theIObj, theSelectionMode, theToAllowDecomposition);
 442     return;
 443   }
 444
 445   if (!theIObj->HasInteractiveContext())
 446   {
 447     theIObj->SetContext (this);
 448   }
 449
 450   if (theDispStatus == AIS_DS_Temporary
 451   && !HasOpenedContext())
 452   {
 453     return;
 454   }
 455   else if (HasOpenedContext())
 456   {
 457     if (theDispStatus == AIS_DS_None
 458      || theDispStatus == AIS_DS_Temporary)
 459     {
 460       myLocalContexts (myCurLocalIndex)->Display (theIObj, theDispMode, theToAllowDecomposition, theSelectionMode);
 461       if (theToUpdateViewer)
 462       {
 463         myMainVwr->Update();
 464       }
 465       return;
 466     }
 467   }
 468
 469   if (!myObjects.IsBound (theIObj))
 470   {
 471     Handle(AIS_GlobalStatus) aStatus = new AIS_GlobalStatus (AIS_DS_Displayed, theDispMode, theSelectionMode);
 472     myObjects.Bind   (theIObj, aStatus);
 473     Handle(Graphic3d_ViewAffinity) anAffinity = myMainVwr->StructureManager()->RegisterObject (theIObj);
 474     myMainPM->Display(theIObj, theDispMode);
 475     if (theSelectionMode != -1)
 476     {
 477       const Handle(SelectMgr_SelectableObject)& anObj = theIObj; // to avoid ambiguity
 478       if (!mgrSelector->Contains (anObj))
 479       {
 480         mgrSelector->Load (theIObj);
 481       }
 482       mgrSelector->Activate (theIObj, theSelectionMode, myMainSel);
 483     }
 484   }
 485   else
 486   {
 487     Handle(AIS_GlobalStatus) aStatus = myObjects (theIObj);
 488     if (aStatus->GraphicStatus() == AIS_DS_Temporary)
 489     {
 490       return;
 491     }
 492
 493     // Erase presentations for all display modes different from aDispMode.
 494     // Then make sure aDispMode is displayed and maybe highlighted.
 495     // Finally, activate selection mode <SelMode> if not yet activated.
 496     TColStd_ListOfInteger aModesToRemove;
 497     for (TColStd_ListIteratorOfListOfInteger aDispModeIter (aStatus->DisplayedModes()); aDispModeIter.More(); aDispModeIter.Next())
 498     {
 499       const Standard_Integer anOldMode = aDispModeIter.Value();
 500       if (anOldMode != theDispMode)
 501       {
 502         aModesToRemove.Append (anOldMode);
 503         if(myMainPM->IsHighlighted (theIObj, anOldMode))
 504         {
 505           myMainPM->Unhighlight (theIObj, anOldMode);
 506         }
 507         myMainPM->Erase (theIObj, anOldMode);
 508       }
 509     }
 510
 511     for (TColStd_ListIteratorOfListOfInteger aRemModeIter (aModesToRemove); aRemModeIter.More(); aRemModeIter.Next())
 512     {
 513       aStatus->RemoveDisplayMode (aRemModeIter.Value());
 514     }
 515
 516     if (!aStatus->IsDModeIn (theDispMode))
 517     {
 518       aStatus->AddDisplayMode (theDispMode);
 519     }
 520
 521     myMainPM->Display (theIObj, theDispMode);
 522     aStatus->SetGraphicStatus (AIS_DS_Displayed);
 523     if (aStatus->IsHilighted())
 524     {
 525       const Standard_Integer aHiMod = theIObj->HasHilightMode() ? theIObj->HilightMode() : theDispMode;
 526       myMainPM->Color (theIObj, aStatus->HilightColor(), aHiMod);
 527     }
 528     if (theSelectionMode != -1)
 529     {
 530       const Handle(SelectMgr_SelectableObject)& anObj = theIObj; // to avoid ambiguity
 531       if (!mgrSelector->Contains (anObj))
 532       {
 533         mgrSelector->Load (theIObj);
 534       }
 535       if (!mgrSelector->IsActivated (theIObj, theSelectionMode))
 536       {
 537         if (!aStatus->IsSModeIn (theSelectionMode))
 538           aStatus->AddSelectionMode (theSelectionMode);
 539         mgrSelector->Activate (theIObj, theSelectionMode, myMainSel);
 540       }
 541     }
 542   }
 543
 544   if (theToUpdateViewer)
 545   {
 546     myMainVwr->Update();
 547   }
 548 }
 549
 550 //=======================================================================
 551 //function : Load
 552 //purpose  :
 553 //=======================================================================
 554 void AIS_InteractiveContext::Load (const Handle(AIS_InteractiveObject)& theIObj,
 555                                    const Standard_Integer               theSelMode,
 556                                    const Standard_Boolean               theToAllowDecomposition)
 557 {
 558   if (theIObj.IsNull())
 559   {
 560     return;
 561   }
 562
 563   if (!theIObj->HasInteractiveContext())
 564   {
 565     theIObj->SetContext (this);
 566   }
 567
 568   if (HasOpenedContext())
 569   {
 570     myLocalContexts (myCurLocalIndex)->Load (theIObj, theToAllowDecomposition, theSelMode);
 571     return;
 572   }
 573
 574   if (theSelMode == -1
 575   && !theToAllowDecomposition)
 576   {
 577     if (!myObjects.IsBound (theIObj))
 578     {
 579       Standard_Integer aDispMode, aHiMod, aSelModeDef;
 580       GetDefModes (theIObj, aDispMode, aHiMod, aSelModeDef);
 581       Handle(AIS_GlobalStatus) aStatus = new AIS_GlobalStatus (AIS_DS_Erased, aDispMode, aSelModeDef);
 582       myObjects.Bind (theIObj, aStatus);
 583     }
 584
 585     // Register theIObj in the selection manager to prepare further activation of selection
 586     const Handle(SelectMgr_SelectableObject)& anObj = theIObj; // to avoid ambiguity
 587     if (!mgrSelector->Contains (anObj))
 588     {
 589       mgrSelector->Load (theIObj);
 590     }
 591   }
 592 }
 593
 594 //=======================================================================
 595 //function : Erase
 596 //purpose  :
 597 //=======================================================================
 598 void AIS_InteractiveContext::Erase (const Handle(AIS_InteractiveObject)& theIObj,
 599                                     const Standard_Boolean               theToUpdateViewer)
 600 {
 601   if (theIObj.IsNull())
 602   {
 603     return;
 604   }
 605
 606   if (!theIObj->IsAutoHilight())
 607   {
 608     theIObj->ClearSelected();
 609   }
 610
 611   Standard_Boolean wasInCtx = Standard_False;
 612   if (HasOpenedContext())
 613   {
 614     // First it is checked if it is possible to remove in the current local context
 615     // then one tries to remove in other local contexts, if they allow it...
 616     wasInCtx = myLocalContexts (myCurLocalIndex)->Erase (theIObj);
 617     for (AIS_DataMapIteratorOfDataMapOfILC aCtxIter (myLocalContexts); aCtxIter.More(); aCtxIter.Next())
 618     {
 619       if (aCtxIter.Value()->AcceptErase())
 620       {
 621         wasInCtx = aCtxIter.Value()->Erase (theIObj) || wasInCtx;
 622       }
 623     }
 624   }
 625
 626   if (!wasInCtx)
 627   {
 628     EraseGlobal (theIObj, Standard_False);
 629   }
 630
 631   if (theToUpdateViewer)
 632   {
 633     myMainVwr->Update();
 634   }
 635 }
 636
 637 //=======================================================================
 638 //function : EraseAll
 639 //purpose  :
 640 //=======================================================================
 641 void AIS_InteractiveContext::EraseAll (const Standard_Boolean theToUpdateViewer)
 642 {
 643   if (HasOpenedContext())
 644   {
 645     return;
 646   }
 647
 648   for (AIS_DataMapIteratorOfDataMapOfIOStatus anObjIter (myObjects); anObjIter.More(); anObjIter.Next())
 649   {
 650     if (anObjIter.Value()->GraphicStatus() == AIS_DS_Displayed)
 651     {
 652       Erase (anObjIter.Key(), Standard_False);
 653     }
 654   }
 655
 656   if (theToUpdateViewer)
 657   {
 658     myMainVwr->Update();
 659   }
 660 }
 661
 662 //=======================================================================
 663 //function : DisplayAll
 664 //purpose  :
 665 //=======================================================================
 666 void AIS_InteractiveContext::DisplayAll (const Standard_Boolean theToUpdateViewer)
 667 {
 668   if (HasOpenedContext())
 669   {
 670     return;
 671   }
 672
 673   for (AIS_DataMapIteratorOfDataMapOfIOStatus anObjIter (myObjects); anObjIter.More(); anObjIter.Next())
 674   {
 675     const AIS_DisplayStatus aStatus = anObjIter.Value()->GraphicStatus();
 676     if (aStatus == AIS_DS_Erased)
 677     {
 678       Display (anObjIter.Key(), Standard_False);
 679     }
 680   }
 681
 682   if (theToUpdateViewer)
 683   {
 684     myMainVwr->Update();
 685   }
 686 }
 687
 688 //=======================================================================
 689 //function : DisplaySelected
 690 //purpose  :
 691 //=======================================================================
 692 void AIS_InteractiveContext::DisplaySelected (const Standard_Boolean theToUpdateViewer)
 693 {
 694   if (HasOpenedContext())
 695   {
 696     return;
 697   }
 698
 699   Standard_Boolean      isFound  = Standard_False;
 700   Handle(AIS_Selection) aSelIter = AIS_Selection::Selection (myCurrentName.ToCString());
 701   for (aSelIter->Init(); aSelIter->More(); aSelIter->Next())
 702   {
 703     Handle(AIS_InteractiveObject) anObj = Handle(AIS_InteractiveObject)::DownCast (aSelIter->Value());
 704     Display (anObj, Standard_False);
 705     isFound = Standard_True;
 706   }
 707
 708   if (isFound && theToUpdateViewer)
 709   {
 710     myMainVwr->Update();
 711   }
 712 }
 713
 714 //=======================================================================
 715 //function : EraseSelected
 716 //purpose  :
 717 //=======================================================================
 718 void AIS_InteractiveContext::EraseSelected (const Standard_Boolean theToUpdateViewer)
 719 {
 720   if (HasOpenedContext())
 721   {
 722     return;
 723   }
 724
 725   Standard_Boolean      isFound  = Standard_False;
 726   Handle(AIS_Selection) aSelIter = AIS_Selection::Selection(myCurrentName.ToCString());
 727
 728   aSelIter->Init();
 729   while (aSelIter->More())
 730   {
 731     Handle(SelectMgr_EntityOwner) anOwner = Handle(SelectMgr_EntityOwner)::DownCast (aSelIter->Value());
 732     Handle(AIS_InteractiveObject) anObj   = Handle(AIS_InteractiveObject)::DownCast (anOwner->Selectable());
 733
 734     Erase (anObj, Standard_False);
 735     isFound = Standard_True;
 736
 737     aSelIter->Init();
 738   }
 739
 740   if (isFound && theToUpdateViewer)
 741   {
 742     myMainVwr->Update();
 743   }
 744 }
 745
 746 //=======================================================================
 747 //function :
 748 //purpose  :
 749 //=======================================================================
 750
 751 Standard_Boolean AIS_InteractiveContext::KeepTemporary(const Handle(AIS_InteractiveObject)& anIObj,
 752                                                        const Standard_Integer WhichContext)
 753 {
 754   if(anIObj.IsNull()) return Standard_False;
 755
 756   if(!HasOpenedContext()) return Standard_False;
 757   if(myObjects.IsBound(anIObj)) return Standard_False;
 758   if(WhichContext!=-1 && !myLocalContexts.IsBound(WhichContext)) return Standard_False;
 759
 760   // Protection : if one tries to preserve a temporary object
 761   // which is not in the local active context... rob 11-06-97
 762
 763   Standard_Integer IsItInLocal = myCurLocalIndex;
 764   Standard_Boolean Found(Standard_False);
 765
 766   while(IsItInLocal>0 && !Found){
 767     if(!myLocalContexts.IsBound(IsItInLocal))
 768       IsItInLocal--;
 769     else if(myLocalContexts(IsItInLocal)->IsIn(anIObj))
 770       Found = Standard_True;
 771     else
 772       IsItInLocal--;
 773   }
 774
 775   if(!Found) return Standard_False;
 776
 777
 778 //  const Handle(AIS_LocalStatus)& LS = (WhichContext== -1) ?
 779 //    myLocalContexts(IsItInLocal)->Status(anIObj):myLocalContexts(WhichContext)->Status(anIObj);
 780   // CLE
 781   // const Handle(AIS_LocalStatus)& LS = myLocalContexts(IsItInLocal)->Status(anIObj);
 782   Handle(AIS_LocalStatus) LS = myLocalContexts(IsItInLocal)->Status(anIObj);
 783   // ENDCLE
 784
 785
 786   if(LS->IsTemporary()){
 787     Standard_Integer DM,HM,SM;
 788     GetDefModes(anIObj,DM,HM,SM);
 789
 790     SM = LS->SelectionModes().IsEmpty() ? SM : LS->SelectionModes().First();
 791     if(LS->DisplayMode()!= DM ){
 792       Standard_Integer LSM =  LS->SelectionModes().IsEmpty() ? -1 : LS->SelectionModes().First();
 793       myLocalContexts(IsItInLocal)->Display(anIObj,DM,LS->Decomposed(),LSM);
 794     }
 795
 796     Handle (AIS_GlobalStatus) GS = new AIS_GlobalStatus(AIS_DS_Displayed,
 797                                                         DM,
 798                                                         SM,
 799                                                         Standard_False);
 800 //    GS->SubIntensityOn();
 801     myObjects.Bind(anIObj,GS);
 802     mgrSelector->Load(anIObj);
 803     mgrSelector->Activate(anIObj,SM,myMainSel);
 804
 805     LS->SetTemporary(Standard_False);
 806   }
 807   return Standard_True;
 808 }
 809
 810 //=======================================================================
 811 //function : DisplayStatus
 812 //purpose  :
 813 //=======================================================================
 814 AIS_DisplayStatus AIS_InteractiveContext::DisplayStatus (const Handle(AIS_InteractiveObject)& theIObj) const
 815 {
 816   if (theIObj.IsNull())
 817   {
 818     return AIS_DS_None;
 819   }
 820   else if (myObjects.IsBound (theIObj))
 821   {
 822     return myObjects (theIObj)->GraphicStatus();
 823   }
 824
 825   for (AIS_DataMapIteratorOfDataMapOfILC aCtxIter (myLocalContexts); aCtxIter.More(); aCtxIter.Next())
 826   {
 827     if (aCtxIter.Value()->IsIn (theIObj))
 828     {
 829       return AIS_DS_Temporary;
 830     }
 831   }
 832   return AIS_DS_None;
 833 }
 834
 835 //=======================================================================
 836 //function : DisplayedModes
 837 //purpose  :
 838 //=======================================================================
 839 const TColStd_ListOfInteger& AIS_InteractiveContext::DisplayedModes (const Handle(AIS_InteractiveObject)& theIObj) const
 840 {
 841   return myObjects (theIObj)->DisplayedModes();
 842 }
 843
 844 //=======================================================================
 845 //function : Remove
 846 //purpose  :
 847 //=======================================================================
 848 void AIS_InteractiveContext::Remove (const Handle(AIS_InteractiveObject)& theIObj,
 849                                      const Standard_Boolean               theToUpdateViewer)
 850 {
 851   if (theIObj.IsNull())
 852   {
 853     return;
 854   }
 855
 856   if (HasOpenedContext())
 857   {
 858     myLocalContexts (myCurLocalIndex)->Remove (theIObj);
 859     for (AIS_DataMapIteratorOfDataMapOfILC aCtxIter (myLocalContexts); aCtxIter.More(); aCtxIter.Next())
 860     {
 861       if (aCtxIter.Value()->AcceptErase())
 862       {
 863         aCtxIter.Value()->Remove (theIObj);
 864       }
 865     }
 866   }
 867
 868   ClearGlobal (theIObj, theToUpdateViewer);
 869 }
 870
 871 //=======================================================================
 872 //function : RemoveAll
 873 //purpose  :
 874 //=======================================================================
 875 void AIS_InteractiveContext::RemoveAll (const Standard_Boolean theToUpdateViewer)
 876 {
 877   AIS_ListOfInteractive aList;
 878   ObjectsInside (aList);
 879   for (AIS_ListIteratorOfListOfInteractive aListIterator (aList); aListIterator.More(); aListIterator.Next())
 880   {
 881     Remove (aListIterator.Value(), Standard_False);
 882   }
 883
 884   if (theToUpdateViewer)
 885   {
 886     myMainVwr->Update();
 887   }
 888 }
 889
 890 //=======================================================================
 891 //function : ClearPrs
 892 //purpose  :
 893 //=======================================================================
 894 void AIS_InteractiveContext::ClearPrs (const Handle(AIS_InteractiveObject)& theIObj,
 895                                        const Standard_Integer               theMode,
 896                                        const Standard_Boolean               theToUpdateViewer)
 897 {
 898   if (theIObj.IsNull())
 899   {
 900     return;
 901   }
 902
 903   if (!HasOpenedContext())
 904   {
 905     ClearGlobalPrs (theIObj, theMode, theToUpdateViewer);
 906     return;
 907   }
 908
 909   Standard_Boolean wasInCtx = myLocalContexts (myCurLocalIndex)->ClearPrs (theIObj, theMode);
 910   for (AIS_DataMapIteratorOfDataMapOfILC aCtxIter (myLocalContexts); aCtxIter.More(); aCtxIter.Next())
 911   {
 912     if (aCtxIter.Value()->AcceptErase())
 913     {
 914       wasInCtx = aCtxIter.Value()->ClearPrs (theIObj, theMode) || wasInCtx;
 915     }
 916   }
 917   if (!wasInCtx)
 918   {
 919     ClearGlobalPrs (theIObj, theMode, theToUpdateViewer);
 920   }
 921   else if (theToUpdateViewer)
 922   {
 923     myMainVwr->Update();
 924   }
 925 }
 926
 927 //=======================================================================
 928 //function : Hilight
 929 //purpose  :
 930 //=======================================================================
 931 void AIS_InteractiveContext::Hilight (const Handle(AIS_InteractiveObject)& theIObj,
 932                                       const Standard_Boolean               theToUpdateViewer)
 933 {
 934   if (theIObj.IsNull())
 935   {
 936     return;
 937   }
 938
 939   if (!theIObj->HasInteractiveContext())
 940   {
 941     theIObj->SetContext (this);
 942   }
 943   if (!HasOpenedContext())
 944   {
 945     if (!myObjects.IsBound (theIObj))
 946     {
 947       return;
 948     }
 949
 950     Handle(AIS_GlobalStatus) aStatus = myObjects (theIObj);
 951     aStatus->SetHilightStatus (Standard_True);
 952     if (aStatus->GraphicStatus() == AIS_DS_Displayed)
 953     {
 954       Standard_Integer aHilightMode = theIObj->HasHilightMode() ? theIObj->HilightMode() : 0;
 955       myMainPM->Highlight (theIObj, aHilightMode);
 956     }
 957   }
 958   else
 959   {
 960     myLocalContexts (myCurLocalIndex)->Hilight (theIObj);
 961   }
 962
 963   if (theToUpdateViewer)
 964   {
 965     myMainVwr->Update();
 966   }
 967 }
 968 //=======================================================================
 969 //function : Hilight
 970 //purpose  :
 971 //=======================================================================
 972
 973 void AIS_InteractiveContext::HilightWithColor(const Handle(AIS_InteractiveObject)& anIObj,
 974                                               const Quantity_NameOfColor aCol,
 975                                               const Standard_Boolean updateviewer)
 976 {
 977   if(anIObj.IsNull()) return;
 978
 979   if(!anIObj->HasInteractiveContext()) anIObj->SetContext(this);
 980
 981   if (!HasOpenedContext())
 982   {
 983     if(!myObjects.IsBound(anIObj)) return;
 984
 985     const Handle(AIS_GlobalStatus)& aStatus = myObjects(anIObj);
 986     aStatus->SetHilightStatus (Standard_True);
 987
 988     if (aStatus->GraphicStatus() == AIS_DS_Displayed)
 989     {
 990       const Standard_Integer aHilightMode = anIObj->HasHilightMode() ? anIObj->HilightMode() : 0;
 991       myMainPM->Color (anIObj, aCol, aHilightMode);
 992       aStatus->SetHilightColor (aCol);
 993     }
 994   }
 995   else
 996   {
 997     myLocalContexts(myCurLocalIndex)->Hilight(anIObj,aCol);
 998   }
 999   if(updateviewer) myMainVwr->Update();
1000 }
1001
1002 //=======================================================================
1003 //function : Unhilight
1004 //purpose  :
1005 //=======================================================================
1006
1007 void AIS_InteractiveContext::Unhilight(const Handle(AIS_InteractiveObject)& anIObj, const Standard_Boolean updateviewer)
1008 {
1009   if(anIObj.IsNull()) return;
1010
1011   if (!HasOpenedContext())
1012   {
1013     if(!myObjects.IsBound(anIObj)) return;
1014
1015     const Handle(AIS_GlobalStatus)& aStatus = myObjects(anIObj);
1016     aStatus->SetHilightStatus (Standard_False);
1017     aStatus->SetHilightColor(Quantity_NOC_WHITE);
1018
1019     if (aStatus->GraphicStatus() == AIS_DS_Displayed)
1020     {
1021       Standard_Integer aHilightMode = anIObj->HasHilightMode() ? anIObj->HilightMode() : 0;
1022       myMainPM->Unhighlight (anIObj, aHilightMode);
1023     }
1024   }
1025   else
1026   {
1027     myLocalContexts(myCurLocalIndex)->Unhilight(anIObj);
1028   }
1029   if(updateviewer) myMainVwr->Update();
1030 }
1031
1032 //=======================================================================
1033 //function : IsHilighted
1034 //purpose  :
1035 //=======================================================================
1036
1037 Standard_Boolean AIS_InteractiveContext::IsHilighted(const Handle(AIS_InteractiveObject)& anIObj) const
1038 {
1039   if(anIObj.IsNull()) return Standard_False;
1040
1041   if (!HasOpenedContext()){
1042     if(!myObjects.IsBound(anIObj))
1043       return Standard_False;
1044     return myObjects(anIObj)->IsHilighted();
1045   }
1046   AIS_DataMapIteratorOfDataMapOfILC ItM(myLocalContexts);
1047   for(;ItM.More();ItM.Next()){
1048     if(ItM.Value()->IsHilighted(anIObj))
1049       return Standard_True;
1050   }
1051   return Standard_False;
1052 }
1053
1054 Standard_Boolean AIS_InteractiveContext::IsHilighted(const Handle(AIS_InteractiveObject)& anIObj,
1055                                                      Standard_Boolean& WithColor,
1056                                                      Quantity_NameOfColor& TheHiCol) const
1057 {
1058   if(!HasOpenedContext()){
1059     if(myObjects.IsBound(anIObj)){
1060       const Handle(AIS_GlobalStatus)& STAT = myObjects(anIObj);
1061       if(STAT->IsHilighted()){
1062         if(STAT->HilightColor()!=Quantity_NOC_WHITE){
1063           WithColor=Standard_True;
1064           TheHiCol = STAT->HilightColor();
1065         }
1066         else
1067           WithColor = Standard_False;
1068         return Standard_True;
1069       }
1070     }
1071     return Standard_False;
1072   }
1073   Standard_Integer MaxIndex = HighestIndex();
1074   for(Standard_Integer i=MaxIndex;i>=1 ; i--){
1075     if(myLocalContexts.IsBound(i)){
1076       if(myLocalContexts(i)->IsHilighted(anIObj,WithColor,TheHiCol))
1077         return Standard_True;
1078     }
1079
1080   }
1081   return Standard_False;
1082 }
1083
1084 //=======================================================================
1085 //function : IsHilighted
1086 //purpose  : Returns true if the objects global status is set to highlighted.
1087 //           theIsCustomColor flag defines if highlight color is not equal to OCCT's
1088 //           default Quantity_NOC_WHITE color. If theIsCustomColor is true,
1089 //           custom highlight color name will be stored to theCustomColorName
1090 //=======================================================================
1091 Standard_Boolean AIS_InteractiveContext::IsHilighted (const Handle(SelectMgr_EntityOwner)& theOwner,
1092                                                       Standard_Boolean& theIsCustomColor,
1093                                                       Quantity_NameOfColor& theCustomColorName) const
1094 {
1095   if (theOwner.IsNull() || !theOwner->HasSelectable())
1096     return Standard_False;
1097
1098   const Handle(AIS_InteractiveObject) anObj =
1099     Handle(AIS_InteractiveObject)::DownCast (theOwner->Selectable());
1100
1101   if (!myObjects.IsBound (anObj))
1102     return Standard_False;
1103
1104   const Handle(AIS_GlobalStatus)& anObjStatus = myObjects (anObj);
1105   if (anObjStatus->IsHilighted())
1106   {
1107     if (anObjStatus->HilightColor() != Quantity_NOC_WHITE)
1108     {
1109       theIsCustomColor = Standard_True;
1110       theCustomColorName = anObjStatus->HilightColor();
1111     }
1112     else
1113     {
1114       theIsCustomColor = Standard_False;
1115     }
1116
1117     return Standard_True;
1118   }
1119
1120   return Standard_False;
1121 }
1122
1123 //=======================================================================
1124 //function : IsDisplayed
1125 //purpose  :
1126 //=======================================================================
1127
1128 Standard_Boolean AIS_InteractiveContext::IsDisplayed(const Handle(AIS_InteractiveObject)& anIObj) const
1129 {
1130   if(anIObj.IsNull()) return Standard_False;
1131
1132
1133   if(myObjects.IsBound(anIObj))
1134     if(myObjects(anIObj)->GraphicStatus()==AIS_DS_Displayed)
1135       return Standard_True;
1136
1137   AIS_DataMapIteratorOfDataMapOfILC ItM(myLocalContexts);
1138   for(;ItM.More();ItM.Next()){
1139     if(ItM.Value()->IsDisplayed(anIObj))
1140       return Standard_True;
1141   }
1142   return Standard_False;
1143
1144 }
1145
1146 //=======================================================================
1147 //function : IsDisplayed
1148 //purpose  :
1149 //=======================================================================
1150 Standard_Boolean AIS_InteractiveContext::IsDisplayed (const Handle(AIS_InteractiveObject)& theIObj,
1151                                                       const Standard_Integer               theMode) const
1152 {
1153   if (theIObj.IsNull())
1154   {
1155     return Standard_False;
1156   }
1157
1158   if (myObjects.IsBound (theIObj))
1159   {
1160     Handle(AIS_GlobalStatus) aStatus = myObjects (theIObj);
1161     if (aStatus->GraphicStatus() == AIS_DS_Displayed
1162      && aStatus->IsDModeIn (theMode))
1163     {
1164       return Standard_True;
1165     }
1166   }
1167
1168   for (AIS_DataMapIteratorOfDataMapOfILC aCtxIter (myLocalContexts); aCtxIter.More(); aCtxIter.Next())
1169   {
1170     if (aCtxIter.Value()->IsDisplayed (theIObj, theMode))
1171     {
1172       return Standard_True;
1173     }
1174   }
1175   return Standard_False;
1176 }
1177
1178 //=======================================================================
1179 //function : DisplayPriority
1180 //purpose  :
1181 //=======================================================================
1182 Standard_Integer AIS_InteractiveContext::DisplayPriority (const Handle(AIS_InteractiveObject)& theIObj) const
1183 {
1184   if (theIObj.IsNull())
1185   {
1186     return -1;
1187   }
1188   else if (!myObjects.IsBound (theIObj))
1189   {
1190     return 0;
1191   }
1192
1193   Handle(AIS_GlobalStatus) aStatus = myObjects (theIObj);
1194   if (aStatus->GraphicStatus() == AIS_DS_Displayed
1195    || aStatus->GraphicStatus() == AIS_DS_Erased)
1196   {
1197     Standard_Integer aDispMode = theIObj->HasDisplayMode()
1198                                ? theIObj->DisplayMode()
1199                                : (theIObj->AcceptDisplayMode (myDisplayMode)
1200                                 ? myDisplayMode
1201                                 : 0);
1202     return myMainPM->DisplayPriority (theIObj, aDispMode);
1203   }
1204   return 0;
1205 }
1206
1207 //=======================================================================
1208 //function : SetDisplayPriority
1209 //purpose  :
1210 //=======================================================================
1211 void AIS_InteractiveContext::SetDisplayPriority (const Handle(AIS_InteractiveObject)& theIObj,
1212                                                  const Standard_Integer               thePriority)
1213 {
1214   if (theIObj.IsNull())
1215   {
1216     return;
1217   }
1218
1219   if (!theIObj->HasInteractiveContext())
1220   {
1221     theIObj->SetContext (this);
1222   }
1223
1224   if (myObjects.IsBound (theIObj))
1225   {
1226     Handle(AIS_GlobalStatus) aStatus = myObjects (theIObj);
1227     if (aStatus->GraphicStatus() == AIS_DS_Displayed
1228      || aStatus->GraphicStatus() == AIS_DS_Erased)
1229     {
1230       Standard_Integer aDisplayMode = theIObj->HasDisplayMode()
1231                                     ? theIObj->DisplayMode()
1232                                     : (theIObj->AcceptDisplayMode (myDisplayMode)
1233                                      ? myDisplayMode
1234                                      : 0);
1235       myMainPM->SetDisplayPriority (theIObj, aDisplayMode, thePriority);
1236     }
1237   }
1238   else if (HasOpenedContext())
1239   {
1240     myLocalContexts (myCurLocalIndex)->SetDisplayPriority (theIObj, thePriority);
1241   }
1242 }
1243
1244 //=======================================================================
1245 //function : Redisplay
1246 //purpose  :
1247 //=======================================================================
1248 void AIS_InteractiveContext::Redisplay (const Handle(AIS_InteractiveObject)& theIObj,
1249                                         const Standard_Boolean               theToUpdateViewer,
1250                                         const Standard_Boolean               theAllModes)
1251 {
1252   RecomputePrsOnly (theIObj, theToUpdateViewer, theAllModes);
1253   RecomputeSelectionOnly (theIObj);
1254 }
1255
1256 //=======================================================================
1257 //function : Redisplay
1258 //purpose  :
1259 //=======================================================================
1260 void AIS_InteractiveContext::Redisplay (const AIS_KindOfInteractive theKOI,
1261                                         const Standard_Integer    /*theSign*/,
1262                                         const Standard_Boolean      theToUpdateViewer)
1263 {
1264   Standard_Boolean isRedisplayed = Standard_False;
1265   for (AIS_DataMapIteratorOfDataMapOfIOStatus anObjIter (myObjects); anObjIter.More(); anObjIter.Next())
1266   {
1267     Handle(AIS_InteractiveObject) anObj = anObjIter.Key();
1268     if (anObj->Type() != theKOI)
1269     {
1270       continue;
1271     }
1272
1273     Redisplay (anObj, Standard_False);
1274     isRedisplayed = anObjIter.Value()->GraphicStatus() == AIS_DS_Displayed
1275                  || isRedisplayed;
1276   }
1277
1278   if (theToUpdateViewer
1279    && isRedisplayed)
1280   {
1281     myMainVwr->Update();
1282   }
1283 }
1284
1285 //=======================================================================
1286 //function : RecomputePrsOnly
1287 //purpose  :
1288 //=======================================================================
1289 void AIS_InteractiveContext::RecomputePrsOnly (const Handle(AIS_InteractiveObject)& theIObj,
1290                                                const Standard_Boolean               theToUpdateViewer,
1291                                                const Standard_Boolean               theAllModes)
1292 {
1293   if (theIObj.IsNull())
1294   {
1295     return;
1296   }
1297
1298   theIObj->Update (theAllModes);
1299   if (!theToUpdateViewer)
1300   {
1301     return;
1302   }
1303
1304   if (HasOpenedContext()
1305    || (myObjects.IsBound (theIObj)
1306     && myObjects (theIObj)->GraphicStatus() == AIS_DS_Displayed))
1307   {
1308     myMainVwr->Update();
1309   }
1310 }
1311 //=======================================================================
1312 //function : RecomputeSelectionOnly
1313 //purpose  :
1314 //=======================================================================
1315 void AIS_InteractiveContext::RecomputeSelectionOnly (const Handle(AIS_InteractiveObject)& theIO)
1316 {
1317   if (theIO.IsNull())
1318   {
1319     return;
1320   }
1321
1322   mgrSelector->RecomputeSelection (theIO);
1323
1324   if (HasOpenedContext())
1325   {
1326     for (Standard_Integer aContextIdx = 1; aContextIdx <= myLocalContexts.Extent(); aContextIdx++)
1327     {
1328       myLocalContexts (aContextIdx)->ClearOutdatedSelection (theIO, Standard_False);
1329     }
1330     return;
1331   }
1332
1333   if (!myObjects.IsBound (theIO) ||
1334       myObjects (theIO)->GraphicStatus() != AIS_DS_Displayed)
1335   {
1336     return;
1337   }
1338
1339   TColStd_ListOfInteger aModes;
1340   ActivatedModes (theIO, aModes);
1341   TColStd_ListIteratorOfListOfInteger aModesIter (aModes);
1342   for (; aModesIter.More(); aModesIter.Next())
1343   {
1344     mgrSelector->Activate (theIO, aModesIter.Value(), myMainSel);
1345   }
1346 }
1347
1348 //=======================================================================
1349 //function : Update
1350 //purpose  :
1351 //=======================================================================
1352 void AIS_InteractiveContext::Update (const Handle(AIS_InteractiveObject)& theIObj,
1353                                      const Standard_Boolean               theUpdateViewer)
1354 {
1355   if (theIObj.IsNull())
1356   {
1357     return;
1358   }
1359
1360   TColStd_ListOfInteger aPrsModes;
1361   theIObj->ToBeUpdated (aPrsModes);
1362   for (TColStd_ListIteratorOfListOfInteger aPrsModesIt (aPrsModes); aPrsModesIt.More(); aPrsModesIt.Next())
1363   {
1364     theIObj->Update (aPrsModesIt.Value(), Standard_False);
1365   }
1366
1367   mgrSelector->Update(theIObj);
1368
1369   for (Standard_Integer aContextIdx = 1; aContextIdx <= myLocalContexts.Extent(); aContextIdx++)
1370   {
1371     myLocalContexts (aContextIdx)->ClearOutdatedSelection (theIObj, Standard_False);
1372   }
1373
1374   if (theUpdateViewer)
1375   {
1376     if (!myObjects.IsBound (theIObj))
1377     {
1378       return;
1379     }
1380
1381     switch (myObjects (theIObj)->GraphicStatus())
1382     {
1383       case AIS_DS_Displayed:
1384       case AIS_DS_Temporary:
1385         myMainVwr->Update();
1386         break;
1387       default:
1388         break;
1389     }
1390   }
1391 }
1392
1393 //=======================================================================
1394 //function : SetLocation
1395 //purpose  :
1396 //=======================================================================
1397 void AIS_InteractiveContext::SetLocation (const Handle(AIS_InteractiveObject)& theIObj,
1398                                           const TopLoc_Location&               theLoc)
1399 {
1400   if (theIObj.IsNull())
1401   {
1402     return;
1403   }
1404
1405   if (theIObj->HasTransformation()
1406    && theLoc.IsIdentity())
1407   {
1408     theIObj->ResetTransformation();
1409     mgrSelector->Update (theIObj, Standard_False);
1410     return;
1411   }
1412   else if (theLoc.IsIdentity())
1413   {
1414     return;
1415   }
1416
1417   // first reset the previous location to properly clean everything...
1418   if (theIObj->HasTransformation())
1419   {
1420     theIObj->ResetTransformation();
1421   }
1422
1423   theIObj->SetLocalTransformation (theLoc.Transformation());
1424
1425   if (!HasOpenedContext())
1426   {
1427     mgrSelector->Update (theIObj, Standard_False);
1428   }
1429   else
1430   {
1431     Handle(StdSelect_ViewerSelector3d) aTempSel = myLocalContexts (myCurLocalIndex)->MainSelector();
1432     mgrSelector->Update (theIObj, aTempSel, Standard_False);
1433   }
1434
1435   // if the object or its part is highlighted dynamically, it is necessary to apply location transformation
1436   // to its highlight structure immediately
1437   if (!myLastPicked.IsNull() && myLastPicked->Selectable() == theIObj)
1438   {
1439     myLastPicked->UpdateHighlightTrsf (myMainVwr,
1440                                        myMainPM,
1441                                        theIObj->HasDisplayMode() ? theIObj->DisplayMode() : 0);
1442   }
1443 }
1444
1445 //=======================================================================
1446 //function : ResetLocation
1447 //purpose  :
1448 //=======================================================================
1449 void AIS_InteractiveContext::ResetLocation (const Handle(AIS_InteractiveObject)& theIObj)
1450 {
1451   if (theIObj.IsNull())
1452   {
1453     return;
1454   }
1455
1456   theIObj->ResetTransformation();
1457   mgrSelector->Update (theIObj, Standard_False);
1458 }
1459
1460 //=======================================================================
1461 //function : HasLocation
1462 //purpose  :
1463 //=======================================================================
1464 Standard_Boolean AIS_InteractiveContext::HasLocation (const Handle(AIS_InteractiveObject)& theIObj) const
1465 {
1466   return !theIObj.IsNull()
1467        && theIObj->HasTransformation();
1468 }
1469
1470 //=======================================================================
1471 //function : Location
1472 //purpose  :
1473 //=======================================================================
1474 TopLoc_Location AIS_InteractiveContext::Location (const Handle(AIS_InteractiveObject)& theIObj) const
1475 {
1476   return theIObj->Transformation();
1477 }
1478
1479 //=======================================================================
1480 //function : SetDeviationCoefficient
1481 //purpose  :
1482 //=======================================================================
1483 void AIS_InteractiveContext::SetDeviationCoefficient (const Standard_Real theCoefficient)
1484 {
1485   myDefaultDrawer->SetDeviationCoefficient (theCoefficient);
1486 }
1487
1488 //=======================================================================
1489 //function : SetDeviationAngle
1490 //purpose  :
1491 //=======================================================================
1492 void AIS_InteractiveContext::SetDeviationAngle (const Standard_Real theAngle)
1493 {
1494   myDefaultDrawer->SetDeviationAngle (theAngle);
1495 }
1496
1497 //=======================================================================
1498 //function : DeviationAngle
1499 //purpose  : Gets  deviationAngle
1500 //=======================================================================
1501 Standard_Real AIS_InteractiveContext::DeviationAngle() const
1502 {
1503   return myDefaultDrawer->DeviationAngle();
1504 }
1505
1506 //=======================================================================
1507 //function : DeviationCoefficient
1508 //purpose  :
1509 //=======================================================================
1510 Standard_Real AIS_InteractiveContext::DeviationCoefficient() const
1511 {
1512   return myDefaultDrawer->DeviationCoefficient();
1513 }
1514
1515 //=======================================================================
1516 //function : SetHLRDeviationCoefficient
1517 //purpose  :
1518 //=======================================================================
1519 void AIS_InteractiveContext::SetHLRDeviationCoefficient (const Standard_Real theCoefficient)
1520 {
1521   myDefaultDrawer->SetHLRDeviationCoefficient (theCoefficient);
1522 }
1523
1524 //=======================================================================
1525 //function : HLRDeviationCoefficient
1526 //purpose  :
1527 //=======================================================================
1528 Standard_Real AIS_InteractiveContext::HLRDeviationCoefficient() const
1529 {
1530   return myDefaultDrawer->HLRDeviationCoefficient();
1531 }
1532
1533 //=======================================================================
1534 //function : SetHLRAngle
1535 //purpose  :
1536 //=======================================================================
1537 void AIS_InteractiveContext::SetHLRAngle (const Standard_Real theAngle)
1538 {
1539   myDefaultDrawer->SetHLRAngle (theAngle);
1540 }
1541
1542 //=======================================================================
1543 //function : SetHLRAngleAndDeviation
1544 //purpose  : compute with anangle a HLRAngle and a HLRDeviationCoefficient
1545 //           and set them in myHLRAngle and in myHLRDeviationCoefficient
1546 //           of myDefaultDrawer
1547 //=======================================================================
1548 void AIS_InteractiveContext::SetHLRAngleAndDeviation (const Standard_Real theAngle)
1549 {
1550   Standard_Real anOutAngl, anOutDefl;
1551   HLRBRep::PolyHLRAngleAndDeflection (theAngle, anOutAngl, anOutDefl);
1552
1553   myDefaultDrawer->SetHLRAngle                (anOutAngl);
1554   myDefaultDrawer->SetHLRDeviationCoefficient (anOutDefl);
1555 }
1556
1557 //=======================================================================
1558 //function : HLRAngle
1559 //purpose  :
1560 //=======================================================================
1561 Standard_Real AIS_InteractiveContext::HLRAngle() const
1562 {
1563   return myDefaultDrawer->HLRAngle();
1564 }
1565
1566 //=======================================================================
1567 //function : SetDisplayMode
1568 //purpose  :
1569 //=======================================================================
1570 void AIS_InteractiveContext::SetDisplayMode (const AIS_DisplayMode  theMode,
1571                                              const Standard_Boolean theToUpdateViewer)
1572 {
1573   if (theMode == myDisplayMode)
1574   {
1575     return;
1576   }
1577
1578   for (AIS_DataMapIteratorOfDataMapOfIOStatus anObjIter (myObjects); anObjIter.More(); anObjIter.Next())
1579   {
1580     Handle(AIS_InteractiveObject) anObj = anObjIter.Key();
1581     Standard_Boolean toProcess = anObj->IsKind (STANDARD_TYPE(AIS_Shape))
1582                               || anObj->IsKind (STANDARD_TYPE(AIS_ConnectedInteractive))
1583                               || anObj->IsKind (STANDARD_TYPE(AIS_MultipleConnectedInteractive));
1584
1585     if (!toProcess
1586      ||  anObj->HasDisplayMode()
1587      || !anObj->AcceptDisplayMode (theMode))
1588     {
1589       continue;
1590     }
1591
1592     Handle(AIS_GlobalStatus) aStatus = anObjIter.Value();
1593     if (aStatus->IsDModeIn (myDisplayMode))
1594     {
1595       aStatus->RemoveDisplayMode (myDisplayMode);
1596     }
1597
1598     aStatus->AddDisplayMode (theMode);
1599     if (aStatus->GraphicStatus() == AIS_DS_Displayed)
1600     {
1601       myMainPM->Display (anObj, theMode);
1602       if (!myLastPicked.IsNull() && myLastPicked->Selectable() == anObj)
1603       {
1604         myMainPM->BeginImmediateDraw();
1605         myMainPM->Unhighlight (anObj, myDisplayMode);
1606         myMainPM->EndImmediateDraw (myMainVwr);
1607       }
1608       if (aStatus->IsSubIntensityOn())
1609       {
1610         myMainPM->Color (anObj, mySubIntensity, theMode);
1611       }
1612       myMainPM->SetVisibility (anObj, myDisplayMode, Standard_False);
1613     }
1614   }
1615
1616   myDisplayMode = theMode;
1617   if (theToUpdateViewer)
1618   {
1619     myMainVwr->Update();
1620   }
1621 }
1622
1623 //=======================================================================
1624 //function : SetDisplayMode
1625 //purpose  :
1626 //=======================================================================
1627 void AIS_InteractiveContext::SetDisplayMode (const Handle(AIS_InteractiveObject)& theIObj,
1628                                              const Standard_Integer               theMode,
1629                                              const Standard_Boolean               theToUpdateViewer)
1630 {
1631   if (!theIObj->HasInteractiveContext())
1632   {
1633     theIObj->SetContext(this);
1634   }
1635
1636   if (!myObjects.IsBound (theIObj))
1637   {
1638     theIObj->SetDisplayMode (theMode);
1639     return;
1640   }
1641   else if (!theIObj->AcceptDisplayMode (theMode))
1642   {
1643     return;
1644   }
1645
1646   Handle(AIS_GlobalStatus) aStatus = myObjects (theIObj);
1647   if (aStatus->GraphicStatus() != AIS_DS_Displayed)
1648   {
1649     theIObj->SetDisplayMode (theMode);
1650     return;
1651   }
1652
1653   // erase presentations for all display modes different from <aMode>
1654   TColStd_ListOfInteger aModesToRemove;
1655   for (TColStd_ListIteratorOfListOfInteger aDispModeIter (aStatus->DisplayedModes()); aDispModeIter.More(); aDispModeIter.Next())
1656   {
1657     const Standard_Integer anOldMode = aDispModeIter.Value();
1658     if (anOldMode != theMode)
1659     {
1660       aModesToRemove.Append (anOldMode);
1661       if (myMainPM->IsHighlighted (theIObj, anOldMode))
1662       {
1663         myMainPM->Unhighlight (theIObj, anOldMode);
1664       }
1665       myMainPM->SetVisibility (theIObj, anOldMode, Standard_False);
1666     }
1667   }
1668
1669   for (TColStd_ListIteratorOfListOfInteger aRemModeIter (aModesToRemove); aRemModeIter.More(); aRemModeIter.Next())
1670   {
1671     aStatus->RemoveDisplayMode (aRemModeIter.Value());
1672   }
1673
1674   if (!aStatus->IsDModeIn (theMode))
1675   {
1676     aStatus->AddDisplayMode (theMode);
1677   }
1678
1679   myMainPM->Display (theIObj, theMode);
1680   Standard_Integer aDispMode, aHiMode, aSelMode;
1681   GetDefModes (theIObj, aDispMode, aHiMode, aSelMode);
1682   if (aStatus->IsHilighted())
1683   {
1684     myMainPM->Highlight (theIObj, aHiMode);
1685   }
1686   if (aStatus->IsSubIntensityOn())
1687   {
1688     myMainPM->Color (theIObj, mySubIntensity, theMode);
1689   }
1690
1691   if (theToUpdateViewer)
1692   {
1693     myMainVwr->Update();
1694   }
1695   theIObj->SetDisplayMode (theMode);
1696 }
1697
1698 //=======================================================================
1699 //function : UnsetDisplayMode
1700 //purpose  :
1701 //=======================================================================
1702 void AIS_InteractiveContext::UnsetDisplayMode (const Handle(AIS_InteractiveObject)& theIObj,
1703                                                const Standard_Boolean               theToUpdateViewer)
1704 {
1705   if (theIObj.IsNull()
1706   || !theIObj->HasDisplayMode())
1707   {
1708     return;
1709   }
1710
1711   if (!myObjects.IsBound (theIObj))
1712   {
1713     theIObj->UnsetDisplayMode();
1714     return;
1715   }
1716
1717   const Standard_Integer anOldMode = theIObj->DisplayMode();
1718   if (myDisplayMode == anOldMode)
1719   {
1720     return;
1721   }
1722
1723   const Handle(AIS_GlobalStatus)& aStatus = myObjects (theIObj);
1724   aStatus->RemoveDisplayMode (anOldMode);
1725   if (!aStatus->IsDModeIn(myDisplayMode))
1726   {
1727     aStatus->AddDisplayMode (myDisplayMode);
1728   }
1729
1730   if (aStatus->GraphicStatus() == AIS_DS_Displayed)
1731   {
1732     if (myMainPM->IsHighlighted (theIObj, anOldMode))
1733     {
1734       myMainPM->Unhighlight (theIObj, anOldMode);
1735     }
1736     myMainPM->SetVisibility (theIObj, anOldMode, Standard_False);
1737     myMainPM->Display (theIObj, myDisplayMode);
1738
1739     Standard_Integer aDispMode, aHiMode, aSelMode;
1740     GetDefModes (theIObj, aDispMode, aHiMode, aSelMode);
1741     if (aStatus->IsHilighted())
1742     {
1743       myMainPM->Highlight (theIObj, aHiMode);
1744     }
1745     if (aStatus->IsSubIntensityOn())
1746     {
1747       myMainPM->Color (theIObj, mySubIntensity, myDisplayMode);
1748     }
1749
1750     if (theToUpdateViewer)
1751     {
1752       myMainVwr->Update();
1753     }
1754   }
1755
1756   theIObj->UnsetDisplayMode();
1757 }
1758
1759 //=======================================================================
1760 //function : SetCurrentFacingModel
1761 //purpose  :
1762 //=======================================================================
1763 void AIS_InteractiveContext::SetCurrentFacingModel (const Handle(AIS_InteractiveObject)& theIObj,
1764                                                     const Aspect_TypeOfFacingModel       theModel)
1765 {
1766   if (!theIObj.IsNull())
1767   {
1768     theIObj->SetCurrentFacingModel (theModel);
1769   }
1770 }
1771
1772 //=======================================================================
1773 //function : redisplayPrsRecModes
1774 //purpose  :
1775 //=======================================================================
1776 void AIS_InteractiveContext::redisplayPrsRecModes (const Handle(AIS_InteractiveObject)& theIObj,
1777                                                    const Standard_Boolean               theToUpdateViewer)
1778 {
1779   if (theIObj->RecomputeEveryPrs())
1780   {
1781     theIObj->Update (Standard_True);
1782     theIObj->UpdateSelection();
1783   }
1784   else
1785   {
1786     for (TColStd_ListIteratorOfListOfInteger aModes (theIObj->ListOfRecomputeModes()); aModes.More(); aModes.Next())
1787     {
1788       theIObj->Update (aModes.Value(), Standard_False);
1789     }
1790     theIObj->UpdateSelection();
1791     theIObj->SetRecomputeOk();
1792   }
1793
1794   if (theToUpdateViewer)
1795   {
1796     UpdateCurrentViewer();
1797   }
1798 }
1799
1800 //=======================================================================
1801 //function : redisplayPrsModes
1802 //purpose  :
1803 //=======================================================================
1804 void AIS_InteractiveContext::redisplayPrsModes (const Handle(AIS_InteractiveObject)& theIObj,
1805                                                 const Standard_Boolean               theToUpdateViewer)
1806 {
1807   if (theIObj->RecomputeEveryPrs())
1808   {
1809     theIObj->Update (Standard_True);
1810     theIObj->UpdateSelection();
1811   }
1812   else
1813   {
1814     TColStd_ListOfInteger aModes;
1815     theIObj->ToBeUpdated (aModes);
1816     for (TColStd_ListIteratorOfListOfInteger aModeIter (aModes); aModeIter.More(); aModeIter.Next())
1817     {
1818       theIObj->Update (aModeIter.Value(), Standard_False);
1819     }
1820     theIObj->SetRecomputeOk();
1821   }
1822
1823   if (theToUpdateViewer)
1824   {
1825     UpdateCurrentViewer();
1826   }
1827 }
1828
1829 //=======================================================================
1830 //function : SetColor
1831 //purpose  :
1832 //=======================================================================
1833 void AIS_InteractiveContext::SetColor (const Handle(AIS_InteractiveObject)& theIObj,
1834                                        const Quantity_NameOfColor           theColor,
1835                                        const Standard_Boolean               theToUpdateViewer)
1836 {
1837   SetColor (theIObj, Quantity_Color(theColor), theToUpdateViewer);
1838 }
1839
1840 //=======================================================================
1841 //function : SetColor
1842 //purpose  :
1843 //=======================================================================
1844 void AIS_InteractiveContext::SetColor (const Handle(AIS_InteractiveObject)& theIObj,
1845                                        const Quantity_Color&                theColor,
1846                                        const Standard_Boolean               theToUpdateViewer)
1847 {
1848   if (theIObj.IsNull())
1849   {
1850     return;
1851   }
1852
1853   if (!theIObj->HasInteractiveContext())
1854   {
1855     theIObj->SetContext (this);
1856   }
1857   theIObj->SetColor (theColor);
1858   redisplayPrsRecModes (theIObj, theToUpdateViewer);
1859 }
1860
1861 //=======================================================================
1862 //function : SetIsoOnTriangulation
1863 //purpose  :
1864 //=======================================================================
1865 void AIS_InteractiveContext::IsoOnTriangulation (const Standard_Boolean theIsEnabled,
1866                                                  const Handle(AIS_InteractiveObject)& theObject)
1867 {
1868   if (theObject.IsNull())
1869   {
1870     return;
1871   }
1872
1873   theObject->SetIsoOnTriangulation (theIsEnabled);
1874 }
1875
1876 //=======================================================================
1877 //function : SetDeviationCoefficient
1878 //purpose  :
1879 //=======================================================================
1880 void AIS_InteractiveContext::SetDeviationCoefficient (const Handle(AIS_InteractiveObject)& theIObj,
1881                                                       const Standard_Real                  theCoefficient,
1882                                                       const Standard_Boolean               theToUpdateViewer)
1883 {
1884   if (theIObj.IsNull())
1885   {
1886     return;
1887   }
1888
1889   if (!theIObj->HasInteractiveContext())
1890   {
1891     theIObj->SetContext (this);
1892   }
1893
1894   // to be modified after the related methods of AIS_Shape are passed to InteractiveObject
1895   if (theIObj->Type() != AIS_KOI_Object
1896    && theIObj->Type() != AIS_KOI_Shape)
1897   {
1898     return;
1899   }
1900   else if (theIObj->Signature() != 0)
1901   {
1902     return;
1903   }
1904
1905   Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast (theIObj);
1906   aShape->SetOwnDeviationCoefficient (theCoefficient);
1907   redisplayPrsModes (theIObj, theToUpdateViewer);
1908 }
1909
1910 //=======================================================================
1911 //function : SetHLRDeviationCoefficient
1912 //purpose  :
1913 //=======================================================================
1914 void AIS_InteractiveContext::SetHLRDeviationCoefficient (const Handle(AIS_InteractiveObject)& theIObj,
1915                                                          const Standard_Real                  theCoefficient,
1916                                                          const Standard_Boolean               theToUpdateViewer)
1917 {
1918   if (theIObj.IsNull())
1919   {
1920     return;
1921   }
1922
1923   if (!theIObj->HasInteractiveContext())
1924   {
1925     theIObj->SetContext (this);
1926   }
1927
1928   // To be modified after the related methods of AIS_Shape are passed to InteractiveObject
1929   if (theIObj->Type() != AIS_KOI_Object
1930    && theIObj->Type() != AIS_KOI_Shape)
1931   {
1932     return;
1933   }
1934   else if (theIObj->Signature() != 0)
1935   {
1936     return;
1937   }
1938
1939   Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast (theIObj);
1940   aShape->SetOwnHLRDeviationCoefficient (theCoefficient);
1941   redisplayPrsModes (theIObj, theToUpdateViewer);
1942 }
1943
1944 //=======================================================================
1945 //function : SetDeviationAngle
1946 //purpose  :
1947 //=======================================================================
1948 void AIS_InteractiveContext::SetDeviationAngle (const Handle(AIS_InteractiveObject)& theIObj,
1949                                                 const Standard_Real                  theAngle,
1950                                                 const Standard_Boolean               theToUpdateViewer)
1951 {
1952   if (theIObj.IsNull())
1953   {
1954     return;
1955   }
1956
1957   if (!theIObj->HasInteractiveContext())
1958   {
1959     theIObj->SetContext (this);
1960   }
1961
1962   // To be modified after the related methods of AIS_Shape are passed to InteractiveObject
1963   if (theIObj->Type() != AIS_KOI_Shape)
1964   {
1965     return;
1966   }
1967   else if (theIObj->Signature() != 0)
1968   {
1969     return;
1970   }
1971
1972   Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast (theIObj);
1973   aShape->SetOwnDeviationAngle (theAngle);
1974   redisplayPrsModes (theIObj, theToUpdateViewer);
1975 }
1976
1977 //=======================================================================
1978 //function : SetAngleAndDeviation
1979 //purpose  :
1980 //=======================================================================
1981 void AIS_InteractiveContext::SetAngleAndDeviation (const Handle(AIS_InteractiveObject)& theIObj,
1982                                                    const Standard_Real                  theAngle,
1983                                                    const Standard_Boolean               theToUpdateViewer)
1984 {
1985   if (theIObj.IsNull())
1986   {
1987     return;
1988   }
1989
1990   if (!theIObj->HasInteractiveContext())
1991   {
1992     theIObj->SetContext (this);
1993   }
1994
1995   // To be modified after the related methods of AIS_Shape are passed to InteractiveObject
1996   if (theIObj->Type() != AIS_KOI_Shape)
1997   {
1998     return;
1999   }
2000   if (theIObj->Signature() != 0)
2001   {
2002     return;
2003   }
2004
2005   Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast (theIObj);
2006   aShape->SetAngleAndDeviation (theAngle);
2007
2008   if (theIObj->RecomputeEveryPrs())
2009   {
2010     theIObj->Update (Standard_True);
2011     theIObj->UpdateSelection();
2012   }
2013   else
2014   {
2015     Update (theIObj, theToUpdateViewer);
2016   }
2017 }
2018
2019 //=======================================================================
2020 //function : SetHLRAngleAndDeviation
2021 //purpose  :
2022 //=======================================================================
2023 void AIS_InteractiveContext::SetHLRAngleAndDeviation (const Handle(AIS_InteractiveObject)& theIObj,
2024                                                       const Standard_Real                  theAngle,
2025                                                       const Standard_Boolean               theToUpdateViewer)
2026 {
2027   if (theIObj.IsNull())
2028   {
2029     return;
2030   }
2031
2032   if (!theIObj->HasInteractiveContext())
2033   {
2034     theIObj->SetContext (this);
2035   }
2036
2037   // To be modified after the related methods of AIS_Shape are passed to InteractiveObject
2038   if (theIObj->Type() != AIS_KOI_Shape)
2039   {
2040     return;
2041   }
2042   if (theIObj->Signature() != 0)
2043   {
2044     return;
2045   }
2046   Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast (theIObj);
2047   aShape->SetHLRAngleAndDeviation (theAngle);
2048   redisplayPrsModes (theIObj, theToUpdateViewer);
2049 }
2050
2051 //=======================================================================
2052 //function : SetHLRDeviationAngle
2053 //purpose  :
2054 //=======================================================================
2055 void AIS_InteractiveContext::SetHLRDeviationAngle (const Handle(AIS_InteractiveObject)& theIObj,
2056                                                    const Standard_Real                  theAngle,
2057                                                    const Standard_Boolean               theToUpdateViewer)
2058 {
2059   if (theIObj.IsNull())
2060   {
2061     return;
2062   }
2063
2064   if (!theIObj->HasInteractiveContext())
2065   {
2066     theIObj->SetContext (this);
2067   }
2068
2069   // To be modified after the related methods of AIS_Shape are passed to InteractiveObject
2070   if (theIObj->Type() != AIS_KOI_Shape)
2071   {
2072     return;
2073   }
2074   if (theIObj->Signature() != 0)
2075   {
2076     return;
2077   }
2078   Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast (theIObj);
2079   aShape->SetOwnHLRDeviationAngle (theAngle);
2080   redisplayPrsModes (theIObj, theToUpdateViewer);
2081 }
2082
2083 //=======================================================================
2084 //function : UnsetColor
2085 //purpose  :
2086 //=======================================================================
2087 void AIS_InteractiveContext::UnsetColor (const Handle(AIS_InteractiveObject)& theIObj,
2088                                          const Standard_Boolean               theToUpdateViewer)
2089 {
2090   if (theIObj.IsNull())
2091   {
2092     return;
2093   }
2094
2095   theIObj->UnsetColor();
2096   redisplayPrsRecModes (theIObj, theToUpdateViewer);
2097 }
2098
2099 //=======================================================================
2100 //function : HasColor
2101 //purpose  :
2102 //=======================================================================
2103 Standard_Boolean AIS_InteractiveContext::HasColor (const Handle(AIS_InteractiveObject)& theIObj) const
2104 {
2105   return theIObj->HasColor();
2106 }
2107
2108 //=======================================================================
2109 //function : Color
2110 //purpose  :
2111 //=======================================================================
2112 Quantity_NameOfColor AIS_InteractiveContext::Color (const Handle(AIS_InteractiveObject)& theIObj) const
2113 {
2114   return theIObj->Color();
2115 }
2116
2117 //=======================================================================
2118 //function : Color
2119 //purpose  :
2120 //=======================================================================
2121 void AIS_InteractiveContext::Color (const Handle(AIS_InteractiveObject)& theIObj,
2122                                     Quantity_Color&                      theColor) const
2123 {
2124   theIObj->Color (theColor);
2125 }
2126
2127 //=======================================================================
2128 //function : Width
2129 //purpose  :
2130 //=======================================================================
2131 Standard_Real AIS_InteractiveContext::Width (const Handle(AIS_InteractiveObject)& theIObj) const
2132 {
2133   return theIObj->Width();
2134 }
2135
2136 //=======================================================================
2137 //function : SetWidth
2138 //purpose  :
2139 //=======================================================================
2140 void AIS_InteractiveContext::SetWidth (const Handle(AIS_InteractiveObject)& theIObj,
2141                                        const Standard_Real                  theWidth,
2142                                        const Standard_Boolean               theToUpdateViewer)
2143 {
2144   if (theIObj.IsNull())
2145   {
2146     return;
2147   }
2148
2149   if (!theIObj->HasInteractiveContext())
2150   {
2151     theIObj->SetContext (this);
2152   }
2153
2154   theIObj->SetWidth (theWidth);
2155   redisplayPrsRecModes (theIObj, theToUpdateViewer);
2156   if (!myLastinMain.IsNull() && myLastinMain->Selectable() == theIObj)
2157   {
2158     if (myLastinMain->IsAutoHilight())
2159     {
2160       const Standard_Integer aHiMode =
2161         theIObj->HasHilightMode() ? theIObj->HilightMode() : 0;
2162       myLastinMain->HilightWithColor (myMainPM, myLastinMain->IsSelected() ? mySelectionColor : myHilightColor, aHiMode);
2163     }
2164     else
2165     {
2166       theIObj->HilightOwnerWithColor (myMainPM, myLastinMain->IsSelected() ? mySelectionColor : myHilightColor, myLastinMain);
2167     }
2168   }
2169 }
2170
2171 //=======================================================================
2172 //function : UnsetWidth
2173 //purpose  :
2174 //=======================================================================
2175 void AIS_InteractiveContext::UnsetWidth (const Handle(AIS_InteractiveObject)& theIObj,
2176                                          const Standard_Boolean               theToUpdateViewer)
2177 {
2178   if (theIObj.IsNull())
2179   {
2180     return;
2181   }
2182
2183   theIObj->UnsetWidth();
2184   redisplayPrsRecModes (theIObj, theToUpdateViewer);
2185 }
2186
2187 //=======================================================================
2188 //function : SetMaterial
2189 //purpose  :
2190 //=======================================================================
2191 void AIS_InteractiveContext::SetMaterial (const Handle(AIS_InteractiveObject)& theIObj,
2192                                           const Graphic3d_NameOfMaterial       theName,
2193                                           const Standard_Boolean               theToUpdateViewer)
2194 {
2195   if (theIObj.IsNull())
2196   {
2197     return;
2198   }
2199
2200   if (!theIObj->HasInteractiveContext())
2201   {
2202     theIObj->SetContext (this);
2203   }
2204
2205   theIObj->SetMaterial (theName);
2206   redisplayPrsRecModes (theIObj, theToUpdateViewer);
2207 }
2208
2209 //=======================================================================
2210 //function : UnsetMaterial
2211 //purpose  :
2212 //=======================================================================
2213 void AIS_InteractiveContext::UnsetMaterial (const Handle(AIS_InteractiveObject)& theIObj,
2214                                             const Standard_Boolean               theToUpdateViewer)
2215 {
2216   if (theIObj.IsNull())
2217   {
2218     return;
2219   }
2220   theIObj->UnsetMaterial();
2221   redisplayPrsRecModes (theIObj, theToUpdateViewer);
2222 }
2223
2224 //=======================================================================
2225 //function : SetTransparency
2226 //purpose  :
2227 //=======================================================================
2228 void AIS_InteractiveContext::SetTransparency (const Handle(AIS_InteractiveObject)& theIObj,
2229                                               const Standard_Real                  theValue,
2230                                               const Standard_Boolean               theToUpdateViewer)
2231 {
2232   if (theIObj.IsNull())
2233   {
2234     return;
2235   }
2236
2237   if (!theIObj->HasInteractiveContext())
2238   {
2239     theIObj->SetContext (this);
2240   }
2241
2242   if (!theIObj->IsTransparent()
2243     && theValue <= 0.05)
2244   {
2245     return;
2246   }
2247
2248   if (theValue <= 0.05)
2249   {
2250     UnsetTransparency (theIObj, theToUpdateViewer);
2251     return;
2252   }
2253
2254   theIObj->SetTransparency (theValue);
2255   redisplayPrsRecModes (theIObj, theToUpdateViewer);
2256 }
2257
2258 //=======================================================================
2259 //function : UnsetTransparency
2260 //purpose  :
2261 //=======================================================================
2262 void AIS_InteractiveContext::UnsetTransparency (const Handle(AIS_InteractiveObject)& theIObj,
2263                                                 const Standard_Boolean               theToUpdateViewer)
2264 {
2265   if (theIObj.IsNull())
2266   {
2267     return;
2268   }
2269
2270   theIObj->UnsetTransparency();
2271   redisplayPrsRecModes (theIObj, theToUpdateViewer);
2272 }
2273
2274 //=======================================================================
2275 //function : SetSelectedAspect
2276 //purpose  :
2277 //=======================================================================
2278 void AIS_InteractiveContext::SetSelectedAspect (const Handle(Prs3d_BasicAspect)& theAspect,
2279                                                 const Standard_Boolean           theIsGlobalChange,
2280                                                 const Standard_Boolean           theToUpdateViewer)
2281 {
2282   if (HasOpenedContext())
2283   {
2284     return;
2285   }
2286
2287   Standard_Boolean isFound = Standard_False;
2288   Handle(AIS_Selection) aSelIter = AIS_Selection::Selection (myCurrentName.ToCString());
2289   for (aSelIter->Init(); aSelIter->More(); aSelIter->Next())
2290   {
2291     isFound = Standard_True;
2292     Handle(AIS_InteractiveObject) anObj = Handle(AIS_InteractiveObject)::DownCast (aSelIter->Value());
2293     anObj->SetAspect (theAspect, theIsGlobalChange);
2294   }
2295
2296   if (isFound
2297    && theToUpdateViewer)
2298   {
2299     myMainVwr->Update();
2300   }
2301 }
2302
2303 //=======================================================================
2304 //function : SetLocalAttributes
2305 //purpose  :
2306 //=======================================================================
2307 void AIS_InteractiveContext::SetLocalAttributes (const Handle(AIS_InteractiveObject)& theIObj,
2308                                                  const Handle(Prs3d_Drawer)&          theDrawer,
2309                                                  const Standard_Boolean               theToUpdateViewer)
2310 {
2311   if (theIObj.IsNull())
2312   {
2313     return;
2314   }
2315
2316   if (!theIObj->HasInteractiveContext())
2317   {
2318     theIObj->SetContext (this);
2319   }
2320
2321   theIObj->SetAttributes (theDrawer);
2322   Update (theIObj, theToUpdateViewer);
2323 }
2324
2325 //=======================================================================
2326 //function : UnsetLocalAttributes
2327 //purpose  :
2328 //=======================================================================
2329 void AIS_InteractiveContext::UnsetLocalAttributes (const Handle(AIS_InteractiveObject)& theIObj,
2330                                                    const Standard_Boolean               theToUpdateViewer)
2331 {
2332   if (theIObj.IsNull())
2333   {
2334     return;
2335   }
2336
2337   if (!theIObj->HasInteractiveContext())
2338   {
2339     theIObj->SetContext (this);
2340   }
2341   theIObj->UnsetAttributes();
2342   Update (theIObj, theToUpdateViewer);
2343 }
2344
2345 //=======================================================================
2346 //function : Status
2347 //purpose  :
2348 //=======================================================================
2349 void AIS_InteractiveContext::Status (const Handle(AIS_InteractiveObject)& theIObj,
2350                                      TCollection_ExtendedString&          theStatus) const
2351 {
2352   theStatus = "";
2353   if (theIObj.IsNull()
2354   || !myObjects.IsBound (theIObj))
2355   {
2356     return;
2357   }
2358
2359   theStatus += "\t ____________________________________________";
2360   theStatus += "\t| Known at Neutral Point:\n\tDisplayStatus:";
2361   const Handle(AIS_GlobalStatus)& aStatus = myObjects (theIObj);
2362   switch (aStatus->GraphicStatus())
2363   {
2364     case AIS_DS_Displayed:
2365     {
2366       theStatus += "\t| -->Displayed\n";
2367       break;
2368     }
2369     case AIS_DS_Erased:
2370     {
2371       theStatus += "\t| -->Erased\n";
2372       break;
2373     }
2374     default:
2375       break;
2376   }
2377
2378   theStatus += "\t| Active Display Modes in the MainViewer :\n";
2379   for (TColStd_ListIteratorOfListOfInteger aDispModeIter (aStatus->DisplayedModes()); aDispModeIter.More(); aDispModeIter.Next())
2380   {
2381     theStatus += "\t|\t Mode ";
2382     theStatus += TCollection_AsciiString (aDispModeIter.Value());
2383     theStatus += "\n";
2384   }
2385   if (IsSelected(theIObj)) theStatus +="\t| Selected\n";
2386
2387   theStatus += "\t| Active Selection Modes in the MainViewer :\n";
2388   for (TColStd_ListIteratorOfListOfInteger aSelModeIter (aStatus->SelectionModes()); aSelModeIter.More(); aSelModeIter.Next())
2389   {
2390     theStatus += "\t\t Mode ";
2391     theStatus += TCollection_AsciiString (aSelModeIter.Value());
2392     theStatus += "\n";
2393   }
2394   theStatus += "\t ____________________________________________";
2395 }
2396
2397 //=======================================================================
2398 //function : GetDefModes
2399 //purpose  :
2400 //=======================================================================
2401 void AIS_InteractiveContext::GetDefModes (const Handle(AIS_InteractiveObject)& theIObj,
2402                                           Standard_Integer&                    theDispMode,
2403                                           Standard_Integer&                    theHiMode,
2404                                           Standard_Integer&                    theSelMode) const
2405 {
2406   if (theIObj.IsNull())
2407   {
2408     return;
2409   }
2410
2411   theDispMode = theIObj->HasDisplayMode()
2412               ? theIObj->DisplayMode()
2413               : (theIObj->AcceptDisplayMode (myDisplayMode)
2414                ? myDisplayMode
2415                : 0);
2416   theHiMode  = theIObj->HasHilightMode()   ? theIObj->HilightMode()   : theDispMode;
2417   theSelMode = theIObj->GlobalSelectionMode();
2418 }
2419
2420 //=======================================================================
2421 //function : EraseGlobal
2422 //purpose  :
2423 //=======================================================================
2424 void AIS_InteractiveContext::EraseGlobal (const Handle(AIS_InteractiveObject)& theIObj,
2425                                           const Standard_Boolean               theToUpdateviewer)
2426 {
2427   if (theIObj.IsNull()
2428   || !myObjects.IsBound (theIObj))
2429   {
2430     return;
2431   }
2432
2433   Handle(AIS_GlobalStatus) aStatus = myObjects (theIObj);
2434
2435   const Standard_Integer aDispMode = theIObj->HasHilightMode() ? theIObj->HilightMode() : 0;
2436   if (aStatus->GraphicStatus() == AIS_DS_Temporary
2437    || aStatus->GraphicStatus() == AIS_DS_Erased)
2438   {
2439     return;
2440   }
2441
2442   for (TColStd_ListIteratorOfListOfInteger aDispModeIter (aStatus->DisplayedModes()); aDispModeIter.More(); aDispModeIter.Next())
2443   {
2444     if (aStatus->IsHilighted())
2445     {
2446       if (IsCurrent (theIObj))
2447       {
2448         AddOrRemoveCurrentObject (theIObj, Standard_False);
2449       }
2450       else if (myMainPM->IsHighlighted (theIObj, aDispModeIter.Value()))
2451       {
2452         myMainPM->Unhighlight (theIObj, aDispModeIter.Value());
2453       }
2454     }
2455
2456     myMainPM->SetVisibility (theIObj, aDispModeIter.Value(), Standard_False);
2457   }
2458
2459   if (IsSelected (theIObj)
2460   && !aStatus->IsDModeIn (aDispMode))
2461   {
2462     myMainPM->SetVisibility (theIObj, aDispMode, Standard_False);
2463   }
2464
2465   for (TColStd_ListIteratorOfListOfInteger aSelModeIter (aStatus->SelectionModes()); aSelModeIter.More(); aSelModeIter.Next())
2466   {
2467     mgrSelector->Deactivate (theIObj, aSelModeIter.Value(), myMainSel);
2468   }
2469   aStatus->ClearSelectionModes();
2470   aStatus->SetGraphicStatus (AIS_DS_Erased);
2471
2472   if (theToUpdateviewer)
2473   {
2474     myMainVwr->Update();
2475   }
2476 }
2477
2478 //=======================================================================
2479 //function : unhighlightOwners
2480 //purpose  :
2481 //=======================================================================
2482 void AIS_InteractiveContext::unhighlightOwners (const Handle(AIS_InteractiveObject)& theObject)
2483 {
2484   Handle(AIS_Selection) aSel = AIS_Selection::Selection (myCurrentName.ToCString());
2485   aSel->Init();
2486   while (aSel->More())
2487   {
2488     const Handle(SelectMgr_EntityOwner) anOwner =
2489       Handle(SelectMgr_EntityOwner)::DownCast (aSel->Value());
2490     if (anOwner->Selectable() == theObject)
2491     {
2492       if (anOwner->IsSelected())
2493       {
2494         AddOrRemoveSelected (anOwner, Standard_False);
2495         aSel->Init();
2496         continue;
2497       }
2498     }
2499     aSel->Next();
2500   }
2501 }
2502
2503 //=======================================================================
2504 //function : ClearGlobal
2505 //purpose  :
2506 //=======================================================================
2507 void AIS_InteractiveContext::ClearGlobal (const Handle(AIS_InteractiveObject)& theIObj,
2508                                           const Standard_Boolean               theToUpdateviewer)
2509 {
2510   if (theIObj.IsNull()
2511   || !myObjects.IsBound (theIObj))
2512   {
2513     // for cases when reference shape of connected interactives was not displayed
2514     // but its selection primitives were calculated
2515     const Handle(SelectMgr_SelectableObject)& anObj = theIObj; // to avoid ambiguity
2516     mgrSelector->Remove (anObj);
2517     return;
2518   }
2519
2520   Handle(AIS_GlobalStatus) aStatus = myObjects (theIObj);
2521   unhighlightOwners (theIObj);
2522   for (TColStd_ListIteratorOfListOfInteger aDispModeIter (aStatus->DisplayedModes()); aDispModeIter.More(); aDispModeIter.Next())
2523   {
2524     myMainPM->Erase (theIObj, aDispModeIter.Value());
2525     myMainPM->Clear (theIObj, aDispModeIter.Value());
2526   }
2527
2528   // Object removes from Detected sequence
2529   for(Standard_Integer aDetIter = 1; aDetIter < myAISDetectedSeq.Length(); ++aDetIter)
2530   {
2531     Handle(AIS_InteractiveObject) anObj = DetectedCurrentObject();
2532     if (!anObj.IsNull()
2533       && anObj != theIObj)
2534     {
2535       myAISDetectedSeq.Remove (aDetIter);
2536     }
2537   }
2538
2539   // remove IO from the selection manager to avoid memory leaks
2540   const Handle(SelectMgr_SelectableObject)& anObj = theIObj; // to avoid ambiguity
2541   mgrSelector->Remove (anObj);
2542
2543   myObjects.UnBind (theIObj);
2544   myMainVwr->StructureManager()->UnregisterObject (theIObj);
2545   for (myMainVwr->InitDefinedViews(); myMainVwr->MoreDefinedViews(); myMainVwr->NextDefinedViews())
2546   {
2547     myMainVwr->DefinedView()->View()->ChangeHiddenObjects()->Remove (theIObj.get());
2548   }
2549
2550   if (!myLastinMain.IsNull() && myLastinMain->Selectable() == theIObj)
2551     myLastinMain.Nullify();
2552   if (!myLastPicked.IsNull() && myLastPicked->Selectable() == theIObj)
2553     myLastPicked.Nullify();
2554   myMainPM->ClearImmediateDraw();
2555
2556   if (theToUpdateviewer && aStatus->GraphicStatus() == AIS_DS_Displayed)
2557   {
2558     myMainVwr->Update();
2559   }
2560 }
2561
2562 //=======================================================================
2563 //function : ClearGlobalPrs
2564 //purpose  :
2565 //=======================================================================
2566 void AIS_InteractiveContext::ClearGlobalPrs (const Handle(AIS_InteractiveObject)& theIObj,
2567                                              const Standard_Integer               theMode,
2568                                              const Standard_Boolean               theToUpdateViewer)
2569 {
2570   if (theIObj.IsNull()
2571   || !myObjects.IsBound (theIObj))
2572   {
2573     return;
2574   }
2575
2576   const Handle(AIS_GlobalStatus)& aStatus = myObjects (theIObj);
2577   if (aStatus->IsDModeIn (theMode))
2578   {
2579     const Standard_Integer aDispMode = theIObj->HasHilightMode() ? theIObj->HilightMode() : 0;
2580     if (aDispMode == theMode
2581      && myMainPM->IsHighlighted (theIObj, theMode))
2582     {
2583       myMainPM->Unhighlight (theIObj, theMode);
2584     }
2585
2586     myMainPM->Erase (theIObj, theMode);
2587     myMainPM->Clear (theIObj, theMode);
2588   }
2589
2590   if (aStatus->GraphicStatus() == AIS_DS_Displayed
2591    && theToUpdateViewer)
2592   {
2593     myMainVwr->Update();
2594   }
2595 }
2596
2597 //=======================================================================
2598 //function : DrawHiddenLine
2599 //purpose  :
2600 //=======================================================================
2601 Standard_Boolean AIS_InteractiveContext::DrawHiddenLine() const
2602 {
2603   return myDefaultDrawer->DrawHiddenLine();
2604 }
2605
2606 //=======================================================================
2607 //function : EnableDrawHiddenLine
2608 //purpose  :
2609 //=======================================================================
2610 void AIS_InteractiveContext::EnableDrawHiddenLine() const
2611 {
2612   myDefaultDrawer->EnableDrawHiddenLine();
2613 }
2614
2615 //=======================================================================
2616 //function : DisableDrawHiddenLine
2617 //purpose  :
2618 //=======================================================================
2619 void AIS_InteractiveContext::DisableDrawHiddenLine() const
2620 {
2621   myDefaultDrawer->DisableDrawHiddenLine();
2622 }
2623
2624 //=======================================================================
2625 //function : HiddenLineAspect
2626 //purpose  :
2627 //=======================================================================
2628 Handle (Prs3d_LineAspect) AIS_InteractiveContext::HiddenLineAspect() const
2629 {
2630   return myDefaultDrawer->HiddenLineAspect();
2631 }
2632
2633 //=======================================================================
2634 //function : SetHiddenLineAspect
2635 //purpose  :
2636 //=======================================================================
2637 void AIS_InteractiveContext::SetHiddenLineAspect (const Handle(Prs3d_LineAspect)& theAspect) const
2638 {
2639   myDefaultDrawer->SetHiddenLineAspect (theAspect);
2640 }
2641
2642 //=======================================================================
2643 //function : SetIsoNumber
2644 //purpose  :
2645 //=======================================================================
2646 void AIS_InteractiveContext::SetIsoNumber (const Standard_Integer theNb,
2647                                            const AIS_TypeOfIso    theType)
2648 {
2649   switch (theType)
2650   {
2651     case AIS_TOI_IsoU:
2652       myDefaultDrawer->UIsoAspect()->SetNumber (theNb);
2653       break;
2654     case AIS_TOI_IsoV:
2655       myDefaultDrawer->VIsoAspect()->SetNumber (theNb);
2656       break;
2657     case AIS_TOI_Both:
2658       myDefaultDrawer->UIsoAspect()->SetNumber (theNb);
2659       myDefaultDrawer->VIsoAspect()->SetNumber (theNb);
2660       break;
2661   }
2662 }
2663
2664 //=======================================================================
2665 //function : IsoNumber
2666 //purpose  :
2667 //=======================================================================
2668 Standard_Integer AIS_InteractiveContext::IsoNumber (const AIS_TypeOfIso theType)
2669 {
2670   switch (theType)
2671   {
2672     case AIS_TOI_IsoU: return myDefaultDrawer->UIsoAspect()->Number();
2673     case AIS_TOI_IsoV: return myDefaultDrawer->VIsoAspect()->Number();
2674     case AIS_TOI_Both: return myDefaultDrawer->UIsoAspect()->Number() == myDefaultDrawer->VIsoAspect()->Number()
2675                             ? myDefaultDrawer->UIsoAspect()->Number()
2676                             : -1;
2677   }
2678   return 0;
2679 }
2680
2681 //=======================================================================
2682 //function : IsoOnPlane
2683 //purpose  :
2684 //=======================================================================
2685 void AIS_InteractiveContext::IsoOnPlane (const Standard_Boolean theToSwitchOn)
2686 {
2687   myDefaultDrawer->SetIsoOnPlane (theToSwitchOn);
2688 }
2689
2690 //=======================================================================
2691 //function : IsoOnPlane
2692 //purpose  :
2693 //=======================================================================
2694 Standard_Boolean AIS_InteractiveContext::IsoOnPlane() const
2695 {
2696   return myDefaultDrawer->IsoOnPlane();
2697 }
2698
2699 //=======================================================================
2700 //function : IsoOnTriangulation
2701 //purpose  :
2702 //=======================================================================
2703 void AIS_InteractiveContext::IsoOnTriangulation (const Standard_Boolean theToSwitchOn)
2704 {
2705   myDefaultDrawer->SetIsoOnTriangulation (theToSwitchOn);
2706 }
2707
2708 //=======================================================================
2709 //function : IsoOnTriangulation
2710 //purpose  :
2711 //=======================================================================
2712 Standard_Boolean AIS_InteractiveContext::IsoOnTriangulation() const
2713 {
2714   return myDefaultDrawer->IsoOnTriangulation();
2715 }
2716
2717 //function : SetPixelTolerance
2718 //purpose  : Disables the mechanism of adaptive tolerance calculation in
2719 //           SelectMgr_ViewerSelector and sets the given tolerance for ALL
2720 //           sensitive entities activated. For more information, see
2721 //           SelectMgr_ViewerSelector.hxx
2722 //=======================================================================
2723 void AIS_InteractiveContext::SetPixelTolerance (const Standard_Integer thePrecision)
2724 {
2725   if (HasOpenedContext())
2726   {
2727     myLocalContexts (myCurLocalIndex)->SetPixelTolerance (thePrecision);
2728   }
2729   else
2730   {
2731     myMainSel->SetPixelTolerance (thePrecision);
2732   }
2733 }
2734
2735 //=======================================================================
2736 //function : PixelTolerance
2737 //purpose  :
2738 //=======================================================================
2739 Standard_Integer AIS_InteractiveContext::PixelTolerance() const
2740 {
2741   return HasOpenedContext()
2742        ? myLocalContexts (myCurLocalIndex)->PixelTolerance()
2743        : myMainSel->PixelTolerance();
2744 }
2745
2746 //=======================================================================
2747 //function : SetSelectionSensitivity
2748 //purpose  : Allows to manage sensitivity of a particular selection of interactive object theObject
2749 //=======================================================================
2750 void AIS_InteractiveContext::SetSelectionSensitivity (const Handle(AIS_InteractiveObject)& theObject,
2751                                                       const Standard_Integer theMode,
2752                                                       const Standard_Integer theNewSensitivity)
2753 {
2754   if (HasOpenedContext())
2755   {
2756     myLocalContexts (myCurLocalIndex)->SetSelectionSensitivity (theObject, theMode, theNewSensitivity);
2757     return;
2758   }
2759
2760   mgrSelector->SetSelectionSensitivity (theObject, theMode, theNewSensitivity);
2761 }
2762
2763 //=======================================================================
2764 //function : IsInLocal
2765 //purpose  :
2766 //=======================================================================
2767 Standard_Boolean AIS_InteractiveContext::IsInLocal (const Handle(AIS_InteractiveObject)& theIObj,
2768                                                     Standard_Integer&                    theIndex) const
2769 {
2770   if (theIObj.IsNull())
2771   {
2772     return Standard_False;
2773   }
2774
2775   // if it exists at neutral point 0 index is returned
2776   if (myObjects.IsBound (theIObj))
2777   {
2778     theIndex = 0;
2779     return Standard_False;
2780   }
2781
2782   for (Standard_Integer aCtxIter = 1; aCtxIter <= myLocalContexts.Extent(); ++aCtxIter)
2783   {
2784     if (myLocalContexts.IsBound (aCtxIter))
2785     {
2786       if(myLocalContexts (aCtxIter)->IsIn (theIObj))
2787       {
2788         theIndex = aCtxIter;
2789         return Standard_True;
2790       }
2791     }
2792   }
2793   theIndex = -1;
2794   return Standard_False;
2795 }
2796
2797 //=======================================================================
2798 //function : InitAttributes
2799 //purpose  :
2800 //=======================================================================
2801 void AIS_InteractiveContext::InitAttributes()
2802 {
2803   mgrSelector->Add (myMainSel);
2804   myCurrentName   = AIS_Context_NewCurName();
2805   mySelectionName = AIS_Context_NewSelName();
2806
2807   AIS_Selection::CreateSelection (mySelectionName.ToCString());
2808   AIS_Selection::CreateSelection (myCurrentName.ToCString());
2809
2810   myDefaultDrawer->SetShadingAspectGlobal (Standard_False);
2811   Graphic3d_MaterialAspect aMat (Graphic3d_NOM_BRASS);
2812   myDefaultDrawer->ShadingAspect()->SetMaterial (aMat);
2813
2814 //  myDefaultDrawer->ShadingAspect()->SetColor(Quantity_NOC_GRAY70);
2815   Handle(Prs3d_LineAspect) aLineAspect = myDefaultDrawer->HiddenLineAspect();
2816   aLineAspect->SetColor      (Quantity_NOC_GRAY20);
2817   aLineAspect->SetWidth      (1.0);
2818   aLineAspect->SetTypeOfLine (Aspect_TOL_DASH);
2819
2820   // tolerance to 2 pixels...
2821   SetPixelTolerance (2);
2822
2823   // Customizing the drawer for trihedrons and planes...
2824   Handle(Prs3d_DatumAspect) aTrihAspect = myDefaultDrawer->DatumAspect();
2825   const Standard_Real aLength = 100.0;
2826   aTrihAspect->SetAxisLength (aLength, aLength, aLength);
2827   const Quantity_NameOfColor aColor = Quantity_NOC_LIGHTSTEELBLUE4;
2828   aTrihAspect->FirstAxisAspect() ->SetColor (aColor);
2829   aTrihAspect->SecondAxisAspect()->SetColor (aColor);
2830   aTrihAspect->ThirdAxisAspect() ->SetColor (aColor);
2831
2832   Handle(Prs3d_PlaneAspect) aPlaneAspect = myDefaultDrawer->PlaneAspect();
2833   const Standard_Real aPlaneLength = 200.0;
2834   aPlaneAspect->SetPlaneLength (aPlaneLength, aPlaneLength);
2835   aPlaneAspect->EdgesAspect()->SetColor (Quantity_NOC_SKYBLUE);
2836 }
2837
2838 //=======================================================================
2839 //function : TrihedronSize
2840 //purpose  :
2841 //=======================================================================
2842 Standard_Real AIS_InteractiveContext::TrihedronSize() const
2843 {
2844   return myDefaultDrawer->DatumAspect()->FirstAxisLength();
2845 }
2846
2847 //=======================================================================
2848 //function : SetTrihedronSize
2849 //purpose  :
2850 //=======================================================================
2851 void AIS_InteractiveContext::SetTrihedronSize (const Standard_Real    theVal,
2852                                                const Standard_Boolean /*updateviewer*/)
2853 {
2854   myDefaultDrawer->DatumAspect()->SetAxisLength (theVal, theVal, theVal);
2855   Redisplay (AIS_KOI_Datum, 3, Standard_False);
2856   Redisplay (AIS_KOI_Datum, 4, Standard_True);
2857 }
2858
2859 //=======================================================================
2860 //function : SetPlaneSize
2861 //purpose  :
2862 //=======================================================================
2863 void AIS_InteractiveContext::SetPlaneSize(const Standard_Real    theValX,
2864                                           const Standard_Real    theValY,
2865                                           const Standard_Boolean /*updateviewer*/)
2866 {
2867   myDefaultDrawer->PlaneAspect()->SetPlaneLength (theValX, theValY);
2868   Redisplay (AIS_KOI_Datum, 7);
2869 }
2870
2871 //=======================================================================
2872 //function : SetPlaneSize
2873 //purpose  :
2874 //=======================================================================
2875 void AIS_InteractiveContext::SetPlaneSize (const Standard_Real    theVal,
2876                                            const Standard_Boolean theToUpdateViewer)
2877 {
2878   SetPlaneSize (theVal, theVal, theToUpdateViewer);
2879 }
2880
2881 //=======================================================================
2882 //function : PlaneSize
2883 //purpose  :
2884 //=======================================================================
2885 Standard_Boolean AIS_InteractiveContext::PlaneSize (Standard_Real& theX,
2886                                                     Standard_Real& theY) const
2887 {
2888   theX = myDefaultDrawer->PlaneAspect()->PlaneXLength();
2889   theY = myDefaultDrawer->PlaneAspect()->PlaneYLength();
2890   return (Abs (theX - theY) <= Precision::Confusion());
2891 }
2892
2893 //=======================================================================
2894 //function : SetAutoActivateSelection
2895 //purpose  :
2896 //=======================================================================
2897 void AIS_InteractiveContext::SetAutoActivateSelection (const Standard_Boolean theIsAuto)
2898 {
2899   myIsAutoActivateSelMode = theIsAuto;
2900 }
2901
2902 //=======================================================================
2903 //function : GetAutoActivateSelection
2904 //purpose  :
2905 //=======================================================================
2906 Standard_Boolean AIS_InteractiveContext::GetAutoActivateSelection() const
2907 {
2908   return myIsAutoActivateSelMode;
2909 }
2910
2911 //=======================================================================
2912 //function : SetZLayer
2913 //purpose  :
2914 //=======================================================================
2915 void AIS_InteractiveContext::SetZLayer (const Handle(AIS_InteractiveObject)& theIObj,
2916                                         const Standard_Integer theLayerId)
2917 {
2918   if (theIObj.IsNull())
2919     return;
2920
2921   theIObj->SetZLayer (theLayerId);
2922 }
2923
2924 //=======================================================================
2925 //function : GetZLayer
2926 //purpose  :
2927 //=======================================================================
2928 Standard_Integer AIS_InteractiveContext::GetZLayer (const Handle(AIS_InteractiveObject)& theIObj) const
2929 {
2930   return !theIObj.IsNull()
2931        ?  theIObj->ZLayer()
2932        :  Graphic3d_ZLayerId_UNKNOWN;
2933 }
2934
2935 //=======================================================================
2936 //function : RebuildSelectionStructs
2937 //purpose  : Rebuilds 1st level of BVH selection forcibly
2938 //=======================================================================
2939 void AIS_InteractiveContext::RebuildSelectionStructs()
2940 {
2941   myMainSel->RebuildObjectsTree (Standard_True);
2942 }
2943
2944 //=======================================================================
2945 //function : Disconnect
2946 //purpose  : Disconnects selectable object from an assembly and updates selection structures
2947 //=======================================================================
2948 void AIS_InteractiveContext::Disconnect (const Handle(AIS_InteractiveObject)& theAssembly,
2949                                          const Handle(AIS_InteractiveObject)& theObjToDisconnect)
2950 {
2951   if (theAssembly->IsInstance ("AIS_MultipleConnectedInteractive"))
2952   {
2953     Handle(AIS_MultipleConnectedInteractive) theObj (Handle(AIS_MultipleConnectedInteractive)::DownCast (theAssembly));
2954     theObj->Disconnect (theObjToDisconnect);
2955     const Handle(SelectMgr_SelectableObject)& anObj = theObjToDisconnect; // to avoid ambiguity
2956     mgrSelector->Remove (anObj);
2957   }
2958   else if (theAssembly->IsInstance ("AIS_ConnectedInteractive") && theObjToDisconnect.IsNull())
2959   {
2960     Handle(AIS_ConnectedInteractive) theObj (Handle(AIS_ConnectedInteractive)::DownCast (theAssembly));
2961     theObj->Disconnect();
2962     const Handle(SelectMgr_SelectableObject)& anObj = theObj; // to avoid ambiguity
2963     mgrSelector->Remove (anObj);
2964   }
2965   else
2966     return;
2967 }
2968
2969 //=======================================================================
2970 //function : FitSelected
2971 //purpose  : Fits the view corresponding to the bounds of selected objects
2972 //=======================================================================
2973 void AIS_InteractiveContext::FitSelected (const Handle(V3d_View)& theView,
2974                                           const Standard_Real theMargin,
2975                                           const Standard_Boolean theToUpdate)
2976 {
2977   Standard_CString aSelName = HasOpenedContext() ?
2978       myLocalContexts (myCurLocalIndex)->SelectionName().ToCString()
2979     : myCurrentName.ToCString();
2980
2981   Bnd_Box aBndSelected;
2982
2983   const Handle(AIS_Selection)& aSelection = AIS_Selection::Selection (aSelName);
2984   AIS_MapOfObjectOwners anObjectOwnerMap;
2985   for (aSelection->Init(); aSelection->More(); aSelection->Next())
2986   {
2987     Handle(AIS_InteractiveObject) anObj (Handle(AIS_InteractiveObject)::DownCast (aSelection->Value()));
2988     if (!anObj.IsNull())
2989     {
2990       if (anObj->IsInfinite())
2991         continue;
2992
2993       Bnd_Box aTmpBnd;
2994       anObj->BoundingBox (aTmpBnd);
2995       aBndSelected.Add (aTmpBnd);
2996     }
2997     else
2998     {
2999       Handle(SelectMgr_EntityOwner) anOwner (Handle(SelectMgr_EntityOwner)::DownCast (aSelection->Value()));
3000       if (anOwner.IsNull())
3001         continue;
3002
3003       Handle(SelectMgr_IndexedMapOfOwner) anOwnerMap;
3004       if (!anObjectOwnerMap.Find (anOwner->Selectable(), anOwnerMap))
3005       {
3006         anOwnerMap = new SelectMgr_IndexedMapOfOwner();
3007         anObjectOwnerMap.Bind (anOwner->Selectable(), anOwnerMap);
3008       }
3009
3010       anOwnerMap->Add (anOwner);
3011     }
3012   }
3013
3014   for (AIS_MapIteratorOfMapOfObjectOwners anIter (anObjectOwnerMap); anIter.More(); anIter.Next())
3015   {
3016     const Handle(SelectMgr_SelectableObject) anObject = anIter.Key();
3017     Bnd_Box aTmpBox = anObject->BndBoxOfSelected (anIter.ChangeValue());
3018     aBndSelected.Add (aTmpBox);
3019   }
3020
3021   anObjectOwnerMap.Clear();
3022
3023   if (aBndSelected.IsVoid())
3024     return;
3025
3026   theView->FitAll (aBndSelected, theMargin, theToUpdate);
3027 }