0027732: Visualization - AIS_ConnectedInteractive crashes on NULL handle returned...
[occt.git] / src / MeshVS / MeshVS_Mesh.cxx
1 // Created on: 2003-09-09
2 // Created by: Alexander SOLOVYOV
3 // Copyright (c) 2003-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16
17 #include <AIS_InteractiveContext.hxx>
18 #include <Aspect_InteriorStyle.hxx>
19 #include <Bnd_Box.hxx>
20 #include <gp_Pnt.hxx>
21 #include <Graphic3d_AspectFillArea3d.hxx>
22 #include <Graphic3d_MaterialAspect.hxx>
23 #include <Graphic3d_NameOfMaterial.hxx>
24 #include <MeshVS_Buffer.hxx>
25 #include <MeshVS_CommonSensitiveEntity.hxx>
26 #include <MeshVS_DataMapIteratorOfDataMapOfIntegerOwner.hxx>
27 #include <MeshVS_DataSource.hxx>
28 #include <MeshVS_Drawer.hxx>
29 #include <MeshVS_DrawerAttribute.hxx>
30 #include <MeshVS_DummySensitiveEntity.hxx>
31 #include <MeshVS_Mesh.hxx>
32 #include <MeshVS_MeshEntityOwner.hxx>
33 #include <MeshVS_MeshOwner.hxx>
34 #include <MeshVS_PrsBuilder.hxx>
35 #include <MeshVS_SelectionModeFlags.hxx>
36 #include <MeshVS_SensitiveFace.hxx>
37 #include <MeshVS_SensitiveMesh.hxx>
38 #include <MeshVS_SensitivePolyhedron.hxx>
39 #include <MeshVS_SensitiveSegment.hxx>
40 #include <MeshVS_SensitiveQuad.hxx>
41 #include <OSD_Timer.hxx>
42 #include <Prs3d_LineAspect.hxx>
43 #include <Prs3d_PointAspect.hxx>
44 #include <Prs3d_Presentation.hxx>
45 #include <Prs3d_Root.hxx>
46 #include <Prs3d_ShadingAspect.hxx>
47 #include <PrsMgr_ModedPresentation.hxx>
48 #include <PrsMgr_PresentationManager3d.hxx>
49 #include <Select3D_SensitiveBox.hxx>
50 #include <Select3D_SensitiveGroup.hxx>
51 #include <Select3D_SensitivePoint.hxx>
52 #include <Select3D_SensitiveTriangle.hxx>
53 #include <SelectBasics_SensitiveEntity.hxx>
54 #include <SelectMgr_EntityOwner.hxx>
55 #include <SelectMgr_Selection.hxx>
56 #include <SelectMgr_SequenceOfOwner.hxx>
57 #include <Standard_Type.hxx>
58 #include <StdSelect_BRepSelectionTool.hxx>
59 #include <TColgp_Array1OfPnt.hxx>
60 #include <TColStd_Array1OfInteger.hxx>
61 #include <TColStd_Array1OfReal.hxx>
62 #include <TColStd_HPackedMapOfInteger.hxx>
63 #include <TColStd_ListIteratorOfListOfInteger.hxx>
64 #include <TColStd_ListIteratorOfListOfReal.hxx>
65 #include <TColStd_MapIteratorOfPackedMapOfInteger.hxx>
66 #include <TColStd_SequenceOfInteger.hxx>
67
68 IMPLEMENT_STANDARD_RTTIEXT(MeshVS_Mesh,AIS_InteractiveObject)
69
70 //================================================================
71 // Function : Constructor MeshVS_Mesh
72 // Purpose  :
73 //================================================================
74 MeshVS_Mesh::MeshVS_Mesh (const Standard_Boolean theIsAllowOverlapped )
75 {
76   myDataSource.Nullify();
77   myHilighter.Nullify();
78   myWholeMeshOwner.Nullify();
79   mySelectionMethod = MeshVS_MSM_NODES;
80
81   SetAutoHilight ( Standard_False );
82
83   SetDisplayMode( MeshVS_DMF_WireFrame ); // Mode as defaut
84   SetHilightMode( MeshVS_DMF_WireFrame ); // Wireframe as default hilight mode
85
86   SetColor ( Quantity_NOC_WHITE );
87   SetMaterial ( Graphic3d_NOM_PLASTIC );
88
89   myCurrentDrawer = new MeshVS_Drawer();
90   myCurrentDrawer->SetColor   ( MeshVS_DA_InteriorColor, Quantity_NOC_BLUE4 );
91   myCurrentDrawer->SetInteger ( MeshVS_DA_InteriorStyle, Aspect_IS_SOLID );
92   myCurrentDrawer->SetInteger ( MeshVS_DA_MaxFaceNodes, 10 );
93   myCurrentDrawer->SetBoolean ( MeshVS_DA_IsAllowOverlapped, theIsAllowOverlapped );
94   myCurrentDrawer->SetBoolean ( MeshVS_DA_Reflection, Standard_True );
95   myCurrentDrawer->SetDouble  ( MeshVS_DA_ShrinkCoeff, 0.8 );
96   myCurrentDrawer->SetBoolean ( MeshVS_DA_ComputeTime, Standard_False );
97   myCurrentDrawer->SetBoolean ( MeshVS_DA_ComputeSelectionTime, Standard_False );
98   myCurrentDrawer->SetBoolean ( MeshVS_DA_DisplayNodes, Standard_True );
99   myCurrentDrawer->SetDouble  ( MeshVS_DA_EdgeWidth, 1.0 );
100   myCurrentDrawer->SetInteger ( MeshVS_DA_EdgeType, Aspect_TOL_SOLID );
101   myCurrentDrawer->SetInteger ( MeshVS_DA_MarkerType,  Aspect_TOM_O );
102   myCurrentDrawer->SetColor   ( MeshVS_DA_MarkerColor, Quantity_NOC_WHITE );
103   myCurrentDrawer->SetDouble  ( MeshVS_DA_MarkerScale, 1.0 );
104   myCurrentDrawer->SetInteger ( MeshVS_DA_BeamType, Aspect_TOL_SOLID );
105   myCurrentDrawer->SetDouble  ( MeshVS_DA_BeamWidth, 1.0 );
106   myCurrentDrawer->SetBoolean ( MeshVS_DA_SmoothShading, Standard_False );
107   myCurrentDrawer->SetBoolean ( MeshVS_DA_SupressBackFaces, Standard_False );
108
109   mySelectionDrawer = new MeshVS_Drawer();
110   mySelectionDrawer->Assign ( myCurrentDrawer );
111   mySelectionDrawer->SetInteger ( MeshVS_DA_MarkerType,  Aspect_TOM_STAR );
112   mySelectionDrawer->SetColor   ( MeshVS_DA_MarkerColor, Quantity_NOC_GRAY80 );
113   mySelectionDrawer->SetDouble  ( MeshVS_DA_MarkerScale, 2.0 );
114
115   mySelectionDrawer->SetColor   ( MeshVS_DA_BeamColor, Quantity_NOC_GRAY80 );
116   mySelectionDrawer->SetInteger ( MeshVS_DA_BeamType,  Aspect_TOL_SOLID );
117   mySelectionDrawer->SetDouble  ( MeshVS_DA_BeamWidth, 3.0 );
118
119   myHilightDrawer = new MeshVS_Drawer ();
120   myHilightDrawer->Assign ( myCurrentDrawer );
121   myHilightDrawer->SetDouble   ( MeshVS_DA_ShrinkCoeff, 0.7 );
122   myHilightDrawer->SetInteger  ( MeshVS_DA_InteriorStyle, Aspect_IS_SOLID );
123   myHilightDrawer->SetColor    ( MeshVS_DA_InteriorColor, Quantity_NOC_YELLOW );
124   myHilightDrawer->SetColor    ( MeshVS_DA_BackInteriorColor, Quantity_NOC_YELLOW );
125   myHilightDrawer->SetColor    ( MeshVS_DA_EdgeColor, Quantity_NOC_GREEN );
126   myHilightDrawer->SetInteger  ( MeshVS_DA_EdgeType, Aspect_TOL_SOLID );
127   myHilightDrawer->SetDouble   ( MeshVS_DA_EdgeWidth, 1.0 );
128   myHilightDrawer->SetMaterial ( MeshVS_DA_FrontMaterial, Graphic3d_NOM_PLASTIC );
129   myHilightDrawer->SetMaterial ( MeshVS_DA_BackMaterial, Graphic3d_NOM_PLASTIC );
130
131   myHilightDrawer->SetColor   ( MeshVS_DA_BeamColor, Quantity_NOC_GRAY80 );
132   myHilightDrawer->SetInteger ( MeshVS_DA_BeamType,  Aspect_TOL_SOLID );
133   myHilightDrawer->SetDouble  ( MeshVS_DA_BeamWidth, 3.0 );
134
135   myHilightDrawer->SetInteger ( MeshVS_DA_MarkerType,  Aspect_TOM_STAR );
136   myHilightDrawer->SetColor   ( MeshVS_DA_MarkerColor, Quantity_NOC_GRAY80 );
137   myHilightDrawer->SetDouble  ( MeshVS_DA_MarkerScale, 2.0 );
138 }
139
140 //================================================================
141 // Function : AcceptDisplayMode
142 // Purpose  :
143 //================================================================
144 Standard_Boolean MeshVS_Mesh::AcceptDisplayMode (const Standard_Integer theMode) const
145 {
146   if (theMode <= 0)
147   {
148     return Standard_False;
149   }
150   else if (myBuilders.IsEmpty())
151   {
152     return Standard_True;
153   }
154
155   for (MeshVS_SequenceOfPrsBuilder::Iterator aBuilderIter (myBuilders); aBuilderIter.More(); aBuilderIter.Next())
156   {
157     Handle(MeshVS_PrsBuilder) aBuilder = aBuilderIter.Value();
158     if (!aBuilder.IsNull()
159       && aBuilder->TestFlags (theMode))
160     {
161       return Standard_True;
162     }
163   }
164   return Standard_False;
165 }
166
167 //================================================================
168 // Function : Compute
169 // Purpose  :
170 //================================================================
171 void MeshVS_Mesh::Compute ( const Handle(PrsMgr_PresentationManager3d)& thePrsMgr,
172                             const Handle(Prs3d_Presentation)& thePresentation,
173                             const Standard_Integer theMode )
174 {
175   Standard_Boolean toShowComputeTime = Standard_True;
176   myCurrentDrawer->GetBoolean (MeshVS_DA_ComputeTime, toShowComputeTime);
177   OSD_Timer aTimer;
178   if (toShowComputeTime)
179   {
180     aTimer.Reset();
181     aTimer.Start();
182   }
183
184   // Repair Ids in map if necessary
185   Handle( MeshVS_DataSource ) aDS = GetDataSource();
186   if (aDS.IsNull()
187    || theMode <= 0)
188   {
189     return;
190   }
191
192   const TColStd_PackedMapOfInteger& aNodes = aDS->GetAllNodes();
193   const TColStd_PackedMapOfInteger& aElems = aDS->GetAllElements();
194   const Standard_Boolean hasNodes    = !aNodes.IsEmpty();
195   const Standard_Boolean hasElements = !aElems.IsEmpty();
196
197   TColStd_PackedMapOfInteger aNodesToExclude, aElemsToExclude;
198   for (MeshVS_SequenceOfPrsBuilder::Iterator aBuilderIter (myBuilders); aBuilderIter.More(); aBuilderIter.Next())
199   {
200     const Handle(MeshVS_PrsBuilder)& aBuilder = aBuilderIter.Value();
201     if (!aBuilder.IsNull()
202       && aBuilder->TestFlags (theMode))
203     {
204       aBuilder->SetPresentationManager (thePrsMgr);
205       if (hasNodes)
206       {
207         aBuilder->Build (thePresentation, aNodes, aNodesToExclude, Standard_False, theMode);
208       }
209       if (hasElements)
210       {
211         aBuilder->Build (thePresentation, aElems, aElemsToExclude, Standard_True,  theMode);
212       }
213     }
214   }
215
216   if (toShowComputeTime)
217   {
218     Standard_Real aSec, aCpu;
219     Standard_Integer aMin, anHour;
220     aTimer.Show (aSec, aMin, anHour, aCpu);
221     std::cout << "DisplayMode : " << theMode << "\n";
222     std::cout << "Compute : " << aSec << " sec\n";
223     std::cout << "Compute CPU : " << aCpu << " sec\n\n";
224   }
225 }
226
227 //================================================================
228 // Function : scanFacesForSharedNodes
229 // Purpose  :
230 //================================================================
231 void MeshVS_Mesh::scanFacesForSharedNodes (const TColStd_PackedMapOfInteger& theAllElements,
232                                            const Standard_Integer theNbMaxFaceNodes,
233                                            TColStd_PackedMapOfInteger& theSharedNodes) const
234 {
235   theSharedNodes.Clear();
236   MeshVS_EntityType aType;
237   Standard_Integer aNbNodes;
238   MeshVS_Buffer aCoordsBuf (3 * theNbMaxFaceNodes * sizeof (Standard_Real));
239   TColStd_Array1OfReal aCoords (aCoordsBuf, 1, 3 * theNbMaxFaceNodes);
240   for (TColStd_MapIteratorOfPackedMapOfInteger aFaceIter (theAllElements); aFaceIter.More(); aFaceIter.Next())
241   {
242     const Standard_Integer aFaceIdx = aFaceIter.Key();
243
244     if (IsSelectableElem (aFaceIdx) &&
245       myDataSource->GetGeomType (aFaceIdx, Standard_True, aType) &&
246       aType == MeshVS_ET_Face)
247     {
248       myDataSource->GetGeom (aFaceIdx, Standard_True, aCoords, aNbNodes, aType );
249       if (aNbNodes == 0)
250         continue;
251
252       MeshVS_Buffer aNodesBuf (aNbNodes * sizeof (Standard_Integer));
253       TColStd_Array1OfInteger aElemNodes (aNodesBuf, 1, aNbNodes);
254       if (!myDataSource->GetNodesByElement (aFaceIdx, aElemNodes, aNbNodes))
255         continue;
256
257       MeshVS_Buffer aFacePntsBuf (aNbNodes * 3 * sizeof (Standard_Real));
258       TColgp_Array1OfPnt aFacePnts (aFacePntsBuf, 1, aNbNodes);
259       for (Standard_Integer aNodeIdx = 1; aNodeIdx <= aNbNodes; ++aNodeIdx)
260       {
261         theSharedNodes.Add (aElemNodes (aNodeIdx));
262       }
263     }
264   }
265 }
266
267 //================================================================
268 // Function : ComputeSelection
269 // Purpose  :
270 //================================================================
271 void MeshVS_Mesh::ComputeSelection (const Handle(SelectMgr_Selection)& theSelection,
272                                     const Standard_Integer theMode)
273 {
274   OSD_Timer gTimer;
275   Standard_Boolean toShowComputeSelectionTime = Standard_True;
276   myCurrentDrawer->GetBoolean( MeshVS_DA_ComputeSelectionTime, toShowComputeSelectionTime);
277   if (toShowComputeSelectionTime)
278   {
279     gTimer.Reset();
280     gTimer.Start();
281   }
282
283   Standard_Integer aMaxFaceNodes = 0;
284   Handle(MeshVS_DataSource) aSource = GetDataSource();
285   if (aSource.IsNull()
286   ||  myCurrentDrawer.IsNull()
287   || !myCurrentDrawer->GetInteger (MeshVS_DA_MaxFaceNodes, aMaxFaceNodes)
288   ||  aMaxFaceNodes <= 0)
289   {
290     return;
291   }
292
293   const Standard_Integer aMode = HasDisplayMode() ? DisplayMode() : DefaultDisplayMode();
294   if (myHilighter.IsNull()
295    || (aMode & MeshVS_DMF_OCCMask) == 0)
296   {
297     return;
298   }
299
300   // Make two array aliases pointing to the same memory:
301   // - TColStd_Array1OfReal for getting values from MeshVS_DataSource interface
302   // - array of gp_Pnt for convenient work with array of points
303   MeshVS_Buffer aCoordsBuf (3 * aMaxFaceNodes * sizeof(Standard_Real));
304   NCollection_Array1<gp_Pnt> aPntArray (aCoordsBuf, 1, aMaxFaceNodes);
305   TColStd_Array1OfReal aPntArrayAsCoordArray (aCoordsBuf, 1, 3 * aMaxFaceNodes);
306
307   const TColStd_PackedMapOfInteger& anAllNodesMap    = aSource->GetAllNodes();
308   const TColStd_PackedMapOfInteger& anAllElementsMap = aSource->GetAllElements();
309   if (aSource->IsAdvancedSelectionEnabled())
310   {
311     Handle(MeshVS_MeshOwner) anOwner;    
312     for (MeshVS_DataMapIteratorOfDataMapOfIntegerOwner anIt (GetOwnerMaps (Standard_False)); anIt.More(); anIt.Next())
313     {
314       anOwner = Handle(MeshVS_MeshOwner)::DownCast (anIt.Value());
315       if (!anOwner.IsNull())
316       {
317         // get the owner if it is already created
318         break;
319       }
320     }
321     if (anOwner.IsNull())
322     {
323       // create one owner for the whole mesh and for all selection modes
324       anOwner = new MeshVS_MeshOwner (this, aSource, 5);
325     }
326
327     // Save the owner. It will be available via GetOwnerMaps method
328     if (!myMeshOwners.IsBound (1))
329     {
330       myMeshOwners.Bind (1, anOwner);
331     }
332     // Create one sensitive entity. It should detect mesh entities correspondingly to selection mode
333     Handle(MeshVS_SensitiveMesh) aSensMesh = new MeshVS_SensitiveMesh (anOwner, theMode);
334     theSelection->Add (aSensMesh);
335   }
336   else
337   {
338     switch (theMode)
339     {
340       case MeshVS_SMF_Node:
341       {
342         myNodeOwners.Clear();
343         for (TColStd_MapIteratorOfPackedMapOfInteger anIter (anAllNodesMap); anIter.More(); anIter.Next())
344         {
345           const Standard_Integer aKey = anIter.Key();
346           Standard_Integer aNbNodes = 0;
347           MeshVS_EntityType aType = MeshVS_ET_NONE;
348           if (!myDataSource->GetGeom (aKey, Standard_False, aPntArrayAsCoordArray, aNbNodes, aType))
349           {
350             continue;
351           }
352
353           Standard_Address anAddr = myDataSource->GetAddr (aKey, Standard_False);
354           Handle(MeshVS_MeshEntityOwner) anOwner = new MeshVS_MeshEntityOwner (this, aKey, anAddr, aType, 5);
355           myNodeOwners.Bind (aKey, anOwner);
356           if (IsSelectableNode (aKey))
357           {
358             Handle(Select3D_SensitivePoint) aPoint = new Select3D_SensitivePoint (anOwner, aPntArray.First());
359             theSelection->Add (aPoint);
360           }
361           else
362           {
363             theSelection->Add (new MeshVS_DummySensitiveEntity (anOwner));
364           }
365         }
366         break;
367       }
368       case MeshVS_SMF_Mesh:
369       {
370         if (myWholeMeshOwner.IsNull())
371         {
372           myWholeMeshOwner = new SelectMgr_EntityOwner (this);
373         }
374
375         switch (mySelectionMethod)
376         {
377           case MeshVS_MSM_BOX:
378           {
379             Bnd_Box aBndBox;
380             BoundingBox (aBndBox);
381             if (!aBndBox.IsVoid())
382             {
383               theSelection->Add (new Select3D_SensitiveBox (myWholeMeshOwner, aBndBox));
384             }
385             break;
386           }
387           case MeshVS_MSM_NODES:
388           {
389             theSelection->Add (new MeshVS_CommonSensitiveEntity (myWholeMeshOwner, this, MeshVS_MSM_NODES));
390             break;
391           }
392           case MeshVS_MSM_PRECISE:
393           {
394             theSelection->Add (new MeshVS_CommonSensitiveEntity (myWholeMeshOwner, this, MeshVS_MSM_PRECISE));
395
396             // since MeshVS_Mesh objects can contain free edges and vertices, it is necessary to create
397             // separate sensitive entity for each of them
398             TColStd_PackedMapOfInteger aSharedNodes;
399             scanFacesForSharedNodes (anAllElementsMap, aMaxFaceNodes, aSharedNodes);
400
401             // create sensitive entities for free edges, if there are any
402             Standard_Integer aNbNodes = 0;
403             MeshVS_EntityType aType = MeshVS_ET_NONE;
404             for (TColStd_MapIteratorOfPackedMapOfInteger anElemIter (anAllElementsMap); anElemIter.More(); anElemIter.Next())
405             {
406               const Standard_Integer anElemIdx = anElemIter.Key();
407               if (IsSelectableElem (anElemIdx)
408                && myDataSource->GetGeomType (anElemIdx, Standard_True, aType)
409                && aType == MeshVS_ET_Link)
410               {
411                 myDataSource->GetGeom (anElemIdx, Standard_True, aPntArrayAsCoordArray, aNbNodes, aType);
412                 if (aNbNodes == 0)
413                 {
414                   continue;
415                 }
416
417                 MeshVS_Buffer aNodesBuf (aNbNodes * sizeof(Standard_Integer));
418                 TColStd_Array1OfInteger aElemNodes (aNodesBuf, 1, aNbNodes);
419                 if (!myDataSource->GetNodesByElement (anElemIdx, aElemNodes, aNbNodes))
420                 {
421                   continue;
422                 }
423
424                 MeshVS_Buffer aPntsBuf (aNbNodes * 3 * sizeof(Standard_Real));
425                 TColgp_Array1OfPnt aLinkPnts (aPntsBuf, 1, aNbNodes);
426                 Standard_Boolean isVertsShared = Standard_True;
427                 for (Standard_Integer aPntIdx = 1; aPntIdx <= aNbNodes; ++aPntIdx)
428                 {
429                   aLinkPnts (aPntIdx) = aPntArray.Value (aPntIdx);
430                   isVertsShared = isVertsShared && aSharedNodes.Contains (aElemNodes (aPntIdx));
431                   aSharedNodes.Add (aElemNodes (aPntIdx));
432                 }
433
434                 if (!isVertsShared)
435                 {
436                   Handle(Select3D_SensitiveEntity) aLinkEnt = new Select3D_SensitiveSegment (myWholeMeshOwner, aLinkPnts.Value (1), aLinkPnts.Value (2));
437                   theSelection->Add (aLinkEnt);
438                 }
439               }
440             }
441
442             // create sensitive entities for free nodes, if there are any
443             for (TColStd_MapIteratorOfPackedMapOfInteger aNodesIter (anAllNodesMap); aNodesIter.More(); aNodesIter.Next())
444             {
445               const Standard_Integer aNodeIdx = aNodesIter.Key();
446               if (IsSelectableNode (aNodeIdx)
447               &&  myDataSource->GetGeom (aNodeIdx, Standard_False, aPntArrayAsCoordArray, aNbNodes, aType)
448               && !aSharedNodes.Contains (aNodeIdx))
449               {
450                 Handle(Select3D_SensitiveEntity) aNodeEnt = new Select3D_SensitivePoint (myWholeMeshOwner, aPntArray.First());
451                 theSelection->Add (aNodeEnt);
452               }
453             }
454           }
455           break;
456         }
457         break;
458       }
459       case MeshVS_SMF_Group:
460       {
461         myGroupOwners.Clear();
462
463         TColStd_PackedMapOfInteger anAllGroupsMap;
464         aSource->GetAllGroups (anAllGroupsMap);
465
466         Handle(MeshVS_HArray1OfSequenceOfInteger) aTopo;
467         for (TColStd_MapIteratorOfPackedMapOfInteger anIter (anAllGroupsMap); anIter.More(); anIter.Next())
468         {
469           const Standard_Integer aKeyGroup = anIter.Key();
470           MeshVS_EntityType aGroupType = MeshVS_ET_NONE;
471           TColStd_PackedMapOfInteger aGroupMap;
472           if (!myDataSource->GetGroup (aKeyGroup, aGroupType, aGroupMap))
473           {
474             continue;
475           }
476
477           Standard_Address anAddr = myDataSource->GetGroupAddr (aKeyGroup);
478           Standard_Integer aPrior = 0;
479           switch (aGroupType)
480           {
481             case MeshVS_ET_Volume: aPrior = 1; break;
482             case MeshVS_ET_Face:   aPrior = 2; break;
483             case MeshVS_ET_Link:   aPrior = 3; break;
484             case MeshVS_ET_0D:     aPrior = 4; break;
485             case MeshVS_ET_Node:   aPrior = 5; break;
486             default: break;
487           }
488
489           Handle(MeshVS_MeshEntityOwner) anOwner = new MeshVS_MeshEntityOwner (this, aKeyGroup, anAddr, aGroupType, aPrior, Standard_True);
490           myGroupOwners.Bind (aKeyGroup, anOwner);
491
492           Standard_Boolean added = Standard_False;
493           Standard_Integer aNbNodes = 0;
494           MeshVS_EntityType aType = MeshVS_ET_NONE;
495           for (TColStd_MapIteratorOfPackedMapOfInteger anIterMG (aGroupMap); anIterMG.More(); anIterMG.Next())
496           {
497             Standard_Integer aKey = anIterMG.Key();
498             if (aGroupType == MeshVS_ET_Node)
499             {
500               if (myDataSource->GetGeom (aKey, Standard_False, aPntArrayAsCoordArray, aNbNodes, aType)
501                && IsSelectableNode/*!IsHiddenNode*/(aKey))
502               {
503                 theSelection->Add (new Select3D_SensitivePoint (anOwner, aPntArray.First ()));
504                 added = Standard_True;
505               }
506             }
507             else if (myDataSource->GetGeomType (aKey, Standard_True, aType)
508                   && IsSelectableElem/*!IsHiddenElem*/(aKey))
509             {
510               myDataSource->GetGeom (aKey, Standard_True, aPntArrayAsCoordArray, aNbNodes, aType);
511               if (aType == MeshVS_ET_Face && aNbNodes > 0) // Faces: 2D-elements
512               {
513                 Handle(Select3D_SensitiveEntity) aSensFace;
514                 if (aNbNodes == 3)
515                 {
516                   aSensFace = new Select3D_SensitiveTriangle (anOwner,
517                                                               aPntArray.Value (1), aPntArray.Value (2), aPntArray.Value (3),
518                                                               Select3D_TOS_INTERIOR);
519                 }
520                 else if (aNbNodes == 4)
521                 {
522                   aSensFace = new MeshVS_SensitiveQuad (anOwner, aPntArray);
523                 }
524                 else
525                 {
526                   aSensFace = new MeshVS_SensitiveFace (anOwner, aPntArray);
527                 }
528                 theSelection->Add (aSensFace);
529                 added = Standard_True;
530               }
531               else if (aType == MeshVS_ET_Link && aNbNodes > 0) // Links: 1D-elements
532               {
533                 Handle (MeshVS_SensitiveSegment) aSeg = new MeshVS_SensitiveSegment (anOwner, aPntArray (1), aPntArray (2));
534                 theSelection->Add (aSeg);
535                 added = Standard_True;
536               }
537               else if (aType == MeshVS_ET_Volume
538                     && aSource->Get3DGeom (aKey, aNbNodes, aTopo))
539               {
540                 Handle(MeshVS_SensitivePolyhedron) aPolyhedron = new MeshVS_SensitivePolyhedron (anOwner, aPntArray, aTopo);
541                 theSelection->Add (aPolyhedron);
542                 added = Standard_True;
543               }
544               else //if ( aType == MeshVS_ET_0D )   // Custom : not only 0D-elements !!!
545               {
546                 Handle(SelectBasics_SensitiveEntity) anEnt = myHilighter->CustomSensitiveEntity (anOwner, aKey);
547                 if (!anEnt.IsNull())
548                 {
549                   theSelection->Add (anEnt);
550                   added = Standard_True;
551                 }
552               }
553             }
554           }
555           if (!added)
556           {
557             theSelection->Add (new MeshVS_DummySensitiveEntity (anOwner));
558           }
559         }
560         break;
561       }
562       default: // all residuary modes
563       {
564         Handle(MeshVS_HArray1OfSequenceOfInteger) aTopo;
565         myElementOwners.Clear();
566
567         MeshVS_DataMapOfIntegerOwner* aCurMap = &my0DOwners;
568         if (theMode == MeshVS_ET_Link)
569         {
570           aCurMap = &myLinkOwners;
571         }
572         else if (theMode == MeshVS_ET_Face)
573         {
574           aCurMap = &myFaceOwners;
575         }
576         else if (theMode == MeshVS_ET_Volume)
577         {
578           aCurMap = &myVolumeOwners;
579         }
580         aCurMap->Clear();
581
582         Standard_Integer aNbNodes = 0;
583         MeshVS_EntityType aType = MeshVS_ET_NONE;
584         for (TColStd_MapIteratorOfPackedMapOfInteger anIterMV (anAllElementsMap); anIterMV.More(); anIterMV.Next())
585         {
586           Standard_Integer aKey = anIterMV.Key();
587           if (myDataSource->GetGeomType (aKey, Standard_True, aType)
588            && theMode == aType)
589           {
590             myDataSource->GetGeom (aKey, Standard_True, aPntArrayAsCoordArray, aNbNodes, aType);
591             Standard_Address anAddr = myDataSource->GetAddr (aKey, Standard_True);
592
593             Standard_Integer aPrior = 0;
594             switch (aType)
595             {
596               case MeshVS_ET_Volume: aPrior = 1; break;
597               case MeshVS_ET_Face:   aPrior = 2; break;
598               case MeshVS_ET_Link:   aPrior = 3; break;
599               case MeshVS_ET_0D:     aPrior = 4; break;
600               default: break;
601             }
602
603             Handle(MeshVS_MeshEntityOwner) anOwner = new MeshVS_MeshEntityOwner (this, aKey, anAddr, aType, aPrior);
604             aCurMap->Bind (aKey, anOwner);
605             if (IsSelectableElem (aKey)) // The element is selectable
606             {
607               if (aType == MeshVS_ET_Face && aNbNodes > 0) // Faces: 2D-elements
608               {
609                 Handle(Select3D_SensitiveEntity) aSensFace;
610                 if (aNbNodes == 3)
611                 {
612                   aSensFace = new Select3D_SensitiveTriangle (anOwner,
613                                                               aPntArray.Value (1), aPntArray.Value (2), aPntArray.Value (3),
614                                                               Select3D_TOS_INTERIOR);
615                 }
616                 else if (aNbNodes == 4)
617                 {
618                   aSensFace = new MeshVS_SensitiveQuad (anOwner, aPntArray);
619                 }
620                 else
621                 {
622                   aSensFace = new MeshVS_SensitiveFace (anOwner, aPntArray);
623                 }
624                 theSelection->Add (aSensFace);
625               }
626               else if (aType == MeshVS_ET_Link && aNbNodes > 0) // Links: 1D-elements
627               {
628                 Handle(MeshVS_SensitiveSegment) aSeg = new MeshVS_SensitiveSegment (anOwner, aPntArray (1), aPntArray (2));
629                 theSelection->Add (aSeg);
630               }
631               else if (aType == MeshVS_ET_Volume
632                     && aSource->Get3DGeom (aKey, aNbNodes, aTopo))
633               {
634                 Handle(MeshVS_SensitivePolyhedron) aPolyhedron = new MeshVS_SensitivePolyhedron (anOwner, aPntArray, aTopo);
635                 theSelection->Add (aPolyhedron);
636               }
637               else //if ( aType == MeshVS_ET_0D )   // Custom : not only 0D-elements !!!
638               {
639                 Handle(SelectBasics_SensitiveEntity) anEnt = myHilighter->CustomSensitiveEntity (anOwner, aKey);
640                 if (!anEnt.IsNull())
641                 {
642                   theSelection->Add (anEnt);
643                 }
644               }
645             }
646             else
647             {
648               theSelection->Add (new MeshVS_DummySensitiveEntity (anOwner));
649             }
650           }
651         }
652         break;
653       }
654     }
655   }
656
657   StdSelect_BRepSelectionTool::PreBuildBVH (theSelection);
658
659   if (toShowComputeSelectionTime)
660   {
661     Standard_Real sec, cpu;
662     Standard_Integer min, hour;
663     gTimer.Show (sec, min, hour, cpu);
664     std::cout << "SelectionMode : " << theMode << "\n";
665     std::cout << "Compute selection: " << sec << " sec\n";
666     std::cout << "Compute selection CPU : " << cpu << " sec\n\n";
667     gTimer.Stop();
668   }
669 }
670
671 //================================================================
672 // Function : GetBuildersCount
673 // Purpose  :
674 //================================================================
675 Standard_Integer MeshVS_Mesh::GetBuildersCount () const
676 {
677   return myBuilders.Length();
678 }
679
680 //================================================================
681 // Function : GetFreeId
682 // Purpose  :
683 //================================================================
684 Standard_Integer MeshVS_Mesh::GetFreeId () const
685 {
686   TColStd_PackedMapOfInteger Ids;
687   Standard_Integer i, len = myBuilders.Length(), curId;
688
689   for ( i=1; i<=len; i++ )
690     Ids.Add( myBuilders.Value(i)->GetId () );
691
692   curId = 0;
693   while ( Ids.Contains( curId ) )
694     curId++;
695
696   return curId;
697 }
698
699 //================================================================
700 // Function : GetBuilder
701 // Purpose  :
702 //================================================================
703 Handle (MeshVS_PrsBuilder) MeshVS_Mesh::GetBuilder ( const Standard_Integer Index ) const
704 {
705   if ( Index>=1 && Index<=myBuilders.Length() )
706     return myBuilders.Value( Index );
707   else
708     return 0;
709 }
710
711 //================================================================
712 // Function : GetBuilderById
713 // Purpose  :
714 //================================================================
715 Handle (MeshVS_PrsBuilder) MeshVS_Mesh::GetBuilderById ( const Standard_Integer Id ) const
716 {
717   Handle (MeshVS_PrsBuilder) Result;
718
719   Standard_Integer i, len = myBuilders.Length();
720   for ( i=1; i<=len; i++ )
721     if ( myBuilders.Value(i)->GetId () == Id )
722     {
723       Result = myBuilders.Value(i);
724       break;
725     }
726   return Result;
727 }
728
729 //================================================================
730 // Function : AddBuilder
731 // Purpose  :
732 //================================================================
733 void MeshVS_Mesh::AddBuilder ( const Handle (MeshVS_PrsBuilder)& theBuilder,
734                                const Standard_Boolean TreatAsHilighter )
735 {
736   if ( theBuilder.IsNull() )
737     return;
738
739   Standard_Integer i, n = myBuilders.Length();
740   for ( i = 1; i<=n; i++ )
741     if ( myBuilders(i)->GetPriority() < theBuilder->GetPriority() )
742       break;
743
744   if ( i>n )
745     myBuilders.Append ( theBuilder );
746   else
747     myBuilders.InsertBefore ( i, theBuilder );
748
749   if( TreatAsHilighter )
750     myHilighter = theBuilder;
751 }
752
753 //================================================================
754 // Function : RemoveBuilder
755 // Purpose  :
756 //================================================================
757 void MeshVS_Mesh::RemoveBuilder ( const Standard_Integer theIndex )
758 {
759   Handle( MeshVS_PrsBuilder ) aBuild = GetBuilder( theIndex );
760   if ( !aBuild.IsNull() )
761   {
762     if ( aBuild == myHilighter )
763       myHilighter.Nullify();
764     myBuilders.Remove ( theIndex );
765   }
766 }
767
768 //================================================================
769 // Function : RemoveBuilderById
770 // Purpose  :
771 //================================================================
772 void MeshVS_Mesh::RemoveBuilderById ( const Standard_Integer Id )
773 {
774   Standard_Integer i, n = myBuilders.Length();
775   for ( i=1; i<=n; i++ )
776   {
777     Handle( MeshVS_PrsBuilder ) aCur = myBuilders(i);
778     if ( !aCur.IsNull() && aCur->GetId()==Id )
779       break;
780   }
781   if ( i>=1 && i<=n )
782   {
783     if ( GetBuilder( i )==myHilighter )
784       myHilighter.Nullify();
785     RemoveBuilder ( i );
786   }
787 }
788
789 //================================================================
790 // Function : SetHiddenElems
791 // Purpose  :
792 //================================================================
793 void MeshVS_Mesh::SetHiddenElems ( const Handle(TColStd_HPackedMapOfInteger)& theMap )
794 {
795   myHiddenElements = theMap;
796
797   // Note: update of list of selectable nodes -- this is not optimal!
798   Standard_Boolean AutoSelUpdate = Standard_False;
799   if ( !GetDrawer().IsNull() && GetDrawer()->GetBoolean( MeshVS_DA_SelectableAuto, AutoSelUpdate ) &&
800        AutoSelUpdate )
801     UpdateSelectableNodes();
802 }
803
804 //================================================================
805 // Function : SetHiddenNodes
806 // Purpose  :
807 //================================================================
808 void MeshVS_Mesh::SetHiddenNodes ( const Handle(TColStd_HPackedMapOfInteger)& theMap )
809 {
810   myHiddenNodes = theMap;
811
812   // Note: update of list of selectable nodes -- this is not optimal!
813   Standard_Boolean AutoSelUpdate = Standard_False;
814   if ( !GetDrawer().IsNull() && GetDrawer()->GetBoolean( MeshVS_DA_SelectableAuto, AutoSelUpdate ) &&
815        AutoSelUpdate )
816     UpdateSelectableNodes();
817 }
818
819 //================================================================
820 // Function : GetHiddenElems
821 // Purpose  :
822 //================================================================
823 const Handle(TColStd_HPackedMapOfInteger)& MeshVS_Mesh::GetHiddenElems () const
824 {
825   return myHiddenElements;
826 }
827
828 //================================================================
829 // Function : GetHiddenNodes
830 // Purpose  :
831 //================================================================
832 const Handle(TColStd_HPackedMapOfInteger)& MeshVS_Mesh::GetHiddenNodes () const
833 {
834   return myHiddenNodes;
835 }
836
837 //================================================================
838 // Function : AddToMap
839 // Purpose  :
840 //================================================================
841 void AddToMap ( MeshVS_DataMapOfIntegerOwner& Result, const MeshVS_DataMapOfIntegerOwner& Addition )
842 {
843   MeshVS_DataMapIteratorOfDataMapOfIntegerOwner anIt ( Addition );
844   for ( ; anIt.More(); anIt.Next() )
845     if ( Result.IsBound ( anIt.Key() ) )
846       Result.ChangeFind ( anIt.Key() ) = anIt.Value();
847     else
848       Result.Bind( anIt.Key(), anIt.Value() );
849 }
850
851 //================================================================
852 // Function : GetOwnerMaps
853 // Purpose  :
854 //================================================================
855 const MeshVS_DataMapOfIntegerOwner& MeshVS_Mesh::GetOwnerMaps ( const Standard_Boolean IsElements )
856 {
857   Handle(MeshVS_DataSource) aDS = GetDataSource();
858   if( !aDS.IsNull() && aDS->IsAdvancedSelectionEnabled() )
859     return myMeshOwners;
860   if ( IsElements )
861   {
862     if ( myElementOwners.IsEmpty() )
863     {
864       AddToMap ( myElementOwners, my0DOwners );
865       AddToMap ( myElementOwners, myLinkOwners );
866       AddToMap ( myElementOwners, myFaceOwners );
867       AddToMap ( myElementOwners, myVolumeOwners );
868     }
869     return myElementOwners;
870   }
871   else
872     return myNodeOwners;
873 }
874
875 //================================================================
876 // Function : IsHiddenElem
877 // Purpose  :
878 //================================================================
879 Standard_Boolean MeshVS_Mesh::IsHiddenElem ( const Standard_Integer theID ) const
880 {
881   return ! myHiddenElements.IsNull() && myHiddenElements->Map().Contains( theID );
882 }
883
884 //================================================================
885 // Function : IsHiddenNode
886 // Purpose  :
887 //================================================================
888 Standard_Boolean MeshVS_Mesh::IsHiddenNode ( const Standard_Integer theID ) const
889 {
890   // note that by default all nodes are hidden
891   return myHiddenNodes.IsNull() || myHiddenNodes->Map().Contains( theID );
892 }
893
894 //================================================================
895 // Function : GetDrawer
896 // Purpose  :
897 //================================================================
898 Handle( MeshVS_Drawer ) MeshVS_Mesh::GetDrawer() const
899 {
900   return myCurrentDrawer;
901 }
902
903 //================================================================
904 // Function : SetDrawer
905 // Purpose  :
906 //================================================================
907 void MeshVS_Mesh::SetDrawer(const Handle(MeshVS_Drawer)& aDrawer)
908 {
909   myCurrentDrawer = aDrawer;
910 }
911
912 //================================================================
913 // Function : GetDataSource
914 // Purpose  :
915 //================================================================
916 Handle(MeshVS_DataSource) MeshVS_Mesh::GetDataSource() const
917 {
918   return myDataSource;
919 }
920
921 //================================================================
922 // Function : SetDataSource
923 // Purpose  :
924 //================================================================
925 void MeshVS_Mesh::SetDataSource( const Handle(MeshVS_DataSource)& theDataSource )
926 {
927   myDataSource = theDataSource;
928 }
929
930 //================================================================
931 // Function : HilightSelected
932 // Purpose  :
933 //================================================================
934 void MeshVS_Mesh::HilightSelected ( const Handle(PrsMgr_PresentationManager3d)& thePM,
935                                     const SelectMgr_SequenceOfOwner& theOwners )
936 {
937   if ( myHilighter.IsNull() )
938     return;
939
940 //  if ( mySelectionPrs.IsNull() )
941 //    mySelectionPrs = new Prs3d_Presentation ( thePM->StructureManager() );
942
943   //new functionality
944
945   Handle( Prs3d_Presentation ) aSelectionPrs;
946
947   aSelectionPrs = GetSelectPresentation( thePM );
948
949   if( HasPresentation() )
950     aSelectionPrs->SetTransformPersistence (Presentation()->TransformPersistence());
951   //----------------
952
953   //   It is very important to call this parent method, because it check whether
954   // mySelectionPrs is created and if not, create it.
955
956 #ifdef OCCT_DEBUG
957   OSD_Timer gTimer;
958   gTimer.Reset();
959   gTimer.Start();
960 #endif
961
962   Standard_Integer len = theOwners.Length(), i;
963
964   Handle (MeshVS_MeshEntityOwner) anOwner;
965   TColStd_PackedMapOfInteger aSelNodes, aSelElements;
966
967   for( i=1; i<=len; i++ )
968   {
969     if (theOwners.Value (i) == GlobalSelOwner())
970     {
971       const Standard_Integer aHiMode = HasHilightMode() ? HilightMode() : 0;
972       const Handle(Prs3d_Drawer)& aSelStyle = !HilightAttributes().IsNull() ? HilightAttributes() : GetContext()->SelectionStyle();
973       thePM->Color (this, aSelStyle, aHiMode);
974       continue;
975     }
976     anOwner = Handle (MeshVS_MeshEntityOwner)::DownCast ( theOwners.Value ( i ) );
977     if ( !anOwner.IsNull() )
978     {
979       // nkv: add support of mesh groups
980       if ( anOwner->IsGroup() ) {
981         MeshVS_EntityType aGroupType;
982         TColStd_PackedMapOfInteger aGroupMap;
983         if ( GetDataSource()->GetGroup( anOwner->ID(), aGroupType, aGroupMap ) ) {
984           if ( aGroupType == MeshVS_ET_Node ) {
985             for( TColStd_MapIteratorOfPackedMapOfInteger anIt(aGroupMap); anIt.More(); anIt.Next() )
986               if( IsSelectableNode/*!IsHiddenNode*/( anIt.Key() ) )
987                 aSelNodes.Add( anIt.Key() );
988           }
989           else {
990             for( TColStd_MapIteratorOfPackedMapOfInteger anIt(aGroupMap); anIt.More(); anIt.Next() )
991               if( IsSelectableElem/*!IsHiddenElem*/( anIt.Key() ) )
992                 aSelElements.Add( anIt.Key() );
993           }
994         }
995       }
996       else {
997         if( anOwner->Type() == MeshVS_ET_Node )
998           aSelNodes.Add( anOwner->ID() );
999         else
1000           aSelElements.Add( anOwner->ID() );
1001       }
1002     }
1003     else if( GetDataSource()->IsAdvancedSelectionEnabled() )
1004     {
1005       Handle(MeshVS_MeshOwner) aMeshOwner = Handle(MeshVS_MeshOwner)::DownCast ( theOwners.Value ( i ) );
1006       if( !aMeshOwner.IsNull() )
1007       {
1008         Handle(TColStd_HPackedMapOfInteger) aNodes = aMeshOwner->GetSelectedNodes();
1009         Handle(TColStd_HPackedMapOfInteger) aElems = aMeshOwner->GetSelectedElements();
1010         if( !aNodes.IsNull() )
1011           aSelNodes.Assign( aNodes->Map() );
1012         if( !aElems.IsNull() )
1013           aSelElements.Assign( aElems->Map() );
1014       }
1015     }
1016 //agv    else if( theOwners.Value ( i )==myWholeMeshOwner )
1017     else if (IsWholeMeshOwner (theOwners.Value ( i )))
1018     {
1019       TColStd_MapIteratorOfPackedMapOfInteger anIt(GetDataSource()->GetAllNodes());
1020       for( ; anIt.More(); anIt.Next() )
1021         if( !IsHiddenNode( anIt.Key() ) )
1022           aSelNodes.Add( anIt.Key() );
1023
1024       anIt = TColStd_MapIteratorOfPackedMapOfInteger( GetDataSource()->GetAllElements() );
1025       for( ; anIt.More(); anIt.Next() )
1026         if( !IsHiddenElem( anIt.Key() ) )
1027           aSelElements.Add( anIt.Key() );
1028
1029       break;
1030     }
1031   }
1032
1033   Standard_Boolean IsNeedToRedisplay = Standard_False;
1034
1035   aSelectionPrs->Clear();
1036
1037   myHilighter->SetDrawer ( mySelectionDrawer );
1038
1039   if( aSelNodes.Extent()>0 )
1040   {
1041     TColStd_PackedMapOfInteger tmp;
1042     myHilighter->Build ( aSelectionPrs, aSelNodes, tmp, Standard_False, MeshVS_DMF_SelectionPrs );
1043   }
1044   if( aSelElements.Extent()>0 )
1045   {
1046     TColStd_PackedMapOfInteger tmp;
1047     myHilighter->Build( aSelectionPrs, aSelElements, tmp, Standard_True, MeshVS_DMF_SelectionPrs );
1048   }
1049
1050   myHilighter->SetDrawer ( 0 );
1051
1052   IsNeedToRedisplay = Standard_True;
1053
1054   aSelectionPrs->SetZLayer (Graphic3d_ZLayerId_Top);
1055
1056   if ( IsNeedToRedisplay )
1057   {
1058     aSelectionPrs->SetDisplayPriority(9);
1059     aSelectionPrs->Display();
1060   }
1061
1062 #ifdef OCCT_DEBUG
1063     Standard_Real sec, cpu;
1064     Standard_Integer min, hour;
1065
1066     gTimer.Show ( sec, min, hour, cpu );
1067     cout << "HilightSelected : " << endl;
1068     cout << aSelNodes.Extent() << " nodes " << endl;
1069     cout << aSelElements.Extent() << " elements " << endl;
1070     cout << "Time : " << sec << " sec" << endl;
1071     cout << "CPU time : " << cpu << " sec" << endl << endl;
1072     gTimer.Stop();
1073 #endif
1074 }
1075
1076 //================================================================
1077 // Function : HilightOwnerWithColor
1078 // Purpose  :
1079 //================================================================
1080 void MeshVS_Mesh::HilightOwnerWithColor ( const Handle(PrsMgr_PresentationManager3d)& thePM,
1081                                           const Handle(Prs3d_Drawer)& theStyle,
1082                                           const Handle(SelectMgr_EntityOwner)& theOwner)
1083 {
1084   if (theOwner.IsNull())
1085     return;
1086
1087   const Quantity_Color& aColor = theStyle->Color();
1088   if (theOwner == GlobalSelOwner())
1089   {
1090     Standard_Integer aHiMode = HasHilightMode() ? HilightMode() : 0;
1091     thePM->Color (this, theStyle, aHiMode, NULL, Graphic3d_ZLayerId_Top);
1092     return;
1093   }
1094
1095   if ( myHilighter.IsNull() )
1096     return;
1097
1098   Handle( Prs3d_Presentation ) aHilightPrs;
1099   aHilightPrs = GetHilightPresentation( thePM );
1100
1101   aHilightPrs->Clear();
1102
1103   //new functionality
1104   if( HasPresentation() )
1105     aHilightPrs->SetTransformPersistence (Presentation()->TransformPersistence());
1106   //----------------
1107
1108   const Standard_Boolean isMeshEntityOwner = theOwner->IsKind ( STANDARD_TYPE ( MeshVS_MeshEntityOwner ) );
1109   const Standard_Boolean isWholeMeshOwner =
1110 //agv    !Owner.IsNull() && Owner==myWholeMeshOwner;
1111     IsWholeMeshOwner (theOwner);
1112
1113   Standard_Integer aDispMode = MeshVS_DMF_Shading;
1114   if ( HasDisplayMode() && ( DisplayMode() & MeshVS_DMF_OCCMask ) > MeshVS_DMF_WireFrame )
1115     aDispMode = ( DisplayMode() & MeshVS_DMF_OCCMask );
1116   //It because we draw hilighted owners only in shading or shrink (not in wireframe)
1117
1118   myHilightDrawer->SetColor( MeshVS_DA_InteriorColor, aColor );
1119   myHilightDrawer->SetColor( MeshVS_DA_BackInteriorColor, aColor );
1120   myHilightDrawer->SetColor( MeshVS_DA_EdgeColor, aColor );
1121   myHilightDrawer->SetColor( MeshVS_DA_BeamColor, aColor );
1122   myHilightDrawer->SetColor( MeshVS_DA_MarkerColor, aColor );
1123   myHilighter->SetDrawer( myHilightDrawer );
1124
1125   if( isMeshEntityOwner )
1126   {
1127     Handle ( MeshVS_MeshEntityOwner ) theAISOwner = Handle ( MeshVS_MeshEntityOwner )::DownCast ( theOwner );
1128     MeshVS_EntityType aType = theAISOwner->Type();
1129     Standard_Integer  anID  = theAISOwner->ID();
1130
1131     if ( theAISOwner->IsGroup() ) {
1132       MeshVS_EntityType aGroupType;
1133       TColStd_PackedMapOfInteger aGroupMap;
1134       if ( myDataSource->GetGroup( anID, aGroupType, aGroupMap ) ) {
1135         TColStd_PackedMapOfInteger tmp;
1136         myHilighter->Build( aHilightPrs, aGroupMap, tmp, aType!=MeshVS_ET_Node,
1137                             aDispMode | MeshVS_DMF_HilightPrs );
1138       }
1139     }
1140     else {
1141       TColStd_PackedMapOfInteger anOne, tmp;
1142       anOne.Add (anID);
1143       myHilighter->Build( aHilightPrs, anOne, tmp, aType!=MeshVS_ET_Node,
1144                           aDispMode | MeshVS_DMF_HilightPrs );
1145     }
1146   }
1147   else if( isWholeMeshOwner  )
1148   {
1149     if( ! GetDataSource().IsNull() )
1150     {
1151       TColStd_PackedMapOfInteger tmp;
1152       myHilighter->Build( aHilightPrs, GetDataSource()->GetAllElements(), tmp,
1153                           Standard_True, MeshVS_DMF_WireFrame );
1154     }
1155   }
1156   else 
1157   {
1158     Handle(MeshVS_MeshOwner) aMeshOwner = Handle(MeshVS_MeshOwner)::DownCast ( theOwner );
1159     if( !aMeshOwner.IsNull() )
1160     {
1161       Handle(TColStd_HPackedMapOfInteger) aNodes = aMeshOwner->GetDetectedNodes();
1162       Handle(TColStd_HPackedMapOfInteger) aElems = aMeshOwner->GetDetectedElements();
1163       // hilight detected entities
1164       if( !aNodes.IsNull() )
1165       {
1166         TColStd_PackedMapOfInteger tmp;
1167         myHilighter->Build( aHilightPrs, aNodes->Map(), tmp, Standard_False,
1168                             aDispMode | MeshVS_DMF_HilightPrs );
1169       }
1170       if( !aElems.IsNull() )
1171       {
1172         TColStd_PackedMapOfInteger tmp;
1173         myHilighter->Build( aHilightPrs, aElems->Map(), tmp, Standard_True,
1174                             aDispMode | MeshVS_DMF_HilightPrs );
1175       }
1176     }    
1177   }
1178
1179   aHilightPrs->SetZLayer (Graphic3d_ZLayerId_Topmost);
1180
1181   if (thePM->IsImmediateModeOn())
1182   {
1183     thePM->AddToImmediateList (aHilightPrs);
1184   }
1185   myHilighter->SetDrawer ( 0 );
1186 }
1187
1188 //=======================================================================
1189 //function : ClearSelected
1190 //purpose  :
1191 //=======================================================================
1192 void MeshVS_Mesh::ClearSelected ()
1193 {
1194   Handle( Prs3d_Presentation ) aSelectionPrs = GetSelectPresentation( NULL );  
1195   if( !aSelectionPrs.IsNull() )
1196     aSelectionPrs->Clear(); 
1197 }
1198
1199 //=======================================================================
1200 //function : FindBuilder
1201 //purpose  :
1202 //=======================================================================
1203 Handle (MeshVS_PrsBuilder) MeshVS_Mesh::FindBuilder ( const Standard_CString theTypeName ) const
1204 {
1205   Standard_Integer len = myBuilders.Length();
1206   Handle(MeshVS_PrsBuilder) aBuilder;
1207   Standard_Boolean IsExist = Standard_False;
1208
1209   for ( Standard_Integer i=1; i<=len && !IsExist; i++)
1210     if ( myBuilders.Value (i)->IsKind ( theTypeName ) )
1211     {
1212       aBuilder = myBuilders.Value (i);
1213       IsExist = Standard_True;
1214     }
1215
1216   return aBuilder;
1217 }
1218
1219 //=======================================================================
1220 //function : SetHilighter
1221 //purpose  :
1222 //=======================================================================
1223 void MeshVS_Mesh::SetHilighter ( const Handle( MeshVS_PrsBuilder )& Builder )
1224 {
1225   myHilighter = Builder;
1226 }
1227
1228 //=======================================================================
1229 //function : SetHilighter
1230 //purpose  :
1231 //=======================================================================
1232 Standard_Boolean MeshVS_Mesh::SetHilighter ( const Standard_Integer Index )
1233 {
1234   Handle( MeshVS_PrsBuilder ) aBuild = GetBuilder( Index );
1235   Standard_Boolean aRes = ( !aBuild.IsNull() );
1236   if ( aRes )
1237     myHilighter = aBuild;
1238   return aRes;
1239 }
1240
1241 //=======================================================================
1242 //function : SetHilighter
1243 //purpose  :
1244 //=======================================================================
1245 Standard_Boolean MeshVS_Mesh::SetHilighterById ( const Standard_Integer Id )
1246 {
1247   Handle( MeshVS_PrsBuilder ) aBuild = GetBuilderById( Id );
1248   Standard_Boolean aRes = ( !aBuild.IsNull() );
1249   if ( aRes )
1250     myHilighter = aBuild;
1251   return aRes;
1252 }
1253
1254 //=======================================================================
1255 //function : GetHilighter
1256 //purpose  :
1257 //=======================================================================
1258 Handle( MeshVS_PrsBuilder ) MeshVS_Mesh::GetHilighter () const
1259 {
1260   return myHilighter;
1261 }
1262
1263 //=======================================================================
1264 //function : IsSelectableElem
1265 //purpose  :
1266 //=======================================================================
1267 Standard_Boolean MeshVS_Mesh::IsSelectableElem ( const Standard_Integer ID ) const
1268 {
1269   return ! IsHiddenElem ( ID );
1270 }
1271
1272 //=======================================================================
1273 //function : IsSelectableNode
1274 //purpose  :
1275 //=======================================================================
1276 Standard_Boolean MeshVS_Mesh::IsSelectableNode ( const Standard_Integer ID ) const
1277 {
1278   return mySelectableNodes.IsNull() ? ! IsHiddenNode ( ID ) : 
1279                                       mySelectableNodes->Map().Contains( ID );
1280 }
1281
1282 //=======================================================================
1283 //function : GetSelectableNodes
1284 //purpose  :
1285 //=======================================================================
1286 const Handle(TColStd_HPackedMapOfInteger)& MeshVS_Mesh::GetSelectableNodes () const
1287 {
1288   return mySelectableNodes;
1289 }
1290
1291 //=======================================================================
1292 //function : SetSelectableNodes
1293 //purpose  :
1294 //=======================================================================
1295 void MeshVS_Mesh::SetSelectableNodes ( const Handle(TColStd_HPackedMapOfInteger)& Ids )
1296 {
1297   mySelectableNodes = Ids;
1298 }
1299
1300 //=======================================================================
1301 //function : UpdateSelectableNodes
1302 //purpose  :
1303 //=======================================================================
1304 void MeshVS_Mesh::UpdateSelectableNodes()
1305 {
1306   mySelectableNodes = new TColStd_HPackedMapOfInteger;
1307   
1308   Standard_Integer aMaxFaceNodes;
1309   Handle( MeshVS_DataSource ) aSource = GetDataSource();
1310   if ( aSource.IsNull() || myCurrentDrawer.IsNull() || !myCurrentDrawer->GetInteger
1311          ( MeshVS_DA_MaxFaceNodes, aMaxFaceNodes ) || aMaxFaceNodes<=0 )
1312     return;
1313
1314   // all non-hidden nodes are selectable;
1315   // by default (i.e. if myHiddenNodes.IsNull()) all nodes are hidden
1316   if ( ! myHiddenNodes.IsNull() )
1317   {
1318     mySelectableNodes->ChangeMap().Subtraction (aSource->GetAllNodes(),
1319                                                 myHiddenNodes->Map());
1320   } 
1321
1322   // add all nodes belonging to non-hidden elements
1323   TColStd_MapIteratorOfPackedMapOfInteger anIter( aSource->GetAllElements() );
1324   for ( ; anIter.More(); anIter.Next() )
1325   {
1326     Standard_Integer aKey = anIter.Key();
1327     if ( IsHiddenElem (aKey) )
1328       continue;
1329
1330     MeshVS_Buffer aNodesBuf (aMaxFaceNodes*sizeof(Standard_Integer));
1331     TColStd_Array1OfInteger aNodes (aNodesBuf, 1, aMaxFaceNodes);
1332     Standard_Integer NbNodes;
1333     if ( !aSource->GetNodesByElement ( aKey, aNodes, NbNodes ) )
1334       continue;
1335     for ( Standard_Integer i=1; i<=NbNodes; i++ )
1336       mySelectableNodes->ChangeMap().Add ( aNodes(i) );
1337   }
1338 }
1339
1340 //=======================================================================
1341 //function : GetMeshSelMethod
1342 //purpose  :
1343 //=======================================================================
1344 MeshVS_MeshSelectionMethod MeshVS_Mesh::GetMeshSelMethod() const
1345 {
1346   return mySelectionMethod;
1347 }
1348
1349 //=======================================================================
1350 //function : SetMeshSelMethod
1351 //purpose  :
1352 //=======================================================================
1353 void MeshVS_Mesh::SetMeshSelMethod( const MeshVS_MeshSelectionMethod M )
1354 {
1355   mySelectionMethod = M;
1356 }
1357
1358 //=======================================================================
1359 //function : IsWholeMeshOwner
1360 //purpose  : 
1361 //=======================================================================
1362
1363 Standard_Boolean MeshVS_Mesh::IsWholeMeshOwner
1364                             (const Handle(SelectMgr_EntityOwner)& theOwn) const
1365 {
1366   return theOwn.IsNull() ? Standard_False : (theOwn == myWholeMeshOwner);
1367 }