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