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