Salome HOME
f09225878fdd3a61f1f9977713c482bab8d082e7
[modules/smesh.git] / src / SMESHGUI / SMESHGUI_VTKUtils.cxx
1 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
2 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
3 //
4 //  This library is free software; you can redistribute it and/or
5 //  modify it under the terms of the GNU Lesser General Public
6 //  License as published by the Free Software Foundation; either
7 //  version 2.1 of the License.
8 //
9 //  This library is distributed in the hope that it will be useful,
10 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
11 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12 //  Lesser General Public License for more details.
13 //
14 //  You should have received a copy of the GNU Lesser General Public
15 //  License along with this library; if not, write to the Free Software
16 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
17 //
18 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
19
20
21 #include "SMESHGUI_VTKUtils.h"
22 #include "SMESHGUI_Utils.h"
23 #include "SMESHGUI_Filter.h"
24
25 #include <vtkRenderer.h>
26 #include <vtkActorCollection.h>
27
28 #include <TColStd_IndexedMapOfInteger.hxx>
29
30 #include <SUIT_Desktop.h>
31 #include <SUIT_Session.h>
32 #include <SUIT_Study.h>
33
34 #include "SalomeApp_SelectionMgr.h"
35
36 #include "SVTK_Selector.h"
37 #include "SVTK_ViewModel.h"
38 #include "SVTK_ViewWindow.h"
39 #include "SVTK_RenderWindow.h"
40 #include "SVTK_InteractorStyle.h"
41 #include "SVTK_RenderWindowInteractor.h"
42
43 #include "utilities.h"
44
45 #include "SALOMEconfig.h"
46 #include CORBA_CLIENT_HEADER(SMESH_Gen)
47 #include CORBA_CLIENT_HEADER(SMESH_Mesh)
48 #include CORBA_CLIENT_HEADER(SMESH_Group)
49 #include CORBA_CLIENT_HEADER(SMESH_Hypothesis)
50
51 #include "SMESHGUI.h"
52 #include "SMESH_Actor.h"
53 #include "SMESH_ObjectDef.h"
54
55 #include <SalomeApp_Application.h>
56 #include <SalomeApp_SelectionMgr.h>
57 #include <SalomeApp_Study.h>
58
59 #include <SALOMEDSClient_Study.hxx>
60 #include <SALOMEDSClient_SObject.hxx>
61
62 #include <SALOME_ListIO.hxx>
63 #include <SALOME_ListIteratorOfListIO.hxx>
64
65 #include <set>
66 using namespace std;
67
68 namespace SMESH{
69
70   typedef map<TKeyOfVisualObj,TVisualObjPtr> TVisualObjCont;
71   static TVisualObjCont VISUAL_OBJ_CONT;
72
73   TVisualObjPtr GetVisualObj(int theStudyId, const char* theEntry){
74     TVisualObjPtr aVisualObj;
75     try{
76       TVisualObjCont::key_type aKey(theStudyId,theEntry);
77       TVisualObjCont::iterator anIter = VISUAL_OBJ_CONT.find(aKey);
78       if(anIter != VISUAL_OBJ_CONT.end()){
79         aVisualObj = anIter->second;
80       }else{
81         SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SMESHGUI::activeStudy()->application() );
82         _PTR(Study) aStudy = SMESHGUI::activeStudy()->studyDS();
83         _PTR(SObject) aSObj = aStudy->FindObjectID(theEntry);
84         if(aSObj){
85           _PTR(GenericAttribute) anAttr;
86           if(aSObj->FindAttribute(anAttr,"AttributeIOR")){
87             _PTR(AttributeIOR) anIOR = anAttr;
88             CORBA::String_var aVal = anIOR->Value().c_str();
89             CORBA::Object_var anObj = app->orb()->string_to_object( aVal.in() );
90             if(!CORBA::is_nil(anObj)){
91               //Try narrow to SMESH_Mesh interafce
92               SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow(anObj);
93               if(!aMesh->_is_nil()){
94                 aVisualObj.reset(new SMESH_MeshObj(aMesh));
95                 aVisualObj->Update();
96                 TVisualObjCont::value_type aValue(aKey,aVisualObj); 
97                 VISUAL_OBJ_CONT.insert(aValue);
98                 return aVisualObj;
99               }
100               //Try narrow to SMESH_Group interafce
101               SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow(anObj);
102               if(!aGroup->_is_nil()){
103                 _PTR(SObject) aFatherSObj = aSObj->GetFather();
104                 if(!aFatherSObj) return aVisualObj;
105                 aFatherSObj = aFatherSObj->GetFather();
106                 if(!aFatherSObj) return aVisualObj;
107                 CORBA::String_var anEntry = aFatherSObj->GetID().c_str();
108                 TVisualObjPtr aVisObj = GetVisualObj(theStudyId,anEntry.in());
109                 if(SMESH_MeshObj* aMeshObj = dynamic_cast<SMESH_MeshObj*>(aVisObj.get())){
110                   aVisualObj.reset(new SMESH_GroupObj(aGroup,aMeshObj));
111                   aVisualObj->Update();
112                   TVisualObjCont::value_type aValue(aKey,aVisualObj);
113                   VISUAL_OBJ_CONT.insert(aValue);
114                   return aVisualObj;
115                 }
116               }
117               //Try narrow to SMESH_subMesh interafce
118               SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow(anObj);
119               if(!aSubMesh->_is_nil()){
120                 _PTR(SObject) aFatherSObj = aSObj->GetFather();
121                 if(!aFatherSObj) return aVisualObj;
122                 aFatherSObj = aFatherSObj->GetFather();
123                 if(!aFatherSObj) return aVisualObj;
124                 CORBA::String_var anEntry = aFatherSObj->GetID().c_str();
125                 TVisualObjPtr aVisObj = GetVisualObj(theStudyId,anEntry.in());
126                 if(SMESH_MeshObj* aMeshObj = dynamic_cast<SMESH_MeshObj*>(aVisObj.get())){
127                   aVisualObj.reset(new SMESH_subMeshObj(aSubMesh,aMeshObj));
128                   aVisualObj->Update();
129                   TVisualObjCont::value_type aValue(aKey,aVisualObj);
130                   VISUAL_OBJ_CONT.insert(aValue);
131                   return aVisualObj;
132                 }
133               }
134             }
135           }
136         }
137       }
138     }catch(...){
139       INFOS("GetMeshObj - There is no SMESH_Mesh object for the SALOMEDS::Strudy and Entry!!!");
140     }
141     return aVisualObj;
142   }
143
144
145   SVTK_ViewWindow*
146   GetViewWindow(const SalomeApp_Module* theModule)
147   {
148     if(SalomeApp_Application* anApp = theModule->getApp()){
149       if(SUIT_ViewManager* aViewManager = anApp->activeViewManager()){
150         if(aViewManager->getType() == SVTK_Viewer::Type()){
151           if(SUIT_ViewWindow* aViewWindow = aViewManager->getActiveView()){
152             return dynamic_cast<SVTK_ViewWindow*>(aViewWindow);
153           }
154         }
155       }
156     }
157     return NULL;
158   }
159
160   SVTK_ViewWindow* FindVtkViewWindow( SUIT_ViewManager* theMgr,
161                                            SUIT_ViewWindow* theWindow )
162   {
163     if( !theMgr )
164       return NULL;
165
166     QPtrVector<SUIT_ViewWindow> views = theMgr->getViews();
167     if( views.containsRef( theWindow ) )
168       return GetVtkViewWindow( theWindow );
169     else
170       return NULL;
171   }
172
173
174   SVTK_ViewWindow* GetVtkViewWindow(SUIT_ViewWindow* theWindow){
175     return dynamic_cast<SVTK_ViewWindow*>(theWindow);
176   }
177
178
179 /*  SUIT_ViewWindow* GetActiveWindow()
180   {
181     SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
182     if( !app )
183       return NULL;
184     SUIT_ViewManager* mgr = app->activeViewManager();
185     if( mgr )
186       return mgr->getActiveView();
187     else
188       return NULL;
189   }*/
190
191   SVTK_ViewWindow* GetCurrentVtkView(){
192     return GetVtkViewWindow( GetActiveWindow() );
193   }
194
195   void RepaintViewWindow(SVTK_ViewWindow* theWindow)
196   {
197     theWindow->Repaint();
198   }
199
200   void RenderViewWindow(SVTK_ViewWindow* theWindow)
201   {
202     theWindow->getRenderer()->Render();
203     theWindow->Repaint();
204   }
205
206   SMESH_Actor* FindActorByEntry(SUIT_ViewWindow *theWindow,
207                                 const char* theEntry)
208   {
209     if(SVTK_ViewWindow* aViewWindow = GetVtkViewWindow(theWindow)){
210       vtkRenderer *aRenderer = aViewWindow->getRenderer();
211       vtkActorCollection *aCollection = aRenderer->GetActors();
212       aCollection->InitTraversal();
213       while(vtkActor *anAct = aCollection->GetNextActor()){
214         if(SMESH_Actor *anActor = dynamic_cast<SMESH_Actor*>(anAct)){
215           if(anActor->hasIO()){
216             Handle(SALOME_InteractiveObject) anIO = anActor->getIO();
217             if(anIO->hasEntry() && strcmp(anIO->getEntry(),theEntry) == 0){
218               return anActor;
219             }
220           }
221         }
222       }
223     }
224     return NULL;
225   }
226
227
228   SMESH_Actor* FindActorByEntry(const char* theEntry){
229     return FindActorByEntry(GetActiveWindow(),theEntry);
230   }
231
232
233   SMESH_Actor* FindActorByObject(CORBA::Object_ptr theObject){
234     SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
235     if( !app )
236       return NULL;
237
238     if(!CORBA::is_nil(theObject)){
239       _PTR(Study) aStudy = GetActiveStudyDocument();
240       CORBA::String_var anIOR = app->orb()->object_to_string( theObject );
241       _PTR(SObject) aSObject = aStudy->FindObjectIOR(anIOR.in());
242       if(aSObject){
243         CORBA::String_var anEntry = aSObject->GetID().c_str();
244         return FindActorByEntry(anEntry.in());
245       }
246     }
247     return NULL;
248   }
249
250
251   SMESH_Actor* CreateActor(_PTR(Study) theStudy,
252                            const char* theEntry,
253                            int theIsClear)
254   {
255     SMESH_Actor *anActor = NULL;
256     CORBA::Long anId = theStudy->StudyId();
257     if(TVisualObjPtr aVisualObj = GetVisualObj(anId,theEntry)){
258       _PTR(SObject) aSObj = theStudy->FindObjectID(theEntry);
259       if(aSObj){
260         _PTR(GenericAttribute) anAttr;
261         if(aSObj->FindAttribute(anAttr,"AttributeName")){
262           _PTR(AttributeName) aName = anAttr;
263           std::string aNameVal = aName->Value();
264           anActor = SMESH_Actor::New(aVisualObj,theEntry,aNameVal.c_str(),theIsClear);
265         }
266       }
267     }
268     return anActor;
269   }
270
271
272   void DisplayActor( SUIT_ViewWindow *theWnd, SMESH_Actor* theActor){
273     if(SVTK_ViewWindow* vtkWnd = GetVtkViewWindow(theWnd)){
274       vtkWnd->AddActor(theActor);
275       vtkWnd->Repaint();
276     }
277   }
278
279
280   void RemoveActor( SUIT_ViewWindow *theWnd, SMESH_Actor* theActor){
281     if(SVTK_ViewWindow* vtkWnd = GetVtkViewWindow(theWnd)){
282       vtkWnd->RemoveActor(theActor);
283       if(theActor->hasIO()){
284         Handle(SALOME_InteractiveObject) anIO = theActor->getIO();
285         if(anIO->hasEntry()){
286           std::string anEntry = anIO->getEntry();
287           SalomeApp_Study* aStudy = dynamic_cast<SalomeApp_Study*>( vtkWnd->getViewManager()->study() );
288           int aStudyId = aStudy->id();
289           TVisualObjCont::key_type aKey(aStudyId,anEntry);
290           VISUAL_OBJ_CONT.erase(aKey);
291         }
292       }
293       theActor->Delete();
294       vtkWnd->Repaint();
295     }
296   }
297
298
299   void FitAll(){
300     if(SVTK_ViewWindow* wnd = GetCurrentVtkView() ){
301       wnd->onFitAll();
302       wnd->Repaint();
303     }
304   }
305
306   vtkRenderer* GetCurrentRenderer(){
307     if(SVTK_ViewWindow* wnd = GetCurrentVtkView() )
308       return wnd->getRenderer();
309     return NULL;
310   }
311
312   void RepaintCurrentView(){
313     if(SVTK_ViewWindow* wnd = GetCurrentVtkView() )
314       wnd->getRenderer()->Render();
315       //wnd->Repaint();
316   }
317
318   void UpdateView(SUIT_ViewWindow *theWnd, EDisplaing theAction, const char* theEntry)
319   {
320     if(SVTK_ViewWindow* aViewWnd = GetVtkViewWindow(theWnd)){
321       vtkRenderer *aRenderer = aViewWnd->getRenderer();
322       vtkActorCollection *aCollection = aRenderer->GetActors();
323       aCollection->InitTraversal();
324       switch(theAction){
325       case eDisplayAll: {
326         while(vtkActor *anAct = aCollection->GetNextActor()){
327           if(SMESH_Actor *anActor = dynamic_cast<SMESH_Actor*>(anAct)){
328             anActor->SetVisibility(true);
329           }
330         }
331         break;
332       }
333       case eDisplayOnly:
334       case eEraseAll: {
335         while(vtkActor *anAct = aCollection->GetNextActor()){
336           if(SMESH_Actor *anActor = dynamic_cast<SMESH_Actor*>(anAct)){
337             anActor->SetVisibility(false);
338           }
339         }
340       }
341       default: {
342         if(SMESH_Actor *anActor = FindActorByEntry(theWnd,theEntry)){
343           switch(theAction) {
344             case eDisplay:
345             case eDisplayOnly:
346               anActor->SetVisibility(true);
347               break;
348             case eErase:
349               anActor->SetVisibility(false);
350               break;
351           }
352         } else {
353           switch(theAction){
354           case eDisplay:
355           case eDisplayOnly:{
356             SalomeApp_Study* aStudy = dynamic_cast<SalomeApp_Study*>( theWnd->getViewManager()->study() );
357             _PTR(Study) aDocument = aStudy->studyDS();
358             if((anActor = CreateActor(aDocument,theEntry,true))) {
359               DisplayActor(theWnd,anActor);
360               FitAll();
361             }
362             break;
363           }
364           }
365         }
366       }
367       }
368     }
369   }
370
371
372   void UpdateView(EDisplaing theAction, const char* theEntry){
373     SalomeApp_Study* aStudy = dynamic_cast< SalomeApp_Study* >( GetActiveStudy() );
374     SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( aStudy->application() );
375     SUIT_ViewWindow *aWnd = app->activeViewManager()->getActiveView();
376     UpdateView(aWnd,theAction,theEntry);
377   }
378
379   void UpdateView(){
380     if(SVTK_ViewWindow* aWnd = SMESH::GetCurrentVtkView()){
381       SalomeApp_SelectionMgr* mgr = SMESHGUI::selectionMgr();
382       SALOME_ListIO selected; mgr->selectedObjects( selected );
383
384       if( selected.Extent() == 0){
385         vtkRenderer* aRenderer = aWnd->getRenderer();
386         vtkActorCollection *aCollection = aRenderer->GetActors();
387         aCollection->InitTraversal();
388         while(vtkActor *anAct = aCollection->GetNextActor()){
389           if(SMESH_Actor *anActor = dynamic_cast<SMESH_Actor*>(anAct)){
390             if(anActor->hasIO())
391               Update(anActor->getIO(),anActor->GetVisibility());
392           }
393         }
394       }else{
395         SALOME_ListIteratorOfListIO anIter( selected );
396         for(; anIter.More(); anIter.Next()){
397           Handle(SALOME_InteractiveObject) anIO = anIter.Value();
398           Update(anIO,true);
399         }
400       }
401       RepaintCurrentView();
402     }
403   }
404
405
406   void Update(const Handle(SALOME_InteractiveObject)& theIO,
407               bool theDisplay)
408   {
409     _PTR(Study) aStudy = GetActiveStudyDocument();
410     CORBA::Long anId = aStudy->StudyId();
411     TVisualObjPtr aVisualObj = SMESH::GetVisualObj(anId,theIO->getEntry());
412     aVisualObj->Update();
413     if ( theDisplay )
414       UpdateView(SMESH::eDisplay,theIO->getEntry());
415   }
416
417
418   void UpdateSelectionProp() {
419     SUIT_Study* aStudy = GetActiveStudy();
420     SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( aStudy->application() );
421     SUIT_ViewManager* vm = app->activeViewManager();
422     QPtrVector<SUIT_ViewWindow> views = vm->getViews();
423
424     SUIT_ResourceMgr* mgr = SMESHGUI::resourceMgr();
425
426     QColor aHiColor = mgr->colorValue( "SMESH", "SettingsSelectColor", Qt::white ),
427            aSelColor = mgr->colorValue( "SMESH", "SettingsItemSelectColor", Qt::yellow ),
428            aPreColor = mgr->colorValue( "SMESH", "SettingsPreSelectColor", Qt::cyan );
429
430     int SW = mgr->integerValue( "SMESH", "SettingsItemSelectWidth", 5 ),
431         PW = mgr->integerValue( "SMESH", "SettingsPreSelectWidth", 5 );
432
433     double SP1 = mgr->doubleValue( "SMESH", "SettingsNodeSelectTol", 0.025 ),
434            SP2 = mgr->doubleValue( "SMESH", "SettingsElementsSelectTol", 0.001 );
435
436     for ( int i=0, n=views.count(); i<n; i++ ) {
437         SVTK_ViewWindow* aVtkView = GetVtkViewWindow( views[i] );
438         if (!aVtkView) continue;
439         // update VTK viewer properties
440         SVTK_RenderWindowInteractor* anInteractor = aVtkView->getRWInteractor();
441         if (anInteractor) {
442           // mesh element selection
443           anInteractor->SetSelectionProp(aSelColor.red()/255., aSelColor.green()/255.,
444                                          aSelColor.blue()/255., SW );
445
446           // tolerances
447           anInteractor->SetSelectionTolerance(SP1, SP2);
448
449           // pre-selection
450           SVTK_InteractorStyle* aStyle =
451             dynamic_cast<SVTK_InteractorStyle*>( anInteractor->GetInteractorStyle() );
452           if (aStyle) {
453             aStyle->setPreselectionProp(aPreColor.red()/255., aPreColor.green()/255.,
454                                         aPreColor.blue()/255., PW);
455           }
456         }
457         // update actors
458         vtkRenderer* aRenderer = aVtkView->getRenderer();
459         vtkActorCollection *aCollection = aRenderer->GetActors();
460         aCollection->InitTraversal();
461         while(vtkActor *anAct = aCollection->GetNextActor()){
462           if(SMESH_Actor *anActor = dynamic_cast<SMESH_Actor*>(anAct)){
463             anActor->SetHighlightColor(aHiColor.red()/255., aHiColor.green()/255.,
464                                        aHiColor.blue()/255.);
465             anActor->SetPreHighlightColor(aPreColor.red()/255., aPreColor.green()/255.,
466                                           aPreColor.blue()/255.);
467           }
468         }
469     }
470   }
471
472
473   //----------------------------------------------------------------------------
474   SVTK_InteractorStyle* GetInteractorStyle(SUIT_ViewWindow *theWindow){
475     if(SVTK_ViewWindow* aWnd = GetVtkViewWindow(theWindow)){
476       if(SVTK_RenderWindowInteractor* anInteractor = aWnd->getRWInteractor()){
477         return dynamic_cast<SVTK_InteractorStyle*>( anInteractor->GetInteractorStyle() );
478       }
479     }
480     return NULL;
481   }
482
483   void SetFilter(const Handle(VTKViewer_Filter)& theFilter,
484                  SVTK_InteractorStyle* theStyle)
485   {
486     theStyle->SetFilter(theFilter);
487   }
488
489   Handle(VTKViewer_Filter) GetFilter(int theId, SVTK_InteractorStyle* theStyle)
490   {
491     return theStyle->GetFilter(theId);
492   }
493
494   bool IsFilterPresent(int theId, SVTK_InteractorStyle* theStyle)
495   {
496     return theStyle->IsFilterPresent(theId);
497   }
498
499   void RemoveFilter(int theId, SVTK_InteractorStyle* theStyle)
500   {
501     theStyle->RemoveFilter(theId);
502   }
503
504   void RemoveFilters(SVTK_InteractorStyle* theStyle)
505   {
506     for ( int id = SMESHGUI_NodeFilter; theStyle && id < SMESHGUI_LastFilter; id++ )
507       theStyle->RemoveFilter( id );
508   }
509
510   bool IsValid(SALOME_Actor* theActor, int theCellId,
511                SVTK_InteractorStyle* theStyle)
512   {
513     return theStyle->IsValid(theActor,theCellId);
514   }
515
516
517   //----------------------------------------------------------------------------
518   void SetPointRepresentation(bool theIsVisible){
519     if(SVTK_ViewWindow* aViewWindow = GetCurrentVtkView()){
520       vtkRenderer *aRenderer = aViewWindow->getRenderer();
521       vtkActorCollection *aCollection = aRenderer->GetActors();
522       aCollection->InitTraversal();
523       while(vtkActor *anAct = aCollection->GetNextActor()){
524         if(SMESH_Actor *anActor = dynamic_cast<SMESH_Actor*>(anAct)){
525           if(anActor->GetVisibility()){
526             anActor->SetPointRepresentation(theIsVisible);
527           }
528         }
529       }
530       RepaintCurrentView();
531     }
532   }
533
534
535   void SetPickable(SMESH_Actor* theActor){
536     if(SVTK_ViewWindow* aWnd = GetCurrentVtkView()){
537       int anIsAllPickable = (theActor == NULL);
538       vtkRenderer *aRenderer = aWnd->getRenderer();
539       vtkActorCollection *aCollection = aRenderer->GetActors();
540       aCollection->InitTraversal();
541       while(vtkActor *anAct = aCollection->GetNextActor()){
542         if(SALOME_Actor *anActor = dynamic_cast<SALOME_Actor*>(anAct)){
543           if(anActor->GetVisibility()){
544             anActor->SetPickable(anIsAllPickable);
545           }
546         }
547       }
548       if(theActor)
549         theActor->SetPickable(!anIsAllPickable);
550       RepaintCurrentView();
551     }
552   }
553
554
555   //----------------------------------------------------------------------------
556   int GetNameOfSelectedNodes(SVTK_Selector* theSelector, 
557                              const Handle(SALOME_InteractiveObject)& theIO, 
558                              QString& theName)
559   {
560     theName = "";
561     TColStd_IndexedMapOfInteger aMapIndex;
562     theSelector->GetIndex(theIO,aMapIndex);
563
564     for(int i = 1; i <= aMapIndex.Extent(); i++)
565       theName += QString(" %1").arg(aMapIndex(i));
566
567     return aMapIndex.Extent();
568   }
569
570   int GetNameOfSelectedElements(SVTK_Selector* theSelector, 
571                                 const Handle(SALOME_InteractiveObject)& theIO, 
572                                 QString& theName)
573   {
574     theName = "";
575     TColStd_IndexedMapOfInteger aMapIndex;
576     theSelector->GetIndex(theIO,aMapIndex);
577
578     typedef std::set<int> TIdContainer;
579     TIdContainer anIdContainer;
580     for( int i = 1; i <= aMapIndex.Extent(); i++)
581       anIdContainer.insert(aMapIndex(i));
582
583     TIdContainer::const_iterator anIter = anIdContainer.begin();
584     for(; anIter != anIdContainer.end(); anIter++)
585       theName += QString(" %1").arg(*anIter);
586
587     return aMapIndex.Extent();
588   }
589
590
591   int GetEdgeNodes(SVTK_Selector* theSelector, 
592                    const TVisualObjPtr& theVisualObject,
593                    int& theId1, 
594                    int& theId2)
595   {
596     const SALOME_ListIO& selected = theSelector->StoredIObjects(); 
597
598     if ( selected.Extent() != 1 )
599       return -1;
600
601     Handle(SALOME_InteractiveObject) anIO = selected.First();
602     if ( anIO.IsNull() || !anIO->hasEntry() )
603       return -1;
604
605     TColStd_IndexedMapOfInteger aMapIndex;
606     theSelector->GetIndex( anIO, aMapIndex );
607     if ( aMapIndex.Extent() != 2 )
608       return -1;
609
610     int anObjId = -1, anEdgeNum = -1;
611     for ( int i = 1; i <= aMapIndex.Extent(); i++ ) {
612       int aVal = aMapIndex( i );
613       if ( aVal > 0 )
614         anObjId = aVal;
615       else
616         anEdgeNum = abs( aVal ) - 1;
617     }
618
619     if ( anObjId == -1 || anEdgeNum == -1 )
620       return -1;
621
622     return theVisualObject->GetEdgeNodes( anObjId, anEdgeNum, theId1, theId2 ) ? 1 : -1;
623   }
624
625   //----------------------------------------------------------------------------
626   int GetNameOfSelectedNodes(SalomeApp_SelectionMgr *theMgr,
627                              const Handle(SALOME_InteractiveObject)& theIO,
628                              QString& theName)
629   {
630     theName = "";
631     if(theIO->hasEntry()){
632       if(FindActorByEntry(theIO->getEntry())){
633         TColStd_IndexedMapOfInteger aMapIndex;
634         theMgr->GetIndexes(theIO,aMapIndex);
635         for(int i = 1; i <= aMapIndex.Extent(); i++){
636           theName += QString(" %1").arg(aMapIndex(i));
637         }
638         return aMapIndex.Extent();
639       }
640     }
641     return -1;
642   }
643
644   int GetNameOfSelectedNodes(SalomeApp_SelectionMgr *theMgr, QString& theName){
645     theName = "";
646     SALOME_ListIO selected; theMgr->selectedObjects( selected );
647     if(selected.Extent() == 1){
648       Handle(SALOME_InteractiveObject) anIO = selected.First();
649       return GetNameOfSelectedNodes(theMgr,anIO,theName);
650     }
651     return -1;
652   }
653   
654
655   int GetNameOfSelectedElements(SalomeApp_SelectionMgr *theMgr,
656                                 const Handle(SALOME_InteractiveObject)& theIO,
657                                 QString& theName)
658   {
659     theName = "";
660     if(theIO->hasEntry()){
661       if(FindActorByEntry(theIO->getEntry())){
662         TColStd_IndexedMapOfInteger aMapIndex;
663         theMgr->GetIndexes(theIO,aMapIndex);
664         typedef set<int> TIdContainer;
665         TIdContainer anIdContainer;
666         for( int i = 1; i <= aMapIndex.Extent(); i++)
667           anIdContainer.insert(aMapIndex(i));
668         TIdContainer::const_iterator anIter = anIdContainer.begin();
669         for(; anIter != anIdContainer.end(); anIter++){
670           theName += QString(" %1").arg(*anIter);
671         }
672         return aMapIndex.Extent();
673       }
674     }
675     return -1;
676   }
677
678
679   int GetNameOfSelectedElements(SalomeApp_SelectionMgr *theMgr, QString& theName)
680   {
681     theName = "";
682     SALOME_ListIO selected; theMgr->selectedObjects( selected );
683
684     if( selected.Extent() == 1){
685       Handle(SALOME_InteractiveObject) anIO = selected.First();
686       return GetNameOfSelectedElements(theMgr,anIO,theName);
687     }
688     return -1;
689   }
690
691   int GetSelected(SalomeApp_SelectionMgr*      theMgr,
692                   TColStd_IndexedMapOfInteger& theMap,
693                   const bool                   theIsElement)
694   {
695     theMap.Clear();
696     SALOME_ListIO selected; theMgr->selectedObjects( selected );
697
698     if ( selected.Extent() == 1 )
699     {
700       Handle(SALOME_InteractiveObject) anIO = selected.First();
701       if ( anIO->hasEntry() ) {
702         theMgr->GetIndexes( anIO, theMap );
703       }
704     }
705     return theMap.Extent();
706   }
707
708
709   int GetEdgeNodes( SalomeApp_SelectionMgr* theMgr, int& theId1, int& theId2 )
710   {
711     SALOME_ListIO selected; theMgr->selectedObjects( selected );
712
713     if ( selected.Extent() != 1 )
714       return -1;
715
716     Handle(SALOME_InteractiveObject) anIO = selected.First();
717     if ( anIO.IsNull() || !anIO->hasEntry() )
718       return -1;
719
720     SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry() );
721     if ( anActor == 0 )
722       return -1;
723
724     TColStd_IndexedMapOfInteger aMapIndex;
725     theMgr->GetIndexes( anIO, aMapIndex );
726     if ( aMapIndex.Extent() != 2 )
727       return -1;
728
729     int anObjId = -1, anEdgeNum = -1;
730     for ( int i = 1; i <= aMapIndex.Extent(); i++ ) {
731       int aVal = aMapIndex( i );
732       if ( aVal > 0 )
733         anObjId = aVal;
734       else
735         anEdgeNum = abs( aVal );
736     }
737
738     if ( anObjId == -1 || anEdgeNum == -1 )
739       return -1;
740
741     return anActor->GetObject()->GetEdgeNodes( anObjId, anEdgeNum, theId1, theId2 ) ? 1 : -1;
742   }
743
744   void SetControlsPrecision( const long theVal )
745   {
746     if( SVTK_ViewWindow* aWnd = SMESH::GetCurrentVtkView() )
747     {
748       vtkRenderer *aRenderer = aWnd->getRenderer();
749       vtkActorCollection *aCollection = aRenderer->GetActors();
750       aCollection->InitTraversal();
751       
752       while ( vtkActor *anAct = aCollection->GetNextActor())
753       {
754         if ( SMESH_Actor *anActor = dynamic_cast<SMESH_Actor*>( anAct ) )
755         {
756           anActor->SetControlsPrecision( theVal );
757           anActor->SetControlMode( anActor->GetControlMode() );
758         }
759       }
760
761     }
762   }
763 }