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