]> SALOME platform Git repositories - modules/smesh.git/blob - src/SMESHGUI/SMESHGUI_Selection.cxx
Salome HOME
6f59abd8c0c9d8d1558907c0739218cc1ed216a9
[modules/smesh.git] / src / SMESHGUI / SMESHGUI_Selection.cxx
1 // Copyright (C) 2007-2020  CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5 //
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
10 //
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 // Lesser General Public License for more details.
15 //
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
19 //
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 //
22
23 // SMESH SMESHGUI_Selection
24 // File   : SMESHGUI_Selection.cxx
25 // Author : Alexander SOLOVYOV, Open CASCADE S.A.S.
26 //
27
28 // SMESH includes
29 #include "SMESHGUI_Selection.h"
30
31 #include "SMESHGUI.h"
32 #include "SMESHGUI_ComputeDlg.h"
33 #include "SMESHGUI_ConvToQuadOp.h"
34 #include "SMESHGUI_GEOMGenUtils.h"
35 #include "SMESHGUI_Utils.h"
36 #include "SMESHGUI_VTKUtils.h"
37
38 #include <SMESH_Type.h>
39 #include <SMESH_Actor.h>
40 #include <SMESH_ScalarBarActor.h>
41
42 // SALOME GUI includes
43 #include <SalomeApp_Application.h>
44 #include <LightApp_VTKSelector.h>
45 #include <SVTK_ViewWindow.h>
46 #include <LightApp_SelectionMgr.h>
47 #include <LightApp_DataOwner.h>
48
49 // IDL includes
50 #include <SALOMEconfig.h>
51 #include CORBA_CLIENT_HEADER(SMESH_Gen)
52 #include CORBA_CLIENT_HEADER(SMESH_Mesh)
53 #include CORBA_CLIENT_HEADER(SMESH_Group)
54
55 //=======================================================================
56 //function : SMESHGUI_Selection
57 //purpose  : 
58 //=======================================================================
59 SMESHGUI_Selection::SMESHGUI_Selection()
60 : LightApp_Selection()
61 {
62 }
63
64 //=======================================================================
65 //function : ~SMESHGUI_Selection
66 //purpose  : 
67 //=======================================================================
68 SMESHGUI_Selection::~SMESHGUI_Selection()
69 {
70 }
71
72 //=======================================================================
73 //function : init
74 //purpose  : 
75 //=======================================================================
76 void SMESHGUI_Selection::init( const QString& client, LightApp_SelectionMgr* mgr )
77 {
78   LightApp_Selection::init( client, mgr );
79
80   if( mgr )
81   {
82     myOwners.clear();
83     mgr->selected(myOwners, client);
84     for( int i=0, n=count(); i<n; i++ ) {
85       myTypes.append( typeName( type( entry( i ) ) ) );
86       myControls.append( controlMode( i ) );
87     }
88   }
89 }
90
91 //=======================================================================
92 //function : processOwner
93 //purpose  : 
94 //=======================================================================
95 bool SMESHGUI_Selection::processOwner( const LightApp_DataOwner* ow )
96 {
97   const LightApp_SVTKDataOwner* owner =
98     dynamic_cast<const LightApp_SVTKDataOwner*> ( ow );
99   if( owner ) {
100     myActors.append( dynamic_cast<SMESH_Actor*>( owner->GetActor() ) );
101   }
102   else if ( ow ) { // SVTK selection disabled
103     QString entry = ow->entry();
104     myActors.append( SMESH::FindActorByEntry( entry.toStdString().c_str() ));
105   }
106   else {
107     myActors.append( 0 );
108   }
109   return true;
110 }
111
112 //=======================================================================
113 //function : parameter
114 //purpose  : 
115 //=======================================================================
116 QVariant SMESHGUI_Selection::parameter( const int ind, const QString& p ) const
117 {
118   QVariant val;
119   if      ( p=="client" )               val = QVariant( LightApp_Selection::parameter( p ) );
120   else if ( p=="type" )                 val = QVariant( myTypes[ind] );
121   else if ( p=="hasActor" )             val = QVariant( getActor( ind ) != 0 );
122   else if ( p=="elemTypes" )            val = QVariant( elemTypes( ind, false ) );
123   else if ( p=="objElemTypes" )         val = QVariant( elemTypes( ind, true ) );
124   else if ( p=="isAutoColor" )          val = QVariant( isAutoColor( ind ) );
125   else if ( p=="numberOfNodes" )        val = QVariant( numberOfNodes( ind ) );
126   else if ( p=="dim" )                  val = QVariant( dim( ind ) );
127   else if ( p=="labeledTypes" )         val = QVariant( labeledTypes( ind ) );
128   else if ( p=="shrinkMode" )           val = QVariant( shrinkMode( ind ) );
129   else if ( p=="entityMode" )           val = QVariant( entityMode( ind ) );
130   else if ( p=="isNumFunctor" )         val = QVariant( isNumFunctor( ind ) );
131   else if ( p=="displayMode" )          val = QVariant( displayMode( ind ) );
132   else if ( p=="isComputable" )         val = QVariant( isComputable( ind ) );
133   else if ( p=="isPreComputable" )      val = QVariant( isPreComputable( ind ) );
134   else if ( p=="hasGeomReference" )     val = QVariant( hasGeomReference( ind ) );
135   else if ( p=="isEditableHyp" )        val = QVariant( isEditableHyp( ind ) );
136   else if ( p=="isImported" )           val = QVariant( isImported( ind ) );
137   else if ( p=="facesOrientationMode" ) val = QVariant( facesOrientationMode( ind ) );
138   else if ( p=="groupType" )            val = QVariant( groupType( ind ) );
139   else if ( p=="isQuadratic" )          val = QVariant( isQuadratic( ind ) );
140   else if ( p=="quadratic2DMode")       val = QVariant( quadratic2DMode( ind ) );
141   else if ( p=="isDistributionVisible") val = QVariant( isDistributionVisible( ind ) );
142   else if ( p=="isScalarBarVisible")    val = QVariant( isScalarBarVisible( ind ) );
143   else if ( p=="hasChildren")           val = QVariant( hasChildren( ind ) );
144   else if ( p=="nbChildren")            val = QVariant( nbChildren( ind ) );
145   else if ( p=="isContainer")           val = QVariant( isContainer( ind ) );
146   else if ( p=="guiState")              val = QVariant( guiState() );
147   else if ( p=="canBreakLink")          val = QVariant( canBreakLink(ind) );
148
149   if ( val.isValid() )
150     return val;
151   else
152     return LightApp_Selection::parameter( ind, p );
153 }
154
155 //=======================================================================
156 //function : parameter
157 //purpose  :
158 //=======================================================================
159 QVariant SMESHGUI_Selection::parameter( const QString& p ) const
160 {
161   QVariant val;
162   if ( p=="controlMode" ) val = QVariant( controlMode() );
163
164   if ( val.isValid() )
165     return val;
166   else
167     return LightApp_Selection::parameter( p );
168 }
169
170 //=======================================================================
171 //function : getVtkOwner
172 //purpose  :
173 //=======================================================================
174
175 SMESH_Actor* SMESHGUI_Selection::getActor( int ind ) const
176 {
177   if( ind >= 0 && ind < count() )
178     return myActors.isEmpty() ? 0 : myActors.at( ind );
179   else
180     return 0;
181 }
182
183 //=======================================================================
184 //function : elemTypes
185 //purpose  : may return {'Elem0d' 'Edge' 'Face' 'Volume' 'BallElem'} at most
186 //=======================================================================
187
188 QList<QVariant> SMESHGUI_Selection::elemTypes( int ind, bool fromObj ) const
189 {
190   QList<QVariant> types;
191   SMESH_Actor* actor = getActor( ind );
192   if ( actor ) {
193     TVisualObjPtr object = actor->GetObject();
194     if ( object ) {
195       if ( object->GetNbEntities( SMDSAbs_Edge ))      types.append( "Edge" );
196       if ( object->GetNbEntities( SMDSAbs_Face ))      types.append( "Face" );
197       if ( object->GetNbEntities( SMDSAbs_Volume ))    types.append( "Volume" );
198       if ( object->GetNbEntities( SMDSAbs_0DElement )) types.append( "Elem0d" );
199       if ( object->GetNbEntities( SMDSAbs_Ball ))      types.append( "BallElem" );
200     }
201   }
202   else if ( fromObj )
203   {
204     if ( ind >= 0 && ind < myTypes.count() && myTypes[ind] != "Unknown" )
205     {
206       _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entry( ind ).toUtf8().data() );
207       CORBA::Object_var obj = SMESH::SObjectToObject( sobj );
208       SMESH::SMESH_IDSource_var idSrc = SMESH::SMESH_IDSource::_narrow( obj );
209       if ( !CORBA::is_nil( idSrc ) )
210       {
211         SMESH::array_of_ElementType_var typeVar = idSrc->GetTypes();
212         for ( CORBA::ULong i = 0; i < typeVar->length(); ++i )
213           switch ( typeVar[i] ) {
214           case SMESH::EDGE:   types.append( "Edge" );     break;
215           case SMESH::FACE:   types.append( "Face" );     break;
216           case SMESH::VOLUME: types.append( "Volume" );   break;
217           case SMESH::ELEM0D: types.append( "Elem0d" );   break;
218           case SMESH::BALL:   types.append( "BallElem" ); break;
219           case SMESH::ALL:
220           case SMESH::NODE:
221           case SMESH::NB_ELEMENT_TYPES: break;
222           }
223       }
224     }
225   }
226   return types;
227 }
228
229 //=======================================================================
230 //function : labeledTypes
231 //purpose  : may return {'Point' 'Cell'} at most
232 //=======================================================================
233
234 QList<QVariant> SMESHGUI_Selection::labeledTypes( int ind ) const
235 {
236   QList<QVariant> types;
237   SMESH_Actor* actor = getActor( ind );
238   if ( actor ) {
239     if ( actor->GetPointsLabeled()) types.append( "Point" );
240     if ( actor->GetCellsLabeled())  types.append( "Cell" );
241   }
242   return types;
243 }
244
245 //=======================================================================
246 //function : displayMode
247 //purpose  : return SMESH_Actor::EReperesent
248 //=======================================================================
249
250 QString SMESHGUI_Selection::displayMode( int ind ) const
251 {
252   SMESH_Actor* actor = getActor( ind );
253   if ( actor ) {
254     switch( actor->GetRepresentation() ) {
255     case SMESH_Actor::eEdge:    return "eEdge";
256     case SMESH_Actor::eSurface: return "eSurface";
257     case SMESH_Actor::ePoint:   return "ePoint";
258     default: break;
259     }
260   }
261   return "Unknown";
262 }
263
264 //=======================================================================
265 //function : isQuadratic
266 //purpose  : return true if the mesh has quadratic/bi-quadratic type
267 //=======================================================================
268
269 bool SMESHGUI_Selection::isQuadratic( int ind ) const
270 {
271   _PTR(SObject) so = SMESH::getStudy()->FindObjectID( entry( ind ).toUtf8().data() );
272   if ( !so )
273     return false;
274   SMESH::SMESH_IDSource_var idSource =  SMESH::SObjectToInterface<SMESH::SMESH_IDSource>( so );
275   if ( idSource->_is_nil() )
276     return false;
277   SMESHGUI_ConvToQuadOp::MeshDestinationType meshTgtType = SMESHGUI_ConvToQuadOp::DestinationMesh( idSource );
278   if ( meshTgtType & SMESHGUI_ConvToQuadOp::Linear )
279     return true;
280   return false;
281 }
282
283 //=======================================================================
284 //function : quadratic2DMode
285 //purpose  : return SMESH_Actor::EQuadratic2DRepresentation
286 //=======================================================================
287 QString SMESHGUI_Selection::quadratic2DMode( int ind ) const
288 {
289   SMESH_Actor* actor = getActor( ind );
290   if ( actor ) {
291     switch( actor->GetQuadratic2DRepresentation() ) {
292     case SMESH_Actor::eLines: return "eLines";
293     case SMESH_Actor::eArcs:  return "eArcs";
294     default: break;
295     }
296   }
297   return "Unknown";
298 }
299
300 //=======================================================================
301 //function : isDistributionVisible
302 //purpose  : Visible/Invisible distribution of the ScalarBar Actor
303 //=======================================================================
304
305 bool SMESHGUI_Selection::isDistributionVisible(int ind) const {
306   SMESH_Actor* actor = getActor( ind );
307   return (actor && actor->GetScalarBarActor() && actor->GetScalarBarActor()->GetDistributionVisibility());
308
309
310 //=======================================================================
311 //function : isScalarBarVisible
312 //purpose  : Visible/Invisible Scalar Bar
313 //=======================================================================
314
315 bool SMESHGUI_Selection::isScalarBarVisible(int ind) const {
316   SMESH_Actor* actor = getActor( ind );
317   return (actor && actor->GetScalarBarActor() && actor->GetScalarBarActor()->GetVisibility());
318 }
319
320 //=======================================================================
321 //function : shrinkMode
322 //purpose  : return either 'IsSrunk', 'IsNotShrunk' or 'IsNotShrinkable'
323 //=======================================================================
324
325 QString SMESHGUI_Selection::shrinkMode( int ind ) const
326 {
327   SMESH_Actor* actor = getActor( ind );
328   if ( actor && actor->IsShrunkable() ) {
329     return actor->IsShrunk() ? "IsShrunk" : "IsNotShrunk";
330   }
331   return "IsNotShrinkable";
332 }
333
334 //=======================================================================
335 //function : entityMode
336 //purpose  : may return {'Elem0d' 'Edge' 'Face' 'Volume' 'BallElem' } at most
337 //=======================================================================
338
339 QList<QVariant> SMESHGUI_Selection::entityMode( int ind ) const
340 {
341   QList<QVariant> types;
342   SMESH_Actor* actor = getActor( ind );
343   if ( actor ) {
344     unsigned int aMode = actor->GetEntityMode();
345     if ( aMode & SMESH_Actor::eVolumes    ) types.append( "Volume" );
346     if ( aMode & SMESH_Actor::eFaces      ) types.append( "Face"   );
347     if ( aMode & SMESH_Actor::eEdges      ) types.append( "Edge"   );
348     if ( aMode & SMESH_Actor::e0DElements ) types.append( "Elem0d" );
349     if ( aMode & SMESH_Actor::eBallElem )   types.append( "BallElem" );
350   }
351   return types;
352 }
353
354 //=======================================================================
355 //function : controlMode
356 //purpose  : return SMESH_Actor::eControl
357 //=======================================================================
358
359 QString SMESHGUI_Selection::controlMode( int ind ) const
360 {
361   SMESH_Actor* actor = getActor( ind );
362   QString mode = "eNone";
363   if ( actor ) {
364     switch( actor->GetControlMode() ) {
365     case SMESH_Actor::eLength:                mode = "eLength";                break;
366     case SMESH_Actor::eLength2D:              mode = "eLength2D";              break;
367     case SMESH_Actor::eDeflection2D:          mode = "eDeflection2D";          break;
368     case SMESH_Actor::eFreeEdges:             mode = "eFreeEdges";             break;
369     case SMESH_Actor::eFreeNodes:             mode = "eFreeNodes";             break;
370     case SMESH_Actor::eFreeBorders:           mode = "eFreeBorders";           break;
371     case SMESH_Actor::eFreeFaces:             mode = "eFreeFaces";             break;
372     case SMESH_Actor::eMultiConnection:       mode = "eMultiConnection";       break;
373     case SMESH_Actor::eMultiConnection2D:     mode = "eMultiConnection2D";     break;
374     case SMESH_Actor::eArea:                  mode = "eArea";                  break;
375     case SMESH_Actor::eVolume3D:              mode = "eVolume3D";              break;
376     case SMESH_Actor::eMaxElementLength2D:    mode = "eMaxElementLength2D";    break;
377     case SMESH_Actor::eMaxElementLength3D:    mode = "eMaxElementLength3D";    break;
378     case SMESH_Actor::eTaper:                 mode = "eTaper";                 break;
379     case SMESH_Actor::eAspectRatio:           mode = "eAspectRatio";           break;
380     case SMESH_Actor::eAspectRatio3D:         mode = "eAspectRatio3D";         break;
381     case SMESH_Actor::eMinimumAngle:          mode = "eMinimumAngle";          break;
382     case SMESH_Actor::eWarping:               mode = "eWarping";               break;
383     case SMESH_Actor::eSkew:                  mode = "eSkew";                  break;
384     case SMESH_Actor::eBareBorderFace:        mode = "eBareBorderFace";        break;
385     case SMESH_Actor::eBareBorderVolume:      mode = "eBareBorderVolume";      break;
386     case SMESH_Actor::eOverConstrainedFace:   mode = "eOverConstrainedFace";   break;
387     case SMESH_Actor::eOverConstrainedVolume: mode = "eOverConstrainedVolume"; break;
388     case SMESH_Actor::eCoincidentNodes:       mode = "eCoincidentNodes";       break;
389     case SMESH_Actor::eCoincidentElems1D:     mode = "eCoincidentElems1D";     break;
390     case SMESH_Actor::eCoincidentElems2D:     mode = "eCoincidentElems2D";     break;
391     case SMESH_Actor::eCoincidentElems3D:     mode = "eCoincidentElems3D";     break;
392     case SMESH_Actor::eCustomControl:         mode = "eCustomControl";         break;
393     default:break;
394     }
395   }
396   return mode;
397 }
398
399 //=======================================================================
400 //function : controlMode
401 //purpose  : gets global control mode; return SMESH_Actor::eControl
402 //=======================================================================
403 QString SMESHGUI_Selection::controlMode() const
404 {
405   if( myControls.count() > 0 ) {
406     QString mode = myControls[0];
407     for( int ind = 1; ind < myControls.count(); ind++ ) {
408       if( mode != myControls[ind] )
409         return "eMixed"; // different controls used for different actors
410     }
411     return mode;
412   }
413   return "eNone";
414 }
415
416 //=======================================================================
417 //function : isNumFunctor
418 //purpose  : return true if a given actor is shown using a numeric functor
419 //=======================================================================
420
421 bool SMESHGUI_Selection::isNumFunctor( int ind ) const
422 {
423   bool result = false;
424   SMESH_Actor* actor = getActor( ind );
425   if ( actor ) {
426     switch( actor->GetControlMode() ) {
427     case SMESH_Actor::eLength:
428     case SMESH_Actor::eLength2D:
429     case SMESH_Actor::eDeflection2D:
430     case SMESH_Actor::eMultiConnection:
431     case SMESH_Actor::eMultiConnection2D:
432     case SMESH_Actor::eArea:
433     case SMESH_Actor::eVolume3D:
434     case SMESH_Actor::eMaxElementLength2D:
435     case SMESH_Actor::eMaxElementLength3D:
436     case SMESH_Actor::eTaper:
437     case SMESH_Actor::eAspectRatio:
438     case SMESH_Actor::eAspectRatio3D:
439     case SMESH_Actor::eMinimumAngle:
440     case SMESH_Actor::eWarping:
441     case SMESH_Actor::eSkew:
442       result = true;
443       break;
444     default:
445       break;
446     }
447   }
448   return result;
449 }
450
451 //=======================================================================
452 //function : facesOrientationMode
453 //purpose  :
454 //=======================================================================
455
456 QString SMESHGUI_Selection::facesOrientationMode( int ind ) const
457 {
458   SMESH_Actor* actor = getActor( ind );
459   if ( actor ) {
460     return actor->GetFacesOriented() ? "IsOriented" : "IsNotOriented";
461   }
462   return "Unknown";
463 }
464
465 //=======================================================================
466 //function : isAutoColor
467 //purpose  : 
468 //=======================================================================
469
470 bool SMESHGUI_Selection::isAutoColor( int ind ) const
471 {
472   if ( ind >= 0 && ind < myTypes.count() && myTypes[ind] != "Unknown" )
473   {
474     _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entry( ind ).toUtf8().data() );
475     CORBA::Object_var obj = SMESH::SObjectToObject( sobj );
476
477     if ( !CORBA::is_nil( obj ) ) {
478       SMESH::SMESH_Mesh_var mesh = SMESH::SMESH_Mesh::_narrow( obj );
479       if ( !CORBA::is_nil( mesh ) )
480         return mesh->GetAutoColor();
481     }
482   }
483   return false;
484 }
485
486 //=======================================================================
487 //function : numberOfNodes
488 //purpose  : this method is actually used to check if an object is empty or not
489 //=======================================================================
490
491 int SMESHGUI_Selection::numberOfNodes( int ind ) const
492 {
493   if ( ind >= 0 && ind < myTypes.count() && myTypes[ind] != "Unknown" )
494   {
495     _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entry( ind ).toUtf8().data() );
496     CORBA::Object_var obj = SMESH::SObjectToObject( sobj );
497
498     if ( !CORBA::is_nil( obj ) ) {
499       SMESH::SMESH_Mesh_var mesh = SMESH::SMESH_Mesh::_narrow( obj );
500       if ( !CORBA::is_nil( mesh ) )
501         return mesh->NbNodes();
502       SMESH::SMESH_subMesh_var aSubMeshObj = SMESH::SMESH_subMesh::_narrow( obj );
503       if ( !CORBA::is_nil( aSubMeshObj ) )
504         return aSubMeshObj->GetNumberOfNodes(true);
505       SMESH::SMESH_GroupBase_var aGroupObj = SMESH::SMESH_GroupBase::_narrow( obj );
506       if ( !CORBA::is_nil( aGroupObj ) )
507         return aGroupObj->IsEmpty() ? 0 : 1; // aGroupObj->Size();
508     }
509   }
510   return 0;
511 }
512
513 //================================================================================
514 /*!
515  * \brief return dimension of elements of the selected object
516  *
517  *  \retval int - 0 for 0D elements, -1 for an empty object (the rest as usual)
518  */
519 //================================================================================
520
521 int SMESHGUI_Selection::dim( int ind ) const
522 {
523   int dim = -1;
524   if ( ind >= 0 && ind < myTypes.count() && myTypes[ind] != "Unknown" )
525   {
526     _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entry( ind ).toUtf8().data() );
527     CORBA::Object_var obj = SMESH::SObjectToObject( sobj );
528
529     if ( !CORBA::is_nil( obj ) ) {
530       SMESH::SMESH_IDSource_var idSrc = SMESH::SMESH_IDSource::_narrow( obj );
531       if ( !CORBA::is_nil( idSrc ) )
532       {
533         SMESH::array_of_ElementType_var types = idSrc->GetTypes();
534         for ( size_t i = 0; i < types->length(); ++ i) {
535           switch ( types[i] ) {
536           case SMESH::EDGE  : dim = std::max( dim, 1 ); break;
537           case SMESH::FACE  : dim = std::max( dim, 2 ); break;
538           case SMESH::VOLUME: dim = std::max( dim, 3 ); break;
539           case SMESH::ELEM0D: dim = std::max( dim, 0 ); break;
540           case SMESH::BALL  : dim = std::max( dim, 0 ); break;
541           default: break;
542           }
543         }
544       }
545     }
546   }
547   return dim;
548 }
549
550 //=======================================================================
551 //function : isComputable
552 //purpose  : return true for a ready-to-compute mesh
553 //=======================================================================
554
555 bool SMESHGUI_Selection::isComputable( int ind ) const
556 {
557   if ( ind >= 0 && ind < myTypes.count() && ( myTypes[ind] == "Mesh" ||
558                                               myTypes[ind].startsWith("Mesh " )))
559   {
560     QMap<int,int> modeMap;
561     _PTR(SObject) meshSO = SMESH::getStudy()->FindObjectID( entry( ind ).toUtf8().data() );
562
563     _PTR(SComponent) component = meshSO->GetFatherComponent();
564     if ( meshSO->Depth() - component->Depth() > 1 ) // sub-mesh, get a mesh
565       while ( meshSO->Depth() - component->Depth() > 1 )
566         meshSO = meshSO->GetFather();
567
568     SMESHGUI_PrecomputeOp::getAssignedAlgos( meshSO, modeMap );
569     return modeMap.size() > 0;
570   }
571   return false;
572 }
573
574 //=======================================================================
575 //function : isPreComputable
576 //purpose  : returns true for a mesh with algorithms
577 //=======================================================================
578
579 bool SMESHGUI_Selection::isPreComputable( int ind ) const
580 {
581   if ( ind >= 0 && ind < myTypes.count() && myTypes[ind] == "Mesh" )
582   {
583     int maxDim = dim( ind );
584     if ( maxDim < 2 ) // we can preview 1D or 2D
585     {
586       QMap<int,int> modeMap;
587       _PTR(SObject) pMesh = SMESH::getStudy()->FindObjectID( entry( ind ).toUtf8().data() );
588       SMESHGUI_PrecomputeOp::getAssignedAlgos( pMesh, modeMap );
589       if ( modeMap.size() > 1 )
590         return (( modeMap.contains( SMESH::DIM_3D )) ||
591                 ( modeMap.contains( SMESH::DIM_2D ) && maxDim < 1 ));
592     }
593   }
594   return false;
595 }
596
597 //=======================================================================
598 //function : hasGeomReference
599 //purpose  : returns true for a mesh or sub-mesh on geometry
600 //=======================================================================
601
602 bool SMESHGUI_Selection::hasGeomReference( int ind ) const
603 {
604   if ( ind >= 0 && ind < myTypes.count() && myTypes[ind] != "Unknown" )
605   {
606     _PTR(SObject) so = SMESH::getStudy()->FindObjectID( entry( ind ).toUtf8().data() );
607     GEOM::GEOM_Object_var shape = SMESH::GetShapeOnMeshOrSubMesh( so );
608     return !shape->_is_nil();
609   }
610   return false;
611 }
612
613 //=======================================================================
614 //function : canBreakLink
615 //purpose  : returns true if selected object is a Shaper object and it can break link
616 //=======================================================================
617
618 bool SMESHGUI_Selection::canBreakLink( int ind ) const
619 {
620   if ( ind >= 0 && ind < myTypes.count()) {
621     if (isReference(ind)) {
622       SUIT_DataOwner* aOwn = myOwners.at(ind);
623       LightApp_DataOwner* sowner = dynamic_cast<LightApp_DataOwner*>(aOwn);
624       QString aEntry = sowner->entry();
625       _PTR(SObject) aSObject = SMESH::getStudy()->FindObjectID(aEntry.toStdString());
626       _PTR(SObject) aFatherObj = aSObject->GetFather();
627       _PTR(SComponent) aComponent = aFatherObj->GetFatherComponent();
628       if (aComponent->ComponentDataType() == "SMESH") {
629         QString aObjEntry = entry(ind);
630         _PTR(SObject) aGeomSObject = SMESH::getStudy()->FindObjectID(aObjEntry.toStdString());
631         GEOM::GEOM_Object_var aObject = SMESH::SObjectToInterface<GEOM::GEOM_Object>(aGeomSObject);
632         if (!aObject->_is_nil())
633           return aObject->IsParametrical();
634       }
635     }
636   }
637   return false;
638 }
639
640 //=======================================================================
641 //function : isEditableHyp
642 //purpose  : 
643 //=======================================================================
644
645 bool SMESHGUI_Selection::isEditableHyp( int ind ) const
646 {
647   bool isEditable = true;
648   if ( ind >= 0 && ind < myTypes.count() && myTypes[ind] == "Hypothesis" )
649   {
650     _PTR(SObject) so = SMESH::getStudy()->FindObjectID( entry( ind ).toUtf8().data() );
651     SMESH::SMESH_Hypothesis_var hyp = SMESH::SObjectToInterface<SMESH::SMESH_Hypothesis>( so );
652     if ( !hyp->_is_nil() )
653     {
654       isEditable = hyp->HasParameters();
655     }
656   }
657   return isEditable;
658 }
659
660 //=======================================================================
661 //function : isVisible
662 //purpose  : 
663 //=======================================================================
664
665 bool SMESHGUI_Selection::isVisible( int ind ) const
666 {
667   if ( ind >= 0 && ind < myTypes.count() && myTypes[ind] != "Unknown" )
668   {
669     SMESH_Actor* actor = SMESH::FindActorByEntry( entry( ind ).toUtf8().data() );
670     if ( actor && actor->hasIO() ) {
671       if ( SVTK_ViewWindow* aViewWindow = SMESH::GetCurrentVtkView() )
672         return aViewWindow->isVisible( actor->getIO() );
673     }
674   }
675   return false;
676 }
677
678 //=======================================================================
679 //function : hasChildren
680 //purpose  : 
681 //=======================================================================
682
683 bool SMESHGUI_Selection::hasChildren( int ind ) const
684 {
685   if ( ind >= 0 )
686   {
687     _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entry( ind ).toUtf8().data() );
688     if ( sobj ) 
689       return SMESH::getStudy()->GetUseCaseBuilder()->HasChildren( sobj );
690   }
691   return false;
692 }
693
694 //=======================================================================
695 //function : hasChildren
696 //purpose  : 
697 //=======================================================================
698
699 int SMESHGUI_Selection::nbChildren( int ind ) const
700 {
701   int nb = 0;
702   if ( ind >= 0 )
703   {
704     _PTR(Study) study = SMESH::getStudy();
705     _PTR(SObject) sobj = study->FindObjectID( entry( ind ).toUtf8().data() );
706     if ( sobj && study->GetUseCaseBuilder()->IsUseCaseNode( sobj ) ) {
707       _PTR(UseCaseIterator) it = study->GetUseCaseBuilder()->GetUseCaseIterator( sobj );
708       for ( it->Init( false ); it->More(); it->Next() ) nb++;
709     }
710   }
711   return nb;
712 }
713
714 //=======================================================================
715 //function : isContainer
716 //purpose  : 
717 //=======================================================================
718
719 bool SMESHGUI_Selection::isContainer( int ind ) const
720 {
721   return ind >= 0 && ind < myTypes.count() && myTypes[ind] == "Unknown";
722 }
723
724 //=======================================================================
725 //function : type
726 //purpose  : 
727 //=======================================================================
728
729 int SMESHGUI_Selection::type( const QString& entry )
730 {
731   int res = -1;
732   _PTR(SObject) obj = SalomeApp_Application::getStudy()->FindObjectID( entry.toUtf8().data() );
733   if ( obj ) {
734     _PTR(SObject) ref;
735     if ( obj->ReferencedObject( ref ) )
736       obj = ref;
737
738     _PTR(SObject) objFather = obj->GetFather();
739     _PTR(SComponent) objComponent = obj->GetFatherComponent();
740
741     if ( objComponent->ComponentDataType() == "SMESH" ) {
742       if ( objComponent->GetIOR() == obj->GetIOR() ) {
743         res = SMESH::COMPONENT;
744       }
745       else {
746         int aLevel = obj->Depth() - objComponent->Depth(),
747           aFTag = objFather->Tag(),
748           anOTag = obj->Tag();
749
750         switch ( aLevel )
751         {
752         case 1:
753           if ( anOTag >= SMESH::Tag_FirstMeshRoot )
754             res = SMESH::MESH;
755           break;
756         case 2:
757           switch ( aFTag )
758           {
759           case SMESH::Tag_HypothesisRoot: res = SMESH::HYPOTHESIS; break;
760           case SMESH::Tag_AlgorithmsRoot: res = SMESH::ALGORITHM;  break;
761           default: break;
762           }
763           break;
764         case 3:
765           switch ( aFTag )
766           {
767           case SMESH::Tag_SubMeshOnVertex:   res = SMESH::SUBMESH_VERTEX;   break;
768           case SMESH::Tag_SubMeshOnEdge:     res = SMESH::SUBMESH_EDGE;     break;
769           case SMESH::Tag_SubMeshOnFace:     res = SMESH::SUBMESH_FACE;     break;
770           case SMESH::Tag_SubMeshOnSolid:    res = SMESH::SUBMESH_SOLID;    break;
771           case SMESH::Tag_SubMeshOnCompound: res = SMESH::SUBMESH_COMPOUND; break;
772           default:
773             if ( aFTag >= SMESH::Tag_FirstGroup) res = SMESH::GROUP;
774             else                                 res = SMESH::SUBMESH;
775             break;
776           }
777           break;
778         }
779       }
780     }
781   }
782   return res;
783 }
784
785 //=======================================================================
786 //function : typeName
787 //purpose  : 
788 //=======================================================================
789
790 QString SMESHGUI_Selection::typeName( const int t )
791 {
792   QString res = "Unknown";
793   switch( t )
794   {
795   case SMESH::HYPOTHESIS:
796     res = "Hypothesis"; break;
797   case SMESH::ALGORITHM:
798     res = "Algorithm"; break;
799   case SMESH::MESH:
800     res = "Mesh"; break;
801   case SMESH::SUBMESH:
802     res = "SubMesh"; break;
803   case SMESH::MESHorSUBMESH:
804     res = "Mesh or submesh"; break;
805   case SMESH::SUBMESH_VERTEX:
806     res = "Mesh vertex"; break;
807   case SMESH::SUBMESH_EDGE:
808     res = "Mesh edge"; break;
809   case SMESH::SUBMESH_FACE:
810     res = "Mesh face"; break;
811   case SMESH::SUBMESH_SOLID:
812     res = "Mesh solid"; break;
813   case SMESH::SUBMESH_COMPOUND:
814     res = "Mesh compound"; break;
815   case SMESH::GROUP:
816     res = "Group"; break;
817   case SMESH::COMPONENT:
818     res = "Component"; break;
819   default:
820      break;
821   }
822   return res;
823 }
824
825 bool SMESHGUI_Selection::isImported( const int ind ) const
826 {
827   bool res = false;
828   _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entry( ind ).toUtf8().constData() );
829   if ( sobj )
830   {
831     SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( SMESH::SObjectToObject( sobj ) );
832     if( !aMesh->_is_nil() )
833     {
834       SMESH::MedFileInfo_var inf = aMesh->GetMEDFileInfo();
835       res = strlen( (char*)inf->fileName ) > 0;
836     }
837   }
838   return res;
839 }
840
841 //=======================================================================
842 //function : guiState
843 //purpose  : 
844 //=======================================================================
845
846 int SMESHGUI_Selection::guiState()
847 {
848   return SMESHGUI::GetSMESHGUI() ? SMESHGUI::GetSMESHGUI()->GetState() : -1;
849 }
850
851 //=======================================================================
852 //function : groupType
853 //purpose  : 
854 //=======================================================================
855
856 QString SMESHGUI_Selection::groupType( int ind ) const
857 {
858   _PTR(SObject) sobj = SMESH::getStudy()->FindObjectID( entry( ind ).toUtf8().constData() );
859   if ( sobj )
860   {
861     SMESH::SMESH_Group_var g = SMESH::SObjectToInterface<SMESH::SMESH_Group>( sobj );
862     if ( !CORBA::is_nil( g ) )
863       return "Group";
864     SMESH::SMESH_GroupOnGeom_var gog = SMESH::SObjectToInterface<SMESH::SMESH_GroupOnGeom>( sobj );
865     if( !CORBA::is_nil( gog ) )
866       return "GroupOnGeom";
867     SMESH::SMESH_GroupOnFilter_var gof = SMESH::SObjectToInterface<SMESH::SMESH_GroupOnFilter>( sobj );
868     if ( !CORBA::is_nil( gof ) )
869       return "GroupOnFilter";
870   }
871   return "";
872 }