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