]> SALOME platform Git repositories - modules/geom.git/blob - src/GEOMGUI/GEOMGUI_Selection.cxx
Salome HOME
Prepare OCCT version 7.1.0+ for SALOME-8.2.0
[modules/geom.git] / src / GEOMGUI / GEOMGUI_Selection.cxx
1 // Copyright (C) 2007-2016  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 // File   : GEOMGUI_Selection.cxx
24 // Author : Alexander SOLOVYOV, Open CASCADE S.A.S. (alexander.solovyov@opencascade.com)
25
26 #include "GEOMGUI_Selection.h"
27 #include <GEOMGUI_DimensionProperty.h>
28 #include <GEOMGUI_AnnotationAttrs.h>
29 #include <GEOMGUI_AnnotationMgr.h>
30
31 #include "GeometryGUI.h"
32 #include "GEOM_Displayer.h"
33
34 #include "Material_Model.h"
35
36 #include <GEOM_Constants.h>
37
38 #include <SalomeApp_Application.h>
39 #include <SalomeApp_Study.h>
40
41 #include "LightApp_DataOwner.h"
42
43 #include <SUIT_Session.h>
44 #include <SUIT_Desktop.h>
45 #include <SUIT_ViewWindow.h>
46 #include <SUIT_ViewManager.h>
47 #include <SUIT_ResourceMgr.h>
48
49 #include <SALOME_Prs.h>
50 #include <SALOME_InteractiveObject.hxx>
51
52 #include <SOCC_Prs.h>
53 #include <SVTK_Prs.h>
54 #include <SALOME_Actor.h>
55 #include <GEOM_Actor.h>
56
57 #include <OCCViewer_ViewModel.h>
58 #include <SVTK_ViewModel.h>
59
60 #include <GEOMImpl_Types.hxx>
61
62 #include <GEOM_AISShape.hxx>
63 #include <GEOM_VTKPropertyMaterial.hxx>
64
65 // OCCT Includes
66 #include <AIS.hxx>
67 #include <AIS_InteractiveObject.hxx>
68 #include <AIS_ListOfInteractive.hxx>
69 #include <AIS_GraphicTool.hxx>
70 #include <Aspect_TypeOfFacingModel.hxx>
71 #include <Prs3d_ShadingAspect.hxx>
72 #include<Graphic3d_MaterialAspect.hxx>
73
74 // VTK Includes
75 #include <vtkActorCollection.h>
76
77 #define OCC_DISPLAY_MODE_TO_STRING( str, dm ) { \
78     if ( dm == AIS_WireFrame ) \
79       str = QString( "Wireframe" ); \
80     else if ( dm == AIS_Shaded )    \
81       str = QString( "Shading" ); \
82     else if ( dm == GEOM_AISShape::ShadingWithEdges )    \
83       str = QString( "ShadingWithEdges" ); \
84     else if ( dm == GEOM_AISShape::TexturedShape )    \
85       str = QString( "Texture" ); \
86     else \
87       str = QString(); }
88
89 #define USE_VISUAL_PROP_MAP
90
91 #ifdef USE_VISUAL_PROP_MAP
92   #define VTK_DISPLAY_MODE_TO_STRING( str, dm ) { \
93       if ( dm == 0 ) \
94         str = QString( "Wireframe" ); \
95       else if ( dm == 1 )    \
96         str = QString( "Shading" ); \
97       else if ( dm == 2 )    \
98         str = QString( "ShadingWithEdges" ); \
99       else \
100         str = QString(); }
101 #else
102   #define VTK_DISPLAY_MODE_TO_STRING( str, dm ) { \
103       if ( dm == 0 ) \
104         str = QString( "Wireframe" ); \
105       else if ( dm == 1 )    \
106         str = QString( "Shading" ); \
107       else if ( dm == 3 )    \
108         str = QString( "ShadingWithEdges" ); \
109       else \
110         str = QString(); }
111 #endif
112
113 GEOMGUI_Selection::GEOMGUI_Selection()
114 : LightApp_Selection()
115 {
116 }
117
118 GEOMGUI_Selection::~GEOMGUI_Selection()
119 {
120 }
121
122 void GEOMGUI_Selection::init( const QString& context, LightApp_SelectionMgr* selMgr )
123 {
124   LightApp_Selection::init( context, selMgr );
125
126   myObjects.resize( count() );
127
128   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( study() );
129   if ( appStudy ) {
130     _PTR(Study) study = appStudy->studyDS();
131     for ( int idx = 0; idx < count(); idx++ ) {
132       QString anEntry = entry( idx );
133       if ( study && !anEntry.isEmpty() ) {
134         _PTR(SObject) aSO( study->FindObjectID( anEntry.toStdString() ) );
135         if ( aSO ) {
136           CORBA::Object_var varObj = GeometryGUI::ClientSObjectToObject( aSO );
137           myObjects[idx] = GEOM::GEOM_BaseObject::_narrow( varObj );
138         }
139       }
140     }
141   }
142 }
143
144 //QVariant GEOMGUI_Selection::contextParameter( const QString& p ) const
145 QVariant GEOMGUI_Selection::parameter( const QString& p ) const
146 {
147   QVariant v;
148   if ( p == "isOCC" )
149     v = activeViewType() == OCCViewer_Viewer::Type();
150   else if ( p == "selectionmode" )
151     v = selectionMode();
152   else if ( p == "hasImported" )
153     v = hasImported();
154   else if ( p == "allImported" )
155     v = allImported();
156   else if (p == "annotationsCount")
157     v = annotationsCount();
158   else
159     v = LightApp_Selection::parameter( p );
160   return v;
161 }
162
163 //QVariant GEOMGUI_Selection::objectParameter( const int idx, const QString& p ) const
164 QVariant GEOMGUI_Selection::parameter( const int idx, const QString& p ) const
165 {
166   QVariant v;
167   if ( p == "type" )
168     v = typeName( idx );
169   else if ( p == "typeid" )
170     v = typeId( idx );
171   else if ( p == "displaymode" )
172     v = displayMode( idx );
173   else if ( p == "isAutoColor" )
174     v = isAutoColor( idx );
175   else if ( p == "isVectorsMode" )
176     v = isVectorsMode( idx );
177   else if ( p == "isVerticesMode" )
178     v = isVerticesMode( idx );
179   else if ( p == "isNameMode" )
180     v = isNameMode( idx );
181   else if ( p == "topLevel" )
182     v = topLevel( idx );
183   else if ( p == "autoBringToFront" )
184     v = autoBringToFront( idx );
185   else if ( p == "hasChildren" )
186     v = hasChildren( idx );
187   else if ( p == "nbChildren" )
188     v = nbChildren(idx);
189   else if ( p == "hasConcealedChildren" )
190     v = hasConcealedChildren( idx );
191   else if ( p == "hasDisclosedChildren" )
192     v = hasDisclosedChildren( idx );
193   else if ( p == "compoundOfVertices" )
194     v = compoundOfVertices( idx );
195   else if ( p == "imported" )
196     v = isImported( idx );
197   else if ( p == "isPhysicalMaterial" )
198     v = isPhysicalMaterial(idx);
199   else if ( p == "isFolder" )
200     v = isFolder(idx);
201   else if ( p == "hasHiddenDimensions" )
202     v = hasHiddenDimensions(idx);
203   else if ( p == "hasVisibleDimensions" )
204     v = hasVisibleDimensions(idx);
205   else if ( p == "hasHiddenAnnotations" )
206     v = hasHiddenAnnotations(idx);
207   else if ( p == "hasVisibleAnnotations" )
208     v = hasVisibleAnnotations(idx);
209   else
210     v = LightApp_Selection::parameter( idx, p );
211
212   return v;
213 }
214
215 // the method to skip temporary objects from selection (called from LightApp)
216 bool GEOMGUI_Selection::processOwner( const LightApp_DataOwner* theOwner )
217 {
218   if ( theOwner->entry().contains( GEOMGUI_AnnotationMgr::GetEntrySeparator() ) ) {
219     myAnnotationEntries.append( theOwner->entry() );
220   }
221   return !theOwner->entry().contains("_");
222 }
223
224 QString GEOMGUI_Selection::typeName( const int index ) const
225 {
226   if ( isComponent( index ) )
227     return "Component";
228   if ( isFolder( index ) )
229     return "Folder";
230
231   static QString aGroup( "Group" );
232   static QString aShape( "Shape" );
233   static QString aField( "Field" );
234   static QString aFieldStep( "FieldStep" );
235   static QString anUnknown( "Unknown" );
236
237   GEOM::GEOM_BaseObject_var anObj = getBaseObject( index );
238   if ( !CORBA::is_nil( anObj ) ) {
239     const int aGeomType = anObj->GetType();
240     switch ( aGeomType ) {
241     case GEOM_GROUP     : return aGroup;
242     case GEOM_FIELD     : return aField;
243     case GEOM_FIELD_STEP: return aFieldStep;
244     default             : return aShape;
245     }
246   }
247   return anUnknown;
248 }
249
250 int GEOMGUI_Selection::typeId( const int index ) const
251 {
252   int aType = -1;
253   GEOM::GEOM_Object_var anObj = getObject( index );
254   if ( !CORBA::is_nil( anObj ) )
255     aType = (int)anObj->GetShapeType();
256   return aType;
257 }
258
259 bool GEOMGUI_Selection::isVisible( const int index ) const
260 {
261 #ifdef USE_VISUAL_PROP_MAP
262   QVariant v = visibleProperty( entry( index ), GEOM::propertyName( GEOM::Visibility ) );
263   if ( v.canConvert( QVariant::Bool ) )
264     return v.toBool();
265 #endif
266
267   bool res = false;
268
269   GEOM::GEOM_Object_var obj = getObject( index );
270   SALOME_View* view = GEOM_Displayer::GetActiveView();
271   if ( !CORBA::is_nil( obj ) && view ) {
272     Handle(SALOME_InteractiveObject) io = new SALOME_InteractiveObject( entry( index ).toLatin1().constData(), "GEOM", "TEMP_IO" );
273     res = view->isVisible( io );
274   }
275
276   return res;
277 }
278
279 bool GEOMGUI_Selection::isAutoColor( const int index ) const
280 {
281   GEOM::GEOM_Object_var obj = getObject( index );
282   if ( !CORBA::is_nil( obj ) )
283     return obj->GetAutoColor();
284   return false;
285 }
286
287 bool GEOMGUI_Selection::isImported( const int index ) const
288 {
289   GEOM::GEOM_Object_var obj = getObject( index );
290   if ( !CORBA::is_nil( obj ) )
291     return obj->GetType() == GEOM_IMPORT;
292   return false;
293 }
294
295 bool GEOMGUI_Selection::hasImported() const
296 {
297   bool res = false;
298   for ( int i = 0; i < count() && !res; i++ )
299     res = isImported( i );
300   return res;
301 }
302
303 bool GEOMGUI_Selection::allImported() const
304 {
305   bool res = true;
306   for ( int i = 0; i < count() && res; i++ )
307     res = isImported( i );
308   return res;
309 }
310
311 QVariant GEOMGUI_Selection::visibleProperty( const QString& entry, const QString& propName ) const
312 {
313   QVariant v;
314   LightApp_Study* aStudy = study();
315   if ( aStudy ) {
316     LightApp_Application* anApp = ::qobject_cast<LightApp_Application*>( aStudy->application() );
317     if ( anApp && anApp->activeViewManager() ) {
318       int id = anApp->activeViewManager()->getGlobalId();
319       v = aStudy->getObjectProperty( id, entry, propName, QVariant() );
320     }
321   }
322   return v;
323 }
324
325 QString GEOMGUI_Selection::displayMode( const int index ) const
326 {
327   QString res;
328   QString viewType = activeViewType();
329   
330 #ifdef USE_VISUAL_PROP_MAP
331   QVariant v = visibleProperty( entry( index ), GEOM::propertyName( GEOM::DisplayMode ) );
332   if ( v.canConvert( QVariant::Int ) ) {
333     int dm = v.toInt();
334     if ( viewType == OCCViewer_Viewer::Type() ) {
335       OCC_DISPLAY_MODE_TO_STRING( res, dm );
336     } else if ( viewType == SVTK_Viewer::Type() ) {
337       VTK_DISPLAY_MODE_TO_STRING( res, dm );
338     }
339     return res;
340   }
341 #endif
342
343   SALOME_View* view = GEOM_Displayer::GetActiveView();
344   if ( view /*fix for 9320==>*/&& ( viewType == OCCViewer_Viewer::Type() || viewType == SVTK_Viewer::Type() ) ) {
345     SALOME_Prs* prs = view->CreatePrs( entry( index ).toLatin1().constData() );
346     if ( prs ) {
347       if ( viewType == OCCViewer_Viewer::Type() ) { // assuming OCC
348         SOCC_Prs* occPrs = (SOCC_Prs*) prs;
349         AIS_ListOfInteractive lst;
350         occPrs->GetObjects( lst );
351         if ( lst.Extent() ) {
352           Handle(AIS_InteractiveObject) io = lst.First();
353           if ( !io.IsNull() ) {
354             int dm;
355             Handle(GEOM_AISShape) aSh = Handle(GEOM_AISShape)::DownCast(io);
356             if(!aSh.IsNull()) {
357               dm = aSh->isTopLevel() ? aSh->prevDisplayMode() : aSh->DisplayMode();
358             } else {
359               dm = io->DisplayMode();
360             }
361             OCC_DISPLAY_MODE_TO_STRING( res, dm );
362             if ( res.isEmpty() ) { // return default display mode of AIS_InteractiveContext
363               OCCViewer_Viewer* occViewer = (OCCViewer_Viewer*)SUIT_Session::session()->activeApplication()->
364                 desktop()->activeWindow()->getViewManager()->getViewModel();
365               Handle(AIS_InteractiveContext) ic = occViewer->getAISContext();
366               dm = ic->DisplayMode();
367               OCC_DISPLAY_MODE_TO_STRING( res, dm );
368             }
369           }
370         }
371       }
372       else if ( viewType == SVTK_Viewer::Type() ) { // assuming VTK
373         SVTK_Prs* vtkPrs = dynamic_cast<SVTK_Prs*>( prs );
374         vtkActorCollection* lst = vtkPrs ? vtkPrs->GetObjects() : 0;
375         if ( lst ) {
376           lst->InitTraversal();
377           vtkActor* actor = lst->GetNextActor();
378           if ( actor ) {
379             SALOME_Actor* salActor = dynamic_cast<SALOME_Actor*>( actor );
380             if ( salActor ) {
381               int dm = salActor->getDisplayMode();
382               VTK_DISPLAY_MODE_TO_STRING( res, dm );
383             } // if ( salome actor )
384           } // if ( actor )
385         } // if ( lst == vtkPrs->GetObjects() )
386       } // if VTK
387     }
388   }
389
390   return res;
391 }
392
393 bool GEOMGUI_Selection::autoBringToFront( const int /*index*/ ) const
394 {
395   return SUIT_Session::session()->resourceMgr()->booleanValue( "Geometry", "auto_bring_to_front", "false" );
396 }
397
398 bool GEOMGUI_Selection::isVectorsMode( const int index ) const
399 {
400 #ifdef USE_VISUAL_PROP_MAP
401   QVariant v = visibleProperty( entry( index ), GEOM::propertyName( GEOM::EdgesDirection ) );
402   if ( v.canConvert( QVariant::Bool ) )
403     return v.toBool();
404 #endif
405
406   bool res = false;
407   
408   SALOME_View* view = GEOM_Displayer::GetActiveView();
409   QString viewType = activeViewType();
410   if ( view && ( viewType == OCCViewer_Viewer::Type() || viewType == SVTK_Viewer::Type() ) ) {
411     SALOME_Prs* prs = view->CreatePrs( entry( index ).toLatin1().constData() );
412     if ( prs ) {
413       if ( viewType == OCCViewer_Viewer::Type() ) { // assuming OCC
414         SOCC_Prs* occPrs = (SOCC_Prs*) prs;
415         AIS_ListOfInteractive lst;
416         occPrs->GetObjects( lst );
417         if ( lst.Extent() ) {
418           Handle(AIS_InteractiveObject) io = lst.First();
419           if ( !io.IsNull() ) {
420             Handle(GEOM_AISShape) aSh = Handle(GEOM_AISShape)::DownCast(io);
421             if ( !aSh.IsNull() )
422               res = aSh->isShowVectors();
423           }
424         }
425       }
426       else if ( viewType == SVTK_Viewer::Type() ) { // assuming VTK
427         SVTK_Prs* vtkPrs = dynamic_cast<SVTK_Prs*>( prs );
428         vtkActorCollection* lst = vtkPrs ? vtkPrs->GetObjects() : 0;
429         if ( lst ) {
430           lst->InitTraversal();
431           vtkActor* actor = lst->GetNextActor();
432           if ( actor ) {
433             GEOM_Actor* aGeomActor = GEOM_Actor::SafeDownCast(actor);
434             if ( aGeomActor )
435               res = aGeomActor->GetVectorMode();
436             }
437         }
438       }
439     }
440   }
441
442   return res;
443 }
444
445 bool GEOMGUI_Selection::isVerticesMode( const int index ) const
446 {
447 #ifdef USE_VISUAL_PROP_MAP
448   QVariant v = visibleProperty( entry( index ), GEOM::propertyName( GEOM::Vertices ) );
449   if ( v.canConvert( QVariant::Bool ) )
450     return v.toBool();
451 #endif
452
453   bool res = false;
454   
455   SALOME_View* view = GEOM_Displayer::GetActiveView();
456   QString viewType = activeViewType();
457   if ( view && ( viewType == OCCViewer_Viewer::Type() || viewType == SVTK_Viewer::Type() ) ) {
458     SALOME_Prs* prs = view->CreatePrs( entry( index ).toLatin1().constData() );
459     if ( prs ) {
460       if ( viewType == OCCViewer_Viewer::Type() ) { // assuming OCC
461         SOCC_Prs* occPrs = (SOCC_Prs*) prs;
462         AIS_ListOfInteractive lst;
463         occPrs->GetObjects( lst );
464         if ( lst.Extent() ) {
465           Handle(AIS_InteractiveObject) io = lst.First();
466           if ( !io.IsNull() ) {
467             Handle(GEOM_AISShape) aSh = Handle(GEOM_AISShape)::DownCast(io);
468             if ( !aSh.IsNull() )
469               res = aSh->isShowVertices();
470           }
471         }
472       }
473       else if ( viewType == SVTK_Viewer::Type() ) { // assuming VTK
474         SVTK_Prs* vtkPrs = dynamic_cast<SVTK_Prs*>( prs );
475         vtkActorCollection* lst = vtkPrs ? vtkPrs->GetObjects() : 0;
476         if ( lst ) {
477           lst->InitTraversal();
478           vtkActor* actor = lst->GetNextActor();
479           if ( actor ) {
480             GEOM_Actor* aGeomActor = GEOM_Actor::SafeDownCast(actor);
481             if ( aGeomActor )
482               res = aGeomActor->GetVerticesMode();
483             }
484         }
485       }
486     }
487   }
488
489   return res;
490 }
491
492 bool GEOMGUI_Selection::isNameMode( const int index ) const
493 {
494 #ifdef USE_VISUAL_PROP_MAP
495   QVariant v = visibleProperty( entry( index ), GEOM::propertyName( GEOM::ShowName ) );
496   if ( v.canConvert( QVariant::Bool ) )
497     return v.toBool();
498 #endif
499
500   bool res = false;
501
502   SALOME_View* view = GEOM_Displayer::GetActiveView();
503   QString viewType = activeViewType();
504   if ( view && ( viewType == OCCViewer_Viewer::Type() || viewType == SVTK_Viewer::Type() ) ) {
505     SALOME_Prs* prs = view->CreatePrs( entry( index ).toLatin1().constData() );
506     if ( prs ) {
507       if ( viewType == OCCViewer_Viewer::Type() ) { // assuming OCC
508         SOCC_Prs* occPrs = (SOCC_Prs*) prs;
509         AIS_ListOfInteractive lst;
510         occPrs->GetObjects( lst );
511         if ( lst.Extent() ) {
512           Handle(AIS_InteractiveObject) io = lst.First();
513           if ( !io.IsNull() ) {
514             Handle(GEOM_AISShape) aSh = Handle(GEOM_AISShape)::DownCast(io);
515             if ( !aSh.IsNull() )
516               res = aSh->isShowName();
517           }
518         }
519       }
520       else if ( viewType == SVTK_Viewer::Type() ) { // assuming VTK
521         SVTK_Prs* vtkPrs = dynamic_cast<SVTK_Prs*>( prs );
522         vtkActorCollection* lst = vtkPrs ? vtkPrs->GetObjects() : 0;
523         if ( lst ) {
524           lst->InitTraversal();
525           vtkActor* actor = lst->GetNextActor();
526           if ( actor ) {
527             GEOM_Actor* aGeomActor = GEOM_Actor::SafeDownCast(actor);
528             if ( aGeomActor )
529               res = aGeomActor->GetNameMode();
530             }
531         }
532       }
533     }
534   }
535
536   return res;
537 }
538
539 bool GEOMGUI_Selection::hasChildren( const _PTR(SObject)& obj )
540 {
541   if ( obj ) {
542     // as soon as Use Case browser data tree was added
543     return obj->GetStudy()->GetUseCaseBuilder()->HasChildren( obj );
544   }
545 }
546
547 bool GEOMGUI_Selection::expandable( const _PTR(SObject)& obj )
548 {
549   bool exp = true;
550   _PTR(GenericAttribute) anAttr;
551   if ( obj && obj->FindAttribute( anAttr, "AttributeExpandable" ) ) {
552     _PTR(AttributeExpandable) aAttrExp = anAttr;
553     exp = aAttrExp->IsExpandable();
554   }
555   return exp;
556 }
557
558 bool GEOMGUI_Selection::isCompoundOfVertices( GEOM::GEOM_Object_ptr obj )
559 {
560   bool ret = false;
561   /*
562   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>
563   (SUIT_Session::session()->activeApplication()->activeStudy());*/
564   if ( /*appStudy && */!CORBA::is_nil( obj ) )
565     ret = obj->GetShapeType() == GEOM::COMPOUND && obj->GetMaxShapeType() == GEOM::VERTEX;
566   return ret;
567 }
568
569 bool GEOMGUI_Selection::isFolder( const _PTR(SObject)& obj )
570 {
571   bool ret = false;
572   _PTR(GenericAttribute) anAttr;
573   if ( obj && obj->FindAttribute(anAttr, "AttributeLocalID") ) {
574     _PTR(AttributeLocalID) aLocalID( anAttr );
575     ret = aLocalID->Value() == 999;
576   }
577   return ret;
578 }
579
580 bool GEOMGUI_Selection::hasChildren( const int index ) const
581 {
582   bool ok = false;
583   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( study() );
584
585   if ( appStudy ) {
586     QString anEntry = entry( index );
587     _PTR(Study) study = appStudy->studyDS();
588     if ( study && !anEntry.isEmpty() ) {
589       _PTR(SObject) aSO( study->FindObjectID( anEntry.toStdString() ) );
590       ok = hasChildren( aSO );
591     }
592   }
593   return ok;
594 }
595
596 int GEOMGUI_Selection::nbChildren( const int index ) const
597 {
598   int nb = 0;
599   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( study() );
600
601   if ( appStudy ) {
602     QString anEntry = entry( index );
603     _PTR(Study) study = appStudy->studyDS();
604     if ( study && !anEntry.isEmpty() ) {
605       _PTR(SObject) aSO( study->FindObjectID( anEntry.toStdString() ) );
606       if ( aSO && aSO->GetStudy()->GetUseCaseBuilder()->IsUseCaseNode(aSO) ) {
607         _PTR(UseCaseIterator) it = aSO->GetStudy()->GetUseCaseBuilder()->GetUseCaseIterator( aSO ); 
608         for (it->Init(false); it->More(); it->Next()) nb++;
609       }
610     }
611   }
612   return nb;
613 }
614
615 bool GEOMGUI_Selection::hasConcealedChildren( const int index ) const
616 {
617   bool OK = false;
618   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( study() );
619
620   if ( appStudy ) {
621     QString anEntry = entry( index );
622     _PTR(Study) study = appStudy->studyDS();
623     if ( study && !anEntry.isEmpty() ) {
624       _PTR(SObject) aSO( study->FindObjectID( anEntry.toStdString() ) );
625       OK = !expandable( aSO ) && hasChildren( aSO );
626     }
627   }
628   return OK;
629 }
630
631 bool GEOMGUI_Selection::hasDisclosedChildren( const int index ) const
632 {
633   bool OK = false;
634   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( study() );
635
636   if ( appStudy )  {
637     QString anEntry = entry( index );
638     _PTR(Study) study = appStudy->studyDS();
639     if ( study && !anEntry.isEmpty() ) {
640       _PTR(SObject) aSO( study->FindObjectID( anEntry.toStdString() ) );
641       OK = expandable( aSO ) && hasChildren( aSO );
642     }
643   }
644   return OK;
645 }
646
647 bool GEOMGUI_Selection::compoundOfVertices( const int index ) const
648 {
649   GEOM::GEOM_Object_var obj = getObject( index );
650   return isCompoundOfVertices( obj );
651 }
652
653 bool GEOMGUI_Selection::isComponent( const int index ) const
654 {
655   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( study() );
656
657   if ( appStudy ) {
658     QString anEntry = entry( index );
659     _PTR(Study) study = appStudy->studyDS();
660     if ( study && !anEntry.isNull() ) {
661       _PTR(SObject) aSO( study->FindObjectID( anEntry.toStdString() ) );
662       if ( aSO && aSO->GetFatherComponent() )
663         return aSO->GetFatherComponent()->GetIOR() == aSO->GetIOR();
664     }
665   }
666   return false;
667 }
668
669 GEOM::GEOM_Object_ptr GEOMGUI_Selection::getObject( const int index ) const
670 {
671   GEOM::GEOM_Object_var o;
672   if ( 0 <= index && index < myObjects.size() )
673     o = GEOM::GEOM_Object::_narrow( myObjects[index] );
674   return o._retn();
675 }
676
677 GEOM::GEOM_BaseObject_ptr GEOMGUI_Selection::getBaseObject( const int index ) const
678 {
679   GEOM::GEOM_BaseObject_var o;
680   if ( 0 <= index && index < myObjects.size() )
681     o = GEOM::GEOM_BaseObject::_duplicate( myObjects[index] );
682   return o._retn();
683 }
684
685 QString GEOMGUI_Selection::selectionMode() const
686 {
687   SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( study()->application() );
688   if ( app ) {
689     GeometryGUI* aGeomGUI = dynamic_cast<GeometryGUI*>( app->module( "Geometry" ) );
690     if ( aGeomGUI ) {
691       switch ( aGeomGUI->getLocalSelectionMode() )
692       {
693         case GEOM_POINT      : return "VERTEX";
694         case GEOM_EDGE       : return "EDGE";
695         case GEOM_WIRE       : return "WIRE";
696         case GEOM_FACE       : return "FACE";
697         case GEOM_SHELL      : return "SHELL";
698         case GEOM_SOLID      : return "SOLID";
699         case GEOM_COMPOUND   : return "COMPOUND";
700         case GEOM_ALLOBJECTS : return "ALL";
701         default: return "";
702       }
703     }
704   }
705   return "";
706 }
707
708 bool GEOMGUI_Selection::topLevel( const int index ) const
709 {
710 #ifdef USE_VISUAL_PROP_MAP
711   QVariant v = visibleProperty( entry( index ), GEOM::propertyName( GEOM::TopLevel ) );
712   if ( v.canConvert<bool>() )
713     return v.toBool();
714 #endif
715
716   bool res = false;
717
718   SALOME_View* view = GEOM_Displayer::GetActiveView();
719   QString viewType = activeViewType();
720   if ( view && viewType == OCCViewer_Viewer::Type() ) {
721     SALOME_Prs* prs = view->CreatePrs( entry( index ).toLatin1().constData() );
722     if ( prs ) {
723       if ( viewType == OCCViewer_Viewer::Type() ) { // assuming OCC
724         SOCC_Prs* occPrs = (SOCC_Prs*) prs;
725         AIS_ListOfInteractive lst;
726         occPrs->GetObjects( lst );
727         if ( lst.Extent() ) {
728           Handle(AIS_InteractiveObject) io = lst.First();
729           if ( !io.IsNull() ) {
730             Handle(GEOM_AISShape) aSh = Handle(GEOM_AISShape)::DownCast(io);
731             if ( !aSh.IsNull() )
732               res = (bool)aSh->isTopLevel();
733           }
734         }
735       }
736     }
737   }
738   return res;
739 }
740
741 bool GEOMGUI_Selection::isPhysicalMaterial( const int idx ) const
742 {
743 #ifdef USE_VISUAL_PROP_MAP
744   QVariant v = visibleProperty( entry( idx ), GEOM::propertyName( GEOM::Material ) );
745   if ( v.canConvert<QString>() ) {
746     Material_Model material;
747     material.fromProperties( v.toString() );
748     return material.isPhysical();
749   }
750 #endif
751
752   bool res = false;
753   
754   SALOME_View* view = GEOM_Displayer::GetActiveView();
755   QString viewType = activeViewType();
756   if ( view ) {
757     SALOME_Prs* prs = view->CreatePrs( entry( idx ).toLatin1().constData() );
758     if ( prs ) {
759       if ( viewType == OCCViewer_Viewer::Type() ) { // assuming OCC
760         SOCC_Prs* occPrs = (SOCC_Prs*) prs;
761         AIS_ListOfInteractive lst;
762         occPrs->GetObjects( lst );
763         if ( lst.Extent() ) {
764           Handle(AIS_InteractiveObject) io = lst.First();
765           if ( !io.IsNull() ) {
766             Handle(GEOM_AISShape) aSh = Handle(GEOM_AISShape)::DownCast(io);
767             if ( !aSh.IsNull() )
768               res = (bool) aSh->Attributes()->ShadingAspect()->
769                 Material(Aspect_TOFM_BOTH_SIDE).MaterialType( Graphic3d_MATERIAL_PHYSIC );
770           }
771         }
772       }
773       else if ( viewType == SVTK_Viewer::Type() ) { // assuming VTK
774         SVTK_Prs* vtkPrs = dynamic_cast<SVTK_Prs*>( prs );
775         vtkActorCollection* lst = vtkPrs ? vtkPrs->GetObjects() : 0;
776         if ( lst ) {
777           lst->InitTraversal();
778           vtkActor* actor = lst->GetNextActor();
779           if ( actor ) {
780             GEOM_Actor* aGeomGActor = GEOM_Actor::SafeDownCast( actor );
781             if ( aGeomGActor ) {
782               GEOM_VTKPropertyMaterial* mat  = GEOM_VTKPropertyMaterial::SafeDownCast(aGeomGActor->GetProperty());
783               if ( mat )
784                 res = mat->GetPhysical();
785             } // if ( salome actor )
786           } // if ( actor )
787         } // if ( lst == vtkPrs->GetObjects() )
788       }
789     }
790   }
791
792   return res;
793 }
794
795 bool GEOMGUI_Selection::isFolder( const int index ) const
796 {
797   bool res = false;
798   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( study() );
799
800   if ( appStudy ) {
801     QString anEntry = entry( index );
802     _PTR(Study) study = appStudy->studyDS();
803     if ( study && !anEntry.isNull() ) {
804       _PTR(SObject) aSO( study->FindObjectID( anEntry.toStdString() ) );
805       if ( aSO ) res = isFolder( aSO );
806     }
807   }
808   return res;
809 }
810
811 bool GEOMGUI_Selection::hasDimensions( const int theIndex, bool& theHidden, bool& theVisible ) const
812 {
813   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( study() );
814
815   if ( !appStudy )
816   {
817     return false;
818   }
819
820   QString anEntry = entry( theIndex );
821   _PTR(Study) aStudy = appStudy->studyDS();
822   if ( !aStudy || anEntry.isNull() )
823   {
824     return false;
825   }
826
827   GEOMGUI_DimensionProperty aDimensions( appStudy, anEntry.toStdString() );
828
829   theHidden  = false;
830   theVisible = false;
831
832   for ( int it = 0; it < aDimensions.GetNumber(); ++it )
833   {
834     if ( aDimensions.IsVisible( it ) )
835       theVisible = true;
836     else
837       theHidden = true;
838   }
839
840   return aDimensions.GetNumber() > 0;
841 }
842
843 bool GEOMGUI_Selection::hasHiddenDimensions( const int theIndex ) const
844 {
845   bool isAnyVisible = false;
846   bool isAnyHidden = false;
847   if ( !hasDimensions( theIndex, isAnyHidden, isAnyVisible ) )
848   {
849     return false;
850   }
851
852   return isAnyHidden;
853 }
854
855 bool GEOMGUI_Selection::hasVisibleDimensions( const int theIndex ) const
856 {
857   bool isAnyVisible = false;
858   bool isAnyHidden = false;
859   if ( !hasDimensions( theIndex, isAnyHidden, isAnyVisible ) )
860   {
861     return false;
862   }
863
864   return isAnyVisible;
865 }
866
867 int GEOMGUI_Selection::annotationsCount() const
868 {
869   return myAnnotationEntries.size();
870 }
871
872 bool GEOMGUI_Selection::hasAnnotations( const int theIndex, bool& theHidden, bool& theVisible ) const
873 {
874   SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( study() );
875   if ( !appStudy )
876     return false;
877
878   QString anEntry = entry( theIndex );
879   _PTR(Study) aStudy = appStudy->studyDS();
880   if ( !aStudy || anEntry.isNull() )
881     return false;
882
883   _PTR(SObject) aSObj = appStudy->studyDS()->FindObjectID( anEntry.toStdString() );\r
884
885   const Handle(GEOMGUI_AnnotationAttrs)\r
886     aShapeAnnotations = GEOMGUI_AnnotationAttrs::FindAttributes( aSObj );\r
887
888   if ( aShapeAnnotations.IsNull() )\r
889     return false;\r
890
891   theHidden  = false;
892   theVisible = false;
893
894   const int aCount = aShapeAnnotations->GetNbAnnotation();
895   for ( int anI = 0; anI < aCount; ++anI )
896   {
897     if ( aShapeAnnotations->GetIsVisible( anI ) )
898       theVisible = true;
899     else
900       theHidden = true;
901   }
902
903   return aCount > 0;
904 }
905
906 bool GEOMGUI_Selection::hasHiddenAnnotations( const int theIndex ) const
907 {
908   bool isAnyVisible, isAnyHidden = false;
909   if ( !hasAnnotations( theIndex, isAnyHidden, isAnyVisible ) )
910   {
911     return false;
912   }
913
914   return isAnyHidden;
915 }
916
917 bool GEOMGUI_Selection::hasVisibleAnnotations( const int theIndex ) const
918 {
919   bool isAnyVisible, isAnyHidden = false;
920   if ( !hasAnnotations( theIndex, isAnyHidden, isAnyVisible ) )
921   {
922     return false;
923   }
924
925   return isAnyVisible;
926 }