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