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