0027957: Visualization, AIS_InteractiveContext - protect from displaying the same...
[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_ConnectedInteractive.hxx>
18
19 #include <AIS_DataMapIteratorOfDataMapOfILC.hxx>
20 #include <AIS_DataMapIteratorOfDataMapOfIOStatus.hxx>
21 #include <AIS_GlobalStatus.hxx>
22 #include <AIS_InteractiveContext.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     myLastPicked->UpdateHighlightTrsf (myMainVwr,
1335                                        myMainPM,
1336                                        theIObj->HasDisplayMode() ? theIObj->DisplayMode() : 0);
1337   }
1338 }
1339
1340 //=======================================================================
1341 //function : ResetLocation
1342 //purpose  :
1343 //=======================================================================
1344 void AIS_InteractiveContext::ResetLocation (const Handle(AIS_InteractiveObject)& theIObj)
1345 {
1346   if (theIObj.IsNull())
1347   {
1348     return;
1349   }
1350
1351   theIObj->ResetTransformation();
1352   mgrSelector->Update (theIObj, Standard_False);
1353 }
1354
1355 //=======================================================================
1356 //function : HasLocation
1357 //purpose  :
1358 //=======================================================================
1359 Standard_Boolean AIS_InteractiveContext::HasLocation (const Handle(AIS_InteractiveObject)& theIObj) const
1360 {
1361   return !theIObj.IsNull()
1362        && theIObj->HasTransformation();
1363 }
1364
1365 //=======================================================================
1366 //function : Location
1367 //purpose  :
1368 //=======================================================================
1369 TopLoc_Location AIS_InteractiveContext::Location (const Handle(AIS_InteractiveObject)& theIObj) const
1370 {
1371   return theIObj->Transformation();
1372 }
1373
1374 //=======================================================================
1375 //function : SetDeviationCoefficient
1376 //purpose  :
1377 //=======================================================================
1378 void AIS_InteractiveContext::SetDeviationCoefficient (const Standard_Real theCoefficient)
1379 {
1380   myDefaultDrawer->SetDeviationCoefficient (theCoefficient);
1381 }
1382
1383 //=======================================================================
1384 //function : SetDeviationAngle
1385 //purpose  :
1386 //=======================================================================
1387 void AIS_InteractiveContext::SetDeviationAngle (const Standard_Real theAngle)
1388 {
1389   myDefaultDrawer->SetDeviationAngle (theAngle);
1390 }
1391
1392 //=======================================================================
1393 //function : DeviationAngle
1394 //purpose  : Gets  deviationAngle
1395 //=======================================================================
1396 Standard_Real AIS_InteractiveContext::DeviationAngle() const
1397 {
1398   return myDefaultDrawer->DeviationAngle();
1399 }
1400
1401 //=======================================================================
1402 //function : DeviationCoefficient
1403 //purpose  :
1404 //=======================================================================
1405 Standard_Real AIS_InteractiveContext::DeviationCoefficient() const
1406 {
1407   return myDefaultDrawer->DeviationCoefficient();
1408 }
1409
1410 //=======================================================================
1411 //function : SetHLRDeviationCoefficient
1412 //purpose  :
1413 //=======================================================================
1414 void AIS_InteractiveContext::SetHLRDeviationCoefficient (const Standard_Real theCoefficient)
1415 {
1416   myDefaultDrawer->SetHLRDeviationCoefficient (theCoefficient);
1417 }
1418
1419 //=======================================================================
1420 //function : HLRDeviationCoefficient
1421 //purpose  :
1422 //=======================================================================
1423 Standard_Real AIS_InteractiveContext::HLRDeviationCoefficient() const
1424 {
1425   return myDefaultDrawer->HLRDeviationCoefficient();
1426 }
1427
1428 //=======================================================================
1429 //function : SetHLRAngle
1430 //purpose  :
1431 //=======================================================================
1432 void AIS_InteractiveContext::SetHLRAngle (const Standard_Real theAngle)
1433 {
1434   myDefaultDrawer->SetHLRAngle (theAngle);
1435 }
1436
1437 //=======================================================================
1438 //function : SetHLRAngleAndDeviation
1439 //purpose  : compute with anangle a HLRAngle and a HLRDeviationCoefficient 
1440 //           and set them in myHLRAngle and in myHLRDeviationCoefficient
1441 //           of myDefaultDrawer 
1442 //=======================================================================
1443 void AIS_InteractiveContext::SetHLRAngleAndDeviation (const Standard_Real theAngle)
1444 {
1445   Standard_Real anOutAngl, anOutDefl;
1446   HLRBRep::PolyHLRAngleAndDeflection (theAngle, anOutAngl, anOutDefl);
1447
1448   myDefaultDrawer->SetHLRAngle                (anOutAngl);
1449   myDefaultDrawer->SetHLRDeviationCoefficient (anOutDefl);
1450 }
1451
1452 //=======================================================================
1453 //function : HLRAngle
1454 //purpose  :
1455 //=======================================================================
1456 Standard_Real AIS_InteractiveContext::HLRAngle() const 
1457 {
1458   return myDefaultDrawer->HLRAngle();
1459 }
1460
1461 //=======================================================================
1462 //function : SetDisplayMode
1463 //purpose  :
1464 //=======================================================================
1465 void AIS_InteractiveContext::SetDisplayMode(const Standard_Integer theMode,
1466                                             const Standard_Boolean theToUpdateViewer)
1467 {
1468   if (theMode == myDisplayMode)
1469   {
1470     return;
1471   }
1472
1473   for (AIS_DataMapIteratorOfDataMapOfIOStatus anObjIter (myObjects); anObjIter.More(); anObjIter.Next())
1474   {
1475     Handle(AIS_InteractiveObject) anObj = anObjIter.Key();
1476     Standard_Boolean toProcess = anObj->IsKind (STANDARD_TYPE(AIS_Shape))
1477                               || anObj->IsKind (STANDARD_TYPE(AIS_ConnectedInteractive))
1478                               || anObj->IsKind (STANDARD_TYPE(AIS_MultipleConnectedInteractive));
1479     
1480     if (!toProcess
1481      ||  anObj->HasDisplayMode()
1482      || !anObj->AcceptDisplayMode (theMode))
1483     {
1484       continue;
1485     }
1486
1487     Handle(AIS_GlobalStatus) aStatus = anObjIter.Value();
1488     aStatus->SetDisplayMode (theMode);
1489
1490     if (aStatus->GraphicStatus() == AIS_DS_Displayed)
1491     {
1492       myMainPM->Display (anObj, theMode);
1493       if (!myLastPicked.IsNull() && myLastPicked->IsSameSelectable (anObj))
1494       {
1495         myMainPM->BeginImmediateDraw();
1496         unhighlightGlobal (anObj, myDisplayMode);
1497         myMainPM->EndImmediateDraw (myMainVwr);
1498       }
1499       if (aStatus->IsSubIntensityOn())
1500       {
1501         highlightWithSubintensity (anObj, theMode);
1502       }
1503       myMainPM->SetVisibility (anObj, myDisplayMode, Standard_False);
1504     }
1505   }
1506
1507   myDisplayMode = theMode;
1508   if (theToUpdateViewer)
1509   {
1510     myMainVwr->Update();
1511   }
1512 }
1513
1514 //=======================================================================
1515 //function : SetDisplayMode
1516 //purpose  :
1517 //=======================================================================
1518 void AIS_InteractiveContext::SetDisplayMode (const Handle(AIS_InteractiveObject)& theIObj,
1519                                              const Standard_Integer               theMode,
1520                                              const Standard_Boolean               theToUpdateViewer)
1521 {
1522   setContextToObject (theIObj);
1523   if (!myObjects.IsBound (theIObj))
1524   {
1525     theIObj->SetDisplayMode (theMode);
1526     return;
1527   }
1528   else if (!theIObj->AcceptDisplayMode (theMode))
1529   {
1530     return;
1531   }
1532
1533   Handle(AIS_GlobalStatus) aStatus = myObjects (theIObj);
1534   if (aStatus->GraphicStatus() != AIS_DS_Displayed)
1535   {
1536     aStatus->SetDisplayMode (theMode);
1537     theIObj->SetDisplayMode (theMode);
1538     return;
1539   }
1540
1541   // erase presentations for all display modes different from <aMode>
1542   const Standard_Integer anOldMode = aStatus->DisplayMode();
1543   if (anOldMode != theMode)
1544   {
1545     if (myMainPM->IsHighlighted (theIObj, anOldMode))
1546     {
1547       unhighlightGlobal (theIObj, anOldMode);
1548     }
1549     myMainPM->SetVisibility (theIObj, anOldMode, Standard_False);
1550   }
1551
1552   aStatus->SetDisplayMode (theMode);
1553
1554   myMainPM->Display (theIObj, theMode);
1555   Standard_Integer aDispMode, aHiMode, aSelMode;
1556   GetDefModes (theIObj, aDispMode, aHiMode, aSelMode);
1557   if (aStatus->IsHilighted())
1558   {
1559     highlightGlobal (theIObj, getSelStyle (theIObj), aHiMode);
1560   }
1561   if (aStatus->IsSubIntensityOn())
1562   {
1563     highlightWithSubintensity (theIObj, theMode);
1564   }
1565
1566   if (theToUpdateViewer)
1567   {
1568     myMainVwr->Update();
1569   }
1570   theIObj->SetDisplayMode (theMode);
1571 }
1572
1573 //=======================================================================
1574 //function : UnsetDisplayMode
1575 //purpose  :
1576 //=======================================================================
1577 void AIS_InteractiveContext::UnsetDisplayMode (const Handle(AIS_InteractiveObject)& theIObj,
1578                                                const Standard_Boolean               theToUpdateViewer)
1579 {
1580   if (theIObj.IsNull()
1581   || !theIObj->HasDisplayMode())
1582   {
1583     return;
1584   }
1585
1586   if (!myObjects.IsBound (theIObj))
1587   {
1588     theIObj->UnsetDisplayMode();
1589     return;
1590   }
1591
1592   const Standard_Integer anOldMode = theIObj->DisplayMode();
1593   if (myDisplayMode == anOldMode)
1594   {
1595     return;
1596   }
1597
1598   const Handle(AIS_GlobalStatus)& aStatus = myObjects (theIObj);
1599   aStatus->SetDisplayMode (myDisplayMode);
1600
1601   if (aStatus->GraphicStatus() == AIS_DS_Displayed)
1602   {
1603     if (myMainPM->IsHighlighted (theIObj, anOldMode))
1604     {
1605       unhighlightGlobal (theIObj, anOldMode);
1606     }
1607     myMainPM->SetVisibility (theIObj, anOldMode, Standard_False);
1608     myMainPM->Display (theIObj, myDisplayMode);
1609
1610     Standard_Integer aDispMode, aHiMode, aSelMode;
1611     GetDefModes (theIObj, aDispMode, aHiMode, aSelMode);
1612     if (aStatus->IsHilighted())
1613     {
1614       highlightSelected (theIObj->GlobalSelOwner());
1615     }
1616     if (aStatus->IsSubIntensityOn())
1617     {
1618       highlightWithSubintensity (theIObj, myDisplayMode);
1619     }
1620
1621     if (theToUpdateViewer)
1622     {
1623       myMainVwr->Update();
1624     }
1625   }
1626
1627   theIObj->UnsetDisplayMode();
1628 }
1629
1630 //=======================================================================
1631 //function : SetCurrentFacingModel
1632 //purpose  :
1633 //=======================================================================
1634 void AIS_InteractiveContext::SetCurrentFacingModel (const Handle(AIS_InteractiveObject)& theIObj,
1635                                                     const Aspect_TypeOfFacingModel       theModel)
1636 {
1637   if (!theIObj.IsNull())
1638   {
1639     theIObj->SetCurrentFacingModel (theModel);
1640   }
1641 }
1642
1643 //=======================================================================
1644 //function : redisplayPrsRecModes
1645 //purpose  :
1646 //=======================================================================
1647 void AIS_InteractiveContext::redisplayPrsRecModes (const Handle(AIS_InteractiveObject)& theIObj,
1648                                                    const Standard_Boolean               theToUpdateViewer)
1649 {
1650   if (theIObj->RecomputeEveryPrs())
1651   {
1652     theIObj->Update (Standard_True);
1653     theIObj->UpdateSelection();
1654   }
1655   else
1656   {
1657     for (TColStd_ListIteratorOfListOfInteger aModes (theIObj->ListOfRecomputeModes()); aModes.More(); aModes.Next())
1658     {
1659       theIObj->Update (aModes.Value(), Standard_False);
1660     }
1661     theIObj->UpdateSelection();
1662     theIObj->SetRecomputeOk();
1663   }
1664
1665   if (theToUpdateViewer)
1666   {
1667     UpdateCurrentViewer();
1668   }
1669 }
1670
1671 //=======================================================================
1672 //function : redisplayPrsModes
1673 //purpose  :
1674 //=======================================================================
1675 void AIS_InteractiveContext::redisplayPrsModes (const Handle(AIS_InteractiveObject)& theIObj,
1676                                                 const Standard_Boolean               theToUpdateViewer)
1677 {
1678   if (theIObj->RecomputeEveryPrs())
1679   {
1680     theIObj->Update (Standard_True);
1681     theIObj->UpdateSelection();
1682   }
1683   else
1684   {
1685     TColStd_ListOfInteger aModes;
1686     theIObj->ToBeUpdated (aModes);
1687     for (TColStd_ListIteratorOfListOfInteger aModeIter (aModes); aModeIter.More(); aModeIter.Next())
1688     {
1689       theIObj->Update (aModeIter.Value(), Standard_False);
1690     }
1691     theIObj->SetRecomputeOk();
1692   }
1693
1694   if (theToUpdateViewer)
1695   {
1696     UpdateCurrentViewer();
1697   }
1698 }
1699
1700 //=======================================================================
1701 //function : SetColor
1702 //purpose  :
1703 //=======================================================================
1704 void AIS_InteractiveContext::SetColor (const Handle(AIS_InteractiveObject)& theIObj,
1705                                        const Quantity_NameOfColor           theColor,
1706                                        const Standard_Boolean               theToUpdateViewer)
1707 {
1708   SetColor (theIObj, Quantity_Color(theColor), theToUpdateViewer);
1709 }
1710
1711 //=======================================================================
1712 //function : SetColor
1713 //purpose  :
1714 //=======================================================================
1715 void AIS_InteractiveContext::SetColor (const Handle(AIS_InteractiveObject)& theIObj,
1716                                        const Quantity_Color&                theColor,
1717                                        const Standard_Boolean               theToUpdateViewer)
1718 {
1719   if (theIObj.IsNull())
1720   {
1721     return;
1722   }
1723
1724   setContextToObject (theIObj);
1725   theIObj->SetColor (theColor);
1726   redisplayPrsRecModes (theIObj, theToUpdateViewer);
1727 }
1728
1729 //=======================================================================
1730 //function : SetIsoOnTriangulation
1731 //purpose  :
1732 //=======================================================================
1733 void AIS_InteractiveContext::IsoOnTriangulation (const Standard_Boolean theIsEnabled,
1734                                                  const Handle(AIS_InteractiveObject)& theObject)
1735 {
1736   if (theObject.IsNull())
1737   {
1738     return;
1739   }
1740
1741   theObject->SetIsoOnTriangulation (theIsEnabled);
1742 }
1743
1744 //=======================================================================
1745 //function : SetDeviationCoefficient
1746 //purpose  :
1747 //=======================================================================
1748 void AIS_InteractiveContext::SetDeviationCoefficient (const Handle(AIS_InteractiveObject)& theIObj,
1749                                                       const Standard_Real                  theCoefficient,
1750                                                       const Standard_Boolean               theToUpdateViewer)
1751 {
1752   if (theIObj.IsNull())
1753   {
1754     return;
1755   }
1756
1757   // to be modified after the related methods of AIS_Shape are passed to InteractiveObject
1758   setContextToObject (theIObj);
1759   if (theIObj->Type() != AIS_KOI_Object
1760    && theIObj->Type() != AIS_KOI_Shape)
1761   {
1762     return;
1763   }
1764   else if (theIObj->Signature() != 0)
1765   {
1766     return;
1767   }
1768
1769   Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast (theIObj);
1770   aShape->SetOwnDeviationCoefficient (theCoefficient);
1771   redisplayPrsModes (theIObj, theToUpdateViewer);
1772 }
1773
1774 //=======================================================================
1775 //function : SetHLRDeviationCoefficient
1776 //purpose  :
1777 //=======================================================================
1778 void AIS_InteractiveContext::SetHLRDeviationCoefficient (const Handle(AIS_InteractiveObject)& theIObj,
1779                                                          const Standard_Real                  theCoefficient,
1780                                                          const Standard_Boolean               theToUpdateViewer)
1781 {
1782   if (theIObj.IsNull())
1783   {
1784     return;
1785   }
1786
1787   // To be modified after the related methods of AIS_Shape are passed to InteractiveObject
1788   setContextToObject (theIObj);
1789   if (theIObj->Type() != AIS_KOI_Object
1790    && theIObj->Type() != AIS_KOI_Shape)
1791   {
1792     return;
1793   }
1794   else if (theIObj->Signature() != 0)
1795   {
1796     return;
1797   }
1798
1799   Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast (theIObj);
1800   aShape->SetOwnHLRDeviationCoefficient (theCoefficient);
1801   redisplayPrsModes (theIObj, theToUpdateViewer);
1802 }
1803
1804 //=======================================================================
1805 //function : SetDeviationAngle
1806 //purpose  :
1807 //=======================================================================
1808 void AIS_InteractiveContext::SetDeviationAngle (const Handle(AIS_InteractiveObject)& theIObj,
1809                                                 const Standard_Real                  theAngle,
1810                                                 const Standard_Boolean               theToUpdateViewer)
1811 {
1812   if (theIObj.IsNull())
1813   {
1814     return;
1815   }
1816
1817   // To be modified after the related methods of AIS_Shape are passed to InteractiveObject
1818   setContextToObject (theIObj);
1819   if (theIObj->Type() != AIS_KOI_Shape)
1820   {
1821     return;
1822   }
1823   else if (theIObj->Signature() != 0)
1824   {
1825     return;
1826   }
1827
1828   Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast (theIObj);
1829   aShape->SetOwnDeviationAngle (theAngle);
1830   redisplayPrsModes (theIObj, theToUpdateViewer);
1831 }
1832
1833 //=======================================================================
1834 //function : SetAngleAndDeviation
1835 //purpose  :
1836 //=======================================================================
1837 void AIS_InteractiveContext::SetAngleAndDeviation (const Handle(AIS_InteractiveObject)& theIObj,
1838                                                    const Standard_Real                  theAngle,
1839                                                    const Standard_Boolean               theToUpdateViewer)
1840 {
1841   if (theIObj.IsNull())
1842   {
1843     return;
1844   }
1845
1846   // To be modified after the related methods of AIS_Shape are passed to InteractiveObject
1847   setContextToObject (theIObj);
1848   if (theIObj->Type() != AIS_KOI_Shape)
1849   {
1850     return;
1851   }
1852   if (theIObj->Signature() != 0)
1853   {
1854     return;
1855   }
1856
1857   Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast (theIObj);
1858   aShape->SetAngleAndDeviation (theAngle);
1859
1860   if (theIObj->RecomputeEveryPrs())
1861   {
1862     theIObj->Update (Standard_True);
1863     theIObj->UpdateSelection();
1864   }
1865   else
1866   {
1867     Update (theIObj, theToUpdateViewer);
1868   }
1869 }
1870
1871 //=======================================================================
1872 //function : SetHLRAngleAndDeviation
1873 //purpose  :
1874 //=======================================================================
1875 void AIS_InteractiveContext::SetHLRAngleAndDeviation (const Handle(AIS_InteractiveObject)& theIObj,
1876                                                       const Standard_Real                  theAngle,
1877                                                       const Standard_Boolean               theToUpdateViewer)
1878 {
1879   if (theIObj.IsNull())
1880   {
1881     return;
1882   }
1883
1884   // To be modified after the related methods of AIS_Shape are passed to InteractiveObject
1885   setContextToObject (theIObj);
1886   if (theIObj->Type() != AIS_KOI_Shape)
1887   {
1888     return;
1889   }
1890   if (theIObj->Signature() != 0)
1891   {
1892     return;
1893   }
1894   Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast (theIObj);
1895   aShape->SetHLRAngleAndDeviation (theAngle);
1896   redisplayPrsModes (theIObj, theToUpdateViewer);
1897 }
1898
1899 //=======================================================================
1900 //function : SetHLRDeviationAngle
1901 //purpose  :
1902 //=======================================================================
1903 void AIS_InteractiveContext::SetHLRDeviationAngle (const Handle(AIS_InteractiveObject)& theIObj,
1904                                                    const Standard_Real                  theAngle,
1905                                                    const Standard_Boolean               theToUpdateViewer)
1906 {
1907   if (theIObj.IsNull())
1908   {
1909     return;
1910   }
1911
1912   // To be modified after the related methods of AIS_Shape are passed to InteractiveObject
1913   setContextToObject (theIObj);
1914   if (theIObj->Type() != AIS_KOI_Shape)
1915   {
1916     return;
1917   }
1918   if (theIObj->Signature() != 0)
1919   {
1920     return;
1921   }
1922   Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast (theIObj);
1923   aShape->SetOwnHLRDeviationAngle (theAngle);
1924   redisplayPrsModes (theIObj, theToUpdateViewer);
1925 }
1926
1927 //=======================================================================
1928 //function : UnsetColor
1929 //purpose  :
1930 //=======================================================================
1931 void AIS_InteractiveContext::UnsetColor (const Handle(AIS_InteractiveObject)& theIObj,
1932                                          const Standard_Boolean               theToUpdateViewer)
1933 {
1934   if (theIObj.IsNull())
1935   {
1936     return;
1937   }
1938
1939   theIObj->UnsetColor();
1940   redisplayPrsRecModes (theIObj, theToUpdateViewer);
1941 }
1942
1943 //=======================================================================
1944 //function : HasColor
1945 //purpose  :
1946 //=======================================================================
1947 Standard_Boolean AIS_InteractiveContext::HasColor (const Handle(AIS_InteractiveObject)& theIObj) const
1948 {
1949   return theIObj->HasColor();
1950 }
1951
1952 //=======================================================================
1953 //function : Color
1954 //purpose  :
1955 //=======================================================================
1956 Quantity_NameOfColor AIS_InteractiveContext::Color (const Handle(AIS_InteractiveObject)& theIObj) const
1957 {
1958   return theIObj->Color();
1959 }
1960
1961 //=======================================================================
1962 //function : Color
1963 //purpose  :
1964 //=======================================================================
1965 void AIS_InteractiveContext::Color (const Handle(AIS_InteractiveObject)& theIObj,
1966                                     Quantity_Color&                      theColor) const
1967 {
1968   theIObj->Color (theColor);
1969 }
1970
1971 //=======================================================================
1972 //function : Width
1973 //purpose  :
1974 //=======================================================================
1975 Standard_Real AIS_InteractiveContext::Width (const Handle(AIS_InteractiveObject)& theIObj) const
1976 {
1977   return theIObj->Width();
1978 }
1979
1980 //=======================================================================
1981 //function : SetWidth
1982 //purpose  :
1983 //=======================================================================
1984 void AIS_InteractiveContext::SetWidth (const Handle(AIS_InteractiveObject)& theIObj,
1985                                        const Standard_Real                  theWidth,
1986                                        const Standard_Boolean               theToUpdateViewer)
1987 {
1988   if (theIObj.IsNull())
1989   {
1990     return;
1991   }
1992
1993   setContextToObject (theIObj);
1994   theIObj->SetWidth (theWidth);
1995   redisplayPrsRecModes (theIObj, theToUpdateViewer);
1996   if (!myLastinMain.IsNull() && myLastinMain->IsSameSelectable (theIObj))
1997   {
1998     if (myLastinMain->IsAutoHilight())
1999     {
2000       const Standard_Integer aHiMode =
2001         theIObj->HasHilightMode() ? theIObj->HilightMode() : 0;
2002       myLastinMain->HilightWithColor (myMainPM,
2003                                       myLastinMain->IsSelected() ? getSelStyle (theIObj) : getHiStyle (theIObj),
2004                                       aHiMode);
2005     }
2006     else
2007     {
2008       theIObj->HilightOwnerWithColor (myMainPM,
2009                                       myLastinMain->IsSelected() ? getSelStyle (theIObj) : getHiStyle (theIObj),
2010                                       myLastinMain);
2011     }
2012   }
2013 }
2014
2015 //=======================================================================
2016 //function : UnsetWidth
2017 //purpose  :
2018 //=======================================================================
2019 void AIS_InteractiveContext::UnsetWidth (const Handle(AIS_InteractiveObject)& theIObj,
2020                                          const Standard_Boolean               theToUpdateViewer)
2021 {
2022   if (theIObj.IsNull())
2023   {
2024     return;
2025   }
2026
2027   theIObj->UnsetWidth();
2028   redisplayPrsRecModes (theIObj, theToUpdateViewer);
2029 }
2030
2031 //=======================================================================
2032 //function : SetMaterial
2033 //purpose  :
2034 //=======================================================================
2035 void AIS_InteractiveContext::SetMaterial (const Handle(AIS_InteractiveObject)& theIObj,
2036                                           const Graphic3d_NameOfMaterial       theName,
2037                                           const Standard_Boolean               theToUpdateViewer)
2038 {
2039   if (theIObj.IsNull())
2040   {
2041     return;
2042   }
2043
2044   setContextToObject (theIObj);
2045   theIObj->SetMaterial (theName);
2046   redisplayPrsRecModes (theIObj, theToUpdateViewer);
2047 }
2048
2049 //=======================================================================
2050 //function : UnsetMaterial
2051 //purpose  :
2052 //=======================================================================
2053 void AIS_InteractiveContext::UnsetMaterial (const Handle(AIS_InteractiveObject)& theIObj,
2054                                             const Standard_Boolean               theToUpdateViewer)
2055 {
2056   if (theIObj.IsNull())
2057   {
2058     return;
2059   }
2060   theIObj->UnsetMaterial();
2061   redisplayPrsRecModes (theIObj, theToUpdateViewer);
2062 }
2063
2064 //=======================================================================
2065 //function : SetTransparency
2066 //purpose  :
2067 //=======================================================================
2068 void AIS_InteractiveContext::SetTransparency (const Handle(AIS_InteractiveObject)& theIObj,
2069                                               const Standard_Real                  theValue,
2070                                               const Standard_Boolean               theToUpdateViewer)
2071 {
2072   if (theIObj.IsNull())
2073   {
2074     return;
2075   }
2076
2077   setContextToObject (theIObj);
2078   if (!theIObj->IsTransparent()
2079     && theValue <= 0.05)
2080   {
2081     return;
2082   }
2083
2084   if (theValue <= 0.05)
2085   {
2086     UnsetTransparency (theIObj, theToUpdateViewer);
2087     return;
2088   }
2089
2090   theIObj->SetTransparency (theValue);
2091   redisplayPrsRecModes (theIObj, theToUpdateViewer);
2092 }
2093
2094 //=======================================================================
2095 //function : UnsetTransparency
2096 //purpose  :
2097 //=======================================================================
2098 void AIS_InteractiveContext::UnsetTransparency (const Handle(AIS_InteractiveObject)& theIObj,
2099                                                 const Standard_Boolean               theToUpdateViewer)
2100 {
2101   if (theIObj.IsNull())
2102   {
2103     return;
2104   }
2105
2106   theIObj->UnsetTransparency();
2107   redisplayPrsRecModes (theIObj, theToUpdateViewer);
2108 }
2109
2110 //=======================================================================
2111 //function : SetSelectedAspect
2112 //purpose  :
2113 //=======================================================================
2114 void AIS_InteractiveContext::SetSelectedAspect (const Handle(Prs3d_BasicAspect)& theAspect,
2115                                                 const Standard_Boolean ,
2116                                                 const Standard_Boolean           theToUpdateViewer)
2117 {
2118   if (HasOpenedContext())
2119   {
2120     return;
2121   }
2122
2123   Standard_Boolean isFound = Standard_False;
2124   for (AIS_NListOfEntityOwner::Iterator aSelIter (mySelection->Objects()); aSelIter.More(); aSelIter.Next())
2125   {
2126     isFound = Standard_True;
2127     Handle(AIS_InteractiveObject) anObj = Handle(AIS_InteractiveObject)::DownCast (aSelIter.Value()->Selectable());
2128     anObj->SetAspect (theAspect);
2129   }
2130
2131   if (isFound && theToUpdateViewer)
2132   {
2133     myMainVwr->Update();
2134   }
2135 }
2136
2137 //=======================================================================
2138 //function : SetLocalAttributes
2139 //purpose  :
2140 //=======================================================================
2141 void AIS_InteractiveContext::SetLocalAttributes (const Handle(AIS_InteractiveObject)& theIObj,
2142                                                  const Handle(Prs3d_Drawer)&          theDrawer,
2143                                                  const Standard_Boolean               theToUpdateViewer)
2144 {
2145   if (theIObj.IsNull())
2146   {
2147     return;
2148   }
2149
2150   setContextToObject (theIObj);
2151   theIObj->SetAttributes (theDrawer);
2152   Update (theIObj, theToUpdateViewer);
2153 }
2154
2155 //=======================================================================
2156 //function : UnsetLocalAttributes
2157 //purpose  :
2158 //=======================================================================
2159 void AIS_InteractiveContext::UnsetLocalAttributes (const Handle(AIS_InteractiveObject)& theIObj,
2160                                                    const Standard_Boolean               theToUpdateViewer)
2161 {
2162   if (theIObj.IsNull())
2163   {
2164     return;
2165   }
2166
2167   setContextToObject (theIObj);
2168   theIObj->UnsetAttributes();
2169   Update (theIObj, theToUpdateViewer);
2170 }
2171
2172 //=======================================================================
2173 //function : Status
2174 //purpose  :
2175 //=======================================================================
2176 void AIS_InteractiveContext::Status (const Handle(AIS_InteractiveObject)& theIObj,
2177                                      TCollection_ExtendedString&          theStatus) const
2178 {
2179   theStatus = "";
2180   if (theIObj.IsNull()
2181   || !myObjects.IsBound (theIObj))
2182   {
2183     return;
2184   }
2185
2186   theStatus += "\t ____________________________________________";
2187   theStatus += "\t| Known at Neutral Point:\n\tDisplayStatus:";
2188   const Handle(AIS_GlobalStatus)& aStatus = myObjects (theIObj);
2189   switch (aStatus->GraphicStatus())
2190   {
2191     case AIS_DS_Displayed:
2192     {
2193       theStatus += "\t| -->Displayed\n";
2194       break;
2195     }
2196     case AIS_DS_Erased:
2197     {
2198       theStatus += "\t| -->Erased\n";
2199       break;
2200     }
2201     default:
2202       break;
2203   }
2204
2205   theStatus += "\t| Active Display Modes in the MainViewer :\n";
2206   theStatus += "\t|\t Mode ";
2207   theStatus += TCollection_AsciiString (aStatus->DisplayMode());
2208   theStatus += "\n";
2209
2210   if (IsSelected(theIObj)) theStatus +="\t| Selected\n";
2211
2212   theStatus += "\t| Active Selection Modes in the MainViewer :\n";
2213   for (TColStd_ListIteratorOfListOfInteger aSelModeIter (aStatus->SelectionModes()); aSelModeIter.More(); aSelModeIter.Next())
2214   {
2215     theStatus += "\t\t Mode ";
2216     theStatus += TCollection_AsciiString (aSelModeIter.Value());
2217     theStatus += "\n";
2218   }
2219   theStatus += "\t ____________________________________________";
2220 }
2221
2222 //=======================================================================
2223 //function : GetDefModes
2224 //purpose  :
2225 //=======================================================================
2226 void AIS_InteractiveContext::GetDefModes (const Handle(AIS_InteractiveObject)& theIObj,
2227                                           Standard_Integer&                    theDispMode,
2228                                           Standard_Integer&                    theHiMode,
2229                                           Standard_Integer&                    theSelMode) const
2230 {
2231   if (theIObj.IsNull())
2232   {
2233     return;
2234   }
2235
2236   theDispMode = theIObj->HasDisplayMode()
2237               ? theIObj->DisplayMode()
2238               : (theIObj->AcceptDisplayMode (myDisplayMode)
2239                ? myDisplayMode
2240                : 0);
2241   theHiMode  = theIObj->HasHilightMode()   ? theIObj->HilightMode()   : theDispMode;
2242   theSelMode = theIObj->GlobalSelectionMode();
2243 }
2244
2245 //=======================================================================
2246 //function : EraseGlobal
2247 //purpose  :
2248 //=======================================================================
2249 void AIS_InteractiveContext::EraseGlobal (const Handle(AIS_InteractiveObject)& theIObj,
2250                                           const Standard_Boolean               theToUpdateviewer)
2251 {
2252   if (theIObj.IsNull()
2253   || !myObjects.IsBound (theIObj))
2254   {
2255     return;
2256   }
2257
2258   Handle(AIS_GlobalStatus) aStatus = myObjects (theIObj);
2259
2260   const Standard_Integer aDispMode = theIObj->HasHilightMode() ? theIObj->HilightMode() : 0;
2261   if (aStatus->GraphicStatus() == AIS_DS_Temporary
2262    || aStatus->GraphicStatus() == AIS_DS_Erased)
2263   {
2264     return;
2265   }
2266
2267   if (aStatus->IsHilighted())
2268   {
2269     if (IsCurrent (theIObj))
2270     {
2271       AddOrRemoveCurrentObject (theIObj, Standard_False);
2272     }
2273     else if (myMainPM->IsHighlighted (theIObj, aStatus->DisplayMode()))
2274     {
2275       unhighlightGlobal (theIObj, aStatus->DisplayMode());
2276     }
2277   }
2278
2279   myMainPM->SetVisibility (theIObj, aStatus->DisplayMode(), Standard_False);
2280
2281   if (aStatus->IsHilighted()
2282    && theIObj->HasHilightMode())
2283   {
2284     unhighlightGlobal (theIObj, aDispMode);
2285   }
2286
2287   if (!myLastPicked.IsNull()
2288     && myLastPicked->IsSameSelectable (theIObj))
2289   {
2290     myMainPM->ClearImmediateDraw();
2291   }
2292
2293   if (IsSelected (theIObj)
2294    && aStatus->DisplayMode() != aDispMode)
2295   {
2296     myMainPM->SetVisibility (theIObj, aDispMode, Standard_False);
2297   }
2298
2299   for (TColStd_ListIteratorOfListOfInteger aSelModeIter (aStatus->SelectionModes()); aSelModeIter.More(); aSelModeIter.Next())
2300   {
2301     mgrSelector->Deactivate (theIObj, aSelModeIter.Value(), myMainSel);
2302   }
2303   aStatus->ClearSelectionModes();
2304   aStatus->SetGraphicStatus (AIS_DS_Erased);
2305
2306   if (theToUpdateviewer)
2307   {
2308     myMainVwr->Update();
2309   }
2310 }
2311
2312 //=======================================================================
2313 //function : unhighlightOwners
2314 //purpose  :
2315 //=======================================================================
2316 void AIS_InteractiveContext::unhighlightOwners (const Handle(AIS_InteractiveObject)& theObject)
2317 {
2318   SelectMgr_SequenceOfOwner aSeq;
2319   for (AIS_NListOfEntityOwner::Iterator aSelIter (mySelection->Objects()); aSelIter.More(); aSelIter.Next())
2320   {
2321     if (aSelIter.Value()->IsSameSelectable (theObject)
2322      && aSelIter.Value()->IsSelected())
2323     {
2324       aSeq.Append (aSelIter.Value());
2325     }
2326   }
2327   for (SelectMgr_SequenceOfOwner::Iterator aDelIter (aSeq); aDelIter.More(); aDelIter.Next())
2328   {
2329     AddOrRemoveSelected (aDelIter.Value(), Standard_False);
2330   }
2331 }
2332
2333 //=======================================================================
2334 //function : ClearGlobal
2335 //purpose  :
2336 //=======================================================================
2337 void AIS_InteractiveContext::ClearGlobal (const Handle(AIS_InteractiveObject)& theIObj,
2338                                           const Standard_Boolean               theToUpdateviewer)
2339 {
2340   if (theIObj.IsNull()
2341   || !myObjects.IsBound (theIObj))
2342   {
2343     // for cases when reference shape of connected interactives was not displayed
2344     // but its selection primitives were calculated
2345     const Handle(SelectMgr_SelectableObject)& anObj = theIObj; // to avoid ambiguity
2346     mgrSelector->Remove (anObj);
2347     return;
2348   }
2349
2350   Handle(AIS_GlobalStatus) aStatus = myObjects (theIObj);
2351   unhighlightOwners (theIObj);
2352
2353   myMainPM->Erase (theIObj, -1);
2354
2355   // Object removes from Detected sequence
2356   for(Standard_Integer aDetIter = 1; aDetIter < myAISDetectedSeq.Length(); ++aDetIter)
2357   {
2358     Handle(AIS_InteractiveObject) anObj = DetectedCurrentObject();
2359     if (!anObj.IsNull()
2360       && anObj != theIObj)
2361     {
2362       myAISDetectedSeq.Remove (aDetIter);
2363     }
2364   }
2365
2366   // remove IO from the selection manager to avoid memory leaks
2367   const Handle(SelectMgr_SelectableObject)& anObj = theIObj; // to avoid ambiguity
2368   mgrSelector->Remove (anObj);
2369
2370   myObjects.UnBind (theIObj);
2371   myMainVwr->StructureManager()->UnregisterObject (theIObj);
2372
2373   for (V3d_ListOfViewIterator aDefViewIter (myMainVwr->DefinedViewIterator()); aDefViewIter.More(); aDefViewIter.Next())
2374   {
2375     aDefViewIter.Value()->View()->ChangeHiddenObjects()->Remove (theIObj.get());
2376   }
2377
2378   if (!myLastinMain.IsNull() && myLastinMain->IsSameSelectable (theIObj))
2379     myLastinMain.Nullify();
2380   if (!myLastPicked.IsNull() && myLastPicked->IsSameSelectable (theIObj))
2381     myLastPicked.Nullify();
2382   myMainPM->ClearImmediateDraw();
2383
2384   if (theToUpdateviewer && aStatus->GraphicStatus() == AIS_DS_Displayed)
2385   {
2386     myMainVwr->Update();
2387   }
2388 }
2389
2390 //=======================================================================
2391 //function : ClearGlobalPrs
2392 //purpose  :
2393 //=======================================================================
2394 void AIS_InteractiveContext::ClearGlobalPrs (const Handle(AIS_InteractiveObject)& theIObj,
2395                                              const Standard_Integer               theMode,
2396                                              const Standard_Boolean               theToUpdateViewer)
2397 {
2398   if (theIObj.IsNull()
2399   || !myObjects.IsBound (theIObj))
2400   {
2401     return;
2402   }
2403
2404   const Handle(AIS_GlobalStatus)& aStatus = myObjects (theIObj);
2405   if (aStatus->DisplayMode() == theMode)
2406   {
2407     const Standard_Integer aDispMode = theIObj->HasHilightMode() ? theIObj->HilightMode() : 0;
2408     if (aDispMode == theMode
2409      && myMainPM->IsHighlighted (theIObj, theMode))
2410     {
2411       unhighlightGlobal (theIObj, theMode);
2412     }
2413
2414     myMainPM->Erase (theIObj, theMode);
2415   }
2416
2417   if (aStatus->GraphicStatus() == AIS_DS_Displayed
2418    && theToUpdateViewer)
2419   {
2420     myMainVwr->Update();
2421   }
2422 }
2423
2424 //=======================================================================
2425 //function : DrawHiddenLine
2426 //purpose  :
2427 //=======================================================================
2428 Standard_Boolean AIS_InteractiveContext::DrawHiddenLine() const
2429 {
2430   return myDefaultDrawer->DrawHiddenLine();
2431 }
2432
2433 //=======================================================================
2434 //function : EnableDrawHiddenLine
2435 //purpose  :
2436 //=======================================================================
2437 void AIS_InteractiveContext::EnableDrawHiddenLine() const
2438 {
2439   myDefaultDrawer->EnableDrawHiddenLine();
2440 }
2441
2442 //=======================================================================
2443 //function : DisableDrawHiddenLine 
2444 //purpose  :
2445 //=======================================================================
2446 void AIS_InteractiveContext::DisableDrawHiddenLine() const
2447 {
2448   myDefaultDrawer->DisableDrawHiddenLine();
2449 }
2450
2451 //=======================================================================
2452 //function : HiddenLineAspect
2453 //purpose  :
2454 //=======================================================================
2455 Handle (Prs3d_LineAspect) AIS_InteractiveContext::HiddenLineAspect() const
2456 {
2457   return myDefaultDrawer->HiddenLineAspect();
2458 }
2459
2460 //=======================================================================
2461 //function : SetHiddenLineAspect
2462 //purpose  :
2463 //=======================================================================
2464 void AIS_InteractiveContext::SetHiddenLineAspect (const Handle(Prs3d_LineAspect)& theAspect) const
2465 {
2466   myDefaultDrawer->SetHiddenLineAspect (theAspect);
2467 }
2468
2469 //=======================================================================
2470 //function : SetIsoNumber
2471 //purpose  :
2472 //=======================================================================
2473 void AIS_InteractiveContext::SetIsoNumber (const Standard_Integer theNb,
2474                                            const AIS_TypeOfIso    theType)
2475 {
2476   switch (theType)
2477   {
2478     case AIS_TOI_IsoU:
2479       myDefaultDrawer->UIsoAspect()->SetNumber (theNb);
2480       break;
2481     case AIS_TOI_IsoV:
2482       myDefaultDrawer->VIsoAspect()->SetNumber (theNb);
2483       break;
2484     case AIS_TOI_Both:
2485       myDefaultDrawer->UIsoAspect()->SetNumber (theNb);
2486       myDefaultDrawer->VIsoAspect()->SetNumber (theNb);
2487       break;
2488   }
2489 }
2490
2491 //=======================================================================
2492 //function : IsoNumber
2493 //purpose  :
2494 //=======================================================================
2495 Standard_Integer AIS_InteractiveContext::IsoNumber (const AIS_TypeOfIso theType)
2496 {
2497   switch (theType)
2498   {
2499     case AIS_TOI_IsoU: return myDefaultDrawer->UIsoAspect()->Number();
2500     case AIS_TOI_IsoV: return myDefaultDrawer->VIsoAspect()->Number();
2501     case AIS_TOI_Both: return myDefaultDrawer->UIsoAspect()->Number() == myDefaultDrawer->VIsoAspect()->Number()
2502                             ? myDefaultDrawer->UIsoAspect()->Number()
2503                             : -1;
2504   }
2505   return 0;
2506 }
2507
2508 //=======================================================================
2509 //function : IsoOnPlane
2510 //purpose  :
2511 //=======================================================================
2512 void AIS_InteractiveContext::IsoOnPlane (const Standard_Boolean theToSwitchOn)
2513 {
2514   myDefaultDrawer->SetIsoOnPlane (theToSwitchOn);
2515 }
2516
2517 //=======================================================================
2518 //function : IsoOnPlane
2519 //purpose  :
2520 //=======================================================================
2521 Standard_Boolean AIS_InteractiveContext::IsoOnPlane() const
2522 {
2523   return myDefaultDrawer->IsoOnPlane();
2524 }
2525
2526 //=======================================================================
2527 //function : IsoOnTriangulation
2528 //purpose  :
2529 //=======================================================================
2530 void AIS_InteractiveContext::IsoOnTriangulation (const Standard_Boolean theToSwitchOn)
2531 {
2532   myDefaultDrawer->SetIsoOnTriangulation (theToSwitchOn);
2533 }
2534
2535 //=======================================================================
2536 //function : IsoOnTriangulation
2537 //purpose  :
2538 //=======================================================================
2539 Standard_Boolean AIS_InteractiveContext::IsoOnTriangulation() const
2540 {
2541   return myDefaultDrawer->IsoOnTriangulation();
2542 }
2543
2544 //function : SetPixelTolerance
2545 //purpose  : Disables the mechanism of adaptive tolerance calculation in
2546 //           SelectMgr_ViewerSelector and sets the given tolerance for ALL
2547 //           sensitive entities activated. For more information, see
2548 //           SelectMgr_ViewerSelector.hxx
2549 //=======================================================================
2550 void AIS_InteractiveContext::SetPixelTolerance (const Standard_Integer thePrecision)
2551 {
2552   if (HasOpenedContext())
2553   {
2554     myLocalContexts (myCurLocalIndex)->SetPixelTolerance (thePrecision);
2555   }
2556   else
2557   {
2558     myMainSel->SetPixelTolerance (thePrecision);
2559   }
2560 }
2561
2562 //=======================================================================
2563 //function : PixelTolerance
2564 //purpose  :
2565 //=======================================================================
2566 Standard_Integer AIS_InteractiveContext::PixelTolerance() const
2567 {
2568   return HasOpenedContext()
2569        ? myLocalContexts (myCurLocalIndex)->PixelTolerance()
2570        : myMainSel->PixelTolerance();
2571 }
2572
2573 //=======================================================================
2574 //function : SetSelectionSensitivity
2575 //purpose  : Allows to manage sensitivity of a particular selection of interactive object theObject
2576 //=======================================================================
2577 void AIS_InteractiveContext::SetSelectionSensitivity (const Handle(AIS_InteractiveObject)& theObject,
2578                                                       const Standard_Integer theMode,
2579                                                       const Standard_Integer theNewSensitivity)
2580 {
2581   if (HasOpenedContext())
2582   {
2583     myLocalContexts (myCurLocalIndex)->SetSelectionSensitivity (theObject, theMode, theNewSensitivity);
2584     return;
2585   }
2586
2587   mgrSelector->SetSelectionSensitivity (theObject, theMode, theNewSensitivity);
2588 }
2589
2590 //=======================================================================
2591 //function : IsInLocal
2592 //purpose  :
2593 //=======================================================================
2594 Standard_Boolean AIS_InteractiveContext::IsInLocal (const Handle(AIS_InteractiveObject)& theIObj,
2595                                                     Standard_Integer&                    theIndex) const
2596 {
2597   if (theIObj.IsNull())
2598   {
2599     return Standard_False;
2600   }
2601
2602   // if it exists at neutral point 0 index is returned
2603   if (myObjects.IsBound (theIObj))
2604   {
2605     theIndex = 0;
2606     return Standard_False;
2607   }
2608
2609   for (Standard_Integer aCtxIter = 1; aCtxIter <= myLocalContexts.Extent(); ++aCtxIter)
2610   {
2611     if (myLocalContexts.IsBound (aCtxIter))
2612     {
2613       if(myLocalContexts (aCtxIter)->IsIn (theIObj))
2614       {
2615         theIndex = aCtxIter;
2616         return Standard_True;
2617       }
2618     }
2619   }
2620   theIndex = -1;
2621   return Standard_False;
2622 }
2623
2624 //=======================================================================
2625 //function : InitAttributes
2626 //purpose  :
2627 //=======================================================================
2628 void AIS_InteractiveContext::InitAttributes()
2629 {
2630   mgrSelector->Add (myMainSel);
2631
2632   Graphic3d_MaterialAspect aMat (Graphic3d_NOM_BRASS);
2633   myDefaultDrawer->ShadingAspect()->SetMaterial (aMat);
2634
2635 //  myDefaultDrawer->ShadingAspect()->SetColor(Quantity_NOC_GRAY70);
2636   Handle(Prs3d_LineAspect) aLineAspect = myDefaultDrawer->HiddenLineAspect();
2637   aLineAspect->SetColor      (Quantity_NOC_GRAY20);
2638   aLineAspect->SetWidth      (1.0);
2639   aLineAspect->SetTypeOfLine (Aspect_TOL_DASH);
2640
2641   // tolerance to 2 pixels...
2642   SetPixelTolerance (2);
2643
2644   // Customizing the drawer for trihedrons and planes...
2645   Handle(Prs3d_DatumAspect) aTrihAspect = myDefaultDrawer->DatumAspect();
2646   const Standard_Real aLength = 100.0;
2647   aTrihAspect->SetAxisLength (aLength, aLength, aLength);
2648   const Quantity_NameOfColor aColor = Quantity_NOC_LIGHTSTEELBLUE4;
2649   aTrihAspect->FirstAxisAspect() ->SetColor (aColor);
2650   aTrihAspect->SecondAxisAspect()->SetColor (aColor);
2651   aTrihAspect->ThirdAxisAspect() ->SetColor (aColor);
2652
2653   Handle(Prs3d_PlaneAspect) aPlaneAspect = myDefaultDrawer->PlaneAspect();
2654   const Standard_Real aPlaneLength = 200.0;
2655   aPlaneAspect->SetPlaneLength (aPlaneLength, aPlaneLength);
2656   aPlaneAspect->EdgesAspect()->SetColor (Quantity_NOC_SKYBLUE);
2657 }
2658
2659 //=======================================================================
2660 //function : TrihedronSize
2661 //purpose  :
2662 //=======================================================================
2663 Standard_Real AIS_InteractiveContext::TrihedronSize() const
2664 {
2665   return myDefaultDrawer->DatumAspect()->FirstAxisLength();
2666 }
2667
2668 //=======================================================================
2669 //function : SetTrihedronSize
2670 //purpose  :
2671 //=======================================================================
2672 void AIS_InteractiveContext::SetTrihedronSize (const Standard_Real    theVal,
2673                                                const Standard_Boolean /*updateviewer*/)
2674 {
2675   myDefaultDrawer->DatumAspect()->SetAxisLength (theVal, theVal, theVal);
2676   Redisplay (AIS_KOI_Datum, 3, Standard_False);
2677   Redisplay (AIS_KOI_Datum, 4, Standard_True);
2678 }
2679
2680 //=======================================================================
2681 //function : SetPlaneSize
2682 //purpose  :
2683 //=======================================================================
2684 void AIS_InteractiveContext::SetPlaneSize(const Standard_Real    theValX,
2685                                           const Standard_Real    theValY,
2686                                           const Standard_Boolean /*updateviewer*/)
2687 {
2688   myDefaultDrawer->PlaneAspect()->SetPlaneLength (theValX, theValY);
2689   Redisplay (AIS_KOI_Datum, 7);
2690 }
2691
2692 //=======================================================================
2693 //function : SetPlaneSize
2694 //purpose  :
2695 //=======================================================================
2696 void AIS_InteractiveContext::SetPlaneSize (const Standard_Real    theVal,
2697                                            const Standard_Boolean theToUpdateViewer)
2698 {
2699   SetPlaneSize (theVal, theVal, theToUpdateViewer);
2700 }
2701
2702 //=======================================================================
2703 //function : PlaneSize
2704 //purpose  :
2705 //=======================================================================
2706 Standard_Boolean AIS_InteractiveContext::PlaneSize (Standard_Real& theX,
2707                                                     Standard_Real& theY) const
2708 {
2709   theX = myDefaultDrawer->PlaneAspect()->PlaneXLength();
2710   theY = myDefaultDrawer->PlaneAspect()->PlaneYLength();
2711   return (Abs (theX - theY) <= Precision::Confusion());
2712 }
2713
2714 //=======================================================================
2715 //function : SetAutoActivateSelection
2716 //purpose  :
2717 //=======================================================================
2718 void AIS_InteractiveContext::SetAutoActivateSelection (const Standard_Boolean theIsAuto)
2719 {
2720   myIsAutoActivateSelMode = theIsAuto;
2721 }
2722
2723 //=======================================================================
2724 //function : GetAutoActivateSelection
2725 //purpose  :
2726 //=======================================================================
2727 Standard_Boolean AIS_InteractiveContext::GetAutoActivateSelection() const
2728 {
2729   return myIsAutoActivateSelMode;
2730 }
2731
2732 //=======================================================================
2733 //function : SetZLayer
2734 //purpose  :
2735 //=======================================================================
2736 void AIS_InteractiveContext::SetZLayer (const Handle(AIS_InteractiveObject)& theIObj,
2737                                         const Standard_Integer theLayerId)
2738 {
2739   if (theIObj.IsNull())
2740     return;
2741
2742   theIObj->SetZLayer (theLayerId);
2743 }
2744
2745 //=======================================================================
2746 //function : GetZLayer
2747 //purpose  :
2748 //=======================================================================
2749 Standard_Integer AIS_InteractiveContext::GetZLayer (const Handle(AIS_InteractiveObject)& theIObj) const
2750 {
2751   return !theIObj.IsNull()
2752        ?  theIObj->ZLayer()
2753        :  Graphic3d_ZLayerId_UNKNOWN;
2754 }
2755
2756 //=======================================================================
2757 //function : RebuildSelectionStructs
2758 //purpose  : Rebuilds 1st level of BVH selection forcibly
2759 //=======================================================================
2760 void AIS_InteractiveContext::RebuildSelectionStructs()
2761 {
2762   myMainSel->RebuildObjectsTree (Standard_True);
2763 }
2764
2765 //=======================================================================
2766 //function : Disconnect
2767 //purpose  : Disconnects selectable object from an assembly and updates selection structures
2768 //=======================================================================
2769 void AIS_InteractiveContext::Disconnect (const Handle(AIS_InteractiveObject)& theAssembly,
2770                                          const Handle(AIS_InteractiveObject)& theObjToDisconnect)
2771 {
2772   if (theAssembly->IsInstance ("AIS_MultipleConnectedInteractive"))
2773   {
2774     Handle(AIS_MultipleConnectedInteractive) theObj (Handle(AIS_MultipleConnectedInteractive)::DownCast (theAssembly));
2775     theObj->Disconnect (theObjToDisconnect);
2776     const Handle(SelectMgr_SelectableObject)& anObj = theObjToDisconnect; // to avoid ambiguity
2777     mgrSelector->Remove (anObj);
2778   }
2779   else if (theAssembly->IsInstance ("AIS_ConnectedInteractive") && theObjToDisconnect.IsNull())
2780   {
2781     Handle(AIS_ConnectedInteractive) theObj (Handle(AIS_ConnectedInteractive)::DownCast (theAssembly));
2782     theObj->Disconnect();
2783     const Handle(SelectMgr_SelectableObject)& anObj = theObj; // to avoid ambiguity
2784     mgrSelector->Remove (anObj);
2785   }
2786   else
2787     return;
2788 }
2789
2790 //=======================================================================
2791 //function : FitSelected
2792 //purpose  : Fits the view corresponding to the bounds of selected objects
2793 //=======================================================================
2794 void AIS_InteractiveContext::FitSelected (const Handle(V3d_View)& theView,
2795                                           const Standard_Real theMargin,
2796                                           const Standard_Boolean theToUpdate)
2797 {
2798   const Handle(AIS_Selection)& aSelection = HasOpenedContext() ?
2799       myLocalContexts(myCurLocalIndex)->Selection() : mySelection;
2800
2801   Bnd_Box aBndSelected;
2802
2803   AIS_MapOfObjectOwners anObjectOwnerMap;
2804   for (aSelection->Init(); aSelection->More(); aSelection->Next())
2805   {
2806     const Handle(SelectMgr_EntityOwner)& anOwner = aSelection->Value();
2807     Handle(AIS_InteractiveObject) anObj = Handle(AIS_InteractiveObject)::DownCast(anOwner->Selectable());
2808     if (anObj->IsInfinite())
2809     {
2810       continue;
2811     }
2812
2813     if (anOwner == anObj->GlobalSelOwner())
2814     {
2815       Bnd_Box aTmpBnd;
2816       anObj->BoundingBox (aTmpBnd);
2817       aBndSelected.Add (aTmpBnd);
2818     }
2819     else
2820     {
2821       Handle(SelectMgr_IndexedMapOfOwner) anOwnerMap;
2822       if (!anObjectOwnerMap.Find (anOwner->Selectable(), anOwnerMap))
2823       {
2824         anOwnerMap = new SelectMgr_IndexedMapOfOwner();
2825         anObjectOwnerMap.Bind (anOwner->Selectable(), anOwnerMap);
2826       }
2827
2828       anOwnerMap->Add (anOwner);
2829     }
2830   }
2831
2832   for (AIS_MapIteratorOfMapOfObjectOwners anIter (anObjectOwnerMap); anIter.More(); anIter.Next())
2833   {
2834     const Handle(SelectMgr_SelectableObject) anObject = anIter.Key();
2835     Bnd_Box aTmpBox = anObject->BndBoxOfSelected (anIter.ChangeValue());
2836     aBndSelected.Add (aTmpBox);
2837   }
2838
2839   anObjectOwnerMap.Clear();
2840
2841   if (aBndSelected.IsVoid())
2842     return;
2843
2844   theView->FitAll (aBndSelected, theMargin, theToUpdate);
2845 }
2846
2847 //=======================================================================
2848 //function : SetTransformPersistence
2849 //purpose  :
2850 //=======================================================================
2851 void AIS_InteractiveContext::SetTransformPersistence (const Handle(AIS_InteractiveObject)& theObject,
2852                                                       const Handle(Graphic3d_TransformPers)& theTrsfPers)
2853 {
2854   theObject->SetTransformPersistence (theTrsfPers);
2855   if (!myObjects.IsBound (theObject))
2856   {
2857     return;
2858   }
2859
2860   mgrSelector->UpdateSelection (theObject);
2861
2862   const Standard_Integer    aLayerId   = myObjects.Find (theObject)->GetLayerIndex();
2863   const Handle(V3d_Viewer)& aCurViewer = CurrentViewer();
2864   for (V3d_ListOfViewIterator anActiveViewIter (aCurViewer->ActiveViewIterator()); anActiveViewIter.More(); anActiveViewIter.Next())
2865   {
2866     anActiveViewIter.Value()->View()->InvalidateBVHData (aLayerId);
2867     anActiveViewIter.Value()->View()->InvalidateZLayerBoundingBox (aLayerId);
2868   }
2869 }