0024002: Overall code and build procedure refactoring -- automatic
[occt.git] / src / AIS / AIS_LocalContext_1.cxx
1 // Created on: 1996-10-30
2 // Created by: Robert COUBLANC
3 // Copyright (c) 1996-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 // Modified by rob Thu Apr 02 1998 
18 //              - use of optimisation in SelectMgr_ViewerSelector
19 //              -> Best management in detected entities...
20
21 #include <AIS_InteractiveContext.hxx>
22 #include <AIS_InteractiveObject.hxx>
23 #include <AIS_LocalContext.hxx>
24 #include <AIS_LocalStatus.hxx>
25 #include <AIS_Selection.hxx>
26 #include <AIS_Shape.hxx>
27 #include <Aspect_Grid.hxx>
28 #include <Geom_Transformation.hxx>
29 #include <Graphic3d_ArrayOfTriangles.hxx>
30 #include <Graphic3d_Group.hxx>
31 #include <NCollection_Map.hxx>
32 #include <OSD_Environment.hxx>
33 #include <Prs3d_Drawer.hxx>
34 #include <Prs3d_Presentation.hxx>
35 #include <Prs3d_ShadingAspect.hxx>
36 #include <Select3D_SensitiveTriangulation.hxx>
37 #include <SelectBasics_SensitiveEntity.hxx>
38 #include <SelectMgr_EntityOwner.hxx>
39 #include <SelectMgr_Filter.hxx>
40 #include <SelectMgr_OrFilter.hxx>
41 #include <SelectMgr_SelectableObject.hxx>
42 #include <SelectMgr_Selection.hxx>
43 #include <SelectMgr_SelectionManager.hxx>
44 #include <SelectMgr_SequenceOfOwner.hxx>
45 #include <Standard_Transient.hxx>
46 #include <StdSelect_BRepOwner.hxx>
47 #include <StdSelect_ViewerSelector3d.hxx>
48 #include <TCollection_AsciiString.hxx>
49 #include <TColStd_ListIteratorOfListOfInteger.hxx>
50 #include <TColStd_ListOfInteger.hxx>
51 #include <TColStd_MapIteratorOfMapOfTransient.hxx>
52 #include <TColStd_MapOfTransient.hxx>
53 #include <TopoDS_Shape.hxx>
54 #include <V3d_View.hxx>
55 #include <Visual3d_View.hxx>
56
57 static Standard_Integer GetHiMod(const Handle(AIS_InteractiveObject)& IO)
58 {
59   return IO->HasHilightMode() ? IO->HilightMode():0;
60 }
61
62 //==================================================
63 // Function: MoveTo
64 // Purpose :
65 //==================================================
66 AIS_StatusOfDetection AIS_LocalContext::MoveTo (const Standard_Integer  theXpix,
67                                                 const Standard_Integer  theYpix,
68                                                 const Handle(V3d_View)& theView,
69                                                 const Standard_Boolean  theToRedrawImmediate)
70 {
71   // check that ViewerSelector gives
72   if (theView->Viewer() != myCTX->CurrentViewer())
73   {
74     return AIS_SOD_Error;
75   }
76
77   myAISCurDetected = 0;
78   myAISDetectedSeq.Clear();
79
80   myCurDetected = 0;
81   myDetectedSeq.Clear();
82   myFilters->SetDisabledObjects (theView->View()->HiddenObjects());
83   myMainVS->Pick (theXpix, theYpix, theView);
84
85   const Standard_Integer aDetectedNb = myMainVS->NbPicked();
86   for (Standard_Integer aDetIter = 1; aDetIter <= aDetectedNb; ++aDetIter)
87   {
88     Handle(SelectMgr_EntityOwner) anOwner = myMainVS->Picked (aDetIter);
89     if (anOwner.IsNull()
90      || !myFilters->IsOk (anOwner))
91     {
92       continue;
93     }
94
95     myDetectedSeq.Append (aDetIter); // normally they are already arranged in correct order...
96     Handle(AIS_InteractiveObject) anObj = Handle(AIS_InteractiveObject)::DownCast (anOwner->Selectable());
97     if (!anObj.IsNull())
98     {
99       myAISDetectedSeq.Append (anObj);
100     }
101   }
102
103   // result of courses..
104   if (aDetectedNb == 0 || myDetectedSeq.IsEmpty())
105   {
106     if (mylastindex != 0 && mylastindex <= myMapOfOwner->Extent())
107     {
108       myMainPM->ClearImmediateDraw();
109       Unhilight (myMapOfOwner->FindKey (mylastindex), theView);
110       if (theToRedrawImmediate)
111       {
112         theView->RedrawImmediate();
113       }
114     }
115
116     mylastindex = 0;
117     return aDetectedNb == 0
118          ? AIS_SOD_Nothing
119          : AIS_SOD_AllBad;
120   }
121
122   // all owners detected by the selector are passed to the
123   // filters and correct ones are preserved...
124   myCurDetected = 1;
125   Handle(SelectMgr_EntityOwner) anOwner = myMainVS->Picked (myDetectedSeq (myCurDetected));
126   manageDetected (anOwner, theView, theToRedrawImmediate);
127   if (myDetectedSeq.Length() == 1)
128   {
129     return aDetectedNb == 1
130          ? AIS_SOD_OnlyOneDetected
131          : AIS_SOD_OnlyOneGood;
132   }
133   else
134   {
135     return AIS_SOD_SeveralGood;
136   }
137 }
138
139 //=======================================================================
140 //function : Select
141 //purpose  : 
142 //=======================================================================
143 AIS_StatusOfPick AIS_LocalContext::Select (const Standard_Boolean toUpdateViewer)
144 {
145   if (myAutoHilight)
146   {
147     UnhilightPicked (Standard_False);
148   }
149
150   AIS_Selection::SetCurrentSelection (mySelName.ToCString());
151
152   Standard_Integer aDetIndex = DetectedIndex();
153   if (aDetIndex <= 0)
154   {
155     ClearSelected (toUpdateViewer);
156     return (AIS_Selection::Extent() == 0) ? AIS_SOP_NothingSelected : AIS_SOP_Removed;
157   }
158
159   const Handle(SelectMgr_EntityOwner)& anOwner = myMapOfOwner->FindKey (aDetIndex);
160
161   ClearSelected (Standard_False);
162
163   if (!anOwner->IsSelected()) // anOwner is not selected
164   {
165     anOwner->SetSelected (Standard_True);
166     AIS_Selection::Select (anOwner);
167   }
168
169   if (myAutoHilight)
170   {
171     const Handle(V3d_Viewer)& aViewer = myCTX->CurrentViewer();
172     for (aViewer->InitActiveViews(); aViewer->MoreActiveViews(); aViewer->NextActiveViews())
173     {
174       Unhilight (anOwner, aViewer->ActiveView());
175     }
176
177     // advanced selection highlighting mechanism
178     if (!anOwner->IsAutoHilight() && anOwner->HasSelectable())
179     {
180       Handle(AIS_InteractiveObject) anIO = Handle(AIS_InteractiveObject)::DownCast(anOwner->Selectable());
181       UpdateSelected (anIO, Standard_False);
182     }
183
184     if (toUpdateViewer)
185     {
186       myCTX->CurrentViewer()->Update();
187     }
188   }
189
190   return (AIS_Selection::Extent() == 1) ? AIS_SOP_OneSelected : AIS_SOP_SeveralSelected;
191 }
192
193 //=======================================================================
194 //function : Select
195 //purpose  : 
196 //=======================================================================
197 AIS_StatusOfPick AIS_LocalContext::Select (const Standard_Integer  theXPMin,
198                                            const Standard_Integer  theYPMin,
199                                            const Standard_Integer  theXPMax,
200                                            const Standard_Integer  theYPMax,
201                                            const Handle(V3d_View)& theView,
202                                            const Standard_Boolean  toUpdateViewer)
203 {
204   if (theView->Viewer() == myCTX->CurrentViewer())
205   {
206     myMainVS->Pick (theXPMin, theYPMin, theXPMax, theYPMax, theView);
207     if (myAutoHilight)
208     {
209       UnhilightPicked (Standard_False);
210     }
211
212     AIS_Selection::SetCurrentSelection (mySelName.ToCString());
213     Standard_Integer aSelNum = AIS_Selection::Extent();
214
215     myMainVS->Init();
216     if (!myMainVS->More())
217     {
218       ClearSelected (toUpdateViewer);
219       mylastindex = 0;
220       return aSelNum == 0 ? AIS_SOP_NothingSelected : AIS_SOP_Removed;
221     }
222
223     ClearSelected (Standard_False);
224
225     for (myMainVS->Init(); myMainVS->More(); myMainVS->Next())
226     {
227       const Handle(SelectMgr_EntityOwner)& anOwner = myMainVS->Picked();
228       if (myFilters->IsOk (anOwner))
229       {
230         // it can be helpful to classify this owner immediately...
231         if (!anOwner->IsSelected())
232         {
233           anOwner->SetSelected (Standard_True);
234           AIS_Selection::Select (anOwner);
235         }
236       }
237     }
238
239     if (myAutoHilight)
240     {
241       HilightPicked (toUpdateViewer);
242     }
243   }
244
245   Standard_Integer aSelNum = AIS_Selection::Extent();
246
247   return (aSelNum == 1) ? AIS_SOP_OneSelected
248                         : (aSelNum > 1) ? AIS_SOP_SeveralSelected
249                                         : AIS_SOP_Error;
250 }
251
252 //==================================================
253 // Function: Select
254 // Purpose : Selection by polyline
255 //==================================================
256 AIS_StatusOfPick AIS_LocalContext::Select (const TColgp_Array1OfPnt2d& thePolyline,
257                                            const Handle(V3d_View)& theView,
258                                            const Standard_Boolean toUpdateViewer)
259 {
260   if (theView->Viewer() == myCTX->CurrentViewer())
261   {
262     myMainVS->Pick (thePolyline, theView);
263
264     AIS_Selection::SetCurrentSelection (mySelName.ToCString());
265
266     Standard_Integer aLastSelNum = AIS_Selection::Extent();
267     myMainVS->Init();
268     if (!myMainVS->More())
269     {
270       // Nothing is selected clear selection.
271       ClearSelected (toUpdateViewer);
272       mylastindex = 0;
273
274       // Return state to know if something was unselected
275       return aLastSelNum == 0 ? AIS_SOP_NothingSelected : AIS_SOP_Removed;
276     }
277
278     if (myAutoHilight)
279     {
280       UnhilightPicked (Standard_False);
281     }
282
283     // Clear previous selection without update to process this selection
284     ClearSelected (Standard_False);
285
286     for (myMainVS->Init(); myMainVS->More(); myMainVS->Next())
287     {
288       const Handle(SelectMgr_EntityOwner)& anOwner = myMainVS->Picked();
289       if (myFilters->IsOk (anOwner))
290       {
291         // it can be helpful to classify this owner immediately...
292         if (!anOwner->IsSelected())
293         {
294           AIS_Selection::AddSelect (anOwner);
295           anOwner->SetSelected (Standard_True);
296         }
297       }
298     }
299
300     if (myAutoHilight)
301     {
302       HilightPicked (toUpdateViewer);
303     }
304   }
305
306   Standard_Integer aSelNum = AIS_Selection::Extent();
307   return (aSelNum == 1) ? AIS_SOP_OneSelected
308                         : (aSelNum > 1) ? AIS_SOP_SeveralSelected
309                                         : AIS_SOP_Error;
310 }
311
312 //=======================================================================
313 //function : ShiftSelect
314 //purpose  : 
315 //=======================================================================
316 AIS_StatusOfPick AIS_LocalContext::ShiftSelect (const Standard_Boolean toUpdateViewer)
317 {
318   Standard_Integer aDetIndex = DetectedIndex();
319   AIS_Selection::SetCurrentSelection (mySelName.ToCString());
320
321   if(aDetIndex > 0)
322   {
323     AIS_Selection::SetCurrentSelection (mySelName.ToCString());
324     Standard_Integer aSelNum = AIS_Selection::Extent();
325     const Handle(SelectMgr_EntityOwner)& anOwner = myMapOfOwner->FindKey (aDetIndex);
326     Standard_Boolean toSelect = anOwner->IsSelected() ? Standard_False : Standard_True;
327     AIS_Selection::Select (anOwner);
328     anOwner->SetSelected (toSelect);
329
330     if(myAutoHilight)
331     {
332       myMainPM->ClearImmediateDraw();
333       const Handle(V3d_Viewer)& aViewer = myCTX->CurrentViewer();
334       for (aViewer->InitActiveViews(); aViewer->MoreActiveViews(); aViewer->NextActiveViews())
335       {
336         Unhilight (anOwner, aViewer->ActiveView());
337       }
338
339       // advanced selection highlighting mechanism
340       if (!anOwner->IsAutoHilight() && anOwner->HasSelectable())
341       {
342         Handle(AIS_InteractiveObject) anIO = Handle(AIS_InteractiveObject)::DownCast (anOwner->Selectable());
343         UpdateSelected (anIO, Standard_False);
344       }
345
346       if (toUpdateViewer)
347       {
348         myCTX->CurrentViewer()->Update();
349       }
350     } 
351
352     Standard_Integer NS = AIS_Selection::Extent();
353     if( NS == 1 ) return AIS_SOP_OneSelected;
354     else if( NS > 1 ) return AIS_SOP_SeveralSelected;
355     return aSelNum == 0 ? AIS_SOP_NothingSelected : AIS_SOP_Removed;
356   }
357   return AIS_SOP_Error;
358 }
359
360 //=======================================================================
361 //function : ShiftSelect
362 //purpose  : 
363 //=======================================================================
364 AIS_StatusOfPick AIS_LocalContext::ShiftSelect (const Standard_Integer  theXPMin,
365                                                 const Standard_Integer  theYPMin,
366                                                 const Standard_Integer  theXPMax,
367                                                 const Standard_Integer  theYPMax,
368                                                 const Handle(V3d_View)& theView,
369                                                 const Standard_Boolean  toUpdateViewer)
370 {
371   myMainPM->ClearImmediateDraw();
372
373   if (theView->Viewer() == myCTX->CurrentViewer())
374   {
375     myMainVS->Pick (theXPMin, theYPMin, theXPMax, theYPMax, theView);
376
377     AIS_Selection::SetCurrentSelection (mySelName.ToCString());
378     Standard_Integer aLastSelNum = AIS_Selection::Extent();
379
380     myMainVS->Init();
381     if (!myMainVS->More())
382     {
383       // Nothing is selected clear selection, but don't clear the selection
384       // as it is shift selection and previous selection matters.
385       // Return state to know if something was unselected
386       return aLastSelNum == 0 ? AIS_SOP_NothingSelected : AIS_SOP_Removed;
387     }
388
389     if (myAutoHilight)
390     {
391       UnhilightPicked (Standard_False);
392     }
393
394     for (myMainVS->Init(); myMainVS->More(); myMainVS->Next())
395     {
396       const Handle(SelectMgr_EntityOwner)& anOwner = myMainVS->Picked();
397       if(myFilters->IsOk (anOwner))
398       {
399         Standard_Boolean toSelect = anOwner->IsSelected() ? Standard_False : Standard_True;
400         AIS_Selection::Select (anOwner);
401         anOwner->SetSelected (toSelect);
402       }
403     }
404
405     if (myAutoHilight)
406     {
407       HilightPicked (toUpdateViewer);
408     }
409   }
410
411   Standard_Integer aSelNum = AIS_Selection::Extent();
412
413   return (aSelNum == 1) ? AIS_SOP_OneSelected
414                         : (aSelNum > 1) ? AIS_SOP_SeveralSelected
415                                         : AIS_SOP_Error;
416 }
417
418 //==================================================
419 // Function: Select
420 // Purpose : Selection by polyline
421 //==================================================
422 AIS_StatusOfPick AIS_LocalContext::ShiftSelect (const TColgp_Array1OfPnt2d& thePolyline,
423                                                 const Handle(V3d_View)&     theView,
424                                                 const Standard_Boolean      toUpdateViewer)
425 {
426   if (theView->Viewer() == myCTX->CurrentViewer())
427   {
428     myMainVS->Pick (thePolyline, theView);
429
430     AIS_Selection::SetCurrentSelection (mySelName.ToCString());
431
432     Standard_Integer aLastSelNum = AIS_Selection::Extent();
433     myMainVS->Init();
434     if(!myMainVS->More())
435     {
436       // Nothing is selected clear selection, but don't clear the selection
437       // as it is shift selection and previous selection matters.
438       // Return state to know if something was unselected
439       return aLastSelNum == 0 ? AIS_SOP_NothingSelected : AIS_SOP_Removed;
440     }
441
442     if (myAutoHilight)
443     {
444       UnhilightPicked (Standard_False);
445     }
446
447     for (myMainVS->Init(); myMainVS->More(); myMainVS->Next())
448     {
449       const Handle(SelectMgr_EntityOwner)& anOwner = myMainVS->Picked();
450       if (myFilters->IsOk (anOwner))
451       {
452         Standard_Boolean toSelect = anOwner->IsSelected() ? Standard_False : Standard_True;
453         AIS_Selection::Select (anOwner);
454         anOwner->SetSelected (toSelect);
455       }
456     }
457     if (myAutoHilight)
458     {
459       HilightPicked (toUpdateViewer);
460     }
461   }
462
463   Standard_Integer aSelNum = AIS_Selection::Extent();
464
465   return (aSelNum == 1) ? AIS_SOP_OneSelected
466                         : (aSelNum > 1) ? AIS_SOP_SeveralSelected
467                                         : AIS_SOP_Error;
468 }
469
470 //==================================================
471 // Function: Hilight
472 // Purpose :
473 //==================================================
474 void AIS_LocalContext::Hilight (const Handle(SelectMgr_EntityOwner)& theOwner,
475                                 const Handle(V3d_View)&              theView)
476 {
477   if (theView.IsNull())
478   {
479     return;
480   }
481
482   const Standard_Integer aHilightMode = GetHiMod (Handle(AIS_InteractiveObject)::DownCast (theOwner->Selectable()));
483   myMainPM->BeginImmediateDraw();
484   theOwner->HilightWithColor (myMainPM, myCTX->HilightColor(), aHilightMode);
485   myMainPM->EndImmediateDraw (theView);
486 }
487
488 //==================================================
489 // Function: Unhilight
490 // Purpose :
491 //==================================================
492 void AIS_LocalContext::Unhilight (const Handle(SelectMgr_EntityOwner)& theOwner,
493                                   const Handle(V3d_View)&              theView)
494 {
495   if (theView.IsNull())
496   {
497     return;
498   }
499
500   const Standard_Integer aHilightMode = GetHiMod (Handle(AIS_InteractiveObject)::DownCast (theOwner->Selectable()));
501   if (IsSelected (theOwner))
502   {
503     if (theOwner->IsAutoHilight())
504     {
505       theOwner->HilightWithColor (myMainPM, myCTX->SelectionColor(), aHilightMode);
506     }
507   }
508   else
509   {
510     theOwner->Unhilight (myMainPM, aHilightMode);
511   }
512 }
513
514 //=======================================================================
515 //function : HilightPicked
516 //purpose  : 
517 //=======================================================================
518 void AIS_LocalContext::HilightPicked(const Standard_Boolean updateviewer)
519 {
520   Handle(AIS_Selection) Sel = AIS_Selection::Selection(mySelName.ToCString());
521   if( Sel.IsNull() ) return;
522
523   typedef NCollection_DataMap <Handle(SelectMgr_SelectableObject), NCollection_Handle<SelectMgr_SequenceOfOwner> > SelectMgr_DataMapOfObjectOwners;
524   SelectMgr_DataMapOfObjectOwners aMap;
525
526   Handle (PrsMgr_PresentationManager3d) PM = myMainPM;
527   
528   // to avoid problems when there is a loop searching for selected objects...
529   const AIS_NListTransient& Obj = Sel->Objects();
530   AIS_NListTransient::Iterator anIter( Obj );
531   for(; anIter.More(); anIter.Next())
532   {
533     const Handle(Standard_Transient)& Tr = anIter.Value();
534     if(!Tr.IsNull()){
535       const Handle(SelectMgr_EntityOwner)& Ownr =
536         *((const Handle(SelectMgr_EntityOwner)*) &Tr);
537       Handle(AIS_InteractiveObject) IO;
538       if(Ownr->HasSelectable()){
539         Handle(StdSelect_BRepOwner) BROwnr = Handle(StdSelect_BRepOwner)::DownCast(Ownr);
540         if(BROwnr.IsNull() || !BROwnr->ComesFromDecomposition()){
541           Handle(SelectMgr_SelectableObject) SO  = Ownr->Selectable();
542           IO = Handle(AIS_InteractiveObject)::DownCast (SO);
543         }
544       }
545       Handle(SelectMgr_SelectableObject) SO = Ownr->Selectable();
546       Standard_Integer HM = GetHiMod(Handle(AIS_InteractiveObject)::DownCast (SO));
547       if ( Ownr->IsAutoHilight() )
548         Ownr->HilightWithColor(PM,myCTX->SelectionColor(),HM);
549       else if ( aMap.IsBound (SO) )
550         aMap(SO)->Append ( Ownr );        
551       else {
552         NCollection_Handle<SelectMgr_SequenceOfOwner> aSeq = new SelectMgr_SequenceOfOwner;
553         aSeq->Append ( Ownr );
554         aMap.Bind ( SO, aSeq );
555       }      
556     }
557   }
558
559   for ( SelectMgr_DataMapOfObjectOwners::Iterator aMapIter(aMap); 
560         aMapIter.More(); aMapIter.Next() )
561   {
562     aMapIter.Key()->HilightSelected (myMainPM, *aMapIter.Value());
563   }
564
565   if (updateviewer)
566   {
567     myCTX->CurrentViewer()->Update();
568   }
569 }
570
571 //==================================================
572 // Function: 
573 // Purpose :
574 //==================================================
575 void AIS_LocalContext::UnhilightPicked (const Standard_Boolean updateviewer)
576 {
577   myMainPM->ClearImmediateDraw();
578
579   Handle(AIS_Selection) Sel = AIS_Selection::Selection(mySelName.ToCString());
580   if( Sel.IsNull() ) return;
581   Handle (PrsMgr_PresentationManager3d) PM = myMainPM;
582   NCollection_Map<Handle(SelectMgr_SelectableObject)> anObjMap;
583   
584   const AIS_NListTransient& Obj = Sel->Objects();
585   AIS_NListTransient::Iterator anIter( Obj );
586   for(; anIter.More(); anIter.Next()){
587     const Handle(Standard_Transient)& Tr = anIter.Value();
588     if(!Tr.IsNull()){
589       const Handle(SelectMgr_EntityOwner)& Ownr =
590         *((const Handle(SelectMgr_EntityOwner)*) &Tr);
591       Standard_Integer HM(0);
592       if(Ownr->HasSelectable()){
593         Handle(SelectMgr_SelectableObject) SO  = Ownr->Selectable();
594         Handle(AIS_InteractiveObject) IO = Handle(AIS_InteractiveObject)::DownCast (SO);
595         anObjMap.Add (IO);
596
597         HM = GetHiMod(IO);
598         Handle(StdSelect_BRepOwner) BROwnr = Handle(StdSelect_BRepOwner)::DownCast(Ownr);
599         if(BROwnr.IsNull() || !BROwnr->ComesFromDecomposition()){
600         }
601       }
602       Ownr->Unhilight(PM,HM);
603     }
604   }
605   
606   for (NCollection_Map<Handle(SelectMgr_SelectableObject)>::Iterator anIter1 ( anObjMap ); 
607         anIter1.More(); anIter1.Next() )
608   {
609     if ( !anIter1.Key()->IsAutoHilight() )
610       anIter1.Key()->ClearSelected();
611   }
612
613   if(updateviewer)
614     myCTX->CurrentViewer()->Update();
615 }
616
617 //=======================================================================
618 //function : IsSelected
619 //purpose  : 
620 //=======================================================================
621 Standard_Boolean AIS_LocalContext::IsSelected(const Handle(AIS_InteractiveObject)& anIObj) const 
622 {
623   return (!FindSelectedOwnerFromIO(anIObj).IsNull());
624 }
625
626 //=======================================================================
627 //function : IsSelected
628 //purpose  : 
629 //=======================================================================
630
631 Standard_Boolean AIS_LocalContext::IsSelected (const Handle(SelectMgr_EntityOwner)& theOwner) const 
632 {
633   return !theOwner.IsNull() && theOwner->IsSelected();
634 }
635
636 //==================================================
637 // Function: 
638 // Purpose :
639 //==================================================
640 void AIS_LocalContext::
641 InitSelected()
642 {
643   AIS_Selection::SetCurrentSelection(mySelName.ToCString());
644   AIS_Selection::CurrentSelection()->Init();
645 }
646
647 //==================================================
648 // Function: 
649 // Purpose :
650 //==================================================
651 Standard_Boolean AIS_LocalContext::
652 MoreSelected() const 
653 {
654   return AIS_Selection::CurrentSelection()->More();
655 }
656
657 //==================================================
658 // Function: 
659 // Purpose :
660 //==================================================
661 void AIS_LocalContext::
662 NextSelected()
663 {
664   AIS_Selection::CurrentSelection()->Next();
665 }
666
667 //==================================================
668 // Function: 
669 // Purpose :
670 //==================================================
671 Standard_Boolean AIS_LocalContext::
672 HasShape() const 
673 {
674   Handle(Standard_Transient) Tr = AIS_Selection::CurrentSelection()->Value();
675   if( Tr.IsNull() ) return Standard_False;
676   Handle(SelectMgr_EntityOwner) EO = Handle(SelectMgr_EntityOwner)::DownCast (Tr);
677   Handle(StdSelect_BRepOwner) BRO = Handle(StdSelect_BRepOwner)::DownCast(EO);
678   if(BRO.IsNull()) return Standard_False;
679   Standard_Boolean hasshape = BRO->HasShape();
680   Standard_Boolean comes = BRO->ComesFromDecomposition();
681   return (hasshape&&comes);
682 }
683
684 //================================================================
685 // Function : HasSelectedShape
686 // Purpose  : Checks if there is a selected shape regardless of its decomposition status
687 //================================================================
688 Standard_Boolean AIS_LocalContext::HasSelectedShape() const
689 {
690   if (AIS_Selection::CurrentSelection()->Extent() == 0)
691     return Standard_False;
692
693   Handle(Standard_Transient) aCurSelection = AIS_Selection::CurrentSelection()->Value();
694   if (aCurSelection.IsNull())
695     return Standard_False;
696
697   Handle(SelectMgr_EntityOwner) anOwner = Handle(SelectMgr_EntityOwner)::DownCast (aCurSelection);
698   Handle(StdSelect_BRepOwner) aBrepOwner = Handle(StdSelect_BRepOwner)::DownCast (anOwner);
699   if (aBrepOwner.IsNull())
700   {
701     return Standard_False;
702   }
703   return aBrepOwner->HasShape();
704 }
705
706 //==================================================
707 // Function: 
708 // Purpose :
709 //==================================================
710 TopoDS_Shape AIS_LocalContext::SelectedShape() const 
711 {
712   Handle(Standard_Transient) aTr = AIS_Selection::CurrentSelection()->Value();
713   Handle(SelectMgr_EntityOwner) anEO = Handle(SelectMgr_EntityOwner)::DownCast (aTr);
714   Handle(StdSelect_BRepOwner) aBRO = Handle(StdSelect_BRepOwner)::DownCast(anEO);
715   if( aBRO.IsNull() ) 
716   {
717     return TopoDS_Shape();
718   }
719
720   return aBRO->Shape().Located (aBRO->Location() * aBRO->Shape().Location());
721 }
722
723 //==================================================
724 // Function: 
725 // Purpose :
726 //==================================================
727 Handle(AIS_InteractiveObject) AIS_LocalContext::
728 SelectedInteractive() const 
729 {
730   Handle(AIS_InteractiveObject) IO;
731   Handle(Standard_Transient) Tr = AIS_Selection::CurrentSelection()->Value();
732   if( !Tr.IsNull() ) {
733     Handle(SelectMgr_EntityOwner) EO = Handle(SelectMgr_EntityOwner)::DownCast (Tr);
734     Handle(SelectMgr_SelectableObject) SO;
735     if(EO->HasSelectable()){
736       SO = EO->Selectable();
737       IO = Handle(AIS_InteractiveObject)::DownCast (SO);
738     }
739   }
740   return IO;
741 }
742 //==================================================
743 // Function: 
744 // Purpose :
745 //==================================================
746 Handle(SelectMgr_EntityOwner) AIS_LocalContext::
747 SelectedOwner() const 
748 {
749   Handle(SelectMgr_EntityOwner) EO;
750   Handle(Standard_Transient) Tr = AIS_Selection::CurrentSelection()->Value();
751   if( !Tr.IsNull() )
752         EO = Handle(SelectMgr_EntityOwner)::DownCast (Tr);
753   return EO;
754 }
755
756 //==================================================
757 // Function: 
758 // Purpose :
759 //==================================================
760 Standard_Boolean AIS_LocalContext::
761 HasApplicative() const 
762 {
763   Handle(AIS_InteractiveObject) IO = SelectedInteractive();
764   if( IO.IsNull() ) return Standard_False;
765   return IO->HasOwner();
766 }
767
768 //==================================================
769 // Function: 
770 // Purpose :
771 //==================================================
772 const Handle(Standard_Transient)& AIS_LocalContext::
773 SelectedApplicative() const 
774 {
775   return SelectedInteractive()->GetOwner();
776 }
777
778
779
780 //=======================================================================
781 //function : UpdateSelection
782 //purpose  : should disappear...
783 //=======================================================================
784 void AIS_LocalContext::UpdateSelected(const Standard_Boolean updateviewer)
785 {
786   UnhilightPicked(Standard_False);
787   HilightPicked(updateviewer);
788 }
789
790 //================================================================
791 // Function : UpdateSelected
792 // Purpose  : Part of advanced selection mechanism.
793 //            Highlightes or clears selection presentation for the given IO
794 //================================================================
795 void AIS_LocalContext::UpdateSelected(const Handle(AIS_InteractiveObject)& anobj,
796                                       const Standard_Boolean updateviewer)
797 {
798   if (anobj.IsNull() || anobj->IsAutoHilight())
799     return;
800
801   AIS_Selection::SetCurrentSelection(mySelName.ToCString());
802   Handle(AIS_Selection) Sel = AIS_Selection::CurrentSelection();
803
804   SelectMgr_SequenceOfOwner aSeq;
805   for ( Sel->Init(); Sel->More(); Sel->Next() ){
806     Handle(SelectMgr_EntityOwner) aOwner = Handle(SelectMgr_EntityOwner)::DownCast(Sel->Value());
807
808     if ( !aOwner.IsNull() && aOwner->HasSelectable() && aOwner->Selectable() == anobj )
809       aSeq.Append( aOwner );
810   }
811
812   if ( aSeq.Length() )
813     anobj->HilightSelected( myMainPM, aSeq );
814   else
815     anobj->ClearSelected();
816
817   if(updateviewer){
818      myCTX->CurrentViewer()->Update();
819   }
820 }
821
822 //==================================================
823 // Function: ClearSelected
824 // Purpose :
825 //==================================================
826 void AIS_LocalContext::ClearSelected (const Standard_Boolean updateviewer)
827 {
828   UnhilightPicked(updateviewer);
829   AIS_Selection::SetCurrentSelection(mySelName.ToCString());
830
831   Handle(AIS_Selection) Sel = AIS_Selection::CurrentSelection();
832   const AIS_NListTransient& Obj = Sel->Objects();
833   AIS_NListTransient::Iterator anIter( Obj );
834   for(; anIter.More(); anIter.Next()){
835     const Handle(Standard_Transient)& Tr = anIter.Value();
836     if(!Tr.IsNull())
837     {
838       (*((const Handle(SelectMgr_EntityOwner)*)&Tr))->SetSelected (Standard_False);
839     }
840   }
841   AIS_Selection::Select();
842   mylastindex = 0;
843 }
844
845 //==================================================
846 // Function: ClearOutdatedSelection
847 // Purpose :
848 //==================================================
849 void AIS_LocalContext::ClearOutdatedSelection (const Handle(AIS_InteractiveObject)& theIO,
850                                                const Standard_Boolean toClearDeactivated)
851 {
852   // 1. Collect selectable entities
853   SelectMgr_IndexedMapOfOwner aValidOwners;
854
855   const TColStd_ListOfInteger& aModes = SelectionModes (theIO);
856
857   TColStd_ListIteratorOfListOfInteger aModeIter (aModes);
858   for (; aModeIter.More(); aModeIter.Next())
859   {
860     int aMode = aModeIter.Value();
861     if (!theIO->HasSelection(aMode))
862     {
863       continue;
864     }
865
866     if (toClearDeactivated && !mySM->IsActivated(theIO, aMode, myMainVS))
867     {
868       continue;
869     }
870
871     Handle(SelectMgr_Selection) aSelection = theIO->Selection(aMode);
872     for (aSelection->Init(); aSelection->More(); aSelection->Next())
873     {
874       Handle(SelectBasics_SensitiveEntity) anEntity = aSelection->Sensitive()->BaseSensitive();
875       if (anEntity.IsNull())
876       {
877         continue;
878       }
879
880       Handle(SelectMgr_EntityOwner) anOwner =
881         Handle(SelectMgr_EntityOwner)::DownCast (anEntity->OwnerId());
882
883       if (anOwner.IsNull())
884       {
885         continue;
886       }
887
888       aValidOwners.Add(anOwner);
889     }
890   }
891
892   // 2. Refresh context's detection and selection and keep only active owners
893   // Keep last detected object for lastindex initialization.
894   Handle(SelectMgr_EntityOwner) aLastPicked = myMainVS->OnePicked();
895
896   // Remove entity owners from detected sequences
897   for (Standard_Integer anIdx = 1; anIdx <= myDetectedSeq.Length(); ++anIdx)
898   {
899     Handle(SelectMgr_EntityOwner) anOwner = myMainVS->Picked (myDetectedSeq (anIdx));
900     if (anOwner.IsNull() || anOwner->Selectable() != theIO || aValidOwners.Contains (anOwner))
901     {
902       continue;
903     }
904
905     myDetectedSeq.Remove (anIdx--);
906
907     if (anIdx < myCurDetected)
908     {
909       myCurDetected--;
910     }
911   }
912   myCurDetected = Max (myCurDetected, 1);
913
914   Standard_Boolean isAISRemainsDetected = Standard_False;
915
916   // 3. AIS_Selection : remove entity owners from AIS_Selection
917   const Handle(V3d_Viewer)& aViewer = myCTX->CurrentViewer();
918   Handle(AIS_Selection) aSelection = AIS_Selection::Selection (mySelName.ToCString());
919   AIS_NListTransient::Iterator anIter (aSelection->Objects());
920   AIS_NListTransient aRemoveEntites;
921   for (; anIter.More(); anIter.Next())
922   {
923     Handle(SelectMgr_EntityOwner) anOwner = Handle(SelectMgr_EntityOwner)::DownCast (anIter.Value());
924     if (anOwner.IsNull() || anOwner->Selectable() != theIO)
925     {
926       continue;
927     }
928
929     if (aValidOwners.Contains (anOwner))
930     {
931       isAISRemainsDetected = Standard_True;
932     }
933     else
934     {
935       aRemoveEntites.Append (anOwner);
936       anOwner->SetSelected (Standard_False);
937       for (aViewer->InitActiveViews(); aViewer->MoreActiveViews(); aViewer->NextActiveViews())
938       {
939         Unhilight (anOwner, aViewer->ActiveView());
940       }
941     }
942   }
943   AIS_NListTransient::Iterator anIterRemove (aRemoveEntites);
944   for (; anIterRemove.More(); anIterRemove.Next())
945   {
946     aSelection->Select (anIterRemove.Value());
947   }
948
949   // 4. AIS_LocalContext - myMapOfOwner : remove entity owners from myMapOfOwner
950   SelectMgr_IndexedMapOfOwner anOwnersToKeep;
951   for (Standard_Integer anIdx = 1; anIdx <= myMapOfOwner->Extent(); anIdx++)
952   {
953     Handle(SelectMgr_EntityOwner) anOwner = myMapOfOwner->FindKey (anIdx);
954     if (anOwner.IsNull())
955     {
956       continue;
957     }
958
959     if (anOwner->Selectable() != theIO || aValidOwners.Contains (anOwner))
960     {
961       anOwnersToKeep.Add (anOwner);
962     }
963     else
964     {
965       for (aViewer->InitActiveViews(); aViewer->MoreActiveViews(); aViewer->NextActiveViews())
966       {
967         Unhilight (anOwner, aViewer->ActiveView());
968       }
969     }
970   }
971   myMapOfOwner->Clear();
972   myMapOfOwner->Assign (anOwnersToKeep);
973   mylastindex = myMapOfOwner->FindIndex (aLastPicked);
974   if (!IsValidIndex (mylastindex))
975   {
976     myMainPM->ClearImmediateDraw();
977   }
978
979   if (!isAISRemainsDetected)
980   {
981     // Remove the interactive object from detected sequences
982     for (Standard_Integer anIdx = 1; anIdx <= myAISDetectedSeq.Length(); ++anIdx)
983     {
984       Handle(AIS_InteractiveObject) aDetectedIO = myAISDetectedSeq.Value (anIdx);
985       if (aDetectedIO.IsNull() || aDetectedIO != theIO)
986       {
987         continue;
988       }
989
990       myAISDetectedSeq.Remove (anIdx--);
991
992       if (anIdx < myAISCurDetected)
993       {
994         myAISCurDetected--;
995       }
996     }
997     myAISCurDetected = Max (myAISCurDetected, 1);
998   }
999 }
1000
1001 //=======================================================================
1002 //function : SetSelected
1003 //purpose  : 
1004 //=======================================================================
1005 void AIS_LocalContext::SetSelected(const Handle(AIS_InteractiveObject)& anIObj,
1006                                    const Standard_Boolean updateviewer)
1007 {
1008   if(!IsValidForSelection(anIObj)) return;
1009   UnhilightPicked(Standard_False);
1010   
1011   //1st case, owner already <anIObj> as owner  
1012   // and not separated is found...
1013
1014   Handle(AIS_Selection) sel = AIS_Selection::Selection(mySelName.ToCString());
1015   //Standard_Boolean found(Standard_False);
1016   Handle(Standard_Transient) Tr;
1017   Handle(SelectMgr_EntityOwner) EO = FindSelectedOwnerFromIO(anIObj);
1018   if(EO.IsNull()){
1019     //check if in selection number 0 there is an owner that can be triturated...
1020     if(anIObj->HasSelection(0)){
1021       const Handle(SelectMgr_Selection)& SIOBJ = anIObj->Selection(0);
1022       SIOBJ->Init();
1023       if(SIOBJ->More()){
1024         Handle(SelectBasics_EntityOwner) BO = SIOBJ->Sensitive()->BaseSensitive()->OwnerId();
1025         EO = Handle(SelectMgr_EntityOwner)::DownCast (BO);
1026       }
1027     }
1028     if(EO.IsNull()) 
1029       EO = new SelectMgr_EntityOwner((const Handle(SelectMgr_SelectableObject)&)anIObj);
1030   }
1031   
1032   ClearSelected(Standard_False);
1033
1034   AIS_Selection::Select(EO);
1035   EO->SetSelected (Standard_True);
1036
1037   HilightPicked(updateviewer);
1038 }
1039
1040 //=======================================================================
1041 //function : AddOrRemoveSelected
1042 //purpose  : 
1043 //=======================================================================
1044
1045 void AIS_LocalContext::AddOrRemoveSelected(const Handle(AIS_InteractiveObject)& anIObj,
1046                                            const Standard_Boolean updateviewer)
1047 {
1048   if(!IsValidForSelection(anIObj)) return;
1049   UnhilightPicked(Standard_False);
1050   // first check if it is selected...
1051   Handle(SelectMgr_EntityOwner) EO;
1052
1053   EO = FindSelectedOwnerFromIO(anIObj);
1054
1055   if (EO.IsNull())
1056   {
1057     if(anIObj->HasSelection(0))
1058     {
1059       const Handle(SelectMgr_Selection)& SIOBJ = anIObj->Selection(0);
1060       SIOBJ->Init();
1061       if(SIOBJ->More()){
1062         Handle(SelectBasics_EntityOwner) BO = SIOBJ->Sensitive()->BaseSensitive()->OwnerId();
1063         EO = Handle(SelectMgr_EntityOwner)::DownCast (BO);
1064       }
1065     }
1066     if(EO.IsNull())
1067     {
1068       EO = new SelectMgr_EntityOwner((const Handle(SelectMgr_SelectableObject)&)anIObj);
1069     }
1070   }
1071   
1072 //  cout<<"AIS_LocalContext::AddOrRemoveSelected : Selection = "<<mySelName<<endl;
1073   const Handle(AIS_Selection)& S = AIS_Selection::Selection(mySelName.ToCString());
1074   
1075   if (!S.IsNull())
1076   {
1077     AIS_SelectStatus aStatus = S->Select(EO);
1078     EO->SetSelected (aStatus == AIS_SS_Added);
1079   }
1080
1081   HilightPicked(updateviewer);
1082 }
1083
1084 //=======================================================================
1085 //function : AddOrRemoveSelected
1086 //purpose  : To check...
1087 //=======================================================================
1088 void AIS_LocalContext::AddOrRemoveSelected(const TopoDS_Shape& Sh,
1089                                            const Standard_Boolean updateviewer)
1090 {     
1091   UnhilightPicked (Standard_False);
1092   Handle(SelectMgr_EntityOwner) EO = FindSelectedOwnerFromShape(Sh);
1093   if (!EO.IsNull())
1094   {
1095     AIS_Selection::Selection(mySelName.ToCString())->Select(EO);
1096     EO->SetSelected (Standard_True);
1097   }
1098   HilightPicked (updateviewer);
1099 }
1100
1101 void AIS_LocalContext::AddOrRemoveSelected (const Handle(SelectMgr_EntityOwner)& theOwner,
1102                                            const Standard_Boolean toUpdateViewer)
1103 {
1104   if(myAutoHilight)
1105   {
1106     UnhilightPicked (Standard_False);
1107   }
1108
1109   Standard_Boolean toSelect = theOwner->IsSelected() ? Standard_False : Standard_True;
1110
1111   AIS_Selection::Selection (mySelName.ToCString())->Select (theOwner);
1112   theOwner->SetSelected (toSelect);
1113
1114   if(myAutoHilight)
1115   {
1116     HilightPicked (toUpdateViewer);
1117   }
1118 }
1119
1120 //==================================================
1121 // Function: manageDetected
1122 // Purpose :
1123 //==================================================
1124 void AIS_LocalContext::manageDetected (const Handle(SelectMgr_EntityOwner)& thePickOwner,
1125                                        const Handle(V3d_View)&              theView,
1126                                        const Standard_Boolean               theToRedrawImmediate)
1127 {
1128   if (thePickOwner.IsNull())
1129   {
1130     myMainPM->ClearImmediateDraw();
1131     if (theToRedrawImmediate)
1132     {
1133       theView->RedrawImmediate();
1134     }
1135     return;
1136   }
1137
1138   if (!myFilters->IsOk (thePickOwner))
1139   {
1140     if (mylastindex != 0)
1141     {
1142       mylastgood = mylastindex;
1143     }
1144     if (theToRedrawImmediate)
1145     {
1146       theView->RedrawImmediate();
1147     }
1148     return;
1149   }
1150
1151   //=======================================================================================================
1152   // 2 cases : a- object is in the map of picks:
1153   //             1. this is the same index as the last detected: -> Do nothing
1154   //             2. otherwise :
1155   //                  - if lastindex = 0 (no object was detected at the last step)
1156   //                    the object presentation is highlighted and lastindex = index(objet)
1157   //                  - othrwise :
1158   //                           the presentation of the object corresponding to lastindex is "unhighlighted"
1159   //                           it is removed if the object is not visualized but only active
1160   //                           then the presentation of the detected object is highlighted and lastindex = index(objet)
1161   //         b- the object is not in the map of picked objects
1162   //                  - if lastindex != 0 (object detected at the last step) it is unhighlighted ...
1163   //            if the object was decomposed, presentation is created for the detected shape and the couple
1164   //             (Proprietaire,Prs)is added in the map.
1165   //           otherwise the couple(proprietaire, NullPrs) is placed in the map and the interactive object
1166   //           itself is highlighted.
1167   //
1168   //=======================================================================================================
1169
1170   const Standard_Integer aNewIndex = myMapOfOwner->Contains  (thePickOwner)
1171                                    ? myMapOfOwner->FindIndex (thePickOwner)
1172                                    : myMapOfOwner->Add       (thePickOwner);
1173
1174   // For the advanced mesh selection mode the owner indices comparison
1175   // is not effective because in that case only one owner manage the
1176   // selection in current selection mode. It is necessary to check the current detected
1177   // entity and hilight it only if the detected entity is not the same as
1178   // previous detected (IsForcedHilight call)
1179   if (aNewIndex != mylastindex
1180    || thePickOwner->IsForcedHilight())
1181   {
1182     myMainPM->ClearImmediateDraw();
1183     if (mylastindex != 0
1184      && mylastindex <= myMapOfOwner->Extent())
1185     {
1186       const Handle(SelectMgr_EntityOwner)& aLastOwner = myMapOfOwner->FindKey (mylastindex);
1187       Unhilight (aLastOwner, theView);
1188     }
1189
1190     if (myAutoHilight)
1191     {
1192       if (!thePickOwner->IsSelected() || myCTX->ToHilightSelected())
1193       {
1194         Hilight (thePickOwner, theView);
1195       }
1196       if (theToRedrawImmediate)
1197       {
1198         theView->RedrawImmediate();
1199       }
1200     }
1201
1202     mylastindex = aNewIndex;
1203   }
1204
1205   if (mylastindex != 0)
1206   {
1207     mylastgood = mylastindex;
1208   }
1209 }
1210
1211 //=======================================================================
1212 //function : HasDetectedShape
1213 //purpose  : 
1214 //=======================================================================
1215
1216 Standard_Boolean AIS_LocalContext::HasDetectedShape() const 
1217 {
1218   if(mylastindex==0) return Standard_False;
1219   return IsShape(mylastindex);
1220 }
1221
1222 //=======================================================================
1223 //function : DetectedShape
1224 //purpose  : 
1225 //=======================================================================
1226
1227 const TopoDS_Shape&
1228 AIS_LocalContext::DetectedShape() const
1229 {
1230   static TopoDS_Shape bidsh;
1231   if(mylastindex != 0)
1232   {
1233     Handle(StdSelect_BRepOwner) BROwnr = Handle(StdSelect_BRepOwner)::DownCast(myMapOfOwner->FindKey (mylastindex));
1234     if(BROwnr.IsNull()) return bidsh;
1235     return BROwnr->Shape();
1236   }
1237   return bidsh;
1238 }                                           
1239
1240 //=======================================================================
1241 //function : DetectedInteractive
1242 //purpose  : 
1243 //=======================================================================
1244
1245 Handle(AIS_InteractiveObject) 
1246 AIS_LocalContext::DetectedInteractive() const 
1247 {
1248   Handle(AIS_InteractiveObject) Iobj;
1249   if(IsValidIndex(mylastindex)){
1250     Handle(SelectMgr_SelectableObject) SO = myMapOfOwner->FindKey(mylastindex)->Selectable();
1251     Iobj = Handle(AIS_InteractiveObject)::DownCast (SO);
1252   }
1253   return Iobj;
1254 }
1255 //=======================================================================
1256 //function : DetectedInteractive
1257 //purpose  : 
1258 //=======================================================================
1259 Handle(SelectMgr_EntityOwner) AIS_LocalContext::DetectedOwner() const 
1260 {
1261   Handle(SelectMgr_EntityOwner) bid;
1262   if(!IsValidIndex(mylastindex)) return bid;
1263   return myMapOfOwner->FindKey(mylastindex);
1264 }
1265
1266
1267 //=======================================================================
1268 //function : ComesFromDecomposition
1269 //purpose  : 
1270 //=======================================================================
1271
1272 Standard_Boolean AIS_LocalContext::ComesFromDecomposition(const Standard_Integer PickedIndex) const 
1273 {
1274   const Handle(SelectMgr_EntityOwner)& OWN = myMapOfOwner->FindKey(PickedIndex);
1275   Handle(SelectMgr_SelectableObject) aSel  = OWN->Selectable();
1276   if (myActiveObjects.IsBound (aSel)) { // debug of jmi
1277     const Handle(AIS_LocalStatus)& Stat      = myActiveObjects(aSel);    
1278     return Stat->Decomposed();
1279   }
1280   return Standard_False;
1281 }
1282
1283 //=======================================================================
1284 //function : DisplaySensitive
1285 //purpose  : 
1286 //=======================================================================
1287
1288 void AIS_LocalContext::DisplaySensitive(const Handle(V3d_View)& aviou)
1289 {
1290     myMainVS->DisplaySensitive(aviou);
1291 }
1292
1293 //=======================================================================
1294 //function : ClearSensitive
1295 //purpose  : 
1296 //=======================================================================
1297
1298 void AIS_LocalContext::ClearSensitive(const Handle(V3d_View)& aviou)
1299 {
1300     myMainVS->ClearSensitive(aviou);
1301 }
1302
1303
1304 //=======================================================================
1305 //function : IsShape
1306 //purpose  : 
1307 //=======================================================================
1308 Standard_Boolean AIS_LocalContext::IsShape(const Standard_Integer Index) const
1309 {
1310   
1311   if(Handle(StdSelect_BRepOwner)::DownCast(myMapOfOwner->FindKey(Index)).IsNull())
1312     return Standard_False;
1313   return 
1314     ComesFromDecomposition(Index);
1315 }
1316
1317 Standard_Boolean AIS_LocalContext::IsValidForSelection(const Handle(AIS_InteractiveObject)& anIObj) const 
1318 {
1319
1320   // Shape was not transfered from AIS_Shape to EntityOwner
1321   Handle(AIS_Shape) shape = Handle(AIS_Shape)::DownCast(anIObj);
1322   if( !shape.IsNull() ) 
1323     return myFilters->IsOk(new StdSelect_BRepOwner(shape->Shape(),shape));
1324   return myFilters->IsOk(new SelectMgr_EntityOwner((const Handle(SelectMgr_SelectableObject)&)anIObj));
1325 }
1326
1327
1328 //=======================================================================
1329 //function : HilightNextDetected
1330 //purpose  :
1331 //=======================================================================
1332 Standard_Integer AIS_LocalContext::HilightNextDetected (const Handle(V3d_View)& theView,
1333                                                         const Standard_Boolean  theToRedrawImmediate)
1334 {
1335   // go to the next owner
1336   if (myDetectedSeq.IsEmpty())
1337   {
1338     return 0;
1339   }
1340
1341   const Standard_Integer aLen = myDetectedSeq.Length();
1342   if (++myCurDetected > aLen)
1343   {
1344     myCurDetected = 1;
1345   }
1346   Handle(SelectMgr_EntityOwner) anOwner = myMainVS->Picked (myDetectedSeq (myCurDetected));
1347   if (anOwner.IsNull())
1348   {
1349     return 0;
1350   }
1351   manageDetected (anOwner, theView, theToRedrawImmediate);
1352   return myCurDetected;
1353 }
1354
1355 //=======================================================================
1356 //function : HilightPreviousDetected
1357 //purpose  :
1358 //=======================================================================
1359 Standard_Integer AIS_LocalContext::HilightPreviousDetected (const Handle(V3d_View)& theView,
1360                                                             const Standard_Boolean  theToRedrawImmediate)
1361 {
1362   if (myDetectedSeq.IsEmpty())
1363   {
1364     return 0;
1365   }
1366
1367   const Standard_Integer aLen = myDetectedSeq.Length();
1368   if (--myCurDetected < 1)
1369   {
1370     myCurDetected = aLen;
1371   }
1372   Handle(SelectMgr_EntityOwner) anOwner = myMainVS->Picked (myDetectedSeq (myCurDetected));
1373   if (anOwner.IsNull())
1374   {
1375     return 0;
1376   }
1377
1378   manageDetected (anOwner, theView, theToRedrawImmediate);
1379   return myCurDetected;
1380 }
1381
1382 //=======================================================================
1383 //function : UnhilightLastDetected
1384 //purpose  :
1385 //=======================================================================
1386 Standard_Boolean AIS_LocalContext::UnhilightLastDetected (const Handle(V3d_View)& theView)
1387 {
1388   if (!IsValidIndex (mylastindex))
1389   {
1390     return Standard_False;
1391   }
1392
1393   myMainPM->BeginImmediateDraw();
1394   const Handle(SelectMgr_EntityOwner)& anOwner = myMapOfOwner->FindKey (mylastindex);
1395   const Standard_Integer aHilightMode = anOwner->HasSelectable()
1396                                       ? GetHiMod (Handle(AIS_InteractiveObject)::DownCast (anOwner->Selectable()))
1397                                       : 0;
1398
1399   myMapOfOwner->FindKey (mylastindex)->Unhilight (myMainPM, aHilightMode);
1400   myMainPM->EndImmediateDraw (theView);
1401   mylastindex = 0;
1402   return Standard_True;
1403 }
1404
1405 //=======================================================================
1406 //function : FindSelectedOwnerFromIO
1407 //purpose  : it is checked if one of the selected owners really presents IObj
1408 //=======================================================================
1409 Handle(SelectMgr_EntityOwner) AIS_LocalContext::FindSelectedOwnerFromIO
1410                           (const Handle(AIS_InteractiveObject)& anIObj) const 
1411 {
1412   Handle(SelectMgr_EntityOwner) EO,bid;
1413   if (anIObj.IsNull()) return EO;
1414   
1415   Handle(AIS_Selection) Sel = AIS_Selection::Selection(mySelName.ToCString());
1416   if(Sel.IsNull()) {
1417 #ifdef OCCT_DEBUG
1418     cout<<"\t\tAIS_LocalCOntext::FindSelectedOwnerFromShape : Selection "
1419         <<mySelName<<" Nulle "<<endl;
1420 #endif
1421     return EO;
1422   }
1423   Standard_Boolean found(Standard_False);
1424   const AIS_NListTransient& Obj = Sel->Objects();
1425   AIS_NListTransient::Iterator anIter( Obj );
1426   for(; anIter.More(); anIter.Next()){
1427     const Handle(Standard_Transient)& Tr = anIter.Value();
1428     if(!Tr.IsNull()){
1429       EO = Handle(SelectMgr_EntityOwner)::DownCast (Tr);
1430       if(EO->HasSelectable()){
1431         Handle(StdSelect_BRepOwner) BROwnr = Handle(StdSelect_BRepOwner)::DownCast(EO);
1432         if(BROwnr.IsNull() || !BROwnr->ComesFromDecomposition()){
1433           if (anIObj == EO->Selectable()){
1434             found =Standard_True;
1435             break;
1436           }
1437         }
1438       }
1439     }
1440   }
1441   if(found)  return EO;
1442   return bid;
1443 }
1444
1445 //=======================================================================
1446 //function : FindSelectedOwnerFromShape
1447 //purpose  : it is checked if one of the selected owners really presents IObj
1448 //=======================================================================
1449 Handle(SelectMgr_EntityOwner) AIS_LocalContext::FindSelectedOwnerFromShape(const TopoDS_Shape& sh) const 
1450 {
1451   Handle(SelectMgr_EntityOwner) EO, bid;
1452   if (sh.IsNull()) return EO;
1453   
1454   Handle(AIS_Selection) Sel = AIS_Selection::Selection(mySelName.ToCString());
1455   if(Sel.IsNull()) {
1456 #ifdef OCCT_DEBUG
1457     cout<<"\t\tAIS_LocalCOntext::FindSelectedOwnerFromShape : Selection "<<mySelName<<" Nulle "<<endl;
1458 #endif
1459     return EO;
1460   }
1461   
1462   Standard_Boolean found(Standard_False);
1463
1464   if (!found) {
1465     NCollection_List<Handle(SelectBasics_EntityOwner)> anActiveOwners;
1466     myMainVS->ActiveOwners (anActiveOwners);
1467     for (NCollection_List<Handle(SelectBasics_EntityOwner)>::Iterator anOwnersIt (anActiveOwners); anOwnersIt.More(); anOwnersIt.Next())
1468     {
1469       EO = Handle(SelectMgr_EntityOwner)::DownCast (anOwnersIt.Value());
1470       Handle(StdSelect_BRepOwner) BROwnr = Handle(StdSelect_BRepOwner)::DownCast(EO);
1471       if (!BROwnr.IsNull() && BROwnr->HasShape() && BROwnr->Shape() == sh) {
1472          found = Standard_True;
1473          break;
1474       }
1475     }
1476   }
1477
1478   if(found)  return EO;
1479   return bid;
1480 }
1481
1482 //=======================================================================
1483 //function : AIS_LocalContext::InitDetected
1484 //purpose  :
1485 //=======================================================================
1486 void AIS_LocalContext::InitDetected()
1487 {
1488   myAISCurDetected = myAISDetectedSeq.Length()? 1 : 0;
1489 }
1490
1491 //=======================================================================
1492 //function : AIS_LocalContext::MoreDetected
1493 //purpose  :
1494 //=======================================================================
1495 Standard_Boolean AIS_LocalContext::MoreDetected() const
1496 {
1497   return (myAISCurDetected > 0 && myAISCurDetected <= myAISDetectedSeq.Length());
1498 }
1499
1500 //=======================================================================
1501 //function : AIS_LocalContext::NextDetected
1502 //purpose  :
1503 //=======================================================================
1504 void AIS_LocalContext::NextDetected()
1505 {
1506   myAISCurDetected++;
1507 }
1508
1509 //=======================================================================
1510 //function : DetectedCurrentShape
1511 //purpose  :
1512 //=======================================================================
1513 const TopoDS_Shape& AIS_LocalContext::DetectedCurrentShape() const
1514 {
1515   static TopoDS_Shape aDummyShape;
1516
1517   Handle(AIS_Shape) aCurrentShape = Handle(AIS_Shape)::DownCast (DetectedCurrentObject());
1518
1519   if (aCurrentShape.IsNull())
1520   {
1521     return aDummyShape;
1522   }
1523
1524   return aCurrentShape->Shape();
1525 }
1526 //=======================================================================
1527 //function : DetectedCurrentObject
1528 //purpose  :
1529 //=======================================================================
1530 Handle(AIS_InteractiveObject) AIS_LocalContext::DetectedCurrentObject() const
1531 {
1532   return MoreDetected() ? myAISDetectedSeq(myAISCurDetected) : NULL;
1533 }