Salome HOME
PAL9994
[modules/visu.git] / src / VISU_I / VISU_View_i.cc
1 //  VISU OBJECT : interactive object for VISU entities implementation
2 //
3 //  Copyright (C) 2003  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.
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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
21 //
22 //
23 //  File   : VISU_View_i.cc
24 //  Author : Alexey PETROV
25 //  Module : VISU
26
27 #include "VISU_View_i.hh"
28
29 #include "VISU_Gen_i.hh"
30 #include "VISU_Prs3d_i.hh"
31 #include "VISU_Table_i.hh"
32 #include "VISU_ViewManager_i.hh"
33
34 #include "VisuGUI_TableDlg.h"
35
36 #include "VISU_Actor.h"
37
38 #include "SALOME_Event.hxx"
39
40 #include "SUIT_ViewWindow.h"
41 #include "SUIT_ViewManager.h"
42 #include "SUIT_Tools.h"
43
44 #include "STD_MDIDesktop.h"
45 #include "STD_TabDesktop.h"
46
47 #include "SVTK_ViewWindow.h"
48 #include "SVTK_ViewModel.h"
49 #include "SVTK_RenderWindow.h"
50
51 #include "SPlot2d_ViewModel.h"
52 #include "Plot2d_ViewFrame.h"
53
54 #include "SalomeApp_Application.h"
55 #include "SalomeApp_Study.h"
56
57 #include <QtxWorkstack.h>
58
59 #include <qworkspace.h>
60
61 #include <vtkCamera.h>
62 #include <vtkRenderer.h>
63
64 using namespace std;
65
66 #ifdef _DEBUG_
67 static int MYDEBUG = 0;
68 #else
69 static int MYDEBUG = 0;
70 #endif
71
72 namespace VISU {
73
74   typedef TVoidMemFunEvent<SUIT_ViewWindow> TFrameActionEvent;
75
76   struct TNewViewEvent: public SALOME_Event
77   {
78     SalomeApp_Application* myApplication;
79     typedef QWidget* TResult;
80     TResult myResult;
81
82     TNewViewEvent (SalomeApp_Application* theApplication):
83       myApplication(theApplication),
84       myResult(NULL)
85     {}
86
87     virtual
88     void
89     Execute()
90     {
91       if (STD_MDIDesktop* aDesktop = dynamic_cast<STD_MDIDesktop*>(myApplication->desktop())) {
92         myResult = aDesktop->workspace();
93       }
94     }
95   };
96
97   View_i::
98   View_i (SalomeApp_Application *theApplication,
99           SUIT_ViewManager* theViewManager):
100     myApplication(theApplication),
101     myWorkspace(NULL),
102     myViewManager(theViewManager)
103   {
104     if(MYDEBUG) MESSAGE("View_i::View_i - "<<this);
105     myWorkspace = ProcessEvent(new TNewViewEvent(theApplication));
106   }
107
108   View_i::
109   ~View_i()
110   {
111     if(MYDEBUG) MESSAGE("View_i::~View_i - "<<this);
112   }
113
114
115   struct TApplicationEvent: public SALOME_Event
116   {
117     SalomeApp_Application* myApplication;
118
119     TApplicationEvent(SalomeApp_Application* theApplication):
120       myApplication(theApplication)
121     {}
122   };
123
124   void
125   View_i::
126   ShowPart (VISU::View::ViewRepresentation theViewRepresentation,
127             CORBA::Boolean theState)
128   {
129     struct TEvent: public TApplicationEvent
130     {
131       VISU::View::ViewRepresentation myViewRepresentation;
132       CORBA::Boolean myState;
133
134       TEvent(SalomeApp_Application* theApplication,
135              VISU::View::ViewRepresentation theViewRepresentation,
136              CORBA::Boolean theState):
137         TApplicationEvent(theApplication),
138         myViewRepresentation(theViewRepresentation),
139         myState(theState)
140       {}
141
142       virtual
143       void
144       Execute()
145       {
146         switch(myViewRepresentation){
147         case VISU::View::OBJECTBROWSER:
148           myApplication->setWindowShown(SalomeApp_Application::WT_ObjectBrowser,myState);
149           break;
150         case VISU::View::PYTHON:
151           myApplication->setWindowShown(SalomeApp_Application::WT_PyConsole,myState);
152           break;
153         case VISU::View::MESSAGES:
154           myApplication->setWindowShown(SalomeApp_Application::WT_LogWindow,myState);
155           break;
156         case VISU::View::VIEWER:{
157           ViewManagerList aViewManagerList = myApplication->viewManagers();
158           // to do something
159           // ...
160           break;
161         }}
162       }
163     };
164
165     ProcessVoidEvent(new TEvent(myApplication,theViewRepresentation,theState));
166   }
167
168   struct TPartShownEvent: public TApplicationEvent
169   {
170     VISU::View::ViewRepresentation myViewRepresentation;
171     typedef bool TResult;
172     TResult myResult;
173
174     TPartShownEvent(SalomeApp_Application* theApplication,
175                     VISU::View::ViewRepresentation theViewRepresentation):
176       TApplicationEvent(theApplication),
177       myViewRepresentation(theViewRepresentation),
178       myResult(false)
179     {}
180
181     virtual
182     void
183     Execute()
184     {
185       switch(myViewRepresentation){
186       case VISU::View::OBJECTBROWSER:
187         myResult = myApplication->isWindowVisible(SalomeApp_Application::WT_ObjectBrowser);
188         break;
189       case VISU::View::PYTHON:
190         myResult = myApplication->isWindowVisible(SalomeApp_Application::WT_PyConsole);
191         break;
192       case VISU::View::MESSAGES:
193         myResult = myApplication->isWindowVisible(SalomeApp_Application::WT_LogWindow);
194         break;
195       case VISU::View::VIEWER:{
196         ViewManagerList aViewManagerList = myApplication->viewManagers();
197         // to do something
198         // ...
199         break;
200       }}
201     }
202   };
203
204   CORBA::Boolean
205   View_i::
206   IsPartShown (VISU::View::ViewRepresentation theViewRepresentation)
207   {
208     return ProcessEvent(new TPartShownEvent(myApplication,theViewRepresentation));
209   }
210
211   // Begin: New methods for view parameters management
212   struct TSplitEvent: public SALOME_Event
213   {
214     SalomeApp_Application * myApplication;
215     SUIT_ViewWindow       * myViewWindow;
216     Qt::Orientation         myOrientation;
217     QtxWorkstack::SplitType mySplitType;
218
219   public:
220     TSplitEvent (SalomeApp_Application * theApplication,
221                  SUIT_ViewWindow       * theViewWindow,
222                  Qt::Orientation         theOrientation,
223                  QtxWorkstack::SplitType theSplitType):
224       myApplication(theApplication),
225       myViewWindow(theViewWindow),
226       myOrientation(theOrientation),
227       mySplitType(theSplitType)
228     {}
229
230     virtual void Execute()
231     {
232       SUIT_Desktop* desk = myApplication->desktop();
233       STD_TabDesktop* tabDesk = dynamic_cast<STD_TabDesktop*>(desk);
234       if (tabDesk) {
235         QtxWorkstack* workstack = tabDesk->workstack();
236         if (workstack) {
237           workstack->Split(myViewWindow, myOrientation, mySplitType);
238         }
239       }
240     }
241   };
242
243   void
244   View_i::
245   SplitRight()
246   {
247     ProcessVoidEvent(new TSplitEvent(myApplication,myViewWindow,
248                                      Qt::Horizontal,QtxWorkstack::SPLIT_MOVE));
249   }
250
251   void
252   View_i::
253   SplitLeft()
254   {
255     ProcessVoidEvent(new TSplitEvent(myApplication,myViewWindow,
256                                      Qt::Horizontal,QtxWorkstack::SPLIT_STAY));
257   }
258
259   void
260   View_i::
261   SplitBottom()
262   {
263     ProcessVoidEvent(new TSplitEvent(myApplication,myViewWindow,
264                                      Qt::Vertical,QtxWorkstack::SPLIT_MOVE));
265   }
266
267   void
268   View_i::
269   SplitTop()
270   {
271     ProcessVoidEvent(new TSplitEvent(myApplication,myViewWindow,
272                                      Qt::Vertical,QtxWorkstack::SPLIT_STAY));
273   }
274
275   void
276   View_i::
277   OnTop()
278   {
279     struct TOnTopEvent: public SALOME_Event
280     {
281       SUIT_ViewWindow * myViewWindow;
282
283     public:
284       TOnTopEvent (SUIT_ViewWindow * theViewWindow):
285         myViewWindow(theViewWindow)
286       {}
287
288       virtual void Execute()
289       {
290         if (myViewWindow) {
291           myViewWindow->setFocus();
292         }
293       }
294     };
295
296     ProcessVoidEvent(new TOnTopEvent(myViewWindow));
297   }
298
299   struct TAttractEvent: public SALOME_Event
300   {
301     SalomeApp_Application * myApplication;
302     SUIT_ViewWindow       * myViewWindow1;
303     SUIT_ViewWindow       * myViewWindow2;
304     bool                    myAttractAll;
305
306   public:
307     TAttractEvent (SalomeApp_Application * theApplication,
308                    SUIT_ViewWindow       * theViewWindow1,
309                    SUIT_ViewWindow       * theViewWindow2,
310                    bool                    theAttractAll):
311       myApplication(theApplication),
312       myViewWindow1(theViewWindow1),
313       myViewWindow2(theViewWindow2),
314       myAttractAll(theAttractAll)
315     {}
316
317     virtual void Execute()
318     {
319       SUIT_Desktop* desk = myApplication->desktop();
320       STD_TabDesktop* tabDesk = dynamic_cast<STD_TabDesktop*>(desk);
321       if (tabDesk) {
322         QtxWorkstack* workstack = tabDesk->workstack();
323         if (workstack) {
324           workstack->Attract(myViewWindow1, myViewWindow2, myAttractAll);
325         }
326       }
327     }
328   };
329
330   void
331   View_i::
332   Attract (VISU::View_ptr theView)
333   {
334     if (!CORBA::is_nil(theView)) {
335       if (VISU::View_i* pView = dynamic_cast<VISU::View_i*>(VISU::GetServant(theView).in())) {
336         ProcessVoidEvent(new TAttractEvent(myApplication,myViewWindow,pView->myViewWindow,false));
337       }
338     }
339   }
340
341   void
342   View_i::
343   AttractAll (VISU::View_ptr theView)
344   {
345     if (!CORBA::is_nil(theView)) {
346       if (VISU::View_i* pView = dynamic_cast<VISU::View_i*>(VISU::GetServant(theView).in())) {
347         ProcessVoidEvent(new TAttractEvent(myApplication,myViewWindow,pView->myViewWindow,true));
348       }
349     }
350   }
351
352   struct TSizePositionEvent: public SALOME_Event
353   {
354     SalomeApp_Application * myApplication;
355     SUIT_ViewWindow       * myViewWindow;
356     double                  myValue;
357     bool                    myIsSize;
358
359   public:
360     TSizePositionEvent (SalomeApp_Application * theApplication,
361                         SUIT_ViewWindow       * theViewWindow,
362                         double                  theValue,
363                         bool                    theIsSize):
364       myApplication(theApplication),
365       myViewWindow(theViewWindow),
366       myValue(theValue),
367       myIsSize(theIsSize)
368     {}
369
370     virtual void Execute()
371     {
372       MESSAGE("TSizePositionEvent::Execute()");
373       SUIT_Desktop* desk = myApplication->desktop();
374       STD_TabDesktop* tabDesk = dynamic_cast<STD_TabDesktop*>(desk);
375       if (tabDesk) {
376         QtxWorkstack* workstack = tabDesk->workstack();
377         if (workstack) {
378           if (myIsSize) {
379             //jfa to do:workstack->SetRelativeSizeInSplitter(myViewWindow, myValue);
380           } else {
381             workstack->SetRelativePositionInSplitter(myViewWindow, myValue);
382           }
383         }
384       }
385     }
386   };
387
388   void
389   View_i::
390   SetRelativePositionInSplitter (CORBA::Double thePosition)
391   {
392     if (thePosition < 0.0 || 1.0 < thePosition) {
393       return;
394     }
395     ProcessVoidEvent(new TSizePositionEvent(myApplication,myViewWindow,thePosition,false));
396   }
397
398   void
399   View_i::
400   SetRelativeSizeInSplitter (CORBA::Double theSize)
401   {
402     if (theSize < 0.0 || 1.0 < theSize) {
403       return;
404     }
405     ProcessVoidEvent(new TSizePositionEvent(myApplication,myViewWindow,theSize,true));
406   }
407
408   struct TWSSizePositionEvent: public SALOME_Event
409   {
410     SalomeApp_Application * myApplication;
411     SUIT_ViewWindow       * myViewWindow;
412     Qt::Orientation         myOrientation;
413     double                  myValue;
414     bool                    myIsSize;
415
416   public:
417     TWSSizePositionEvent (SalomeApp_Application * theApplication,
418                           SUIT_ViewWindow       * theViewWindow,
419                           Qt::Orientation         theOrientation,
420                           double                  theValue,
421                           bool                    theIsSize):
422       myApplication(theApplication),
423       myViewWindow(theViewWindow),
424       myOrientation(theOrientation),
425       myValue(theValue),
426       myIsSize(theIsSize)
427     {}
428
429     virtual void Execute()
430     {
431       MESSAGE("TWSSizePositionEvent::Execute()");
432       SUIT_Desktop* desk = myApplication->desktop();
433       STD_TabDesktop* tabDesk = dynamic_cast<STD_TabDesktop*>(desk);
434       if (tabDesk) {
435         QtxWorkstack* workstack = tabDesk->workstack();
436         if (workstack) {
437           if (myIsSize) {
438             //jfa to do:workstack->SetRelativeSize(myViewWindow, myOrientation, myValue);
439           } else {
440             workstack->SetRelativePosition(myViewWindow, myOrientation, myValue);
441           }
442         }
443       }
444     }
445   };
446
447   void
448   View_i::
449   SetRelativePositionX (CORBA::Double thePosition)
450   {
451     if (thePosition < 0.0 || 1.0 < thePosition) {
452       return;
453     }
454     ProcessVoidEvent(new TWSSizePositionEvent(myApplication,myViewWindow,
455                                               Qt::Horizontal,thePosition,false));
456   }
457
458   void
459   View_i::
460   SetRelativePositionY (CORBA::Double thePosition)
461   {
462     if (thePosition < 0.0 || 1.0 < thePosition) {
463       return;
464     }
465     ProcessVoidEvent(new TWSSizePositionEvent(myApplication,myViewWindow,
466                                               Qt::Vertical,thePosition,false));
467   }
468
469   void
470   View_i::
471   SetRelativeSizeX (CORBA::Double theSize)
472   {
473     if (theSize < 0.0 || 1.0 < theSize) {
474       return;
475     }
476     ProcessVoidEvent(new TWSSizePositionEvent(myApplication,myViewWindow,
477                                               Qt::Horizontal,theSize,true));
478   }
479
480   void
481   View_i::
482   SetRelativeSizeY (CORBA::Double theSize)
483   {
484     if (theSize < 0.0 || 1.0 < theSize) {
485       return;
486     }
487     ProcessVoidEvent(new TWSSizePositionEvent(myApplication,myViewWindow,
488                                               Qt::Vertical,theSize,true));
489   }
490   // End: New methods for view parameters management
491
492   // Begin: Old methods for view parameters management, they don't work now
493   struct TSetViewSize: public SALOME_Event
494   {
495     SUIT_ViewWindow* myViewWindow;
496     typedef void (QRect::* TAction)(int);
497     TAction myAction;
498     CORBA::Long mySize;
499
500   public:
501     TSetViewSize(SUIT_ViewWindow* theViewWindow,
502                  TAction theAction,
503                  CORBA::Long theSize):
504       myViewWindow(theViewWindow),
505       myAction(theAction),
506       mySize(theSize)
507     {}
508
509     virtual
510     void
511     Execute()
512     {
513       if (QWidget* aParent = myViewWindow->parentWidget(true)) {
514         QRect aQRect = aParent->frameGeometry();
515         (aQRect.*myAction)(mySize);
516         aParent->setGeometry(aQRect);
517       }
518     }
519   };
520
521   void
522   View_i::
523   SetViewWidth(CORBA::Long theWidth)
524   {
525     ProcessVoidEvent(new TSetViewSize(myViewWindow,&QRect::setWidth,theWidth));
526   }
527
528   void
529   View_i::
530   SetViewHeight(CORBA::Long theHeight)
531   {
532     ProcessVoidEvent(new TSetViewSize(myViewWindow,&QRect::setHeight,theHeight));
533   }
534
535
536   struct TGetViewSize: public SALOME_Event
537   {
538     SUIT_ViewWindow* myViewWindow;
539
540     typedef int (QRect::* TAction)() const;
541     TAction myAction;
542
543     typedef CORBA::Long TResult;
544     TResult myResult;
545
546   public:
547     TGetViewSize(SUIT_ViewWindow* theViewWindow,
548                  TAction theAction):
549       myViewWindow(theViewWindow),
550       myAction(theAction)
551     {}
552
553     virtual
554     void
555     Execute()
556     {
557       if(QWidget* aParent = myViewWindow->parentWidget(true)){
558         QRect aQRect = aParent->frameGeometry();
559         myResult = (aQRect.*myAction)();
560       }
561     }
562   };
563
564
565   CORBA::Long
566   View_i::
567   GetViewWidth()
568   {
569     return ProcessEvent(new TGetViewSize(myViewWindow,&QRect::width));
570   }
571
572   CORBA::Long
573   View_i::
574   GetViewHeight()
575   {
576     return ProcessEvent(new TGetViewSize(myViewWindow,&QRect::height));
577   }
578
579
580   class TWorkspaceEvent: public SALOME_Event
581   {
582   protected:
583     QWidget* myViewWindow;
584     QWidget* myWorkspace;
585
586   public:
587     TWorkspaceEvent(QWidget* theViewWindow,
588                     QWidget* theWorkspace):
589       myViewWindow(theViewWindow),
590       myWorkspace(theWorkspace)
591     {}
592   };
593
594
595   class TAlignEvent: public TWorkspaceEvent
596   {
597   protected:
598     Qt::AlignmentFlags myAligment;
599
600   public:
601     TAlignEvent(QWidget* theViewWindow,
602                 QWidget* theWorkspace,
603                 Qt::AlignmentFlags theAligment):
604       TWorkspaceEvent(theViewWindow,theWorkspace),
605       myAligment(theAligment)
606     {}
607
608     virtual
609     void
610     Execute()
611     {
612       if(QWidget* aParent = myViewWindow->parentWidget(true))
613         SUIT_Tools::alignWidget(aParent,myWorkspace,myAligment);
614     }
615   };
616
617
618   void
619   View_i::
620   SetViewPositionHorizontal (VISU::View::ViewPosition theViewPosition)
621   {
622     if (myWorkspace) {
623       switch (theViewPosition) {
624       case VISU::View::LEFT:
625         ProcessVoidEvent(new TAlignEvent(myViewWindow,myWorkspace,Qt::AlignLeft));
626         break;
627       case VISU::View::CENTER:
628         ProcessVoidEvent(new TAlignEvent(myViewWindow,myWorkspace,Qt::AlignHCenter));
629         break;
630       case VISU::View::RIGHT:
631         ProcessVoidEvent(new TAlignEvent(myViewWindow,myWorkspace,Qt::AlignRight));
632         break;
633       }
634     }
635   }
636
637
638   void
639   View_i::
640   SetViewPositionVertical (VISU::View::ViewPosition theViewPosition)
641   {
642     if (myWorkspace) {
643       switch (theViewPosition) {
644       case VISU::View::TOP:
645         ProcessVoidEvent(new TAlignEvent(myViewWindow,myWorkspace,Qt::AlignTop));
646         break;
647       case VISU::View::CENTER:
648         ProcessVoidEvent(new TAlignEvent(myViewWindow,myWorkspace,Qt::AlignVCenter));
649         break;
650       case VISU::View::BOTTOM:
651         ProcessVoidEvent(new TAlignEvent(myViewWindow,myWorkspace,Qt::AlignBottom));
652         break;
653       }
654     }
655   }
656
657
658   class TXYEvent: public TWorkspaceEvent
659   {
660   protected:
661     CORBA::Double myX, myY;
662
663   public:
664     TXYEvent(QWidget* theViewWindow,
665              QWidget* theWorkspace,
666              CORBA::Double theX,
667              CORBA::Double theY):
668       TWorkspaceEvent(theViewWindow,theWorkspace),
669       myX(theX),
670       myY(theY)
671     {}
672   };
673
674
675   void
676   View_i::
677   SetRelativePosition (CORBA::Double theX, CORBA::Double theY)
678   {
679     struct TEvent: public TXYEvent
680     {
681     public:
682       TEvent(QWidget* theViewWindow,
683              QWidget* theWorkspace,
684              CORBA::Double theX,
685              CORBA::Double theY):
686         TXYEvent(theViewWindow,theWorkspace,theX,theY)
687       {}
688
689       virtual
690       void
691       Execute()
692       {
693         if(QWidget* aParent = myViewWindow->parentWidget(true))
694           aParent->move(int(myX*myWorkspace->width()),int(myY*myWorkspace->height()));
695       }
696     };
697
698     if (myWorkspace)
699       ProcessVoidEvent(new TEvent(myViewWindow,myWorkspace,theX,theY));
700   }
701
702   void
703   View_i::
704   SetRelativeSize (CORBA::Double theX, CORBA::Double theY)
705   {
706     struct TEvent: public TXYEvent
707     {
708     public:
709       TEvent(QWidget* theViewWindow,
710              QWidget* theWorkspace,
711              CORBA::Double theX,
712              CORBA::Double theY):
713         TXYEvent(theViewWindow,theWorkspace,theX,theY)
714       {}
715
716       virtual
717       void
718       Execute()
719       {
720         if(QWidget* aParent = myViewWindow->parentWidget(true))
721           aParent->setGeometry(aParent->x(),
722                                aParent->y(),
723                                int(myX*myWorkspace->width()),
724                                int(myY*myWorkspace->height()));
725       }
726     };
727
728     if (myWorkspace)
729       ProcessVoidEvent(new TEvent(myViewWindow,myWorkspace,theX,theY));
730   }
731   // End: Old methods for view parameters management, they don't work now
732
733   void
734   View_i::
735   SetBackground (const SALOMEDS::Color& theColor)
736   {
737     struct TEvent: public SALOME_Event
738     {
739       QWidget* myWidget;
740       SALOMEDS::Color myColor;
741     public:
742       TEvent(QWidget* theWidget,
743              const SALOMEDS::Color& theColor):
744         myWidget(theWidget),
745         myColor(theColor)
746       {}
747       virtual void Execute(){
748         int aColor[3];
749         aColor[0] = int(255.0*myColor.R);
750         aColor[1] = int(255.0*myColor.G);
751         aColor[2] = int(255.0*myColor.B);
752         myWidget->setBackgroundColor(QColor(aColor[0],aColor[1],aColor[2]));
753       }
754     };
755
756     ProcessVoidEvent(new TEvent(myViewWindow,theColor));
757   }
758
759
760   struct TBackgroundEvent: public SALOME_Event
761   {
762     QWidget* myWidget;
763     typedef SALOMEDS::Color TResult;
764     TResult myResult;
765
766     TBackgroundEvent(QWidget* theWidget):
767       myWidget(theWidget)
768     {}
769
770     virtual
771     void
772     Execute()
773     {
774       const QColor& aColor = myWidget->backgroundColor();
775       myResult.R = aColor.red()/255.0;
776       myResult.G = aColor.green()/255.0;
777       myResult.B = aColor.blue()/255.0;
778     }
779   };
780
781   SALOMEDS::Color
782   View_i::
783   GetBackground()
784   {
785     return ProcessEvent(new TBackgroundEvent(myViewWindow));
786   }
787
788   void
789   View_i::
790   Minimize()
791   {
792     ProcessVoidEvent(new TFrameActionEvent(myViewWindow,&SUIT_ViewWindow::showMinimized));
793   }
794
795   void
796   View_i::
797   Restore()
798   {
799     ProcessVoidEvent(new TFrameActionEvent(myViewWindow,&SUIT_ViewWindow::showNormal));
800   }
801
802   void
803   View_i::
804   Maximize()
805   {
806     ProcessVoidEvent(new TFrameActionEvent(myViewWindow,&SUIT_ViewWindow::showMaximized));
807   }
808
809   void
810   View_i::
811   EraseAll()
812   {}
813
814   void
815   View_i::
816   DisplayAll()
817   {}
818
819   void
820   View_i::
821   Erase (PrsObject_ptr thePrsObj)
822   {}
823
824   void
825   View_i::
826   Display (PrsObject_ptr thePrsObj)
827   {}
828
829   void
830   View_i::
831   DisplayOnly (PrsObject_ptr thePrsObj)
832   {}
833
834   void
835   View_i::
836   Update()
837   {}
838
839   class TSavePictureEvent: public SALOME_Event
840   {
841     SUIT_ViewWindow * myViewWindow;
842     const char      * myFileName;
843   public:
844     typedef CORBA::Boolean TResult;
845     TResult myResult;
846     TSavePictureEvent (SUIT_ViewWindow * theViewWindow, const char * theFileName)
847       : myViewWindow(theViewWindow),
848         myFileName(theFileName),
849         myResult(false)
850     {
851     }
852
853     virtual void Execute()
854     {
855       if (myViewWindow) {
856         QImage img = myViewWindow->dumpView();
857         if (!img.isNull()) {
858           QString fileName (myFileName);
859           if (!fileName.isEmpty()) {
860             QString fmt = SUIT_Tools::extension(fileName).upper();
861             if (fmt.isEmpty()) fmt = QString("BMP"); // default format
862             if (fmt == "JPG" ) fmt = "JPEG";
863             //QApplication::setOverrideCursor(Qt::waitCursor);
864             img.save(fileName, fmt.latin1());
865             //QApplication::restoreOverrideCursor();
866           }
867         }
868       }
869     }
870   };
871
872   CORBA::Boolean
873   View_i::SavePicture(const char* theFileName)
874   {
875     return ProcessEvent(new TSavePictureEvent (myViewWindow,theFileName));
876   }
877
878   const char*
879   View_i::
880   GetComment() const
881   {
882     return "";
883   }
884
885   void
886   View_i::
887   ToStream (std::ostringstream& theStr)
888   {
889   }
890
891
892   //================= OLD CODE ===================
893
894   //QAD_Study* CheckStudy (SALOMEDS::Study_ptr theStudy)
895   //{
896   //  //QAD_Desktop* aDesktop = QAD_Application::getDesktop();
897   //  //QAD_Study* aStudy = aDesktop->findStudy(theStudy);
898   //  if (!aStudy) {
899   //    CORBA::String_var aName = theStudy->Name();
900   //    aFileInfo.setFile(aName.in());
901   //    if (aFileInfo.exists())
902   //      aStudy = aDesktop->loadStudy(aFileInfo.baseName());
903   //    else
904   //      aStudy = aDesktop->loadStudy(aName.in());
905   //    if (!aStudy) {
906   //      MESSAGE("CheckStudy()::ERROR: Can't load study");
907   //    }
908   //  }
909   //  return aStudy;
910   //}
911
912   template<class TViewer>
913   struct TNewSpecViewEvent: public SALOME_Event
914   {
915     SalomeApp_Application* myApplication;
916
917     typedef SUIT_ViewManager* TResult;
918     TResult myResult;
919
920     TNewSpecViewEvent (SalomeApp_Application* theApplication):
921       myApplication(theApplication),
922       myResult(NULL)
923     {}
924
925     virtual
926     void
927     Execute()
928     {
929       myResult = myApplication->getViewManager(TViewer::Type(), false);
930       if (!myResult) {
931         myResult = myApplication->getViewManager(TViewer::Type(), true);
932         myResult->closeAllViews();
933       }
934     }
935   };
936
937   //===========================================================================
938   XYPlot_i::XYPlot_i (SalomeApp_Application* theApplication)
939     : View_i(theApplication, NULL)
940   {
941     if (MYDEBUG) MESSAGE("XYPlot_i::XYPlot_i");
942     if (theApplication) {
943       myViewManager = ProcessEvent(new TNewSpecViewEvent<SPlot2d_Viewer>(theApplication));
944     }
945   }
946
947
948   struct TCreatePlot2dViewEvent: public SALOME_Event
949   {
950     SUIT_ViewManager* myViewManager;
951     XYPlot_i        * myPlot2dView;
952     int               myNew;
953
954     typedef Plot2d_ViewFrame* TResult;
955     TResult myResult;
956
957     TCreatePlot2dViewEvent (SUIT_ViewManager* theViewManager,
958                             XYPlot_i        * thePlot2dView,
959                             const int         theNew):
960       myViewManager(theViewManager),
961       myPlot2dView(thePlot2dView),
962       myNew(theNew),
963       myResult(NULL)
964     {}
965
966     virtual
967     void
968     Execute()
969     {
970       if (myNew) {
971         myPlot2dView->myViewWindow = myViewManager->createViewWindow();
972       } else {
973         myPlot2dView->myViewWindow = myViewManager->getActiveView();
974       }
975       if (myPlot2dView->myViewWindow) {
976         Plot2d_ViewWindow* aPlot2dVW = dynamic_cast<Plot2d_ViewWindow*>(myPlot2dView->myViewWindow);
977         if (aPlot2dVW) {
978           myResult = aPlot2dVW->getViewFrame();
979           if (myResult) {
980             myResult->Repaint();
981           }
982         }
983       }
984     }
985   };
986
987   Storable* XYPlot_i::Create (int theNew)
988   {
989     myView = ProcessEvent(new TCreatePlot2dViewEvent(myViewManager, this, theNew));
990     return this;
991   }
992
993   void XYPlot_i::Update()
994   {
995     ProcessVoidEvent(new TVoidMemFunEvent<Plot2d_ViewFrame>(myView,&Plot2d_ViewFrame::Repaint));
996   }
997
998   void XYPlot_i::Close()
999   {
1000     //jfa: may be need to be enclosed in SALOME_Event?
1001     myViewWindow->close();
1002   }
1003
1004   XYPlot_i::~XYPlot_i() {
1005     if(MYDEBUG) MESSAGE("XYPlot_i::~XYPlot_i");
1006   }
1007
1008   void XYPlot_i::SetTitle (const char* theTitle)
1009   {
1010     ProcessVoidEvent(new TVoidMemFun1ArgEvent<SUIT_ViewWindow,const QString&,QString>
1011                      (myViewWindow, &SUIT_ViewWindow::setCaption, QString(theTitle)));
1012   }
1013   char* XYPlot_i::GetTitle()
1014   {
1015     //jfa: may be need to be enclosed in SALOME_Event?
1016     return CORBA::string_dup(myViewWindow->caption().latin1());
1017   }
1018
1019   void XYPlot_i::SetSubTitle (const char* theTitle)
1020   {
1021     ProcessVoidEvent(new TVoidMemFun1ArgEvent<Plot2d_ViewFrame,const QString&,QString>
1022                      (myView, &Plot2d_ViewFrame::setTitle, QString(theTitle)));
1023   }
1024
1025   char* XYPlot_i::GetSubTitle()
1026   {
1027     //jfa: may be need to be enclosed in SALOME_Event?
1028     return CORBA::string_dup(myView->getTitle());
1029   }
1030
1031   void XYPlot_i::SetCurveType (VISU::XYPlot::CurveType theType)
1032   {
1033     ProcessVoidEvent(new TVoidMemFun2ArgEvent<Plot2d_ViewFrame,int,bool>
1034                      (myView,&Plot2d_ViewFrame::setCurveType,theType,true));
1035   }
1036
1037   VISU::XYPlot::CurveType XYPlot_i::GetCurveType()
1038   {
1039     //jfa: may be need to be enclosed in SALOME_Event?
1040     return (VISU::XYPlot::CurveType)myView->getCurveType();
1041   }
1042
1043   void XYPlot_i::SetMarkerSize (CORBA::Long theSize)
1044   {
1045     ProcessVoidEvent(new TVoidMemFun2ArgEvent<Plot2d_ViewFrame,int,bool>
1046                      (myView,&Plot2d_ViewFrame::setMarkerSize,theSize,true));
1047   }
1048
1049   CORBA::Long XYPlot_i::GetMarkerSize()
1050   {
1051     //jfa: may be need to be enclosed in SALOME_Event?
1052     return myView->getMarkerSize();
1053   }
1054
1055   class TEnableGridEvent: public SALOME_Event
1056   {
1057   public:
1058     typedef void (Plot2d_ViewFrame::* TFun)(bool, const int, bool, const int, bool);
1059     TEnableGridEvent (Plot2d_ViewFrame* theView, TFun theFun,
1060                       CORBA::Boolean theMajor, CORBA::Long theNumMajor,
1061                       CORBA::Boolean theMinor, CORBA::Long theNumMinor):
1062       myView(theView), myFun(theFun),
1063       myMajor(theMajor), myNumMajor(theNumMajor),
1064       myMinor(theMinor), myNumMinor(theNumMinor)
1065     {}
1066
1067     virtual void Execute()
1068     {
1069       (myView->*myFun)(myMajor,myNumMajor,myMinor,myNumMinor,true);
1070     }
1071   protected:
1072     Plot2d_ViewFrame* myView;
1073     TFun myFun;
1074     CORBA::Boolean myMajor, myMinor;
1075     CORBA::Long myNumMajor, myNumMinor;
1076   };
1077
1078   void XYPlot_i::EnableXGrid (CORBA::Boolean theMajor, CORBA::Long theNumMajor,
1079                               CORBA::Boolean theMinor, CORBA::Long theNumMinor)
1080   {
1081     ProcessVoidEvent(new TEnableGridEvent(myView,&Plot2d_ViewFrame::setXGrid,
1082                                           theMajor,theNumMajor,theMinor,theNumMinor));
1083   }
1084   void XYPlot_i::EnableYGrid(CORBA::Boolean theMajor, CORBA::Long theNumMajor,
1085                              CORBA::Boolean theMinor, CORBA::Long theNumMinor)
1086   {
1087     //asl: Plot2d_ViewFrame::setYGrid has more parameters
1088     //ProcessVoidEvent(new TEnableGridEvent(myView,&Plot2d_ViewFrame::setYGrid,
1089     //                 theMajor,theNumMajor,theMinor,theNumMinor));
1090   }
1091
1092   class TSetScaleModeEvent: public SALOME_Event
1093   {
1094   public:
1095     typedef void (Plot2d_ViewFrame::* TFun)(const int, bool);
1096     TSetScaleModeEvent (Plot2d_ViewFrame* theView, TFun theFun, int theScaling):
1097       myView(theView), myFun(theFun), myScaling(theScaling)
1098     {}
1099
1100     virtual void Execute()
1101     {
1102       (myView->*myFun)(myScaling,true);
1103     }
1104   protected:
1105     Plot2d_ViewFrame* myView;
1106     TFun myFun;
1107     int myScaling;
1108   };
1109
1110   void XYPlot_i::SetHorScaling (VISU::Scaling theScaling)
1111   {
1112     ProcessVoidEvent(new TSetScaleModeEvent(myView,&Plot2d_ViewFrame::setHorScaleMode,
1113                                             theScaling == VISU::LOGARITHMIC));
1114   }
1115
1116   VISU::Scaling XYPlot_i::GetHorScaling()
1117   {
1118     //jfa: may be need to be enclosed in SALOME_Event?
1119     return (VISU::Scaling)myView->getHorScaleMode();
1120   }
1121
1122   void XYPlot_i::SetVerScaling(VISU::Scaling theScaling)
1123   {
1124     ProcessVoidEvent(new TSetScaleModeEvent(myView,&Plot2d_ViewFrame::setVerScaleMode,
1125                                             theScaling == VISU::LOGARITHMIC));
1126   }
1127
1128   VISU::Scaling XYPlot_i::GetVerScaling()
1129   {
1130     //jfa: may be need to be enclosed in SALOME_Event?
1131     return (VISU::Scaling)myView->getVerScaleMode();
1132   }
1133
1134   class TSetTitleEvent: public SALOME_Event
1135   {
1136   public:
1137     TSetTitleEvent (Plot2d_ViewFrame* theView, Plot2d_ViewFrame::ObjectType theType, const char* theTitle):
1138       myView(theView), myType(theType), myTitle(theTitle)
1139     {}
1140     virtual void Execute()
1141     {
1142       myView->setTitle(true,myTitle,myType);
1143     }
1144   protected:
1145     Plot2d_ViewFrame* myView;
1146     Plot2d_ViewFrame::ObjectType myType;
1147     const char* myTitle;
1148   };
1149
1150   void XYPlot_i::SetXTitle (const char* theTitle)
1151   {
1152     ProcessVoidEvent(new TSetTitleEvent(myView, Plot2d_ViewFrame::XTitle, theTitle));
1153   }
1154   char* XYPlot_i::GetXTitle()
1155   {
1156     //jfa: may be need to be enclosed in SALOME_Event?
1157     return CORBA::string_dup(myView->getTitle(Plot2d_ViewFrame::XTitle));
1158   }
1159
1160   void XYPlot_i::SetYTitle (const char* theTitle)
1161   {
1162     ProcessVoidEvent(new TSetTitleEvent(myView, Plot2d_ViewFrame::YTitle, theTitle));
1163   }
1164   char* XYPlot_i::GetYTitle()
1165   {
1166     //jfa: may be need to be enclosed in SALOME_Event?
1167     return CORBA::string_dup(myView->getTitle(Plot2d_ViewFrame::YTitle));
1168   }
1169
1170   void XYPlot_i::ShowLegend (CORBA::Boolean theShowing)
1171   {
1172     ProcessVoidEvent(new TVoidMemFun2ArgEvent<Plot2d_ViewFrame,bool,bool>
1173                      (myView,&Plot2d_ViewFrame::showLegend,theShowing,true));
1174   }
1175
1176   class TXYPlotViewEvent: public SALOME_Event
1177   {
1178     SalomeApp_Application* myApplication;
1179     Plot2d_ViewFrame*      myView;
1180     PrsObject_ptr          myPrsObj;
1181     int                    myDisplaing;
1182
1183   public:
1184     TXYPlotViewEvent(SalomeApp_Application* theApplication,
1185                      Plot2d_ViewFrame*      theView,
1186                      PrsObject_ptr          thePrsObj,
1187                      int                    theDisplaing)
1188       : myApplication(theApplication),
1189       myView(theView),
1190       myPrsObj(thePrsObj),
1191       myDisplaing(theDisplaing)
1192     {
1193     }
1194
1195     virtual void Execute()
1196     {
1197       // is it Curve ?
1198       if (Curve_i* aCurve = dynamic_cast<Curve_i*>(VISU::GetServant(myPrsObj).in())) {
1199         UpdatePlot2d(myView,myDisplaing,aCurve);
1200       }
1201       // is it Container ?
1202       if (Container_i* aContainer = dynamic_cast<Container_i*>(VISU::GetServant(myPrsObj).in())) {
1203         int nbCurves = aContainer->GetNbCurves();
1204         for ( int i = 1; i <= nbCurves; i++ ) {
1205           VISU::Curve_i* aCurve = aContainer->GetCurve( i );
1206           if ( aCurve && aCurve->IsValid() ) {
1207             UpdatePlot2d(myView,myDisplaing,aCurve);
1208           }
1209         }
1210         myView->Repaint();
1211       }
1212       // is it Table ?
1213       if (Table_i* aTable = dynamic_cast<Table_i*>(VISU::GetServant(myPrsObj).in())) {
1214         _PTR(Study) aCStudy;
1215         if (SUIT_Study* aSStudy = myApplication->activeStudy()) {
1216           if (SalomeApp_Study* aStudy = dynamic_cast<SalomeApp_Study*>(aSStudy)) {
1217             aCStudy = aStudy->studyDS();
1218           }
1219         }
1220         if (!aCStudy) return;
1221         _PTR(SObject) TableSO = aCStudy->FindObjectID(aTable->GetEntry().latin1());
1222         if (TableSO) {
1223           _PTR(ChildIterator) Iter = aCStudy->NewChildIterator(TableSO);
1224           for (; Iter->More(); Iter->Next()) {
1225             CORBA::Object_var childObject = VISU::ClientSObjectToObject(Iter->Value());
1226             if (!CORBA::is_nil(childObject)) {
1227               CORBA::Object_ptr aCurve = VISU::Curve::_narrow(childObject);
1228               if (!CORBA::is_nil(aCurve))
1229                 UpdatePlot2d(myView, myDisplaing,
1230                              dynamic_cast<VISU::Curve_i*>(VISU::GetServant(aCurve).in()));
1231             }
1232           }
1233           myView->Repaint();
1234         }
1235       }
1236     }
1237   };
1238
1239   void XYPlot_i::Display (PrsObject_ptr thePrsObj)
1240   {
1241     ProcessVoidEvent(new TXYPlotViewEvent (myApplication,myView,thePrsObj,eDisplay));
1242   }
1243
1244   void XYPlot_i::Erase (PrsObject_ptr thePrsObj)
1245   {
1246     ProcessVoidEvent(new TXYPlotViewEvent (myApplication,myView,thePrsObj,eErase));
1247   }
1248
1249   void XYPlot_i::DisplayOnly (PrsObject_ptr thePrsObj)
1250   {
1251     ProcessVoidEvent(new TXYPlotViewEvent (myApplication,myView,thePrsObj,eDisplayOnly));
1252   }
1253
1254   void XYPlot_i::EraseAll()
1255   {
1256     ProcessVoidEvent(new TVoidMemFunEvent<Plot2d_ViewFrame> (myView,&Plot2d_ViewFrame::EraseAll));
1257   }
1258
1259   void XYPlot_i::FitAll()
1260   {
1261     ProcessVoidEvent(new TVoidMemFunEvent<Plot2d_ViewFrame> (myView,&Plot2d_ViewFrame::fitAll));
1262   }
1263
1264
1265   //===========================================================================
1266   TableView_i::TableView_i (SalomeApp_Application* theApplication)
1267     : View_i(theApplication, NULL)
1268   {
1269   }
1270
1271   struct TCreateTableViewEvent: public SALOME_Event
1272   {
1273     SalomeApp_Application* myApplication;
1274     VISU::Table_i*         myTable;
1275
1276     typedef VisuGUI_TableDlg* TResult;
1277     TResult myResult;
1278
1279     TCreateTableViewEvent (SalomeApp_Application* theApplication,
1280                            VISU::Table_i*         theTable):
1281       myApplication(theApplication),
1282       myTable(theTable),
1283       myResult(NULL)
1284     {}
1285
1286     virtual
1287     void
1288     Execute()
1289     {
1290       if (myTable != NULL) {
1291         if (SUIT_Study* aSStudy = myApplication->activeStudy()) {
1292           if (SalomeApp_Study* aStudy = dynamic_cast<SalomeApp_Study*>(aSStudy)) {
1293             if (_PTR(Study) aCStudy = aStudy->studyDS()) {
1294               _PTR(SObject) aSObject = aCStudy->FindObjectID(myTable->GetObjectEntry());
1295               if (aSObject) {
1296                 myResult = new VisuGUI_TableDlg (myApplication->desktop(),
1297                                                  aSObject,
1298                                                  false,
1299                                                  VisuGUI_TableDlg::ttAuto,
1300                                                  Qt::Vertical);
1301                 myResult->show();
1302               }
1303             }
1304           }
1305         }
1306       }
1307     }
1308   };
1309
1310   Storable* TableView_i::Create (VISU::Table_ptr theTable)
1311   {
1312     if (MYDEBUG) MESSAGE("TableView_i::Create - " << (!theTable->_is_nil()));
1313     if (!theTable->_is_nil()) {
1314       VISU::Table_i* table =
1315         dynamic_cast<VISU::Table_i*>(VISU::GetServant(theTable).in());
1316       if (MYDEBUG) MESSAGE("TableView_i::Create - dynamic_cast = " << table);
1317
1318       myView = ProcessEvent(new TCreateTableViewEvent(myApplication, table));
1319       if (myView)
1320         return this;
1321     }
1322     return NULL;
1323   }
1324
1325   TableView_i::~TableView_i()
1326   {
1327     if(MYDEBUG) MESSAGE("TableView_i::~TableView_i");
1328     delete myView;
1329   }
1330
1331   void TableView_i::SetTitle (const char* theTitle)
1332   {
1333     ProcessVoidEvent(new TVoidMemFun1ArgEvent<VisuGUI_TableDlg,const QString&,QString>
1334                      (myView, &VisuGUI_TableDlg::setCaption, QString(theTitle)));
1335   }
1336
1337   char* TableView_i::GetTitle()
1338   {
1339     //jfa: may be need to be enclosed in SALOME_Event?
1340     return CORBA::string_dup(myView->caption().latin1());
1341   }
1342
1343   void TableView_i::Close()
1344   {
1345     //jfa: may be need to be enclosed in SALOME_Event?
1346     myView->close();
1347   }
1348
1349
1350   //===========================================================================
1351   int View3D_i::myNbViewParams = 0;
1352   const string View3D_i::myComment = "VIEW3D";
1353   const char* View3D_i::GetComment() const { return myComment.c_str();}
1354
1355   QString View3D_i::GenerateViewParamsName()
1356   {
1357     return VISU::GenerateName("ViewParams", ++myNbViewParams);
1358   }
1359
1360   View3D_i::View3D_i (SalomeApp_Application* theApplication)
1361     : View_i(theApplication, NULL)
1362   {
1363     if (MYDEBUG) MESSAGE("View3D_i::View3D_i");
1364     if (theApplication) {
1365       myViewManager = ProcessEvent(new TNewSpecViewEvent<SVTK_Viewer>(theApplication));
1366     }
1367   }
1368
1369   struct TCreateView3dEvent: public SALOME_Event
1370   {
1371     SUIT_ViewManager* myViewManager;
1372     int               myNew;
1373
1374     typedef SUIT_ViewWindow* TResult;
1375     TResult myResult;
1376
1377     TCreateView3dEvent (SUIT_ViewManager* theViewManager,
1378                         const int         theNew):
1379       myViewManager(theViewManager),
1380       myNew(theNew),
1381       myResult(NULL)
1382     {}
1383
1384     virtual
1385     void
1386     Execute()
1387     {
1388       if (myNew) {
1389         myResult = myViewManager->createViewWindow();
1390       } else {
1391         myResult = myViewManager->getActiveView();
1392       }
1393     }
1394   };
1395
1396   Storable* View3D_i::Create (int theNew)
1397   {
1398     if (MYDEBUG) MESSAGE("View3D_i::Create");
1399     myViewWindow = ProcessEvent(new TCreateView3dEvent(myViewManager, theNew));
1400     return this;
1401   }
1402
1403   void View3D_i::Update()
1404   {
1405     class TEvent: public SALOME_Event
1406     {
1407       SUIT_ViewWindow* myViewWindow;
1408     public:
1409       TEvent(SUIT_ViewWindow* theStudyFrame):
1410         myViewWindow(theStudyFrame)
1411       {}
1412       virtual void Execute()
1413       {
1414         SVTK_ViewWindow* vf = GetViewWindow(myViewWindow);
1415         vtkRenderer* Renderer = vf->getRenderer();
1416         vtkActorCollection* theActors = Renderer->GetActors();
1417         theActors->InitTraversal();
1418         while (vtkActor *anAct = theActors->GetNextActor()) {
1419           if (VISU_Actor* anActor = dynamic_cast<VISU_Actor*>(anAct)) {
1420             VISU::Prs3d_i* aPrs3d  = anActor->GetPrs3d();
1421             if (anActor->GetVisibility() && aPrs3d) {
1422               aPrs3d->Update();
1423               aPrs3d->UpdateActor(anActor);
1424             }
1425           }
1426         }
1427         RepaintView(myViewWindow);
1428       }
1429     };
1430     ProcessVoidEvent(new TEvent(myViewWindow));
1431   }
1432
1433   bool View3D_i::SaveViewParams (SUIT_ViewManager* theViewManager, const char* theName)
1434   {
1435     MESSAGE("View3D_i::SaveViewParams()");
1436     _PTR(Study) aCStudy;
1437     if (SUIT_Study* aSStudy = theViewManager->study()) {
1438       if (SalomeApp_Study* aStudy = dynamic_cast<SalomeApp_Study*>(aSStudy)) {
1439         aCStudy = aStudy->studyDS();
1440       }
1441     }
1442     if (!aCStudy)
1443       return false;
1444
1445     if (theName) {
1446       std::vector<_PTR(SObject)> aList = aCStudy->FindObjectByName(theName, "VISU");
1447       _PTR(GenericAttribute) anAttr;
1448       int iEnd = aList.size();
1449       for (int i = 0; i < iEnd; i++) {
1450         _PTR(SObject) anObj = aList[i];
1451         string anEntry = anObj->GetID();
1452         if(MYDEBUG) MESSAGE("View3D_i::SaveViewParams - anEntry = " << anEntry);
1453         if (anObj->FindAttribute(anAttr, "AttributeComment")) {
1454           _PTR(AttributeComment) aCmnt (anAttr);
1455           string aComm (aCmnt->Value());
1456           if (MYDEBUG) MESSAGE("View3D_i::SaveViewPoint - aComm = " << aComm);
1457           if (aComm.compare(View3D_i::myComment) >= 0) {
1458             aCmnt->SetValue(ToString(theViewManager->getActiveView()).c_str());
1459             return true;
1460           }
1461         }
1462       }
1463     }
1464     _PTR(SComponent) aSComponent = ClientFindOrCreateVisuComponent(aCStudy);
1465     string aSComponentEntry = aSComponent->GetID();
1466     string anEntry = CreateAttributes(aCStudy, aSComponentEntry.c_str(), "", "", theName, "",
1467                                       ToString(theViewManager->getActiveView()).c_str());
1468     return true;
1469   }
1470
1471   class TSaveViewParamsEvent: public SALOME_Event
1472   {
1473     SUIT_ViewManager* myViewManager;
1474     const char*       myName;
1475   public:
1476     TSaveViewParamsEvent (SUIT_ViewManager* theViewManager,
1477                           const char*       theName):
1478       myViewManager(theViewManager),
1479       myName(theName)
1480     {}
1481
1482     virtual void Execute()
1483     {
1484       myResult = View3D_i::SaveViewParams(myViewManager, myName);
1485     }
1486     typedef CORBA::Boolean TResult;
1487     TResult myResult;
1488   };
1489
1490   CORBA::Boolean View3D_i::SaveViewParams (const char* theName)
1491   {
1492     return ProcessEvent(new TSaveViewParamsEvent (myViewManager, theName));
1493   }
1494
1495   bool View3D_i::RestoreViewParams (SUIT_ViewManager* theViewManager, const char* theName)
1496   {
1497     _PTR(Study) aCStudy;
1498     if (SUIT_Study* aSStudy = theViewManager->study()) {
1499       if (SalomeApp_Study* aStudy = dynamic_cast<SalomeApp_Study*>(aSStudy)) {
1500         aCStudy = aStudy->studyDS();
1501       }
1502     }
1503     if (!aCStudy)
1504       return false;
1505
1506     std::vector<_PTR(SObject)> aList = aCStudy->FindObjectByName(theName, "VISU");
1507     _PTR(GenericAttribute) anAttr;
1508     int iEnd = aList.size();
1509     if (MYDEBUG) MESSAGE("View3D_i::RestoreViewPoint - iEnd = " << iEnd);
1510     for (int i = 0; i < iEnd; i++) {
1511       _PTR(SObject) anObj = aList[i];
1512       string anEntry = anObj->GetID();
1513       if (MYDEBUG) MESSAGE("View3D_i::RestoreViewPoint - anEntry = " << anEntry);
1514       if (anObj->FindAttribute(anAttr, "AttributeComment")) {
1515         _PTR(AttributeComment) aCmnt (anAttr);
1516         QString strIn(aCmnt->Value().c_str());
1517         Storable::TRestoringMap aMap;
1518         Storable::StrToMap(strIn, aMap);
1519         if (Storable::FindValue(aMap, "myComment").compare
1520             (View3D_i::myComment.c_str()) >= 0) {
1521           if (MYDEBUG) MESSAGE("View3D_i::RestoreViewPoint - aComm = " << strIn);
1522           Restore(theViewManager->getActiveView(), aMap);
1523           return true;
1524         }
1525       }
1526     }
1527     return false;
1528   }
1529
1530   class TRestoreViewParamsEvent: public SALOME_Event
1531   {
1532     SUIT_ViewManager* myViewManager;
1533     const char*       myName;
1534   public:
1535     TRestoreViewParamsEvent (SUIT_ViewManager* theViewManager,
1536                              const char*       theName):
1537       myViewManager(theViewManager),
1538       myName(theName)
1539     {}
1540
1541     virtual void Execute()
1542     {
1543       myResult = View3D_i::RestoreViewParams(myViewManager, myName);
1544     }
1545     typedef CORBA::Boolean TResult;
1546     TResult myResult;
1547   };
1548
1549   CORBA::Boolean View3D_i::RestoreViewParams (const char* theName)
1550   {
1551     return ProcessEvent(new TRestoreViewParamsEvent (myViewManager, theName));
1552   }
1553
1554   void View3D_i::Restore (SUIT_ViewWindow* theStudyFrame,
1555                           const Storable::TRestoringMap& theMap)
1556   {
1557     SALOMEDS::Color aColor;
1558     aColor.R = VISU::Storable::FindValue(theMap,"myColor.R").toDouble();
1559     aColor.G = VISU::Storable::FindValue(theMap,"myColor.G").toDouble();
1560     aColor.B = VISU::Storable::FindValue(theMap,"myColor.B").toDouble();
1561
1562     double aPosition[3];
1563     aPosition[0] = VISU::Storable::FindValue(theMap,"myPosition[0]").toDouble();
1564     aPosition[1] = VISU::Storable::FindValue(theMap,"myPosition[1]").toDouble();
1565     aPosition[2] = VISU::Storable::FindValue(theMap,"myPosition[2]").toDouble();
1566
1567     double aFocalPnt[3];
1568     aFocalPnt[0] = VISU::Storable::FindValue(theMap,"myFocalPnt[0]").toDouble();
1569     aFocalPnt[1] = VISU::Storable::FindValue(theMap,"myFocalPnt[1]").toDouble();
1570     aFocalPnt[2] = VISU::Storable::FindValue(theMap,"myFocalPnt[2]").toDouble();
1571
1572     double aViewUp[3];
1573     aViewUp[0] = VISU::Storable::FindValue(theMap,"myViewUp[0]").toDouble();
1574     aViewUp[1] = VISU::Storable::FindValue(theMap,"myViewUp[1]").toDouble();
1575     aViewUp[2] = VISU::Storable::FindValue(theMap,"myViewUp[2]").toDouble();
1576
1577     double aParallelScale = VISU::Storable::FindValue(theMap,"myParallelScale").toDouble();
1578
1579     double aScaleFactor[3];
1580     aScaleFactor[0] = VISU::Storable::FindValue(theMap,"myScaleFactor[0]").toDouble();
1581     aScaleFactor[1] = VISU::Storable::FindValue(theMap,"myScaleFactor[1]").toDouble();
1582     aScaleFactor[2] = VISU::Storable::FindValue(theMap,"myScaleFactor[2]").toDouble();
1583
1584     SetBackground(theStudyFrame,aColor);
1585     SetPointOfView(theStudyFrame,aPosition);
1586     SetViewUp(theStudyFrame,aViewUp);
1587     SetFocalPoint(theStudyFrame,aFocalPnt);
1588     SetParallelScale(theStudyFrame,aParallelScale);
1589     ScaleView(theStudyFrame,VISU::View3D::XAxis,aScaleFactor[0]);
1590     ScaleView(theStudyFrame,VISU::View3D::YAxis,aScaleFactor[1]);
1591     ScaleView(theStudyFrame,VISU::View3D::ZAxis,aScaleFactor[2]);
1592   }
1593
1594
1595   string View3D_i::ToString (SUIT_ViewWindow* theStudyFrame)
1596   {
1597     ostringstream strOut;
1598     Storable::DataToStream( strOut, "myComment", myComment.c_str() );
1599     ToStream(theStudyFrame,strOut);
1600     strOut<<ends;
1601     if(MYDEBUG) MESSAGE("View3D_i::ToString - "<<strOut.str());
1602     return strOut.str();
1603   }
1604
1605   void View3D_i::ToStream (SUIT_ViewWindow* theStudyFrame, std::ostringstream& theStr)
1606   {
1607     Storable::DataToStream(theStr,"myType",VISU::TVIEW3D);
1608
1609     float backint[3];
1610     GetRenderer(theStudyFrame)->GetBackground(backint);
1611     Storable::DataToStream(theStr,"myColor.R",backint[0]);
1612     Storable::DataToStream(theStr,"myColor.G",backint[1]);
1613     Storable::DataToStream(theStr,"myColor.B",backint[2]);
1614
1615     double aPosition[3];
1616     GetPointOfView(theStudyFrame,aPosition);
1617     Storable::DataToStream(theStr,"myPosition[0]",aPosition[0]);
1618     Storable::DataToStream(theStr,"myPosition[1]",aPosition[1]);
1619     Storable::DataToStream(theStr,"myPosition[2]",aPosition[2]);
1620
1621     double aFocalPnt[3];
1622     GetFocalPoint(theStudyFrame,aFocalPnt);
1623     Storable::DataToStream(theStr,"myFocalPnt[0]",aFocalPnt[0]);
1624     Storable::DataToStream(theStr,"myFocalPnt[1]",aFocalPnt[1]);
1625     Storable::DataToStream(theStr,"myFocalPnt[2]",aFocalPnt[2]);
1626
1627     double aViewUp[3];
1628     GetCamera(theStudyFrame)->GetViewUp(aViewUp);
1629     Storable::DataToStream(theStr,"myViewUp[0]",aViewUp[0]);
1630     Storable::DataToStream(theStr,"myViewUp[1]",aViewUp[1]);
1631     Storable::DataToStream(theStr,"myViewUp[2]",aViewUp[2]);
1632
1633     Storable::DataToStream(theStr,"myParallelScale",GetParallelScale(theStudyFrame));
1634
1635     double aScaleFactor[3];
1636     GetViewWindow(theStudyFrame)->GetScale(aScaleFactor);
1637     Storable::DataToStream(theStr,"myScaleFactor[0]",aScaleFactor[0]);
1638     Storable::DataToStream(theStr,"myScaleFactor[1]",aScaleFactor[1]);
1639     Storable::DataToStream(theStr,"myScaleFactor[2]",aScaleFactor[2]);
1640   }
1641
1642   void View3D_i::ToStream(std::ostringstream& theStr)
1643   {
1644     ToStream(myViewWindow,theStr);
1645   }
1646
1647   void View3D_i::Close()
1648   {
1649     //jfa: may be need to be enclosed in SALOME_Event?
1650     myViewWindow->close();
1651   }
1652
1653   View3D_i::~View3D_i()
1654   {
1655     if(MYDEBUG) MESSAGE("View3D_i::~View3D_i");
1656   }
1657
1658   void View3D_i::SetTitle (const char* theTitle)
1659   {
1660     ProcessVoidEvent(new TVoidMemFun1ArgEvent<SUIT_ViewWindow,const QString&,QString>
1661                      (myViewWindow,&SUIT_ViewWindow::setCaption,QString(theTitle)));
1662   }
1663
1664   char* View3D_i::GetTitle()
1665   {
1666     //jfa: may be need to be enclosed in SALOME_Event?
1667     return CORBA::string_dup(myViewWindow->caption().latin1());
1668   }
1669
1670   void View3D_i::SetBackground (SUIT_ViewWindow* theStudyFrame,
1671                                 const SALOMEDS::Color& theColor)
1672   {
1673     //jfa: may be need to be enclosed in SALOME_Event?
1674     int aColor[3];
1675     aColor[0] = int(255.0*theColor.R);
1676     aColor[1] = int(255.0*theColor.G);
1677     aColor[2] = int(255.0*theColor.B);
1678     QColor aNewColor(aColor[0],aColor[1],aColor[2]);
1679     GetViewWindow(theStudyFrame)->setBackgroundColor(aNewColor);
1680   }
1681
1682   SALOMEDS::Color View3D_i::GetBackground (SUIT_ViewWindow* theStudyFrame)
1683   {
1684     //jfa: may be need to be enclosed in SALOME_Event?
1685     SALOMEDS::Color aColor;
1686     float backint[3];
1687     GetRenderer(theStudyFrame)->GetBackground(backint);
1688     aColor.R = backint[0];  aColor.G = backint[1];  aColor.B = backint[2];
1689     return aColor;
1690   }
1691
1692   class TUpdateViewerEvent: public SALOME_Event
1693   {
1694     SUIT_ViewWindow* myViewWindow;
1695     Prs3d_i* myPrs3d;
1696     int myDisplaing;
1697   public:
1698     TUpdateViewerEvent(SUIT_ViewWindow* theStudyFrame,
1699                        Prs3d_i* thePrs3d,
1700                        int theDisplaing):
1701       myViewWindow(theStudyFrame),
1702       myPrs3d(thePrs3d),
1703       myDisplaing(theDisplaing)
1704     {}
1705     virtual void Execute(){
1706       UpdateViewer(myViewWindow,myDisplaing,myPrs3d);
1707     }
1708   };
1709
1710   void View3D_i::EraseAll()
1711   {
1712     if(MYDEBUG) MESSAGE("View3D_i::EraseAll");
1713     ProcessVoidEvent(new TUpdateViewerEvent(myViewWindow,NULL,eEraseAll));
1714   }
1715
1716   void View3D_i::DisplayAll()
1717   {
1718     if(MYDEBUG) MESSAGE("View3D_i::DisplayAll");
1719     ProcessVoidEvent(new TUpdateViewerEvent(myViewWindow,NULL,eDisplayAll));
1720   }
1721
1722   void View3D_i::Erase (PrsObject_ptr thePrsObj)
1723   {
1724     if(MYDEBUG) MESSAGE("View3D_i::Erase");
1725     CORBA::Object_ptr anObj = thePrsObj;
1726     if(Prs3d_i* aPrs =  dynamic_cast<Prs3d_i*>(VISU::GetServant(anObj).in())){
1727       ProcessVoidEvent(new TUpdateViewerEvent(myViewWindow,aPrs,eErase));
1728     }
1729   }
1730
1731   void View3D_i::Display (PrsObject_ptr thePrsObj)
1732   {
1733     if(MYDEBUG) MESSAGE("View3D_i::Display");
1734     CORBA::Object_ptr anObj = thePrsObj;
1735     if(Prs3d_i* aPrs =  dynamic_cast<Prs3d_i*>(VISU::GetServant(anObj).in())){
1736       ProcessVoidEvent(new TUpdateViewerEvent(myViewWindow,aPrs,eDisplay));
1737     }
1738   }
1739
1740   void View3D_i::DisplayOnly (PrsObject_ptr thePrsObj)
1741   {
1742     if(MYDEBUG) MESSAGE("View3D_i::DisplayOnly");
1743     CORBA::Object_ptr anObj = thePrsObj;
1744     if(Prs3d_i* aPrs =  dynamic_cast<Prs3d_i*>(VISU::GetServant(anObj).in())){
1745       ProcessVoidEvent(new TUpdateViewerEvent(myViewWindow,aPrs,eDisplayOnly));
1746     }
1747   }
1748
1749   void View3D_i::FitAll()
1750   {
1751     ProcessVoidEvent(new TVoidMemFunEvent<SVTK_ViewWindow>
1752                      (GetViewWindow(myViewWindow), &SVTK_ViewWindow::onFitAll));
1753     Update();
1754   }
1755
1756   void View3D_i::SetView (VISU::View3D::ViewType theType)
1757   {
1758     switch (theType) {
1759     case VISU::View3D::FRONT :
1760       ProcessVoidEvent(new TVoidMemFunEvent<SVTK_ViewWindow>
1761                        (GetViewWindow(myViewWindow), &SVTK_ViewWindow::onFrontView));
1762       break;
1763     case VISU::View3D::BACK :
1764       ProcessVoidEvent(new TVoidMemFunEvent<SVTK_ViewWindow>
1765                        (GetViewWindow(myViewWindow), &SVTK_ViewWindow::onBackView));
1766       break;
1767     case VISU::View3D::LEFT :
1768       ProcessVoidEvent(new TVoidMemFunEvent<SVTK_ViewWindow>
1769                        (GetViewWindow(myViewWindow),&SVTK_ViewWindow::onLeftView));
1770       break;
1771     case VISU::View3D::RIGHT :
1772       ProcessVoidEvent(new TVoidMemFunEvent<SVTK_ViewWindow>
1773                        (GetViewWindow(myViewWindow),&SVTK_ViewWindow::onRightView));
1774       break;
1775     case VISU::View3D::TOP :
1776       ProcessVoidEvent(new TVoidMemFunEvent<SVTK_ViewWindow>
1777                        (GetViewWindow(myViewWindow),&SVTK_ViewWindow::onTopView));
1778       break;
1779     case VISU::View3D::BOTTOM :
1780       ProcessVoidEvent(new TVoidMemFunEvent<SVTK_ViewWindow>
1781                        (GetViewWindow(myViewWindow),&SVTK_ViewWindow::onBottomView));
1782       break;
1783     }
1784     Update();
1785   }
1786
1787   class TSet3DViewParamEvent: public SALOME_Event
1788   {
1789   public:
1790     typedef void (*TFun)(SUIT_ViewWindow* theStudyFrame, const CORBA::Double theParam[3]);
1791     TSet3DViewParamEvent (TFun theFun,
1792                           SUIT_ViewWindow* theStudyFrame,
1793                           const CORBA::Double theParam[3]):
1794       myFun(theFun),
1795       myViewWindow(theStudyFrame),
1796       myParam(theParam)
1797     {}
1798     virtual void Execute(){
1799       myFun(myViewWindow,myParam);
1800     }
1801   private:
1802     TFun myFun;
1803     SUIT_ViewWindow* myViewWindow;
1804     const CORBA::Double* myParam;
1805   };
1806
1807   void View3D_i::SetPointOfView (SUIT_ViewWindow* theStudyFrame,
1808                                  const CORBA::Double thePosition[3])
1809   {
1810     //jfa: may be need to be enclosed in SALOME_Event?
1811     GetCamera(theStudyFrame)->SetPosition(thePosition);
1812   }
1813
1814   void View3D_i::SetPointOfView (const VISU::View3D::XYZ thePosition)
1815   {
1816     if(MYDEBUG) MESSAGE("View3D_i::SetPointOfView");
1817     ProcessVoidEvent(new TSet3DViewParamEvent(&SetPointOfView,myViewWindow,thePosition));
1818   }
1819
1820   void View3D_i::GetPointOfView (SUIT_ViewWindow* theStudyFrame,
1821                                  CORBA::Double thePosition[3])
1822   {
1823     //jfa: may be need to be enclosed in SALOME_Event?
1824     GetCamera(theStudyFrame)->GetPosition(thePosition);
1825   }
1826
1827   VISU::View3D::XYZ_slice* View3D_i::GetPointOfView()
1828   {
1829     //jfa: may be need to be enclosed in SALOME_Event?
1830     if(MYDEBUG) MESSAGE("View3D_i::GetPointOfView");
1831     CORBA::Double aPosition[3];
1832     GetPointOfView(myViewWindow,aPosition);
1833     return VISU::View3D::XYZ_dup(aPosition);
1834   }
1835
1836   void View3D_i::SetViewUp (SUIT_ViewWindow* theStudyFrame,
1837                             const CORBA::Double theViewUp[3])
1838   {
1839     GetCamera(theStudyFrame)->SetViewUp(theViewUp);
1840   }
1841
1842   void View3D_i::SetViewUp (const VISU::View3D::XYZ theViewUp)
1843   {
1844     if(MYDEBUG) MESSAGE("View3D_i::SetViewUp");
1845     ProcessVoidEvent(new TSet3DViewParamEvent(&SetViewUp,myViewWindow,theViewUp));
1846   }
1847
1848   void View3D_i::GetViewUp (SUIT_ViewWindow* theStudyFrame,
1849                             CORBA::Double theViewUp[3])
1850   {
1851     GetCamera(theStudyFrame)->GetViewUp(theViewUp);
1852   }
1853
1854   VISU::View3D::XYZ_slice* View3D_i::GetViewUp()
1855   {
1856     //jfa: may be need to be enclosed in SALOME_Event?
1857     if(MYDEBUG) MESSAGE("View3D_i::GetViewUp");
1858     CORBA::Double aViewUp[3];
1859     GetCamera(myViewWindow)->GetViewUp(aViewUp);
1860     return VISU::View3D::XYZ_dup(aViewUp);
1861   }
1862
1863   void View3D_i::SetFocalPoint (SUIT_ViewWindow* theStudyFrame,
1864                                 const CORBA::Double theFocalPnt[3])
1865   {
1866     GetCamera(theStudyFrame)->SetFocalPoint(theFocalPnt);
1867   }
1868
1869   void View3D_i::SetFocalPoint (const VISU::View3D::XYZ theCoord)
1870   {
1871     if(MYDEBUG) MESSAGE("View3D_i::SetFocalPoint");
1872     ProcessVoidEvent(new TSet3DViewParamEvent(&SetFocalPoint,myViewWindow,theCoord));
1873   }
1874
1875
1876   void View3D_i::GetFocalPoint (SUIT_ViewWindow* theStudyFrame,
1877                                 CORBA::Double theFocalPnt[3])
1878   {
1879     GetCamera(theStudyFrame)->GetFocalPoint(theFocalPnt);
1880   }
1881
1882   VISU::View3D::XYZ_slice* View3D_i::GetFocalPoint()
1883   {
1884     //jfa: may be need to be enclosed in SALOME_Event?
1885     if(MYDEBUG) MESSAGE("View3D_i::GetFocalPoint");
1886     CORBA::Double aFocalPnt[3];
1887     GetFocalPoint(myViewWindow,aFocalPnt);
1888     return VISU::View3D::XYZ_dup(aFocalPnt);
1889   }
1890
1891   class TSetViewParamEvent: public SALOME_Event
1892   {
1893   public:
1894     typedef void (*TFun)(SUIT_ViewWindow* theStudyFrame, CORBA::Double theParam);
1895     TSetViewParamEvent (TFun theFun,
1896                         SUIT_ViewWindow* theStudyFrame,
1897                         CORBA::Double theParam):
1898       myFun(theFun),
1899       myViewWindow(theStudyFrame),
1900       myParam(theParam)
1901     {}
1902     virtual void Execute()
1903     {
1904       myFun(myViewWindow,myParam);
1905     }
1906   private:
1907     TFun myFun;
1908     SUIT_ViewWindow* myViewWindow;
1909     CORBA::Double myParam;
1910   };
1911
1912   void View3D_i::SetParallelScale (SUIT_ViewWindow* theStudyFrame,
1913                                    CORBA::Double theScale)
1914   {
1915     GetCamera(theStudyFrame)->SetParallelScale(theScale);
1916   }
1917
1918   void View3D_i::SetParallelScale (CORBA::Double theScale)
1919   {
1920     if(MYDEBUG) MESSAGE("View3D_i::SetParallelScale");
1921     ProcessVoidEvent(new TSetViewParamEvent(&SetParallelScale,myViewWindow,theScale));
1922   }
1923
1924   CORBA::Double View3D_i::GetParallelScale (SUIT_ViewWindow* theStudyFrame)
1925   {
1926     return GetCamera(theStudyFrame)->GetParallelScale();
1927   }
1928
1929   CORBA::Double View3D_i::GetParallelScale()
1930   {
1931     //jfa: may be need to be enclosed in SALOME_Event?
1932     if(MYDEBUG) MESSAGE("View3D_i::GetParallelScale");
1933     return GetParallelScale(myViewWindow);
1934   }
1935
1936   void View3D_i::ScaleView (SUIT_ViewWindow* theStudyFrame,
1937                             VISU::View3D::Axis theAxis, CORBA::Double theParam)
1938   {
1939     SVTK_ViewWindow* aViewFrame = GetViewWindow(theStudyFrame);
1940     double aScaleFactor[3];
1941     aViewFrame->GetScale(aScaleFactor);
1942     aScaleFactor[theAxis] = theParam;
1943     aViewFrame->SetScale(aScaleFactor);
1944   }
1945
1946   void SetScaleView (SUIT_ViewWindow* theStudyFrame, const CORBA::Double theScale[3])
1947   {
1948     double aScale[3] = {theScale[0], theScale[1], theScale[2]};
1949     GetViewWindow(theStudyFrame)->SetScale(aScale);
1950   }
1951
1952   void View3D_i::ScaleView(VISU::View3D::Axis theAxis, CORBA::Double theParam)
1953   {
1954     if(MYDEBUG) MESSAGE("View3D_i::ScaleView");
1955     double aScale[3];
1956     GetViewWindow(myViewWindow)->GetScale(aScale);
1957     aScale[theAxis] = theParam;
1958     ProcessVoidEvent(new TSet3DViewParamEvent(&SetScaleView,myViewWindow,aScale));
1959   }
1960
1961   void View3D_i::RemoveScale()
1962   {
1963     if(MYDEBUG) MESSAGE("View3D_i::RemoveScale");
1964     double aScale[3] = {1.0, 1.0, 1.0};
1965     ProcessVoidEvent(new TSet3DViewParamEvent(&SetScaleView,myViewWindow,aScale));
1966   }
1967 }