]> SALOME platform Git repositories - modules/gui.git/blob - src/SVTK/SVTK_ViewWindow.cxx
Salome HOME
271aa4c938e9e4809392a4ad2dbd9aeffce4b9f8
[modules/gui.git] / src / SVTK / SVTK_ViewWindow.cxx
1 // Copyright (C) 2007-2012  CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5 //
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License.
10 //
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 // Lesser General Public License for more details.
15 //
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
19 //
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 //
22
23 #include "SVTK_NonIsometricDlg.h"
24 #include "SVTK_UpdateRateDlg.h"
25 #include "SVTK_CubeAxesDlg.h"
26 #include "SVTK_SetRotationPointDlg.h"
27 #include "SVTK_ViewParameterDlg.h"
28 #include "SVTK_ViewModel.h"
29 #include "VTKViewer_Texture.h"
30 #include "VTKViewer_OpenGLRenderer.h"
31
32 #include "SALOME_Actor.h"
33
34 #include <QMenu>
35 #include <QToolBar>
36 #include <QEvent>
37 #include <QFileInfo>
38 #include <QXmlStreamWriter>
39 #include <QXmlStreamReader>
40 #include <QXmlStreamAttributes>
41
42 #include <vtkTextProperty.h>
43 #include <vtkActorCollection.h>
44 #include <vtkRenderWindow.h>
45 #include <vtkRenderer.h>
46 #include <vtkCamera.h>
47 #include <vtkPointPicker.h>
48 #include <vtkCellPicker.h>
49 #include <vtkAxisActor2D.h>
50 #include <vtkGL2PSExporter.h>
51 #include <vtkInteractorStyle.h>
52 #include <vtkProperty.h>
53 #include <vtkCallbackCommand.h>
54 #include <vtkJPEGReader.h>
55 #include <vtkBMPReader.h>
56 #include <vtkTIFFReader.h>
57 #include <vtkPNGReader.h>
58 #include <vtkMetaImageReader.h>
59 #include <vtkImageMapToColors.h>
60 #include <vtkTexture.h>
61
62 #include "QtxAction.h"
63
64 #include "SUIT_Session.h"
65 #include "SUIT_MessageBox.h"
66 #include "SUIT_Accel.h"
67 #include "SUIT_Tools.h"
68 #include "SUIT_ResourceMgr.h"
69 #include "SUIT_Accel.h"
70 #include "SUIT_OverrideCursor.h"
71 #include "SUIT_ViewManager.h"
72 #include "QtxActionToolMgr.h"
73 #include "QtxMultiAction.h"
74
75 #include "VTKViewer_Utilities.h"
76 #include "VTKViewer_Trihedron.h"
77
78 #include "SVTK_View.h"
79 #include "SVTK_Selector.h"
80
81 #include "SVTK_Event.h"
82 #include "SVTK_Renderer.h"
83 #include "SVTK_ViewWindow.h"
84 #include "SVTK_InteractorStyle.h"
85 #include "SVTK_RenderWindowInteractor.h"
86 #include "SVTK_GenericRenderWindowInteractor.h"
87 #include "SVTK_CubeAxesActor2D.h"
88 #include "SVTK_ComboAction.h"
89 #include "SVTK_KeyFreeInteractorStyle.h"
90 #include "SVTK_Selector.h"
91 #include "SVTK_Recorder.h"
92 #include "SVTK_RecorderDlg.h"
93
94 #include "vtkPVAxesWidget.h"
95 #include "vtkPVAxesActor.h"
96
97 #include "SALOME_ListIteratorOfListIO.hxx"
98
99 #include "VTKViewer_Algorithm.h"
100 #include "SVTK_Functor.h"
101
102 #include <OpenGLUtils_FrameBuffer.h>
103
104
105 namespace SVTK
106 {
107   int convertAction( const int accelAction )
108   {
109     switch ( accelAction ) {
110     case SUIT_Accel::PanLeft     : return SVTK::PanLeftEvent;
111     case SUIT_Accel::PanRight    : return SVTK::PanRightEvent;
112     case SUIT_Accel::PanUp       : return SVTK::PanUpEvent;
113     case SUIT_Accel::PanDown     : return SVTK::PanDownEvent;
114     case SUIT_Accel::ZoomIn      : return SVTK::ZoomInEvent;
115     case SUIT_Accel::ZoomOut     : return SVTK::ZoomOutEvent;
116     case SUIT_Accel::RotateLeft  : return SVTK::RotateLeftEvent;
117     case SUIT_Accel::RotateRight : return SVTK::RotateRightEvent;
118     case SUIT_Accel::RotateUp    : return SVTK::RotateUpEvent;
119     case SUIT_Accel::RotateDown  : return SVTK::RotateDownEvent;  
120     }
121     return accelAction;
122   }
123 }
124
125
126
127
128
129 /*!
130   Constructor
131 */
132 SVTK_ViewWindow::SVTK_ViewWindow(SUIT_Desktop* theDesktop):
133   SUIT_ViewWindow(theDesktop),
134   myView(NULL),
135   myDumpImage(QImage()),
136   myKeyFreeInteractorStyle(SVTK_KeyFreeInteractorStyle::New()),
137   myEventCallbackCommand(vtkCallbackCommand::New())
138 {
139   setWindowFlags( windowFlags() & ~Qt::Window );
140   // specific of vtkSmartPointer
141   myKeyFreeInteractorStyle->Delete();
142 }
143
144 /*!
145   To initialize #SVTK_ViewWindow instance
146 */
147 void SVTK_ViewWindow::Initialize(SVTK_ViewModelBase* theModel)
148 {
149   myInteractor = new SVTK_RenderWindowInteractor(this,"SVTK_RenderWindowInteractor");
150   
151   SVTK_Selector* aSelector = SVTK_Selector::New(); 
152   aSelector->SetDynamicPreSelection( SUIT_Session::session()->resourceMgr()->
153                                      booleanValue( "VTKViewer", "dynamic_preselection", true ) );
154   
155   SVTK_GenericRenderWindowInteractor* aDevice = SVTK_GenericRenderWindowInteractor::New();
156   aDevice->SetRenderWidget(myInteractor);
157   aDevice->SetSelector(aSelector);
158   
159   SVTK_Renderer* aRenderer = SVTK_Renderer::New();
160   aRenderer->Initialize(aDevice,aSelector);
161   
162   myInteractor->Initialize(aDevice,aRenderer,aSelector);
163   
164   aDevice->Delete();
165   aRenderer->Delete();
166   aSelector->Delete();
167   
168   myToolBar = toolMgr()->createToolBar( tr("LBL_TOOLBAR_LABEL"), false, Qt::AllToolBarAreas, -1, this );
169   myRecordingToolBar = toolMgr()->createToolBar( tr("LBL_TOOLBAR_RECORD_LABEL"), false, Qt::AllToolBarAreas, -1, this );
170   
171   createActions( SUIT_Session::session()->resourceMgr() );
172   createToolBar();
173   
174   SetEventDispatcher(myInteractor->GetDevice());
175   myInteractor->setBackgroundRole( QPalette::NoRole );//NoBackground
176   myInteractor->setFocusPolicy(Qt::StrongFocus);
177   myInteractor->setFocus();
178   setFocusProxy(myInteractor);
179   
180   myUpdateRateDlg = new SVTK_UpdateRateDlg( getAction( UpdateRate ), this, "SVTK_UpdateRateDlg" );
181   myNonIsometricDlg = new SVTK_NonIsometricDlg( getAction( NonIsometric ), this, "SVTK_NonIsometricDlg" );
182   myCubeAxesDlg = new SVTK_CubeAxesDlg( getAction( GraduatedAxes ), this, "SVTK_CubeAxesDlg" );
183   myCubeAxesDlg->initialize();
184   mySetRotationPointDlg = new SVTK_SetRotationPointDlg
185     ( getAction( ChangeRotationPointId ), this, "SVTK_SetRotationPointDlg" );
186   myViewParameterDlg = new SVTK_ViewParameterDlg
187     ( getAction( ViewParametersId ), this, "SVTK_ViewParameterDlg" );
188   
189   myDefaultInteractorStyle = SVTK_InteractorStyle::New();
190   myInteractor->PushInteractorStyle(myDefaultInteractorStyle);
191   myDefaultInteractorStyle->Delete();
192   
193   myRecorder = SVTK_Recorder::New();
194   
195   myRecorder->SetNbFPS( 17.3 );
196   myRecorder->SetQuality( 100 );
197   myRecorder->SetProgressiveMode( true );
198   myRecorder->SetUseSkippedFrames( true );
199   myRecorder->SetRenderWindow( myInteractor->getRenderWindow() );
200   
201   setCentralWidget(myInteractor);
202   
203   myAxesWidget = vtkPVAxesWidget::New();
204   myAxesWidget->SetParentRenderer(aRenderer->GetDevice());
205   myAxesWidget->SetViewport(0, 0, 0.25, 0.25);
206   myAxesWidget->SetInteractor(myInteractor->GetDevice());
207   myAxesWidget->SetEnabled(1);
208   myAxesWidget->SetInteractive(0);
209
210   vtkPVAxesActor* anAxesActor = myAxesWidget->GetAxesActor();
211   anAxesActor->GetXAxisTipProperty()->SetColor(   1.0, 0.0, 0.0 );
212   anAxesActor->GetXAxisShaftProperty()->SetColor( 1.0, 0.0, 0.0 );
213   anAxesActor->GetXAxisLabelProperty()->SetColor( 1.0, 0.0, 0.0 );
214   anAxesActor->GetYAxisTipProperty()->SetColor(   0.0, 1.0, 0.0 );
215   anAxesActor->GetYAxisShaftProperty()->SetColor( 0.0, 1.0, 0.0 );
216   anAxesActor->GetYAxisLabelProperty()->SetColor( 0.0, 1.0, 0.0 );
217   anAxesActor->GetZAxisTipProperty()->SetColor(   0.0, 0.0, 1.0 );
218   anAxesActor->GetZAxisShaftProperty()->SetColor( 0.0, 0.0, 1.0 );
219   anAxesActor->GetZAxisLabelProperty()->SetColor( 0.0, 0.0, 1.0 );
220
221   myView = new SVTK_View(this);
222   Initialize(myView,theModel);
223
224
225   myEventCallbackCommand->SetClientData(this);
226   myEventCallbackCommand->SetCallback(SVTK_ViewWindow::ProcessEvents);
227   myEventCallbackCommand->Delete();
228
229   GetInteractor()->GetInteractorStyle()->AddObserver(SVTK::OperationFinished, 
230                                                      myEventCallbackCommand.GetPointer(), 0.0);
231   myKeyFreeInteractorStyle->AddObserver(SVTK::OperationFinished, 
232                                         myEventCallbackCommand.GetPointer(), 0.0);
233
234
235   
236   myInteractor->getRenderWindow()->Render();
237   setBackground( Qtx::BackgroundData( Qt::black ) ); // set default background
238   onResetView();
239 }
240
241 /*!
242   To initialize #SVTK_ViewWindow instance
243 */
244 void SVTK_ViewWindow::Initialize(SVTK_View* theView,
245                                  SVTK_ViewModelBase* theModel)
246 {
247   connect(theView,SIGNAL(KeyPressed(QKeyEvent*)),
248           this,SLOT(onKeyPressed(QKeyEvent*)) );
249   connect(theView,SIGNAL(KeyReleased(QKeyEvent*)),
250           this,SLOT(onKeyReleased(QKeyEvent*)));
251   connect(theView,SIGNAL(MouseButtonPressed(QMouseEvent*)),
252           this,SLOT(onMousePressed(QMouseEvent*)));
253   connect(theView,SIGNAL(MouseButtonReleased(QMouseEvent*)),
254           this,SLOT(onMouseReleased(QMouseEvent*)));
255   connect(theView,SIGNAL(MouseDoubleClicked(QMouseEvent*)),
256           this,SLOT(onMouseDoubleClicked(QMouseEvent*)));
257   connect(theView,SIGNAL(MouseMove(QMouseEvent*)),
258           this,SLOT(onMouseMoving(QMouseEvent*)));
259   connect(theView,SIGNAL(contextMenuRequested(QContextMenuEvent*)),
260           this,SIGNAL(contextMenuRequested(QContextMenuEvent *)));
261   connect(theView,SIGNAL(selectionChanged()),
262           theModel,SLOT(onSelectionChanged()));
263
264   connect( this, SIGNAL( transformed( SVTK_ViewWindow* ) ), SLOT( emitViewModified() ) );
265 }
266
267 /*!
268   Destructor
269 */
270 SVTK_ViewWindow::~SVTK_ViewWindow()
271 {
272   myRecorder->Delete();
273   myAxesWidget->Delete();
274 }
275
276
277 /*!
278   \return corresponding view
279 */
280 SVTK_View* SVTK_ViewWindow::getView() 
281
282   return myView; 
283 }
284
285 /*!
286   \return corresponding vtk render window
287 */
288 vtkRenderWindow* SVTK_ViewWindow::getRenderWindow()
289 {
290   return GetInteractor()->getRenderWindow();
291 }
292
293 /*!
294   \return corresponding vtk render window interactor
295 */
296 SVTK_RenderWindowInteractor* SVTK_ViewWindow::GetInteractor() const
297 {
298   return myInteractor;
299 }
300
301 /*!
302   \return corresponding vtk render window interactor
303 */
304 vtkRenderWindowInteractor* SVTK_ViewWindow::getInteractor() const
305 {
306   return myInteractor->GetDevice();
307 }
308
309 /*!
310   \return corresponding vtk renderer
311 */
312 vtkRenderer* SVTK_ViewWindow::getRenderer() const
313 {
314   return GetInteractor()->getRenderer();
315 }
316
317 /*!
318   Redirect the request to SVTK_RenderWindowInteractor::GetRenderer
319 */
320 SVTK_Renderer* SVTK_ViewWindow::GetRenderer() const
321 {
322   return GetInteractor()->GetRenderer();
323 }
324
325 /*!
326   \return corresponding vtk selector
327 */
328 SVTK_Selector* SVTK_ViewWindow::GetSelector() const
329
330   return GetInteractor()->GetSelector(); 
331 }
332
333 /*!
334   Processes transformation "front view"
335 */
336 void SVTK_ViewWindow::onFrontView()
337 {
338   GetRenderer()->OnFrontView();
339   Repaint();
340   emit transformed( this );
341 }
342
343 /*!
344   Processes transformation "back view"
345 */
346 void SVTK_ViewWindow::onBackView()
347 {
348   GetRenderer()->OnBackView();
349   Repaint();
350   emit transformed( this );
351 }
352
353 /*!
354   Processes transformation "top view"
355 */
356 void SVTK_ViewWindow::onTopView()
357 {
358   GetRenderer()->OnTopView();
359   Repaint();
360   emit transformed( this );
361 }
362
363 /*!
364   Processes transformation "bottom view"
365 */
366 void SVTK_ViewWindow::onBottomView()
367 {
368   GetRenderer()->OnBottomView();
369   Repaint();
370   emit transformed( this );
371 }
372
373 /*!
374   Processes transformation "left view"
375 */
376 void SVTK_ViewWindow::onLeftView()
377 {
378   GetRenderer()->OnLeftView();
379   Repaint();
380   emit transformed( this );
381 }
382
383 /*!
384   Processes transformation "right view"
385 */
386 void SVTK_ViewWindow::onRightView()
387 {
388   GetRenderer()->OnRightView();
389   Repaint();
390   emit transformed( this );
391 }
392
393 /*!
394   \brief Rotate view 90 degrees clockwise
395 */
396 void SVTK_ViewWindow::onClockWiseView()
397 {
398   GetRenderer()->onClockWiseView();
399   Repaint();
400   emit transformed( this );
401 }
402
403 /*!
404   \brief Rotate view 90 degrees conterclockwise
405 */
406 void SVTK_ViewWindow::onAntiClockWiseView()
407 {
408   GetRenderer()->onAntiClockWiseView();
409   Repaint();
410   emit transformed( this );
411 }
412
413 /*!
414   Processes transformation "reset view": sets default orientation of viewport camera
415 */
416 void SVTK_ViewWindow::onResetView()
417 {
418   GetRenderer()->OnResetView();
419   Repaint();
420   emit transformed( this );
421 }
422
423 /*!
424   Processes transformation "fit all"
425 */
426 void SVTK_ViewWindow::onFitAll()
427 {
428   GetRenderer()->OnFitAll();
429   Repaint();
430   emit transformed( this );
431 }
432
433 /*!
434   SLOT: called if selection is changed
435 */
436 void SVTK_ViewWindow::onSelectionChanged()
437 {
438   myView->onSelectionChanged();
439 }
440
441 /*!
442   Change selection mode
443   \param theMode - new selection mode
444 */
445 void SVTK_ViewWindow::SetSelectionMode(Selection_Mode theMode)
446 {
447   GetSelector()->SetSelectionMode(theMode);
448 }
449
450 /*!
451   \return selection mode
452 */
453 Selection_Mode SVTK_ViewWindow::SelectionMode() const
454 {
455   return GetSelector()->SelectionMode();
456 }
457
458 /*!
459   Unhilights all objects in viewer
460 */
461 void SVTK_ViewWindow::unHighlightAll() 
462 {
463   myView->unHighlightAll();
464 }
465
466 /*!
467   Hilights/unhilights object in viewer
468   \param theIO - object to be updated
469   \param theIsHighlight - if it is true, object will be hilighted, otherwise it will be unhilighted
470   \param theIsUpdate - update current viewer
471 */
472 void SVTK_ViewWindow::highlight(const Handle(SALOME_InteractiveObject)& theIO, 
473                                 bool theIsHighlight, 
474                                 bool theIsUpdate ) 
475 {
476   myView->highlight( theIO, theIsHighlight, theIsUpdate );
477 }
478
479 /*!
480   \return true if object is in viewer or in collector
481   \param theIO - object to be checked
482 */
483 bool SVTK_ViewWindow::isInViewer( const Handle(SALOME_InteractiveObject)& theIO ) 
484 {
485   return myView->isInViewer( theIO );
486 }
487
488 /*!
489   \return true if object is displayed in viewer
490   \param theIO - object to be checked
491 */
492 bool SVTK_ViewWindow::isVisible( const Handle(SALOME_InteractiveObject)& theIO ) 
493 {
494   return myView->isVisible( theIO );
495 }
496
497 /*!
498   Display object
499   \param theEntry - entry that corresponds to intractive objects
500 */
501 Handle(SALOME_InteractiveObject) SVTK_ViewWindow::FindIObject(const char* theEntry) 
502 {
503   return myView->FindIObject(theEntry);
504 }
505
506 /*!
507   Display object
508   \param theIO - object
509   \param theImmediatly - update viewer
510 */
511 void SVTK_ViewWindow::Display(const Handle(SALOME_InteractiveObject)& theIO,
512                               bool theImmediatly) 
513 {
514   myView->Display(theIO,theImmediatly);
515 }
516
517 /*!
518   Erase object
519   \param theIO - object
520   \param theImmediatly - update viewer
521 */
522 void SVTK_ViewWindow::Erase(const Handle(SALOME_InteractiveObject)& theIO,
523                             bool theImmediatly) 
524 {
525   myView->Erase(theIO,theImmediatly);
526 }
527
528 /*!
529   Display only passed object
530   \param theIO - object
531 */
532 void SVTK_ViewWindow::DisplayOnly(const Handle(SALOME_InteractiveObject)& theIO) 
533 {
534   myView->DisplayOnly(theIO);
535 }
536
537 /*!
538   Display all objects in view
539 */
540 void SVTK_ViewWindow::DisplayAll() 
541 {
542   myView->DisplayAll();
543 }
544
545 /*!
546   Erase all objects in view
547 */
548 void SVTK_ViewWindow::EraseAll() 
549 {
550   myView->EraseAll();
551 }
552
553 /*!
554   Sets background color [obsolete]
555   \param color - new background color
556 */
557 void SVTK_ViewWindow::setBackgroundColor( const QColor& c )
558 {
559   Qtx::BackgroundData bg = background();
560   bg.setColor( c );
561   setBackground( bg );
562 }
563
564 /*!
565   \return background color of viewer [obsolete]
566 */
567 QColor SVTK_ViewWindow::backgroundColor() const
568 {
569   return background().color();
570 }
571
572 /*!
573   Sets background data
574   \param bgData - new background data
575 */
576 void SVTK_ViewWindow::setBackground( const Qtx::BackgroundData& bgData )
577 {
578   bool ok = false;
579
580   if ( bgData.isValid() ) {
581     switch ( bgData.mode() ) {
582     case Qtx::ColorBackground:
583       {
584         QColor c = bgData.color();
585         if ( c.isValid() ) {
586           // show solid-colored background
587           getRenderer()->SetTexturedBackground( false );  // cancel texture mode
588           getRenderer()->SetGradientBackground( false );  // cancel gradient mode
589           getRenderer()->SetBackground( c.red()/255.0,
590                                         c.green()/255.0,
591                                         c.blue()/255.0 ); // set background color
592           ok = true;
593         }
594         break;
595       }
596     case Qtx::SimpleGradientBackground:
597       {
598         QColor c1, c2;
599         int type = bgData.gradient( c1, c2 );
600         if ( c1.isValid() )
601         {
602           if ( !c2.isValid() )
603             c2 = c1;
604
605           // show two-color gradient background
606           getRenderer()->SetTexturedBackground( false );    // cancel texture mode
607           getRenderer()->SetGradientBackground( true );     // switch to gradient mode
608
609           VTKViewer_OpenGLRenderer* aRenderer =
610             VTKViewer_OpenGLRenderer::SafeDownCast( getRenderer() );
611           if( aRenderer )
612           {
613             aRenderer->SetGradientType( type );
614             aRenderer->SetBackground( c1.redF(), c1.greenF(), c1.blueF() );
615             aRenderer->SetBackground2( c2.redF(), c2.greenF(), c2.blueF() );
616             ok = true;
617           }
618         }
619         break;
620       }
621     case Qtx::CustomGradientBackground:
622       {
623         // NOT IMPLEMENTED YET
624         getRenderer()->SetTexturedBackground( false );  // cancel texture mode
625         getRenderer()->SetGradientBackground( false );  // cancel gradient mode
626         // .........
627         break;
628       }
629     default:
630       break;
631     }
632     if ( bgData.isTextureShown() ) {
633       QString fileName;
634       int textureMode = bgData.texture( fileName );
635       QFileInfo fi( fileName );
636       if ( !fileName.isEmpty() && fi.exists() ) {
637         // read texture from file
638         QString extension = fi.suffix().toLower();
639         vtkImageReader2* aReader = 0;
640         if ( extension == "jpg" || extension == "jpeg" )
641           aReader = vtkJPEGReader::New();
642         else if ( extension == "bmp" )
643           aReader = vtkBMPReader::New();
644         else if ( extension == "tif" || extension == "tiff" )
645           aReader = vtkTIFFReader::New();
646         else if ( extension == "png" )
647           aReader = vtkPNGReader::New();
648         else if ( extension == "mhd" || extension == "mha" )
649           aReader = vtkMetaImageReader::New();           
650         if ( aReader ) {
651           // create texture
652           aReader->SetFileName( fi.absoluteFilePath().toLatin1().constData() );
653           aReader->Update();      
654           VTKViewer_Texture* aTexture = VTKViewer_Texture::New();           
655           vtkImageMapToColors* aMap = 0;
656           vtkAlgorithmOutput* anOutput;
657           /*
658           // special processing for BMP reader
659           vtkBMPReader* aBMPReader = (vtkBMPReader*)aReader;
660           if ( aBMPReader ) {
661           // Special processing for BMP file
662           aBMPReader->SetAllow8BitBMP(1);
663             
664           aMap = vtkImageMapToColors::New();
665           aMap->SetInputConnection( aBMPReader->GetOutputPort() );
666           aMap->SetLookupTable( (vtkScalarsToColors*)aBMPReader->GetLookupTable() );
667           aMap->SetOutputFormatToRGB();
668             
669           anOutput = aMap->GetOutputPort();
670           }
671           else {
672           }
673           */
674           anOutput = aReader->GetOutputPort( 0 );
675           aTexture->SetInputConnection( anOutput );
676           // set texture mode
677           // VSR: Currently, VTK only supports Stretch mode, so below code will give
678           // the same results for all modes
679           switch ( textureMode ) {
680           case Qtx::TileTexture:
681             aTexture->SetPosition((int)VTKViewer_Texture::Tiled);
682             break;
683           case Qtx::StretchTexture:
684             aTexture->SetPosition((int)VTKViewer_Texture::Stretched);
685             break;
686           case Qtx::CenterTexture:
687             aTexture->SetPosition((int)VTKViewer_Texture::Centered);
688           default:
689             break;
690           }
691           // show textured background
692           getRenderer()->SetTexturedBackground( true );
693           getRenderer()->SetBackgroundTexture( aTexture );
694           
695           // clean-up resources
696           if ( aMap )
697             aMap->Delete();
698           aReader->Delete();
699           aTexture->Delete();
700           ok = true;
701         }
702       }
703     }
704   }
705   if ( ok )
706     myBackground = bgData;
707 }
708
709 /*!
710   \return background data of viewer
711 */
712 Qtx::BackgroundData SVTK_ViewWindow::background() const
713 {
714   return myBackground;
715 }
716
717
718 /*!
719   Redirect the request to SVTK_RenderWindowInteractor::GetInteractorStyle
720 */
721 vtkInteractorStyle* SVTK_ViewWindow::GetInteractorStyle() const
722 {
723   return GetInteractor()->GetInteractorStyle();
724 }
725
726 /*!
727   Redirect the request to SVTK_RenderWindowInteractor::PushInteractorStyle
728 */
729 void SVTK_ViewWindow::PushInteractorStyle(vtkInteractorStyle* theStyle)
730 {
731   GetInteractor()->PushInteractorStyle(theStyle);
732 }
733
734 /*!
735   Redirect the request to SVTK_RenderWindowInteractor::PopInteractorStyle
736 */
737 void SVTK_ViewWindow::PopInteractorStyle()
738 {
739   GetInteractor()->PopInteractorStyle();
740 }
741
742 /*!
743   Updates current viewer
744 */
745 void SVTK_ViewWindow::Repaint(bool theUpdateTrihedron)
746 {
747   if(theUpdateTrihedron) 
748     GetRenderer()->OnAdjustTrihedron();
749
750   GetInteractor()->update();
751
752   SVTK_InteractorStyle* aStyle = (SVTK_InteractorStyle*)getInteractor()->GetInteractorStyle();
753   if ( aStyle )
754     aStyle->OnTimer();
755 }
756
757 /*!
758   Redirect the request to #SVTK_Renderer::GetScale
759 */
760 void SVTK_ViewWindow::GetScale( double theScale[3] ) 
761 {
762   GetRenderer()->GetScale( theScale );
763 }
764
765 /*!
766   Redirect the request to #SVTK_Renderer::SetScale
767 */
768 void SVTK_ViewWindow::SetScale( double theScale[3] ) 
769 {
770   GetRenderer()->SetScale( theScale );
771   Repaint();
772   emit transformed( this );
773 }
774
775 /*!
776   Redirect the request to #SVTK_Renderer::IsTrihedronDisplayed
777 */
778 bool SVTK_ViewWindow::isTrihedronDisplayed()
779 {
780   return GetRenderer()->IsTrihedronDisplayed();
781 }
782
783 /*!
784   Redirect the request to #SVTK_Renderer::IsCubeAxesDisplayed
785 */
786 bool SVTK_ViewWindow::isCubeAxesDisplayed()
787 {
788   return GetRenderer()->IsCubeAxesDisplayed();
789 }
790
791 /*!
792   Redirect the request to #SVTK_Renderer::OnViewTrihedron
793 */
794 void SVTK_ViewWindow::onViewTrihedron()
795 {
796   GetRenderer()->OnViewTrihedron();
797   Repaint();
798 }
799
800 /*!
801   Redirect the request to #SVTK_Renderer::OnViewCubeAxes
802 */
803 void SVTK_ViewWindow::onViewCubeAxes()
804 {
805   GetRenderer()->OnViewCubeAxes();
806   Repaint();
807 }
808
809 /*!
810   Redirect the request to #SVTK_Renderer::GetTrihedron
811 */
812 VTKViewer_Trihedron* SVTK_ViewWindow::GetTrihedron()
813 {
814   return GetRenderer()->GetTrihedron();
815 }
816
817 /*!
818   Redirect the request to #SVTK_Renderer::GetCubeAxes
819 */
820 SVTK_CubeAxesActor2D* SVTK_ViewWindow::GetCubeAxes()
821 {
822   return GetRenderer()->GetCubeAxes();
823 }
824
825 /*!
826   \return trihedron size
827 */
828 vtkFloatingPointType SVTK_ViewWindow::GetTrihedronSize() const
829 {
830   return GetRenderer()->GetTrihedronSize();
831 }
832
833 /*!
834   Sets projection mode
835   \param theMode - projection mode ( 0 - orthogonal, 1 - perspective )
836 */
837 void SVTK_ViewWindow::SetProjectionMode(const int theMode)
838 {
839   activateProjectionMode( theMode );
840 }
841
842
843 /*!
844   Set the gravity center as a focal point
845 */
846 void SVTK_ViewWindow::activateSetFocalPointGravity()
847 {
848   myEventDispatcher->InvokeEvent(SVTK::SetFocalPointGravity, 0);
849 }
850
851 /*!
852   Set the selected point as a focal point
853 */
854 void SVTK_ViewWindow::activateSetFocalPointSelected()
855 {
856   myEventDispatcher->InvokeEvent(SVTK::SetFocalPointSelected, 0);
857 }
858
859 /*!
860   Set the point selected by user as a focal point
861 */
862 void SVTK_ViewWindow::activateStartFocalPointSelection()
863 {
864   myEventDispatcher->InvokeEvent(SVTK::StartFocalPointSelection,0);
865 }
866
867 void SVTK_ViewWindow::activateProjectionMode(int theMode)
868 {
869   if (theMode)
870     toolMgr()->action( ProjectionModeId )->setChecked( true );
871   else
872     toolMgr()->action( ParallelModeId )->setChecked( true );
873 }
874
875 /*!
876   Sets actual interaction style
877   \param theStyle - type of interaction style ( 0 - standard, 1 - keyboard free )
878 */
879 void SVTK_ViewWindow::SetInteractionStyle(const int theStyle)
880 {
881   onSwitchInteractionStyle( theStyle==1 );
882 }
883
884 /*!
885   Sets actual zooming style
886   \param theStyle - type of zooming style ( 0 - standard, 1 - advanced (at cursor) )
887 */
888 void SVTK_ViewWindow::SetZoomingStyle(const int theStyle)
889 {
890   onSwitchZoomingStyle( theStyle==1 );
891 }
892
893 /*!
894   Switch dynamic preselection on / off
895   \param theDynPreselection - dynamic pre-selection mode
896 */
897 void SVTK_ViewWindow::SetDynamicPreSelection( bool theDynPreselection )
898 {
899   onSwitchDynamicPreSelection( theDynPreselection );
900 }
901
902 /*!
903   Switches "keyboard free" interaction style on/off
904 */
905 void SVTK_ViewWindow::onSwitchInteractionStyle(bool theOn)
906 {
907   if (theOn) {
908     // check if style is already set
909     if ( GetInteractorStyle() != myKeyFreeInteractorStyle.GetPointer() )
910     {
911       // keep the same style extensions
912       SVTK_InteractorStyle* aStyle = (SVTK_InteractorStyle*)GetInteractorStyle();
913       if ( aStyle ) {
914         myKeyFreeInteractorStyle->SetControllerIncrement(aStyle->ControllerIncrement());
915         myKeyFreeInteractorStyle->SetControllerOnKeyDown(aStyle->ControllerOnKeyDown());
916       }
917
918       PushInteractorStyle(myKeyFreeInteractorStyle.GetPointer());
919     }
920   }
921   else {
922     // pop only key free  style
923     if ( GetInteractorStyle() == myKeyFreeInteractorStyle.GetPointer() )
924       PopInteractorStyle();
925   }
926
927   // update action state if method is called outside
928   QtxAction* a = getAction( SwitchInteractionStyleId );
929   if ( a->isChecked() != theOn ) a->setChecked( theOn );
930 }
931
932 /*!
933   Toogles advanced zooming style (relatively to the cursor position) on/off
934 */
935 void SVTK_ViewWindow::onSwitchZoomingStyle( bool theOn )
936 {
937   if( myDefaultInteractorStyle.GetPointer() )
938     myDefaultInteractorStyle->SetAdvancedZoomingEnabled( theOn );
939   if( myKeyFreeInteractorStyle.GetPointer() )
940     myKeyFreeInteractorStyle->SetAdvancedZoomingEnabled( theOn );
941
942   // update action state if method is called outside
943   QtxAction* a = getAction( SwitchZoomingStyleId );
944   if ( a->isChecked() != theOn )
945     a->setChecked( theOn );
946 }
947
948 /*!
949   Toogles dynamic preselection on/off
950 */
951 void SVTK_ViewWindow::onSwitchDynamicPreSelection( bool theOn )
952 {
953   GetSelector()->SetDynamicPreSelection( theOn );
954
955   // update action state if method is called outside
956   QtxAction* a = getAction( SwitchDynamicPreselectionId );
957   if ( a->isChecked() != theOn )
958     a->setChecked( theOn );
959 }
960
961 /*!
962   Sets incremental speed
963   \param theValue - new incremental speed
964   \param theMode - modification mode
965 */
966 void SVTK_ViewWindow::SetIncrementalSpeed(const int theValue, const int theMode)
967 {
968   if ( (SVTK_InteractorStyle*)GetInteractorStyle() )
969     ((SVTK_InteractorStyle*)GetInteractorStyle())->SetIncrementSpeed(theValue, theMode);
970 }
971
972 /*!
973   Sets spacemouse buttons for the functions
974   \param theBtn1 - spacemouse button for the "decrease speed increment"
975   \param theBtn2 - spacemouse button for the "increase speed increment"
976   \param theBtn3 - spacemouse button for the "dominant combined switch"
977 */
978 void SVTK_ViewWindow::SetSpacemouseButtons(const int theBtn1, 
979                                            const int theBtn2,
980                                            const int theBtn3)
981 {
982   int val = theBtn1;
983   myEventDispatcher->InvokeEvent(SVTK::SetSMDecreaseSpeedEvent, &val);
984   val = theBtn2;
985   myEventDispatcher->InvokeEvent(SVTK::SetSMIncreaseSpeedEvent, &val);
986   val = theBtn3;
987   myEventDispatcher->InvokeEvent(SVTK::SetSMDominantCombinedSwitchEvent, &val);
988 }
989
990 /*!
991   Sets trihedron size
992   \param theSize - new trihedron size
993   \param theRelative - trihedron relativeness
994 */
995 void SVTK_ViewWindow::SetTrihedronSize(const vtkFloatingPointType theSize, const bool theRelative)
996 {
997   GetRenderer()->SetTrihedronSize(theSize, theRelative);
998   Repaint();
999 }
1000
1001 /*! If parameter theIsForcedUpdate is true, recalculate parameters for
1002  *  trihedron and cube axes, even if trihedron and cube axes is invisible.
1003  */
1004 void SVTK_ViewWindow::AdjustTrihedrons(const bool theIsForcedUpdate)
1005 {
1006   GetRenderer()->AdjustActors();
1007   Repaint();
1008 }
1009
1010 /*!
1011   Redirect the request to #SVTK_Renderer::OnAdjustTrihedron
1012 */
1013 void SVTK_ViewWindow::onAdjustTrihedron()
1014 {   
1015   GetRenderer()->OnAdjustTrihedron();
1016 }
1017
1018 /*!
1019   Redirect the request to #SVTK_Renderer::OnAdjustCubeAxes
1020 */
1021 void SVTK_ViewWindow::onAdjustCubeAxes()
1022 {   
1023   GetRenderer()->OnAdjustCubeAxes();
1024 }
1025
1026 void SVTK_ViewWindow::synchronize(SVTK_ViewWindow* otherViewWindow )
1027 {
1028   if ( otherViewWindow ) {
1029     bool blocked = blockSignals( true );
1030     doSetVisualParameters( otherViewWindow->getVisualParameters(), true );
1031     blockSignals( blocked );
1032   }
1033 }
1034
1035 /*!
1036   Emits key pressed
1037 */
1038 void SVTK_ViewWindow::onKeyPressed(QKeyEvent* event)
1039 {
1040   emit keyPressed( this, event );
1041 }
1042
1043 /*!
1044   Emits key released
1045 */
1046 void SVTK_ViewWindow::onKeyReleased(QKeyEvent* event)
1047 {
1048   emit keyReleased( this, event );
1049 }
1050
1051 /*!
1052   Emits mouse pressed
1053 */
1054 void SVTK_ViewWindow::onMousePressed(QMouseEvent* event)
1055 {
1056   emit mousePressed(this, event);
1057 }
1058
1059 /*!
1060   Emits mouse released
1061 */
1062 void SVTK_ViewWindow::onMouseReleased(QMouseEvent* event)
1063 {
1064   emit mouseReleased( this, event );
1065 }
1066
1067 /*!
1068   Emits mouse moving
1069 */
1070 void SVTK_ViewWindow::onMouseMoving(QMouseEvent* event)
1071 {
1072   emit mouseMoving( this, event );
1073 }
1074
1075 /*!
1076   Emits mouse double clicked
1077 */
1078 void SVTK_ViewWindow::onMouseDoubleClicked( QMouseEvent* event )
1079 {
1080   emit mouseDoubleClicked( this, event );
1081 }
1082
1083 /*!
1084   Redirect the request to #SVTK_Renderer::AddActor
1085 */
1086 void SVTK_ViewWindow::AddActor( VTKViewer_Actor* theActor, 
1087                                 bool theUpdate,
1088                                 bool theIsAdjustActors )
1089 {
1090   GetRenderer()->AddActor(theActor, theIsAdjustActors);
1091   if(theUpdate) 
1092     Repaint();
1093   emit actorAdded(theActor);
1094 }
1095
1096 /*!
1097   Redirect the request to #SVTK_Renderer::RemoveActor
1098 */
1099 void SVTK_ViewWindow::RemoveActor( VTKViewer_Actor* theActor, 
1100                                    bool theUpdate,
1101                                    bool theIsAdjustActors )
1102 {
1103   GetRenderer()->RemoveActor(theActor, theIsAdjustActors);
1104   if(theUpdate) 
1105     Repaint();
1106   emit actorRemoved(theActor);
1107 }
1108
1109 QImage SVTK_ViewWindow::dumpViewContent()
1110 {
1111   vtkRenderWindow* aWindow = getRenderWindow();
1112   int* aSize = aWindow->GetSize();
1113   int aWidth = aSize[0];
1114   int aHeight = aSize[1];
1115   
1116   OpenGLUtils_FrameBuffer aFrameBuffer;
1117   if( aFrameBuffer.init( aWidth, aHeight ) )
1118   {
1119     glPushAttrib( GL_VIEWPORT_BIT );
1120     glViewport( 0, 0, aWidth, aHeight );
1121     aFrameBuffer.bind();
1122
1123     // draw scene
1124     aWindow->Render();
1125
1126     aFrameBuffer.unbind();
1127     glPopAttrib();
1128
1129     QImage anImage( aWidth, aHeight, QImage::Format_RGB32 );
1130
1131     aFrameBuffer.bind();
1132     glReadPixels( 0, 0, aWidth, aHeight, GL_RGBA, GL_UNSIGNED_BYTE, anImage.bits() );
1133     aFrameBuffer.unbind();
1134
1135     anImage = anImage.rgbSwapped();
1136     anImage = anImage.mirrored();
1137     return anImage;
1138   }
1139
1140   // if frame buffers are unsupported, use old functionality
1141   unsigned char *aData = 
1142     aWindow->GetRGBACharPixelData( 0, 0, aWidth-1, aHeight-1, 0 );
1143   
1144   QImage anImage( aData, aWidth, aHeight, QImage::Format_ARGB32 );
1145
1146   anImage = anImage.rgbSwapped();
1147   anImage = anImage.mirrored();
1148   return anImage;
1149 }
1150
1151 /*!
1152   \return QImage, containing all scene rendering in window
1153 */
1154 QImage SVTK_ViewWindow::dumpView()
1155 {
1156   if( myDumpImage.isNull() )
1157     return dumpViewContent();
1158   
1159   RefreshDumpImage();
1160   return myDumpImage;
1161 }
1162
1163 QString SVTK_ViewWindow::filter() const
1164 {
1165   return tr( "SVTK_IMAGE_FILES" );
1166 }
1167
1168 bool SVTK_ViewWindow::dumpViewToFormat( const QImage& img, const QString& fileName, const QString& format )
1169 {
1170   if ( format != "PS" && format != "EPS" && format != "PDF" )
1171     return SUIT_ViewWindow::dumpViewToFormat( img, fileName, format );
1172
1173   SUIT_OverrideCursor wc;
1174
1175   vtkGL2PSExporter *anExporter = vtkGL2PSExporter::New();
1176   anExporter->SetRenderWindow(getRenderWindow());
1177
1178   if ( format == "PS" ) {
1179     anExporter->SetFileFormatToPS();
1180     anExporter->CompressOff();
1181   }
1182
1183   if ( format == "EPS" ) {
1184     anExporter->SetFileFormatToEPS();
1185     anExporter->CompressOff();
1186   }
1187
1188   if ( format == "PDF" ) {
1189     anExporter->SetFileFormatToPDF();
1190   }
1191
1192   QString aFilePrefix(fileName);
1193   QString anExtension(SUIT_Tools::extension(fileName));
1194   aFilePrefix.truncate(aFilePrefix.length() - 1 - anExtension.length());
1195   anExporter->SetFilePrefix(aFilePrefix.toLatin1().data());
1196   anExporter->Write();
1197   anExporter->Delete();
1198
1199   return true;
1200 }
1201
1202 /*!
1203   \refresh QImage, containing all scene rendering in window
1204 */
1205 void SVTK_ViewWindow::RefreshDumpImage()
1206 {
1207   myDumpImage = dumpViewContent();
1208 }
1209
1210 /*!
1211   Redirect the request to #SVTK_Renderer::SetSelectionProp
1212 */
1213 void SVTK_ViewWindow::SetSelectionProp(const double& theRed, 
1214                                        const double& theGreen, 
1215                                        const double& theBlue, 
1216                                        const int& theWidth) 
1217 {
1218   myView->SetSelectionProp(theRed,theGreen,theBlue,theWidth);
1219 }
1220
1221 /*!
1222   Redirect the request to #SVTK_Renderer::SetSelectionProp
1223 */
1224 void SVTK_ViewWindow::SetPreselectionProp(const double& theRed, 
1225                                           const double& theGreen, 
1226                                           const double& theBlue, 
1227                                           const int& theWidth) 
1228 {
1229   myView->SetPreselectionProp(theRed,theGreen,theBlue,theWidth);
1230 }
1231
1232 /*!
1233   Redirect the request to #SVTK_Renderer::SetSelectionTolerance
1234 */
1235 void SVTK_ViewWindow::SetSelectionTolerance(const double& theTolNodes, 
1236                                             const double& theTolItems,
1237                                             const double& theTolObjects)
1238 {
1239   myView->SetSelectionTolerance(theTolNodes, theTolItems, theTolObjects);
1240 }
1241
1242 /*!
1243   Get visibility status of the static trihedron
1244 */
1245 bool SVTK_ViewWindow::IsStaticTrihedronVisible() const
1246 {
1247   return (bool)myAxesWidget->GetEnabled();
1248 }
1249
1250 /*!
1251   Set visibility status of the static trihedron
1252 */
1253 void SVTK_ViewWindow::SetStaticTrihedronVisible( const bool theIsVisible )
1254 {
1255   myAxesWidget->SetEnabled( (int)theIsVisible );
1256 }
1257
1258 /*!
1259   Performs action
1260   \param accelAction - action
1261 */
1262 bool SVTK_ViewWindow::action( const int accelAction  )
1263 {
1264   if ( accelAction == SUIT_Accel::ZoomFit )
1265     onFitAll();
1266   else {
1267     int anEvent = SVTK::convertAction( accelAction );
1268     GetInteractor()->InvokeEvent(anEvent, 0);
1269   }
1270   return true;
1271 }
1272
1273 /*!
1274   \return action by it's id
1275 */
1276 QtxAction* SVTK_ViewWindow::getAction( int id ) const
1277 {
1278   return dynamic_cast<QtxAction*>( toolMgr()->action( id ) );
1279 }
1280
1281
1282 // old visual parameters had 13 values.  New format added additional 
1283 // 76 values for graduated axes, so both numbers are processed.
1284 const int nNormalParams = 13;   // number of view windows parameters excluding graduated axes params
1285 const int nGradAxisParams = 25; // number of parameters of ONE graduated axis (X, Y, or Z)
1286 const int nTrihedronParams = 3; // number of parameters for Trihedron
1287 const int nAllParams = nNormalParams + 3*nGradAxisParams + nTrihedronParams + 1; // number of all visual parameters
1288
1289 /*! The method returns visual parameters of a graduated axis actor (x,y,z axis of graduated axes)
1290  */
1291 void getGradAxisVisualParams( QXmlStreamWriter& writer, vtkAxisActor2D* actor, QString theAxis )
1292 {
1293   //QString params;
1294   if ( !actor )
1295     return ;//params;
1296
1297   // Name
1298   bool isVisible = actor->GetTitleVisibility();
1299   QString title ( actor->GetTitle() );
1300   vtkFloatingPointType color[ 3 ];
1301   int font = VTK_ARIAL;
1302   int bold = 0;
1303   int italic = 0;
1304   int shadow = 0;
1305
1306   vtkTextProperty* txtProp = actor->GetTitleTextProperty();
1307   if ( txtProp )
1308   {
1309     txtProp->GetColor( color );
1310     font = txtProp->GetFontFamily();
1311     bold = txtProp->GetBold();
1312     italic = txtProp->GetItalic();
1313     shadow = txtProp->GetShadow();
1314   }
1315   writer.writeStartElement("GraduatedAxis");
1316   writer.writeAttribute("Axis", theAxis);
1317
1318   writer.writeStartElement("Title");
1319   writer.writeAttribute("isVisible", QString("%1").arg(isVisible));
1320   writer.writeAttribute("Text", title);
1321   writer.writeAttribute("Font", QString("%1").arg(font));
1322   writer.writeAttribute("Bold", QString("%1").arg(bold));
1323   writer.writeAttribute("Italic", QString("%1").arg(italic));
1324   writer.writeAttribute("Shadow", QString("%1").arg(shadow));
1325
1326   writer.writeStartElement("Color");
1327   writer.writeAttribute("R", QString("%1").arg(color[0]));
1328   writer.writeAttribute("G", QString("%1").arg(color[1]));
1329   writer.writeAttribute("B", QString("%1").arg(color[2]));
1330   writer.writeEndElement();
1331   writer.writeEndElement();
1332
1333   //params.sprintf( "* Graduated Axis: * Name *%u*%s*%.2f*%.2f*%.2f*%u*%u*%u*%u", isVisible, 
1334   //              title.toLatin1().data(), color[0], color[1], color[2], font, bold, italic, shadow );
1335
1336   // Labels
1337   isVisible = actor->GetLabelVisibility();
1338   int labels = actor->GetNumberOfLabels();
1339   int offset = actor->GetTickOffset();
1340   font = VTK_ARIAL;
1341   bold = false;
1342   italic = false;
1343   shadow = false;
1344
1345   txtProp = actor->GetLabelTextProperty();
1346   if ( txtProp )
1347   {
1348     txtProp->GetColor( color );
1349     font = txtProp->GetFontFamily();
1350     bold = txtProp->GetBold();
1351     italic = txtProp->GetItalic();
1352     shadow = txtProp->GetShadow();
1353   }
1354
1355   writer.writeStartElement("Labels");
1356   writer.writeAttribute("isVisible", QString("%1").arg(isVisible));
1357   writer.writeAttribute("Number", QString("%1").arg(labels));
1358   writer.writeAttribute("Offset", QString("%1").arg(offset));
1359   writer.writeAttribute("Font", QString("%1").arg(font));
1360   writer.writeAttribute("Bold", QString("%1").arg(bold));
1361   writer.writeAttribute("Italic", QString("%1").arg(italic));
1362   writer.writeAttribute("Shadow", QString("%1").arg(shadow));
1363
1364   writer.writeStartElement("Color");
1365   writer.writeAttribute("R", QString("%1").arg(color[0]));
1366   writer.writeAttribute("G", QString("%1").arg(color[1]));
1367   writer.writeAttribute("B", QString("%1").arg(color[2]));
1368   writer.writeEndElement();
1369   writer.writeEndElement();
1370   //  params += QString().sprintf( "* Labels *%u*%u*%u*%.2f*%.2f*%.2f*%u*%u*%u*%u", isVisible, labels, offset,  
1371   //                           color[0], color[1], color[2], font, bold, italic, shadow );
1372
1373   // Tick marks
1374   isVisible = actor->GetTickVisibility();
1375   int length = actor->GetTickLength();
1376   writer.writeStartElement("TickMarks");
1377   writer.writeAttribute("isVisible", QString("%1").arg(isVisible));
1378   writer.writeAttribute("Length", QString("%1").arg(length));
1379   writer.writeEndElement();
1380   
1381   //params += QString().sprintf( "* Tick marks *%u*%u", isVisible, length );
1382   
1383   writer.writeEndElement();
1384   //return params;
1385 }
1386
1387 void setGradAxisVisualParams(QXmlStreamReader& reader, vtkAxisActor2D* actor)
1388 {
1389   if ( !actor )
1390     return;
1391
1392   do {
1393     reader.readNext();
1394   } while (!reader.isStartElement());
1395
1396   // Read title params
1397   QXmlStreamAttributes aAttr = reader.attributes();
1398   bool isVisible = aAttr.value("isVisible").toString().toUShort();
1399   QString title = aAttr.value("Text").toString();
1400   int font = aAttr.value("Font").toString().toInt();
1401   int bold = aAttr.value("Bold").toString().toInt();
1402   int italic = aAttr.value("Italic").toString().toInt();
1403   int shadow = aAttr.value("Shadow").toString().toInt();
1404
1405   //printf("#### TITLE: %i, %s, %i, %i, %i, %i\n", isVisible, qPrintable(title), font, bold, italic, shadow);
1406
1407   do {
1408     reader.readNext();
1409   } while (!reader.isStartElement());
1410   
1411   // Read title color
1412   aAttr = reader.attributes();
1413
1414   vtkFloatingPointType color[3];
1415   color[0] = aAttr.value("R").toString().toDouble();
1416   color[1] = aAttr.value("G").toString().toDouble();
1417   color[2] = aAttr.value("B").toString().toDouble();
1418   //printf("#### Color: %f, %f, %f\n", color[0], color[1], color[2]);
1419
1420   actor->SetTitleVisibility( isVisible );
1421   actor->SetTitle( title.toLatin1() );
1422   vtkTextProperty* txtProp = actor->GetTitleTextProperty();
1423   if ( txtProp ) {
1424     txtProp->SetColor( color );
1425     txtProp->SetFontFamily( font );
1426     txtProp->SetBold( bold );
1427     txtProp->SetItalic( italic );
1428     txtProp->SetShadow( shadow );
1429   }
1430
1431   // Labels
1432
1433   do {
1434     reader.readNext();
1435   } while (!reader.isStartElement()); 
1436   // Read labels
1437   aAttr = reader.attributes();
1438   isVisible = aAttr.value("isVisible").toString().toUShort();
1439   int labels = aAttr.value("Number").toString().toInt();
1440   int offset = aAttr.value("Offset").toString().toInt();
1441   font = aAttr.value("Font").toString().toInt();
1442   bold = aAttr.value("Bold").toString().toInt();
1443   italic = aAttr.value("Italic").toString().toInt();
1444   shadow = aAttr.value("Shadow").toString().toInt();
1445
1446   do {
1447     reader.readNext();
1448   } while (!reader.isStartElement()); 
1449   // Read Color
1450   aAttr = reader.attributes();
1451
1452   color[0] = aAttr.value("R").toString().toDouble();
1453   color[1] = aAttr.value("G").toString().toDouble();
1454   color[2] = aAttr.value("B").toString().toDouble();
1455
1456   actor->SetLabelVisibility( isVisible );
1457   actor->SetNumberOfLabels( labels );
1458   actor->SetTickOffset( offset );
1459   txtProp = actor->GetLabelTextProperty();
1460   if ( txtProp ) {
1461     txtProp->SetColor( color );
1462     txtProp->SetFontFamily( font );
1463     txtProp->SetBold( bold );
1464     txtProp->SetItalic( italic );
1465     txtProp->SetShadow( shadow );
1466   }
1467
1468   // Tick Marks
1469   do {
1470     reader.readNext();
1471   } while (!reader.isStartElement()); 
1472   aAttr = reader.attributes();
1473
1474   // retrieve and set tick marks properties
1475   isVisible = aAttr.value("isVisible").toString().toUShort();
1476   int length = aAttr.value("Length").toString().toInt();
1477   
1478   actor->SetTickVisibility( isVisible );
1479   actor->SetTickLength( length );
1480 }
1481
1482 /*! The method restores visual parameters of a graduated axis actor (x,y,z axis)
1483  */
1484 void setGradAxisVisualParams( vtkAxisActor2D* actor, const QString& params )
1485 {
1486   if ( !actor )
1487     return;
1488
1489   QStringList paramsLst = params.split( '*' );
1490
1491   if ( paramsLst.size() == nGradAxisParams ) { // altogether name, lable, ticks parameters make up 25 values
1492
1493     // retrieve and set name parameters
1494     bool isVisible = paramsLst[2].toUShort();
1495     QString title = paramsLst[3];
1496     vtkFloatingPointType color[3];
1497     color[0] = paramsLst[4].toDouble();
1498     color[1] = paramsLst[5].toDouble();
1499     color[2] = paramsLst[6].toDouble();
1500     int font = paramsLst[7].toInt();
1501     int bold = paramsLst[8].toInt();
1502     int italic = paramsLst[9].toInt();
1503     int shadow = paramsLst[10].toInt();
1504
1505     actor->SetTitleVisibility( isVisible );
1506     actor->SetTitle( title.toLatin1() );
1507     vtkTextProperty* txtProp = actor->GetTitleTextProperty();
1508     if ( txtProp ) {
1509       txtProp->SetColor( color );
1510       txtProp->SetFontFamily( font );
1511       txtProp->SetBold( bold );
1512       txtProp->SetItalic( italic );
1513       txtProp->SetShadow( shadow );
1514     }
1515
1516     // retrieve and set lable parameters
1517     isVisible = paramsLst[12].toUShort();
1518     int labels = paramsLst[13].toInt();
1519     int offset = paramsLst[14].toInt();
1520     color[0] = paramsLst[15].toDouble();
1521     color[1] = paramsLst[16].toDouble();
1522     color[2] = paramsLst[17].toDouble();
1523     font = paramsLst[18].toInt();
1524     bold = paramsLst[19].toInt();
1525     italic = paramsLst[20].toInt();
1526     shadow = paramsLst[21].toInt();
1527
1528     actor->SetLabelVisibility( isVisible );
1529     actor->SetNumberOfLabels( labels );
1530     actor->SetTickOffset( offset );
1531     txtProp = actor->GetLabelTextProperty();
1532     if ( txtProp ) {
1533       txtProp->SetColor( color );
1534       txtProp->SetFontFamily( font );
1535       txtProp->SetBold( bold );
1536       txtProp->SetItalic( italic );
1537       txtProp->SetShadow( shadow );
1538     }
1539
1540     // retrieve and set tick marks properties
1541     isVisible = paramsLst[23].toUShort();
1542     int length = paramsLst[24].toInt();
1543
1544     actor->SetTickVisibility( isVisible );
1545     actor->SetTickLength( length );
1546   }
1547 }
1548
1549 /*! The method returns the visual parameters of this view as a formated string
1550  */
1551 QString SVTK_ViewWindow::getVisualParameters()
1552 {
1553   double pos[3], focalPnt[3], viewUp[3], parScale, scale[3];
1554   
1555   // save position, focal point, viewUp, scale
1556   vtkCamera* camera = getRenderer()->GetActiveCamera();
1557   camera->GetPosition( pos );
1558   camera->GetFocalPoint( focalPnt );
1559   camera->GetViewUp( viewUp );
1560   parScale = camera->GetParallelScale();
1561   GetScale( scale );
1562
1563   // Parameters are given in the following format:view position (3 digits), focal point position (3 digits)
1564   // view up values (3 digits), parallel scale (1 digit), scale (3 digits, 
1565   // Graduated axes parameters (X, Y, Z axes parameters)
1566   QString retStr;
1567   QXmlStreamWriter aWriter(&retStr);
1568   aWriter.setAutoFormatting(true);
1569
1570   aWriter.writeStartDocument();
1571   aWriter.writeStartElement("ViewState");
1572
1573   aWriter.writeStartElement("Position");
1574   aWriter.writeAttribute("X", QString("%1").arg(pos[0]));
1575   aWriter.writeAttribute("Y", QString("%1").arg(pos[1]));
1576   aWriter.writeAttribute("Z", QString("%1").arg(pos[2]));
1577   aWriter.writeEndElement();
1578
1579   aWriter.writeStartElement("FocalPoint");
1580   aWriter.writeAttribute("X", QString::number(focalPnt[0]));
1581   aWriter.writeAttribute("Y", QString::number(focalPnt[1]));
1582   aWriter.writeAttribute("Z", QString::number(focalPnt[2]));
1583   aWriter.writeEndElement();
1584
1585   aWriter.writeStartElement("ViewUp");
1586   aWriter.writeAttribute("X", QString::number(viewUp[0]));
1587   aWriter.writeAttribute("Y", QString::number(viewUp[1]));
1588   aWriter.writeAttribute("Z", QString::number(viewUp[2]));
1589   aWriter.writeEndElement();
1590
1591   aWriter.writeStartElement("ViewScale");
1592   aWriter.writeAttribute("Parallel", QString::number(parScale));
1593   aWriter.writeAttribute("X", QString::number(scale[0]));
1594   aWriter.writeAttribute("Y", QString::number(scale[1]));
1595   aWriter.writeAttribute("Z", QString::number(scale[2]));
1596   aWriter.writeEndElement();
1597
1598   if ( SVTK_CubeAxesActor2D* gradAxesActor = GetCubeAxes() ) {
1599     aWriter.writeStartElement("DisplayCubeAxis");
1600     aWriter.writeAttribute("Show", QString( "%1" ).arg( GetRenderer()->IsCubeAxesDisplayed()));
1601     aWriter.writeEndElement();
1602
1603     getGradAxisVisualParams(aWriter, gradAxesActor->GetXAxisActor2D(), "X");
1604     getGradAxisVisualParams(aWriter, gradAxesActor->GetYAxisActor2D(), "Y");
1605     getGradAxisVisualParams(aWriter, gradAxesActor->GetZAxisActor2D(), "Z");
1606   }
1607
1608   aWriter.writeStartElement("Trihedron");
1609   aWriter.writeAttribute("isShown",  QString( "%1" ).arg( isTrihedronDisplayed()));
1610   aWriter.writeAttribute("Size", QString::number(GetTrihedronSize()));
1611   aWriter.writeEndElement();
1612
1613   aWriter.writeStartElement("Background");
1614   aWriter.writeAttribute("Value",  QString( "%1" ).arg( Qtx::backgroundToString(background()) ));
1615   aWriter.writeEndElement();
1616
1617   aWriter.writeEndElement();
1618   aWriter.writeEndDocument();
1619
1620   return retStr;
1621 }
1622
1623 /*!
1624   The method restores visual parameters of this view or postpones it untill the view is shown
1625 */ 
1626 void SVTK_ViewWindow::setVisualParameters( const QString& parameters )
1627 {
1628   //printf("#### %s\n", qPrintable(parameters));
1629   SVTK_RenderWindowInteractor* anInteractor = GetInteractor();
1630   if ( anInteractor->isVisible() ) {
1631     doSetVisualParameters( parameters ); 
1632   }
1633   else {
1634     myVisualParams = parameters;
1635     anInteractor->installEventFilter(this);
1636   }
1637 }
1638
1639 /*!
1640   The method restores visual parameters of this view from a formated string
1641 */
1642 void SVTK_ViewWindow::doSetVisualParameters( const QString& parameters, bool baseParamsOnly )
1643 {
1644   
1645   double pos[3], focalPnt[3], viewUp[3], parScale, scale[3];
1646
1647   QXmlStreamReader aReader(parameters);
1648   SVTK_CubeAxesActor2D* gradAxesActor = GetCubeAxes();
1649
1650   while(!aReader.atEnd()) {
1651     aReader.readNext();
1652     if (aReader.isStartElement()) {
1653       QXmlStreamAttributes aAttr = aReader.attributes();
1654       //printf("### Name = %s\n", qPrintable(aReader.name().toString()));
1655       if (aReader.name() == "Position") {       
1656         pos[0] = aAttr.value("X").toString().toDouble();
1657         pos[1] = aAttr.value("Y").toString().toDouble();
1658         pos[2] = aAttr.value("Z").toString().toDouble();
1659         //printf("#### Position %f; %f; %f\n", pos[0], pos[1], pos[2]);
1660       }
1661       else if (aReader.name() == "FocalPoint") {
1662         focalPnt[0] = aAttr.value("X").toString().toDouble();
1663         focalPnt[1] = aAttr.value("Y").toString().toDouble();
1664         focalPnt[2] = aAttr.value("Z").toString().toDouble();
1665         //printf("#### FocalPoint %f; %f; %f\n", focalPnt[0], focalPnt[1], focalPnt[2]);
1666       }
1667       else if (aReader.name() == "ViewUp") {
1668         viewUp[0] = aAttr.value("X").toString().toDouble();
1669         viewUp[1] = aAttr.value("Y").toString().toDouble();
1670         viewUp[2] = aAttr.value("Z").toString().toDouble();
1671         //printf("#### ViewUp %f; %f; %f\n", viewUp[0], viewUp[1], viewUp[2]);
1672       }
1673       else if (aReader.name() == "ViewScale") {
1674         parScale = aAttr.value("Parallel").toString().toDouble();
1675         scale[0] = aAttr.value("X").toString().toDouble();
1676         scale[1] = aAttr.value("Y").toString().toDouble();
1677         scale[2] = aAttr.value("Z").toString().toDouble();
1678         //printf("#### ViewScale %f; %f; %f\n", scale[0], scale[1], scale[2]);
1679       } 
1680       else if (aReader.name() == "DisplayCubeAxis") {
1681         if ( !baseParamsOnly ) {
1682           if (aAttr.value("Show") == "0")
1683             gradAxesActor->VisibilityOff();
1684           else
1685             gradAxesActor->VisibilityOn();
1686         }
1687       }
1688       else if (aReader.name() == "GraduatedAxis") {
1689         if ( !baseParamsOnly ) {
1690           if(aAttr.value("Axis") == "X") 
1691             setGradAxisVisualParams(aReader, gradAxesActor->GetXAxisActor2D());
1692           else if(aAttr.value("Axis") == "Y")
1693             setGradAxisVisualParams(aReader, gradAxesActor->GetYAxisActor2D());
1694           else if(aAttr.value("Axis") == "Z")
1695             setGradAxisVisualParams(aReader, gradAxesActor->GetZAxisActor2D());
1696         }
1697       } 
1698       else if (aReader.name() == "Trihedron") {
1699         if ( !baseParamsOnly ) {
1700           if (aAttr.value("isShown") == "0")
1701             GetTrihedron()->VisibilityOff();
1702           else
1703             GetTrihedron()->VisibilityOn();
1704           SetTrihedronSize(aAttr.value("Size").toString().toDouble());
1705         }
1706       }
1707       else if (aReader.name() == "Background") {
1708         if ( !baseParamsOnly ) {
1709           setBackground( Qtx::stringToBackground( aAttr.value("Value").toString() ) );
1710         }
1711       }
1712     }
1713   }
1714   if (!aReader.hasError()) {
1715     vtkCamera* camera = getRenderer()->GetActiveCamera();
1716     camera->SetPosition( pos );
1717     camera->SetFocalPoint( focalPnt );
1718     camera->SetViewUp( viewUp );
1719     camera->SetParallelScale( parScale );
1720     GetRenderer()->SetScale( scale );
1721     //SetScale( scale );
1722   }
1723   else {
1724     QStringList paramsLst = parameters.split( '*' );
1725     if ( paramsLst.size() >= nNormalParams ) {
1726       // 'reading' list of parameters
1727       pos[0] = paramsLst[0].toDouble();
1728       pos[1] = paramsLst[1].toDouble();
1729       pos[2] = paramsLst[2].toDouble();
1730       focalPnt[0] = paramsLst[3].toDouble();
1731       focalPnt[1] = paramsLst[4].toDouble();
1732       focalPnt[2] = paramsLst[5].toDouble();
1733       viewUp[0] = paramsLst[6].toDouble();
1734       viewUp[1] = paramsLst[7].toDouble();
1735       viewUp[2] = paramsLst[8].toDouble();
1736       parScale = paramsLst[9].toDouble();
1737       scale[0] = paramsLst[10].toDouble();
1738       scale[1] = paramsLst[11].toDouble();
1739       scale[2] = paramsLst[12].toDouble();
1740       
1741       // applying parameters
1742       vtkCamera* camera = getRenderer()->GetActiveCamera();
1743       camera->SetPosition( pos );
1744       camera->SetFocalPoint( focalPnt );
1745       camera->SetViewUp( viewUp );
1746       camera->SetParallelScale( parScale );
1747       GetRenderer()->SetScale( scale );
1748       //SetScale( scale );
1749       
1750       // apply graduated axes parameters
1751       if ( !baseParamsOnly ) {
1752         SVTK_CubeAxesActor2D* gradAxesActor = GetCubeAxes();
1753         if ( gradAxesActor && paramsLst.size() == nAllParams ) {
1754           int i = nNormalParams+1, j = i + nGradAxisParams - 1;
1755           ::setGradAxisVisualParams( gradAxesActor->GetXAxisActor2D(), parameters.section( '*', i, j ) ); 
1756           i = j + 1; j += nGradAxisParams;
1757           ::setGradAxisVisualParams( gradAxesActor->GetYAxisActor2D(), parameters.section( '*', i, j ) ); 
1758           i = j + 1; j += nGradAxisParams;
1759           ::setGradAxisVisualParams( gradAxesActor->GetZAxisActor2D(), parameters.section( '*', i, j ) ); 
1760         
1761           if ( paramsLst[13].toUShort() )
1762             gradAxesActor->VisibilityOn();
1763           else
1764             gradAxesActor->VisibilityOff();
1765         }
1766         else if ( paramsLst.size() == nAllParams ) {
1767           if ( paramsLst[90].toUShort() )
1768             GetTrihedron()->VisibilityOn();
1769           else
1770             GetTrihedron()->VisibilityOff();
1771         
1772           SetTrihedronSize(paramsLst[91].toDouble());
1773         }
1774       }
1775     }
1776   }
1777   Repaint();
1778 }
1779
1780
1781 /*!
1782   Delayed setVisualParameters
1783 */
1784 bool SVTK_ViewWindow::eventFilter( QObject* theWatched, QEvent* theEvent )
1785 {
1786   if ( theEvent->type() == QEvent::Show && theWatched->inherits( "SVTK_RenderWindowInteractor" ) ) {
1787     SVTK_RenderWindowInteractor* anInteractor = (SVTK_RenderWindowInteractor*)theWatched;
1788     if ( anInteractor->isVisible() ) {
1789       doSetVisualParameters( myVisualParams );
1790       anInteractor->removeEventFilter( this ); // theWatched = RenderWindowInteractor
1791     }
1792   }
1793   return SUIT_ViewWindow::eventFilter( theWatched, theEvent );
1794 }
1795
1796
1797 /*!
1798   Change rotation point
1799 */
1800 void SVTK_ViewWindow::onChangeRotationPoint(bool theIsActivate)
1801 {
1802   if(theIsActivate){
1803     mySetRotationPointDlg->addObserver();
1804     if ( mySetRotationPointDlg->IsFirstShown() )
1805       activateSetRotationGravity();
1806     mySetRotationPointDlg->show();
1807   }else
1808     mySetRotationPointDlg->hide();
1809 }
1810
1811 /*!
1812   Set the gravity center as a rotation point
1813 */
1814 void SVTK_ViewWindow::activateSetRotationGravity()
1815 {
1816   myEventDispatcher->InvokeEvent(SVTK::SetRotateGravity,0);
1817 }
1818
1819 /*!
1820   Set the selected point as a rotation point
1821 */
1822 void SVTK_ViewWindow::activateSetRotationSelected(void* theData)
1823 {
1824   myEventDispatcher->InvokeEvent(SVTK::ChangeRotationPoint,theData);
1825 }
1826
1827 /*!
1828   Set the point selected by user as a rotation point
1829 */
1830 void SVTK_ViewWindow::activateStartPointSelection()
1831 {
1832   myEventDispatcher->InvokeEvent(SVTK::StartPointSelection,0);
1833 }
1834
1835 /*!
1836   Set the view projection mode: orthogonal or perspective
1837 */
1838 void SVTK_ViewWindow::onPerspectiveMode()
1839 {
1840   bool anIsParallelMode = toolMgr()->action( ParallelModeId )->isChecked();
1841
1842   // advanced zooming is not available in perspective mode
1843   if( QtxAction* anAction = getAction( SwitchZoomingStyleId ) )
1844     anAction->setEnabled( anIsParallelMode );
1845
1846   vtkCamera* aCamera = getRenderer()->GetActiveCamera();
1847   aCamera->SetParallelProjection(anIsParallelMode);
1848   GetInteractor()->GetDevice()->CreateTimer(VTKI_TIMER_FIRST);
1849
1850   emit transformed( this );
1851 }
1852
1853 void SVTK_ViewWindow::SetEventDispatcher(vtkObject* theDispatcher)
1854 {
1855   myEventDispatcher = theDispatcher;
1856 }
1857
1858 /*!
1859   Creates all actions of svtk main window
1860 */
1861 void SVTK_ViewWindow::createActions(SUIT_ResourceMgr* theResourceMgr)
1862 {
1863   QtxAction* anAction;
1864   QtxActionToolMgr* mgr = toolMgr();
1865
1866   // Dump view
1867   anAction = new QtxAction(tr("MNU_DUMP_VIEW"), 
1868                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_VTKVIEWER_VIEW_DUMP" ) ),
1869                            tr( "MNU_DUMP_VIEW" ), 0, this);
1870   anAction->setStatusTip(tr("DSC_DUMP_VIEW"));
1871   connect(anAction, SIGNAL(activated()), this, SLOT(onDumpView()));
1872   mgr->registerAction( anAction, DumpId );
1873
1874   // FitAll
1875   anAction = new QtxAction(tr("MNU_FITALL"), 
1876                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_VTKVIEWER_VIEW_FITALL" ) ),
1877                            tr( "MNU_FITALL" ), 0, this);
1878   anAction->setStatusTip(tr("DSC_FITALL"));
1879   connect(anAction, SIGNAL(activated()), this, SLOT(onFitAll()));
1880   mgr->registerAction( anAction, FitAllId );
1881
1882   // FitRect
1883   anAction = new QtxAction(tr("MNU_FITRECT"), 
1884                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_VTKVIEWER_VIEW_FITAREA" ) ),
1885                            tr( "MNU_FITRECT" ), 0, this);
1886   anAction->setStatusTip(tr("DSC_FITRECT"));
1887   connect(anAction, SIGNAL(activated()), this, SLOT(activateWindowFit()));
1888   mgr->registerAction( anAction, FitRectId );
1889
1890   // Zoom
1891   anAction = new QtxAction(tr("MNU_ZOOM_VIEW"), 
1892                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_VTKVIEWER_VIEW_ZOOM" ) ),
1893                            tr( "MNU_ZOOM_VIEW" ), 0, this);
1894   anAction->setStatusTip(tr("DSC_ZOOM_VIEW"));
1895   connect(anAction, SIGNAL(activated()), this, SLOT(activateZoom()));
1896   mgr->registerAction( anAction, ZoomId );
1897
1898   // Panning
1899   anAction = new QtxAction(tr("MNU_PAN_VIEW"), 
1900                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_VTKVIEWER_VIEW_PAN" ) ),
1901                            tr( "MNU_PAN_VIEW" ), 0, this);
1902   anAction->setStatusTip(tr("DSC_PAN_VIEW"));
1903   connect(anAction, SIGNAL(activated()), this, SLOT(activatePanning()));
1904   mgr->registerAction( anAction, PanId );
1905
1906   // Global Panning
1907   anAction = new QtxAction(tr("MNU_GLOBALPAN_VIEW"), 
1908                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_VTKVIEWER_VIEW_GLOBALPAN" ) ),
1909                            tr( "MNU_GLOBALPAN_VIEW" ), 0, this);
1910   anAction->setStatusTip(tr("DSC_GLOBALPAN_VIEW"));
1911   connect(anAction, SIGNAL(activated()), this, SLOT(activateGlobalPanning()));
1912   mgr->registerAction( anAction, GlobalPanId );
1913
1914   // Change rotation point
1915   anAction = new QtxAction(tr("MNU_CHANGINGROTATIONPOINT_VIEW"), 
1916                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_SVTK_ROTATION_POINT" ) ),
1917                            tr( "MNU_CHANGINGROTATIONPOINT_VIEW" ), 0, this);
1918   anAction->setStatusTip(tr("DSC_CHANGINGROTATIONPOINT_VIEW"));
1919   anAction->setCheckable(true);
1920   connect(anAction, SIGNAL(toggled(bool)), this, SLOT(onChangeRotationPoint(bool)));
1921   mgr->registerAction( anAction, ChangeRotationPointId );
1922
1923   // Rotation
1924   anAction = new QtxAction(tr("MNU_ROTATE_VIEW"), 
1925                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_VTKVIEWER_VIEW_ROTATE" ) ),
1926                            tr( "MNU_ROTATE_VIEW" ), 0, this);
1927   anAction->setStatusTip(tr("DSC_ROTATE_VIEW"));
1928   connect(anAction, SIGNAL(activated()), this, SLOT(activateRotation()));
1929   mgr->registerAction( anAction, RotationId );
1930
1931   // Projections
1932   anAction = new QtxAction(tr("MNU_FRONT_VIEW"), 
1933                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_VTKVIEWER_VIEW_FRONT" ) ),
1934                            tr( "MNU_FRONT_VIEW" ), 0, this, false, "Viewers:Front view");
1935   anAction->setStatusTip(tr("DSC_FRONT_VIEW"));
1936   connect(anAction, SIGNAL(activated()), this, SLOT(onFrontView()));
1937   this->addAction(anAction);
1938   mgr->registerAction( anAction, FrontId );
1939
1940   anAction = new QtxAction(tr("MNU_BACK_VIEW"), 
1941                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_VTKVIEWER_VIEW_BACK" ) ),
1942                            tr( "MNU_BACK_VIEW" ), 0, this, false, "Viewers:Back view");
1943   anAction->setStatusTip(tr("DSC_BACK_VIEW"));
1944   connect(anAction, SIGNAL(activated()), this, SLOT(onBackView()));
1945   this->addAction(anAction);
1946   mgr->registerAction( anAction, BackId );
1947
1948   anAction = new QtxAction(tr("MNU_TOP_VIEW"), 
1949                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_VTKVIEWER_VIEW_TOP" ) ),
1950                            tr( "MNU_TOP_VIEW" ), 0, this, false, "Viewers:Top view");
1951   anAction->setStatusTip(tr("DSC_TOP_VIEW"));
1952   connect(anAction, SIGNAL(activated()), this, SLOT(onTopView()));
1953   this->addAction(anAction);
1954   mgr->registerAction( anAction, TopId );
1955
1956   anAction = new QtxAction(tr("MNU_BOTTOM_VIEW"), 
1957                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_VTKVIEWER_VIEW_BOTTOM" ) ),
1958                            tr( "MNU_BOTTOM_VIEW" ), 0, this, false, "Viewers:Bottom view");
1959   anAction->setStatusTip(tr("DSC_BOTTOM_VIEW"));
1960   connect(anAction, SIGNAL(activated()), this, SLOT(onBottomView()));
1961   this->addAction(anAction);
1962   mgr->registerAction( anAction, BottomId );
1963
1964   anAction = new QtxAction(tr("MNU_LEFT_VIEW"), 
1965                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_VTKVIEWER_VIEW_LEFT" ) ),
1966                            tr( "MNU_LEFT_VIEW" ), 0, this, false, "Viewers:Left view");
1967   anAction->setStatusTip(tr("DSC_LEFT_VIEW"));
1968   connect(anAction, SIGNAL(activated()), this, SLOT(onLeftView()));
1969   this->addAction(anAction);
1970   mgr->registerAction( anAction, LeftId );
1971
1972   anAction = new QtxAction(tr("MNU_RIGHT_VIEW"), 
1973                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_VTKVIEWER_VIEW_RIGHT" ) ),
1974                            tr( "MNU_RIGHT_VIEW" ), 0, this, false, "Viewers:Right view");
1975   anAction->setStatusTip(tr("DSC_RIGHT_VIEW"));
1976   connect(anAction, SIGNAL(activated()), this, SLOT(onRightView()));
1977   this->addAction(anAction);
1978   mgr->registerAction( anAction, RightId );
1979
1980   // rotate anticlockwise
1981   anAction = new QtxAction(tr("MNU_ANTICLOCKWISE_VIEW"),
1982                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_VTKVIEWER_VIEW_ANTICLOCKWISE" ) ),
1983                            tr( "MNU_ANTICLOCKWISE_VIEW" ), 0, this, false, "Viewers:Rotate anticlockwise");
1984   anAction->setStatusTip(tr("DSC_ANTICLOCKWISE_VIEW"));
1985   connect(anAction, SIGNAL(triggered()), this, SLOT(onAntiClockWiseView()));
1986   this->addAction(anAction);
1987   mgr->registerAction( anAction, AntiClockWiseId );
1988
1989   // rotate clockwise
1990   anAction = new QtxAction(tr("MNU_CLOCKWISE_VIEW"),
1991                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_VTKVIEWER_VIEW_CLOCKWISE" ) ),
1992                            tr( "MNU_CLOCKWISE_VIEW" ), 0, this, false, "Viewers:Rotate clockwise");
1993   anAction->setStatusTip(tr("DSC_CLOCKWISE_VIEW"));
1994   connect(anAction, SIGNAL(triggered()), this, SLOT(onClockWiseView()));
1995   this->addAction(anAction);
1996   mgr->registerAction( anAction, ClockWiseId );
1997
1998   // Reset
1999   anAction = new QtxAction(tr("MNU_RESET_VIEW"), 
2000                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_VTKVIEWER_VIEW_RESET" ) ),
2001                            tr( "MNU_RESET_VIEW" ), 0, this, false, "Viewers:Reset view");
2002   anAction->setStatusTip(tr("DSC_RESET_VIEW"));
2003   connect(anAction, SIGNAL(activated()), this, SLOT(onResetView()));
2004   this->addAction(anAction);
2005   mgr->registerAction( anAction, ResetId );
2006
2007   // onViewTrihedron: Shows - Hides Trihedron
2008   anAction = new QtxAction(tr("MNU_SHOW_TRIHEDRON"), 
2009                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_VTKVIEWER_VIEW_TRIHEDRON" ) ),
2010                            tr( "MNU_SHOW_TRIHEDRON" ), 0, this);
2011   anAction->setStatusTip(tr("DSC_SHOW_TRIHEDRON"));
2012   connect(anAction, SIGNAL(activated()), this, SLOT(onViewTrihedron()));
2013   mgr->registerAction( anAction, ViewTrihedronId );
2014
2015   // onNonIsometric: Manage non-isometric params
2016   anAction = new QtxAction(tr("MNU_SVTK_SCALING"), 
2017                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_SVTK_SCALING" ) ),
2018                            tr( "MNU_SVTK_SCALING" ), 0, this);
2019   anAction->setStatusTip(tr("DSC_SVTK_SCALING"));
2020   anAction->setCheckable(true);
2021   connect(anAction, SIGNAL(toggled(bool)), this, SLOT(onNonIsometric(bool)));
2022   mgr->registerAction( anAction, NonIsometric );
2023
2024   // onGraduatedAxes: Manage graduated axes params
2025   anAction = new QtxAction(tr("MNU_SVTK_GRADUATED_AXES"), 
2026                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_SVTK_GRADUATED_AXES" ) ),
2027                            tr( "MNU_SVTK_GRADUATED_AXES" ), 0, this);
2028   anAction->setStatusTip(tr("DSC_SVTK_GRADUATED_AXES"));
2029   anAction->setCheckable(true);
2030   connect(anAction, SIGNAL(toggled(bool)), this, SLOT(onGraduatedAxes(bool)));
2031   mgr->registerAction( anAction, GraduatedAxes );
2032
2033   // onGraduatedAxes: Manage graduated axes params
2034   anAction = new QtxAction(tr("MNU_SVTK_UPDATE_RATE"), 
2035                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_SVTK_UPDATE_RATE" ) ),
2036                            tr( "MNU_SVTK_UPDATE_RATE" ), 0, this);
2037   anAction->setStatusTip(tr("DSC_SVTK_UPDATE_RATE"));
2038   anAction->setCheckable(true);
2039   connect(anAction, SIGNAL(toggled(bool)), this, SLOT(onUpdateRate(bool)));
2040   mgr->registerAction( anAction, UpdateRate );
2041
2042   // Set perspective mode group
2043   anAction = new QtxAction(tr("MNU_SVTK_PARALLEL_MODE"), 
2044                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_SVTK_VIEW_PARALLEL" ) ),
2045                            tr( "MNU_SVTK_PARALLEL_MODE" ), 0, this);
2046   anAction->setStatusTip(tr("DSC_SVTK_PARALLEL_MODE"));
2047   anAction->setCheckable(true);
2048   connect(anAction, SIGNAL(toggled(bool)), this, SLOT(onPerspectiveMode()));
2049   mgr->registerAction( anAction, ParallelModeId );
2050
2051   anAction = new QtxAction(tr("MNU_SVTK_PERSPECTIVE_MODE"), 
2052                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_SVTK_VIEW_PERSPECTIVE" ) ),
2053                            tr( "MNU_SVTK_PERSPECTIVE_MODE" ), 0, this);
2054   anAction->setStatusTip(tr("DSC_SVTK_PERSPECTIVE_MODE"));
2055   anAction->setCheckable(true);
2056   connect(anAction, SIGNAL(toggled(bool)), this, SLOT(onPerspectiveMode()));
2057   mgr->registerAction( anAction, ProjectionModeId );
2058
2059   QActionGroup* aPerspectiveGroup = new QActionGroup( this );
2060   aPerspectiveGroup->addAction( mgr->action( ParallelModeId ) );
2061   aPerspectiveGroup->addAction( mgr->action( ProjectionModeId ) );
2062
2063   // View Parameters
2064   anAction = new QtxAction(tr("MNU_VIEWPARAMETERS_VIEW"), 
2065                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_SVTK_VIEW_PARAMETERS" ) ),
2066                            tr( "MNU_VIEWPARAMETERS_VIEW" ), 0, this);
2067   anAction->setStatusTip(tr("DSC_VIEWPARAMETERS_VIEW"));
2068   anAction->setCheckable(true);
2069   connect(anAction, SIGNAL(toggled(bool)), this, SLOT(onViewParameters(bool)));
2070   mgr->registerAction( anAction, ViewParametersId );
2071
2072   // Synchronize View 
2073   mgr->registerAction( synchronizeAction(), SynchronizeId );
2074
2075   // Switch between interaction styles
2076   anAction = new QtxAction(tr("MNU_SVTK_STYLE_SWITCH"), 
2077                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_SVTK_STYLE_SWITCH" ) ),
2078                            tr( "MNU_SVTK_STYLE_SWITCH" ), 0, this);
2079   anAction->setStatusTip(tr("DSC_SVTK_STYLE_SWITCH"));
2080   anAction->setCheckable(true);
2081   connect(anAction, SIGNAL(toggled(bool)), this, SLOT(onSwitchInteractionStyle(bool)));
2082   mgr->registerAction( anAction, SwitchInteractionStyleId );
2083
2084   // Switch between zooming styles
2085   anAction = new QtxAction(tr("MNU_SVTK_ZOOMING_STYLE_SWITCH"), 
2086                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_SVTK_ZOOMING_STYLE_SWITCH" ) ),
2087                            tr( "MNU_SVTK_ZOOMING_STYLE_SWITCH" ), 0, this);
2088   anAction->setStatusTip(tr("DSC_SVTK_ZOOMING_STYLE_SWITCH"));
2089   anAction->setCheckable(true);
2090   connect(anAction, SIGNAL(toggled(bool)), this, SLOT(onSwitchZoomingStyle(bool)));
2091   mgr->registerAction( anAction, SwitchZoomingStyleId );
2092
2093   // Turn on/off dynamic pre-selection
2094   anAction = new QtxAction(tr("MNU_SVTK_DYNAMIC_PRESLECTION_SWITCH"), 
2095                            theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_SVTK_DYNAMIC_PRESLECTION_SWITCH" ) ),
2096                            tr( "MNU_SVTK_DYNAMIC_PRESLECTION_SWITCH" ), 0, this);
2097   anAction->setStatusTip(tr("DSC_SVTK_DYNAMIC_PRESLECTION_SWITCH"));
2098   anAction->setCheckable(true);
2099   connect(anAction, SIGNAL(toggled(bool)), this, SLOT(onSwitchDynamicPreSelection(bool)));
2100   mgr->registerAction( anAction, SwitchDynamicPreselectionId );
2101
2102   // Start recording
2103   myStartAction = new QtxAction(tr("MNU_SVTK_RECORDING_START"), 
2104                                 theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_SVTK_RECORDING_START" ) ),
2105                                 tr( "MNU_SVTK_RECORDING_START" ), 0, this);
2106   myStartAction->setStatusTip(tr("DSC_SVTK_RECORDING_START"));
2107   connect( myStartAction, SIGNAL( triggered ( bool ) ), this, SLOT( onStartRecording() ) );
2108   mgr->registerAction( myStartAction, StartRecordingId );
2109
2110   // Play recording
2111   myPlayAction = new QtxAction(tr("MNU_SVTK_RECORDING_PLAY"), 
2112                                theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_SVTK_RECORDING_PLAY" ) ),
2113                                tr( "MNU_SVTK_RECORDING_PLAY" ), 0, this);
2114   myPlayAction->setStatusTip(tr("DSC_SVTK_RECORDING_PLAY"));
2115   myPlayAction->setEnabled( false );
2116   connect( myPlayAction, SIGNAL( triggered ( bool ) ), this, SLOT( onPlayRecording() ) );
2117   mgr->registerAction( myPlayAction, PlayRecordingId );
2118
2119   // Pause recording
2120   myPauseAction = new QtxAction(tr("MNU_SVTK_RECORDING_PAUSE"), 
2121                                 theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_SVTK_RECORDING_PAUSE" ) ),
2122                                 tr( "MNU_SVTK_RECORDING_PAUSE" ), 0, this);
2123   myPauseAction->setStatusTip(tr("DSC_SVTK_RECORDING_PAUSE"));
2124   myPauseAction->setEnabled( false );
2125   connect( myPauseAction, SIGNAL( triggered ( bool ) ), this, SLOT( onPauseRecording() ) );
2126   mgr->registerAction( myPauseAction, PauseRecordingId );
2127
2128   // Stop recording
2129   myStopAction = new QtxAction(tr("MNU_SVTK_RECORDING_STOP"), 
2130                                theResourceMgr->loadPixmap( "VTKViewer", tr( "ICON_SVTK_RECORDING_STOP" ) ),
2131                                tr( "MNU_SVTK_RECORDING_STOP" ), 0, this);
2132   myStopAction->setStatusTip(tr("DSC_SVTK_RECORDING_STOP"));
2133   myStopAction->setEnabled( false );
2134   connect( myStopAction, SIGNAL( triggered ( bool ) ), this, SLOT( onStopRecording() ) );
2135   mgr->registerAction( myStopAction, StopRecordingId );
2136 }
2137
2138 /*!
2139   Creates toolbar of svtk main window
2140 */
2141 void SVTK_ViewWindow::createToolBar()
2142 {
2143   QtxActionToolMgr* mgr = toolMgr();
2144   
2145   mgr->append( DumpId, myToolBar );
2146   mgr->append( SwitchInteractionStyleId, myToolBar );
2147   mgr->append( SwitchZoomingStyleId, myToolBar );
2148   mgr->append( SwitchDynamicPreselectionId, myToolBar );
2149   mgr->append( ViewTrihedronId, myToolBar );
2150
2151   QtxMultiAction* aScaleAction = new QtxMultiAction( this );
2152   aScaleAction->insertAction( getAction( FitAllId ) );
2153   aScaleAction->insertAction( getAction( FitRectId ) );
2154   aScaleAction->insertAction( getAction( ZoomId ) );
2155   mgr->append( aScaleAction, myToolBar );
2156
2157   QtxMultiAction* aPanningAction = new QtxMultiAction( this );
2158   aPanningAction->insertAction( getAction( PanId ) );
2159   aPanningAction->insertAction( getAction( GlobalPanId ) );
2160   mgr->append( aPanningAction, myToolBar );
2161
2162   mgr->append( ChangeRotationPointId, myToolBar );
2163
2164   mgr->append( RotationId, myToolBar );
2165
2166   QtxMultiAction* aViewsAction = new QtxMultiAction( this );
2167   aViewsAction->insertAction( getAction( FrontId ) );
2168   aViewsAction->insertAction( getAction( BackId ) );
2169   aViewsAction->insertAction( getAction( TopId ) );
2170   aViewsAction->insertAction( getAction( BottomId ) );
2171   aViewsAction->insertAction( getAction( LeftId ) );
2172   aViewsAction->insertAction( getAction( RightId ) );
2173   mgr->append( aViewsAction, myToolBar );
2174
2175   mgr->append( AntiClockWiseId, myToolBar );
2176   mgr->append( ClockWiseId, myToolBar );
2177
2178   mgr->append( ResetId, myToolBar );
2179
2180   mgr->append( UpdateRate, myToolBar );
2181   mgr->append( NonIsometric, myToolBar );
2182   mgr->append( GraduatedAxes, myToolBar );
2183
2184   mgr->append( ViewParametersId, myToolBar );
2185   mgr->append( SynchronizeId, myToolBar );
2186
2187   mgr->append( toolMgr()->separator(), myToolBar );
2188
2189   mgr->append( ParallelModeId, myToolBar );
2190   mgr->append( ProjectionModeId, myToolBar );
2191
2192   mgr->append( StartRecordingId, myRecordingToolBar );
2193   mgr->append( PlayRecordingId, myRecordingToolBar );
2194   mgr->append( PauseRecordingId, myRecordingToolBar );
2195   mgr->append( StopRecordingId, myRecordingToolBar );
2196 }
2197
2198 void SVTK_ViewWindow::onUpdateRate(bool theIsActivate)
2199 {
2200   if(theIsActivate){
2201     myUpdateRateDlg->Update();
2202     myUpdateRateDlg->show();
2203   }else
2204     myUpdateRateDlg->hide();
2205 }
2206
2207 void SVTK_ViewWindow::onNonIsometric(bool theIsActivate)
2208 {
2209   if(theIsActivate){
2210     myNonIsometricDlg->Update();
2211     myNonIsometricDlg->show();
2212   }else
2213     myNonIsometricDlg->hide();
2214 }
2215
2216 void SVTK_ViewWindow::onGraduatedAxes(bool theIsActivate)
2217 {
2218   if(theIsActivate){
2219     myCubeAxesDlg->Update();
2220     myCubeAxesDlg->show();
2221   }else
2222     myCubeAxesDlg->hide();
2223 }
2224
2225 /*!
2226   Starts rotation transformation
2227 */
2228 void SVTK_ViewWindow::activateRotation()
2229 {
2230   myEventDispatcher->InvokeEvent(SVTK::StartRotate,0);
2231 }
2232
2233
2234 /*!
2235   Starts panning transformation
2236 */
2237 void SVTK_ViewWindow::activatePanning()
2238 {
2239   myEventDispatcher->InvokeEvent(SVTK::StartPan,0);
2240 }
2241
2242 /*!
2243   Starts zoom transformation
2244 */
2245 void SVTK_ViewWindow::activateZoom()
2246 {
2247   myEventDispatcher->InvokeEvent(SVTK::StartZoom,0);
2248 }
2249
2250 /*!
2251   Starts window fit transformation
2252 */
2253 void SVTK_ViewWindow::activateWindowFit()
2254 {
2255   myEventDispatcher->InvokeEvent(SVTK::StartFitArea,0);
2256 }
2257
2258 /*!
2259   Starts global panning transformation
2260 */
2261 void SVTK_ViewWindow::activateGlobalPanning()
2262 {
2263   myEventDispatcher->InvokeEvent(SVTK::StartGlobalPan,0);
2264 }
2265
2266 void SVTK_ViewWindow::onStartRecording()
2267 {
2268   myRecorder->CheckExistAVIMaker();
2269   if (myRecorder->ErrorStatus()) {
2270     SUIT_MessageBox::warning(this, tr("ERROR"), tr("MSG_NO_AVI_MAKER") );
2271   }
2272   else {
2273     SVTK_RecorderDlg* aRecorderDlg = new SVTK_RecorderDlg( this, myRecorder );
2274
2275     if( !aRecorderDlg->exec() )
2276       return;
2277
2278     myStartAction->setEnabled( false );
2279     myPlayAction->setEnabled( false );
2280     myPauseAction->setEnabled( true );
2281     myStopAction->setEnabled( true );
2282
2283     // to prevent resizing the window while recording
2284     myPreRecordingMinSize = minimumSize();
2285     myPreRecordingMaxSize = maximumSize();
2286     setFixedSize( size() );
2287
2288     myRecorder->Record();
2289   }
2290 }
2291
2292 void SVTK_ViewWindow::onPlayRecording()
2293 {
2294   myStartAction->setEnabled( false );
2295   myPlayAction->setEnabled( false );
2296   myPauseAction->setEnabled( true );
2297   myStopAction->setEnabled( true );
2298
2299   myRecorder->Pause();
2300 }
2301
2302 void SVTK_ViewWindow::onPauseRecording()
2303 {
2304   myStartAction->setEnabled( false );
2305   myPlayAction->setEnabled( true );
2306   myPauseAction->setEnabled( false );
2307   myStopAction->setEnabled( true );
2308
2309   myRecorder->Pause();
2310 }
2311
2312 void SVTK_ViewWindow::onStopRecording()
2313 {
2314   myStartAction->setEnabled( true );
2315   myPlayAction->setEnabled( false );
2316   myPauseAction->setEnabled( false );
2317   myStopAction->setEnabled( false );
2318
2319   myRecorder->Stop();
2320
2321   setMinimumSize( myPreRecordingMinSize );
2322   setMaximumSize( myPreRecordingMaxSize );
2323 }
2324
2325 /*!
2326   To invoke a VTK event on SVTK_RenderWindowInteractor instance
2327 */
2328 void SVTK_ViewWindow::InvokeEvent(unsigned long theEvent, void* theCallData)
2329 {
2330   GetInteractor()->InvokeEvent(theEvent,theCallData);
2331 }
2332
2333 /*!
2334   Modify view parameters
2335 */
2336 void SVTK_ViewWindow::onViewParameters(bool theIsActivate)
2337 {
2338   if(theIsActivate){
2339     myViewParameterDlg->addObserver();
2340     myViewParameterDlg->show();
2341   }else
2342     myViewParameterDlg->hide();
2343 }
2344
2345 /*!
2346   Custom show event handler
2347 */
2348 void SVTK_ViewWindow::showEvent( QShowEvent * theEvent ) 
2349 {
2350   emit Show( theEvent );
2351 }
2352
2353 /*!
2354   Custom hide event handler
2355 */
2356 void SVTK_ViewWindow::hideEvent( QHideEvent * theEvent ) 
2357 {
2358   emit Hide( theEvent );
2359 }
2360
2361 /*!
2362   Emit transformed signal.
2363 */
2364 void SVTK_ViewWindow::emitTransformed() {
2365   transformed(this);
2366 }
2367
2368 /*!
2369   Processes events
2370 */
2371 void SVTK_ViewWindow::ProcessEvents(vtkObject* vtkNotUsed(theObject),
2372                                     unsigned long theEvent,
2373                                     void* theClientData,
2374                                     void* theCallData)
2375 {
2376   SVTK_ViewWindow* self = reinterpret_cast<SVTK_ViewWindow*>(theClientData);
2377   if(self)
2378     self->emitTransformed();
2379 }
2380
2381 /*!
2382   Get camera properties for the SVTK view window.
2383   \return shared pointer on camera properties.
2384 */
2385 SUIT_CameraProperties SVTK_ViewWindow::cameraProperties()
2386 {
2387   SUIT_CameraProperties aProps;
2388
2389   // get vtk camera
2390   vtkCamera* aCamera = getRenderer()->GetActiveCamera();
2391   if ( !aCamera )
2392     return aProps;
2393   
2394   aProps.setDimension( SUIT_CameraProperties::Dim3D );
2395   if ( toolMgr()->action( ParallelModeId ) ) {
2396     if ( toolMgr()->action( ParallelModeId )->isChecked() )
2397       aProps.setProjection( SUIT_CameraProperties::PrjOrthogonal );
2398     else
2399       aProps.setProjection( SUIT_CameraProperties::PrjPerspective );
2400   }
2401
2402   double aFocalPoint[3];
2403   double aPosition[3];
2404   double aViewUp[3];
2405   double anAxialScale[3];
2406
2407   aCamera->OrthogonalizeViewUp();
2408   aCamera->GetFocalPoint(aFocalPoint);
2409   aCamera->GetPosition(aPosition);
2410   aCamera->GetViewUp(aViewUp);
2411   
2412   aProps.setFocalPoint(aFocalPoint[0], aFocalPoint[1], aFocalPoint[2]);
2413   aProps.setPosition(aPosition[0], aPosition[1], aPosition[2]);
2414   aProps.setViewUp(aViewUp[0], aViewUp[1], aViewUp[2]);
2415   aProps.setMappingScale(aCamera->GetParallelScale());
2416
2417   if (aProps.getProjection() == SUIT_CameraProperties::PrjPerspective)
2418   {
2419     aProps.setViewAngle(aCamera->GetViewAngle());
2420   }
2421
2422   GetRenderer()->GetScale(anAxialScale);
2423   aProps.setAxialScale(anAxialScale[0], anAxialScale[1], anAxialScale[2]);
2424   
2425   return aProps;
2426 }
2427
2428 /*!
2429   Synchronize views.
2430   This implementation synchronizes camera propreties.
2431 */
2432 void SVTK_ViewWindow::synchronize( SUIT_ViewWindow* theView )
2433 {
2434   bool blocked = blockSignals( true );
2435
2436   SUIT_CameraProperties aProps = theView->cameraProperties();
2437   if ( !cameraProperties().isCompatible( aProps ) ) {
2438     // other view, this one is being currently synchronized to, seems has become incompatible
2439     // we have to break synchronization
2440     updateSyncViews();
2441     return;
2442   }
2443
2444   // get camera
2445   vtkCamera* aCamera = getRenderer()->GetActiveCamera();
2446   
2447   double aFocalPoint[3];
2448   double aPosition[3];
2449   double aViewUp[3];
2450   double anAxialScale[3];
2451
2452   // get common properties
2453   aProps.getViewUp(aViewUp[0], aViewUp[1], aViewUp[2]);
2454   aProps.getPosition(aPosition[0], aPosition[1], aPosition[2]);
2455   aProps.getFocalPoint(aFocalPoint[0], aFocalPoint[1], aFocalPoint[2]);
2456   aProps.getAxialScale(anAxialScale[0], anAxialScale[1], anAxialScale[2]);
2457   
2458   // restore properties to the camera
2459   aCamera->SetViewUp(aViewUp);
2460   aCamera->SetPosition(aPosition);
2461   aCamera->SetFocalPoint(aFocalPoint);
2462   aCamera->SetParallelScale(aProps.getMappingScale());
2463
2464   if (aProps.getProjection() == SUIT_CameraProperties::PrjPerspective)
2465   {
2466     aCamera->SetViewAngle(aProps.getViewAngle());
2467   }
2468
2469   GetRenderer()->SetScale(anAxialScale);
2470
2471   getRenderer()->ResetCameraClippingRange();
2472   Repaint(false);
2473
2474   blockSignals( blocked );
2475 }