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 #include "Plot2d_ViewModel.h"
  54
  55 #include "SalomeApp_Application.h"
  56 #include "SalomeApp_Study.h"
  57
  58 #include <QtxWorkstack.h>
  59
  60 #include <qworkspace.h>
  61
  62 #include <vtkCamera.h>
  63 #include <vtkRenderer.h>
  64
  65 using namespace std;
  66
  67 #ifdef _DEBUG_
  68 static int MYDEBUG = 0;
  69 #else
  70 static int MYDEBUG = 0;
  71 #endif
  72
  73 namespace VISU {
  74
  75   typedef TVoidMemFunEvent<SUIT_ViewWindow> TFrameActionEvent;
  76
  77   struct TNewViewEvent: public SALOME_Event
  78   {
  79     SalomeApp_Application* myApplication;
  80     typedef QWidget* TResult;
  81     TResult myResult;
  82
  83     TNewViewEvent (SalomeApp_Application* theApplication):
  84       myApplication(theApplication),
  85       myResult(NULL)
  86     {}
  87
  88     virtual
  89     void
  90     Execute()
  91     {
  92       if (STD_MDIDesktop* aDesktop = dynamic_cast<STD_MDIDesktop*>(myApplication->desktop())) {
  93         myResult = aDesktop->workspace();
  94       }
  95     }
  96   };
  97
  98   View_i::
  99   View_i (SalomeApp_Application *theApplication,
 100           SUIT_ViewManager* theViewManager):
 101     myApplication(theApplication),
 102     myWorkspace(NULL),
 103     myViewManager(theViewManager)
 104   {
 105     if(MYDEBUG) MESSAGE("View_i::View_i - "<<this);
 106     myWorkspace = ProcessEvent(new TNewViewEvent(theApplication));
 107   }
 108
 109   View_i::
 110   ~View_i()
 111   {
 112     if(MYDEBUG) MESSAGE("View_i::~View_i - "<<this);
 113   }
 114
 115
 116   struct TApplicationEvent: public SALOME_Event
 117   {
 118     SalomeApp_Application* myApplication;
 119
 120     TApplicationEvent(SalomeApp_Application* theApplication):
 121       myApplication(theApplication)
 122     {}
 123   };
 124
 125   void
 126   View_i::
 127   ShowPart (VISU::View::ViewRepresentation theViewRepresentation,
 128             CORBA::Boolean theState)
 129   {
 130     struct TEvent: public TApplicationEvent
 131     {
 132       VISU::View::ViewRepresentation myViewRepresentation;
 133       CORBA::Boolean myState;
 134
 135       TEvent(SalomeApp_Application* theApplication,
 136              VISU::View::ViewRepresentation theViewRepresentation,
 137              CORBA::Boolean theState):
 138         TApplicationEvent(theApplication),
 139         myViewRepresentation(theViewRepresentation),
 140         myState(theState)
 141       {}
 142
 143       virtual
 144       void
 145       Execute()
 146       {
 147         switch(myViewRepresentation){
 148         case VISU::View::OBJECTBROWSER:
 149           myApplication->setWindowShown(SalomeApp_Application::WT_ObjectBrowser,myState);
 150           break;
 151         case VISU::View::PYTHON:
 152           myApplication->setWindowShown(SalomeApp_Application::WT_PyConsole,myState);
 153           break;
 154         case VISU::View::MESSAGES:
 155           myApplication->setWindowShown(SalomeApp_Application::WT_LogWindow,myState);
 156           break;
 157         case VISU::View::VIEWER:{
 158           ViewManagerList aViewManagerList = myApplication->viewManagers();
 159           // to do something
 160           // ...
 161           break;
 162         }}
 163       }
 164     };
 165
 166     ProcessVoidEvent(new TEvent(myApplication,theViewRepresentation,theState));
 167   }
 168
 169   struct TPartShownEvent: public TApplicationEvent
 170   {
 171     VISU::View::ViewRepresentation myViewRepresentation;
 172     typedef bool TResult;
 173     TResult myResult;
 174
 175     TPartShownEvent(SalomeApp_Application* theApplication,
 176                     VISU::View::ViewRepresentation theViewRepresentation):
 177       TApplicationEvent(theApplication),
 178       myViewRepresentation(theViewRepresentation),
 179       myResult(false)
 180     {}
 181
 182     virtual
 183     void
 184     Execute()
 185     {
 186       switch(myViewRepresentation){
 187       case VISU::View::OBJECTBROWSER:
 188         myResult = myApplication->isWindowVisible(SalomeApp_Application::WT_ObjectBrowser);
 189         break;
 190       case VISU::View::PYTHON:
 191         myResult = myApplication->isWindowVisible(SalomeApp_Application::WT_PyConsole);
 192         break;
 193       case VISU::View::MESSAGES:
 194         myResult = myApplication->isWindowVisible(SalomeApp_Application::WT_LogWindow);
 195         break;
 196       case VISU::View::VIEWER:{
 197         ViewManagerList aViewManagerList = myApplication->viewManagers();
 198         // to do something
 199         // ...
 200         break;
 201       }}
 202     }
 203   };
 204
 205   CORBA::Boolean
 206   View_i::
 207   IsPartShown (VISU::View::ViewRepresentation theViewRepresentation)
 208   {
 209     return ProcessEvent(new TPartShownEvent(myApplication,theViewRepresentation));
 210   }
 211
 212   // Begin: New methods for view parameters management
 213   struct TSplitEvent: public SALOME_Event
 214   {
 215     SalomeApp_Application * myApplication;
 216     SUIT_ViewWindow       * myViewWindow;
 217     Qt::Orientation         myOrientation;
 218     QtxWorkstack::SplitType mySplitType;
 219
 220   public:
 221     TSplitEvent (SalomeApp_Application * theApplication,
 222                  SUIT_ViewWindow       * theViewWindow,
 223                  Qt::Orientation         theOrientation,
 224                  QtxWorkstack::SplitType theSplitType):
 225       myApplication(theApplication),
 226       myViewWindow(theViewWindow),
 227       myOrientation(theOrientation),
 228       mySplitType(theSplitType)
 229     {}
 230
 231     virtual void Execute()
 232     {
 233       SUIT_Desktop* desk = myApplication->desktop();
 234       STD_TabDesktop* tabDesk = dynamic_cast<STD_TabDesktop*>(desk);
 235       if (tabDesk) {
 236         QtxWorkstack* workstack = tabDesk->workstack();
 237         if (workstack) {
 238           workstack->Split(myViewWindow, myOrientation, mySplitType);
 239         }
 240       }
 241     }
 242   };
 243
 244   void
 245   View_i::
 246   SplitRight()
 247   {
 248     ProcessVoidEvent(new TSplitEvent(myApplication,myViewWindow,
 249                                      Qt::Horizontal,QtxWorkstack::SPLIT_MOVE));
 250   }
 251
 252   void
 253   View_i::
 254   SplitLeft()
 255   {
 256     ProcessVoidEvent(new TSplitEvent(myApplication,myViewWindow,
 257                                      Qt::Horizontal,QtxWorkstack::SPLIT_STAY));
 258   }
 259
 260   void
 261   View_i::
 262   SplitBottom()
 263   {
 264     ProcessVoidEvent(new TSplitEvent(myApplication,myViewWindow,
 265                                      Qt::Vertical,QtxWorkstack::SPLIT_MOVE));
 266   }
 267
 268   void
 269   View_i::
 270   SplitTop()
 271   {
 272     ProcessVoidEvent(new TSplitEvent(myApplication,myViewWindow,
 273                                      Qt::Vertical,QtxWorkstack::SPLIT_STAY));
 274   }
 275
 276   void
 277   View_i::
 278   OnTop()
 279   {
 280     struct TOnTopEvent: public SALOME_Event
 281     {
 282       SUIT_ViewWindow * myViewWindow;
 283
 284     public:
 285       TOnTopEvent (SUIT_ViewWindow * theViewWindow):
 286         myViewWindow(theViewWindow)
 287       {}
 288
 289       virtual void Execute()
 290       {
 291         if (myViewWindow) {
 292           myViewWindow->setFocus();
 293         }
 294       }
 295     };
 296
 297     ProcessVoidEvent(new TOnTopEvent(myViewWindow));
 298   }
 299
 300   struct TAttractEvent: public SALOME_Event
 301   {
 302     SalomeApp_Application * myApplication;
 303     SUIT_ViewWindow       * myViewWindow1;
 304     SUIT_ViewWindow       * myViewWindow2;
 305     bool                    myAttractAll;
 306
 307   public:
 308     TAttractEvent (SalomeApp_Application * theApplication,
 309                    SUIT_ViewWindow       * theViewWindow1,
 310                    SUIT_ViewWindow       * theViewWindow2,
 311                    bool                    theAttractAll):
 312       myApplication(theApplication),
 313       myViewWindow1(theViewWindow1),
 314       myViewWindow2(theViewWindow2),
 315       myAttractAll(theAttractAll)
 316     {}
 317
 318     virtual void Execute()
 319     {
 320       SUIT_Desktop* desk = myApplication->desktop();
 321       STD_TabDesktop* tabDesk = dynamic_cast<STD_TabDesktop*>(desk);
 322       if (tabDesk) {
 323         QtxWorkstack* workstack = tabDesk->workstack();
 324         if (workstack) {
 325           workstack->Attract(myViewWindow1, myViewWindow2, myAttractAll);
 326         }
 327       }
 328     }
 329   };
 330
 331   void
 332   View_i::
 333   Attract (VISU::View_ptr theView)
 334   {
 335     if (!CORBA::is_nil(theView)) {
 336       if (VISU::View_i* pView = dynamic_cast<VISU::View_i*>(VISU::GetServant(theView).in())) {
 337         ProcessVoidEvent(new TAttractEvent(myApplication,myViewWindow,pView->myViewWindow,false));
 338       }
 339     }
 340   }
 341
 342   void
 343   View_i::
 344   AttractAll (VISU::View_ptr theView)
 345   {
 346     if (!CORBA::is_nil(theView)) {
 347       if (VISU::View_i* pView = dynamic_cast<VISU::View_i*>(VISU::GetServant(theView).in())) {
 348         ProcessVoidEvent(new TAttractEvent(myApplication,myViewWindow,pView->myViewWindow,true));
 349       }
 350     }
 351   }
 352
 353   struct TSizePositionEvent: public SALOME_Event
 354   {
 355     SalomeApp_Application * myApplication;
 356     SUIT_ViewWindow       * myViewWindow;
 357     double                  myValue;
 358     bool                    myIsSize;
 359
 360   public:
 361     TSizePositionEvent (SalomeApp_Application * theApplication,
 362                         SUIT_ViewWindow       * theViewWindow,
 363                         double                  theValue,
 364                         bool                    theIsSize):
 365       myApplication(theApplication),
 366       myViewWindow(theViewWindow),
 367       myValue(theValue),
 368       myIsSize(theIsSize)
 369     {}
 370
 371     virtual void Execute()
 372     {
 373       MESSAGE("TSizePositionEvent::Execute()");
 374       SUIT_Desktop* desk = myApplication->desktop();
 375       STD_TabDesktop* tabDesk = dynamic_cast<STD_TabDesktop*>(desk);
 376       if (tabDesk) {
 377         QtxWorkstack* workstack = tabDesk->workstack();
 378         if (workstack) {
 379           if (myIsSize) {
 380             //jfa to do:workstack->SetRelativeSizeInSplitter(myViewWindow, myValue);
 381           } else {
 382             workstack->SetRelativePositionInSplitter(myViewWindow, myValue);
 383           }
 384         }
 385       }
 386     }
 387   };
 388
 389   void
 390   View_i::
 391   SetRelativePositionInSplitter (CORBA::Double thePosition)
 392   {
 393     if (thePosition < 0.0 || 1.0 < thePosition) {
 394       return;
 395     }
 396     ProcessVoidEvent(new TSizePositionEvent(myApplication,myViewWindow,thePosition,false));
 397   }
 398
 399   void
 400   View_i::
 401   SetRelativeSizeInSplitter (CORBA::Double theSize)
 402   {
 403     if (theSize < 0.0 || 1.0 < theSize) {
 404       return;
 405     }
 406     ProcessVoidEvent(new TSizePositionEvent(myApplication,myViewWindow,theSize,true));
 407   }
 408
 409   struct TWSSizePositionEvent: public SALOME_Event
 410   {
 411     SalomeApp_Application * myApplication;
 412     SUIT_ViewWindow       * myViewWindow;
 413     Qt::Orientation         myOrientation;
 414     double                  myValue;
 415     bool                    myIsSize;
 416
 417   public:
 418     TWSSizePositionEvent (SalomeApp_Application * theApplication,
 419                           SUIT_ViewWindow       * theViewWindow,
 420                           Qt::Orientation         theOrientation,
 421                           double                  theValue,
 422                           bool                    theIsSize):
 423       myApplication(theApplication),
 424       myViewWindow(theViewWindow),
 425       myOrientation(theOrientation),
 426       myValue(theValue),
 427       myIsSize(theIsSize)
 428     {}
 429
 430     virtual void Execute()
 431     {
 432       MESSAGE("TWSSizePositionEvent::Execute()");
 433       SUIT_Desktop* desk = myApplication->desktop();
 434       STD_TabDesktop* tabDesk = dynamic_cast<STD_TabDesktop*>(desk);
 435       if (tabDesk) {
 436         QtxWorkstack* workstack = tabDesk->workstack();
 437         if (workstack) {
 438           if (myIsSize) {
 439             //jfa to do:workstack->SetRelativeSize(myViewWindow, myOrientation, myValue);
 440           } else {
 441             workstack->SetRelativePosition(myViewWindow, myOrientation, myValue);
 442           }
 443         }
 444       }
 445     }
 446   };
 447
 448   void
 449   View_i::
 450   SetRelativePositionX (CORBA::Double thePosition)
 451   {
 452     if (thePosition < 0.0 || 1.0 < thePosition) {
 453       return;
 454     }
 455     ProcessVoidEvent(new TWSSizePositionEvent(myApplication,myViewWindow,
 456                                               Qt::Horizontal,thePosition,false));
 457   }
 458
 459   void
 460   View_i::
 461   SetRelativePositionY (CORBA::Double thePosition)
 462   {
 463     if (thePosition < 0.0 || 1.0 < thePosition) {
 464       return;
 465     }
 466     ProcessVoidEvent(new TWSSizePositionEvent(myApplication,myViewWindow,
 467                                               Qt::Vertical,thePosition,false));
 468   }
 469
 470   void
 471   View_i::
 472   SetRelativeSizeX (CORBA::Double theSize)
 473   {
 474     if (theSize < 0.0 || 1.0 < theSize) {
 475       return;
 476     }
 477     ProcessVoidEvent(new TWSSizePositionEvent(myApplication,myViewWindow,
 478                                               Qt::Horizontal,theSize,true));
 479   }
 480
 481   void
 482   View_i::
 483   SetRelativeSizeY (CORBA::Double theSize)
 484   {
 485     if (theSize < 0.0 || 1.0 < theSize) {
 486       return;
 487     }
 488     ProcessVoidEvent(new TWSSizePositionEvent(myApplication,myViewWindow,
 489                                               Qt::Vertical,theSize,true));
 490   }
 491   // End: New methods for view parameters management
 492
 493   // Begin: Old methods for view parameters management, they don't work now
 494   struct TSetViewSize: public SALOME_Event
 495   {
 496     SUIT_ViewWindow* myViewWindow;
 497     typedef void (QRect::* TAction)(int);
 498     TAction myAction;
 499     CORBA::Long mySize;
 500
 501   public:
 502     TSetViewSize(SUIT_ViewWindow* theViewWindow,
 503                  TAction theAction,
 504                  CORBA::Long theSize):
 505       myViewWindow(theViewWindow),
 506       myAction(theAction),
 507       mySize(theSize)
 508     {}
 509
 510     virtual
 511     void
 512     Execute()
 513     {
 514       if (QWidget* aParent = myViewWindow->parentWidget(true)) {
 515         QRect aQRect = aParent->frameGeometry();
 516         (aQRect.*myAction)(mySize);
 517         aParent->setGeometry(aQRect);
 518       }
 519     }
 520   };
 521
 522   void
 523   View_i::
 524   SetViewWidth(CORBA::Long theWidth)
 525   {
 526     ProcessVoidEvent(new TSetViewSize(myViewWindow,&QRect::setWidth,theWidth));
 527   }
 528
 529   void
 530   View_i::
 531   SetViewHeight(CORBA::Long theHeight)
 532   {
 533     ProcessVoidEvent(new TSetViewSize(myViewWindow,&QRect::setHeight,theHeight));
 534   }
 535
 536
 537   struct TGetViewSize: public SALOME_Event
 538   {
 539     SUIT_ViewWindow* myViewWindow;
 540
 541     typedef int (QRect::* TAction)() const;
 542     TAction myAction;
 543
 544     typedef CORBA::Long TResult;
 545     TResult myResult;
 546
 547   public:
 548     TGetViewSize(SUIT_ViewWindow* theViewWindow,
 549                  TAction theAction):
 550       myViewWindow(theViewWindow),
 551       myAction(theAction)
 552     {}
 553
 554     virtual
 555     void
 556     Execute()
 557     {
 558       if(QWidget* aParent = myViewWindow->parentWidget(true)){
 559         QRect aQRect = aParent->frameGeometry();
 560         myResult = (aQRect.*myAction)();
 561       }
 562     }
 563   };
 564
 565
 566   CORBA::Long
 567   View_i::
 568   GetViewWidth()
 569   {
 570     return ProcessEvent(new TGetViewSize(myViewWindow,&QRect::width));
 571   }
 572
 573   CORBA::Long
 574   View_i::
 575   GetViewHeight()
 576   {
 577     return ProcessEvent(new TGetViewSize(myViewWindow,&QRect::height));
 578   }
 579
 580
 581   class TWorkspaceEvent: public SALOME_Event
 582   {
 583   protected:
 584     QWidget* myViewWindow;
 585     QWidget* myWorkspace;
 586
 587   public:
 588     TWorkspaceEvent(QWidget* theViewWindow,
 589                     QWidget* theWorkspace):
 590       myViewWindow(theViewWindow),
 591       myWorkspace(theWorkspace)
 592     {}
 593   };
 594
 595
 596   class TAlignEvent: public TWorkspaceEvent
 597   {
 598   protected:
 599     Qt::AlignmentFlags myAligment;
 600
 601   public:
 602     TAlignEvent(QWidget* theViewWindow,
 603                 QWidget* theWorkspace,
 604                 Qt::AlignmentFlags theAligment):
 605       TWorkspaceEvent(theViewWindow,theWorkspace),
 606       myAligment(theAligment)
 607     {}
 608
 609     virtual
 610     void
 611     Execute()
 612     {
 613       if(QWidget* aParent = myViewWindow->parentWidget(true))
 614         SUIT_Tools::alignWidget(aParent,myWorkspace,myAligment);
 615     }
 616   };
 617
 618
 619   void
 620   View_i::
 621   SetViewPositionHorizontal (VISU::View::ViewPosition theViewPosition)
 622   {
 623     if (myWorkspace) {
 624       switch (theViewPosition) {
 625       case VISU::View::LEFT:
 626         ProcessVoidEvent(new TAlignEvent(myViewWindow,myWorkspace,Qt::AlignLeft));
 627         break;
 628       case VISU::View::CENTER:
 629         ProcessVoidEvent(new TAlignEvent(myViewWindow,myWorkspace,Qt::AlignHCenter));
 630         break;
 631       case VISU::View::RIGHT:
 632         ProcessVoidEvent(new TAlignEvent(myViewWindow,myWorkspace,Qt::AlignRight));
 633         break;
 634       }
 635     }
 636   }
 637
 638
 639   void
 640   View_i::
 641   SetViewPositionVertical (VISU::View::ViewPosition theViewPosition)
 642   {
 643     if (myWorkspace) {
 644       switch (theViewPosition) {
 645       case VISU::View::TOP:
 646         ProcessVoidEvent(new TAlignEvent(myViewWindow,myWorkspace,Qt::AlignTop));
 647         break;
 648       case VISU::View::CENTER:
 649         ProcessVoidEvent(new TAlignEvent(myViewWindow,myWorkspace,Qt::AlignVCenter));
 650         break;
 651       case VISU::View::BOTTOM:
 652         ProcessVoidEvent(new TAlignEvent(myViewWindow,myWorkspace,Qt::AlignBottom));
 653         break;
 654       }
 655     }
 656   }
 657
 658
 659   class TXYEvent: public TWorkspaceEvent
 660   {
 661   protected:
 662     CORBA::Double myX, myY;
 663
 664   public:
 665     TXYEvent(QWidget* theViewWindow,
 666              QWidget* theWorkspace,
 667              CORBA::Double theX,
 668              CORBA::Double theY):
 669       TWorkspaceEvent(theViewWindow,theWorkspace),
 670       myX(theX),
 671       myY(theY)
 672     {}
 673   };
 674
 675
 676   void
 677   View_i::
 678   SetRelativePosition (CORBA::Double theX, CORBA::Double theY)
 679   {
 680     struct TEvent: public TXYEvent
 681     {
 682     public:
 683       TEvent(QWidget* theViewWindow,
 684              QWidget* theWorkspace,
 685              CORBA::Double theX,
 686              CORBA::Double theY):
 687         TXYEvent(theViewWindow,theWorkspace,theX,theY)
 688       {}
 689
 690       virtual
 691       void
 692       Execute()
 693       {
 694         if(QWidget* aParent = myViewWindow->parentWidget(true))
 695           aParent->move(int(myX*myWorkspace->width()),int(myY*myWorkspace->height()));
 696       }
 697     };
 698
 699     if (myWorkspace)
 700       ProcessVoidEvent(new TEvent(myViewWindow,myWorkspace,theX,theY));
 701   }
 702
 703   void
 704   View_i::
 705   SetRelativeSize (CORBA::Double theX, CORBA::Double theY)
 706   {
 707     struct TEvent: public TXYEvent
 708     {
 709     public:
 710       TEvent(QWidget* theViewWindow,
 711              QWidget* theWorkspace,
 712              CORBA::Double theX,
 713              CORBA::Double theY):
 714         TXYEvent(theViewWindow,theWorkspace,theX,theY)
 715       {}
 716
 717       virtual
 718       void
 719       Execute()
 720       {
 721         if(QWidget* aParent = myViewWindow->parentWidget(true))
 722           aParent->setGeometry(aParent->x(),
 723                                aParent->y(),
 724                                int(myX*myWorkspace->width()),
 725                                int(myY*myWorkspace->height()));
 726       }
 727     };
 728
 729     if (myWorkspace)
 730       ProcessVoidEvent(new TEvent(myViewWindow,myWorkspace,theX,theY));
 731   }
 732   // End: Old methods for view parameters management, they don't work now
 733
 734   void
 735   View_i::
 736   SetBackground (const SALOMEDS::Color& theColor)
 737   {
 738     struct TEvent: public SALOME_Event
 739     {
 740       QWidget* myWidget;
 741       SALOMEDS::Color myColor;
 742     public:
 743       TEvent(QWidget* theWidget,
 744              const SALOMEDS::Color& theColor):
 745         myWidget(theWidget),
 746         myColor(theColor)
 747       {}
 748       virtual void Execute(){
 749         int aColor[3];
 750         aColor[0] = int(255.0*myColor.R);
 751         aColor[1] = int(255.0*myColor.G);
 752         aColor[2] = int(255.0*myColor.B);
 753         myWidget->setBackgroundColor(QColor(aColor[0],aColor[1],aColor[2]));
 754       }
 755     };
 756
 757     ProcessVoidEvent(new TEvent(myViewWindow,theColor));
 758   }
 759
 760
 761   struct TBackgroundEvent: public SALOME_Event
 762   {
 763     QWidget* myWidget;
 764     typedef SALOMEDS::Color TResult;
 765     TResult myResult;
 766
 767     TBackgroundEvent(QWidget* theWidget):
 768       myWidget(theWidget)
 769     {}
 770
 771     virtual
 772     void
 773     Execute()
 774     {
 775       const QColor& aColor = myWidget->backgroundColor();
 776       myResult.R = aColor.red()/255.0;
 777       myResult.G = aColor.green()/255.0;
 778       myResult.B = aColor.blue()/255.0;
 779     }
 780   };
 781
 782   SALOMEDS::Color
 783   View_i::
 784   GetBackground()
 785   {
 786     return ProcessEvent(new TBackgroundEvent(myViewWindow));
 787   }
 788
 789   void
 790   View_i::
 791   Minimize()
 792   {
 793     ProcessVoidEvent(new TFrameActionEvent(myViewWindow,&SUIT_ViewWindow::showMinimized));
 794   }
 795
 796   void
 797   View_i::
 798   Restore()
 799   {
 800     ProcessVoidEvent(new TFrameActionEvent(myViewWindow,&SUIT_ViewWindow::showNormal));
 801   }
 802
 803   void
 804   View_i::
 805   Maximize()
 806   {
 807     ProcessVoidEvent(new TFrameActionEvent(myViewWindow,&SUIT_ViewWindow::showMaximized));
 808   }
 809
 810   void
 811   View_i::
 812   EraseAll()
 813   {}
 814
 815   void
 816   View_i::
 817   DisplayAll()
 818   {}
 819
 820   void
 821   View_i::
 822   Erase (PrsObject_ptr thePrsObj)
 823   {}
 824
 825   void
 826   View_i::
 827   Display (PrsObject_ptr thePrsObj)
 828   {}
 829
 830   void
 831   View_i::
 832   DisplayOnly (PrsObject_ptr thePrsObj)
 833   {}
 834
 835   void
 836   View_i::
 837   Update()
 838   {}
 839
 840   class TSavePictureEvent: public SALOME_Event
 841   {
 842     SUIT_ViewWindow * myViewWindow;
 843     const char      * myFileName;
 844   public:
 845     typedef CORBA::Boolean TResult;
 846     TResult myResult;
 847     TSavePictureEvent (SUIT_ViewWindow * theViewWindow, const char * theFileName)
 848       : myViewWindow(theViewWindow),
 849         myFileName(theFileName),
 850         myResult(false)
 851     {
 852     }
 853
 854     virtual void Execute()
 855     {
 856       if (myViewWindow) {
 857         QImage img = myViewWindow->dumpView();
 858         if (!img.isNull()) {
 859           QString fileName (myFileName);
 860           if (!fileName.isEmpty()) {
 861             QString fmt = SUIT_Tools::extension(fileName).upper();
 862             if (fmt.isEmpty()) fmt = QString("BMP"); // default format
 863             if (fmt == "JPG" ) fmt = "JPEG";
 864             //QApplication::setOverrideCursor(Qt::waitCursor);
 865             img.save(fileName, fmt.latin1());
 866             //QApplication::restoreOverrideCursor();
 867           }
 868         }
 869       }
 870     }
 871   };
 872
 873   CORBA::Boolean
 874   View_i::SavePicture(const char* theFileName)
 875   {
 876     return ProcessEvent(new TSavePictureEvent (myViewWindow,theFileName));
 877   }
 878
 879   const char*
 880   View_i::
 881   GetComment() const
 882   {
 883     return "";
 884   }
 885
 886   void
 887   View_i::
 888   ToStream (std::ostringstream& theStr)
 889   {
 890   }
 891
 892
 893   //================= OLD CODE ===================
 894
 895   //QAD_Study* CheckStudy (SALOMEDS::Study_ptr theStudy)
 896   //{
 897   //  //QAD_Desktop* aDesktop = QAD_Application::getDesktop();
 898   //  //QAD_Study* aStudy = aDesktop->findStudy(theStudy);
 899   //  if (!aStudy) {
 900   //    CORBA::String_var aName = theStudy->Name();
 901   //    aFileInfo.setFile(aName.in());
 902   //    if (aFileInfo.exists())
 903   //      aStudy = aDesktop->loadStudy(aFileInfo.baseName());
 904   //    else
 905   //      aStudy = aDesktop->loadStudy(aName.in());
 906   //    if (!aStudy) {
 907   //      MESSAGE("CheckStudy()::ERROR: Can't load study");
 908   //    }
 909   //  }
 910   //  return aStudy;
 911   //}
 912
 913   template<class TViewer>
 914   struct TNewSpecViewEvent: public SALOME_Event
 915   {
 916     SalomeApp_Application* myApplication;
 917
 918     typedef SUIT_ViewManager* TResult;
 919     TResult myResult;
 920
 921     TNewSpecViewEvent (SalomeApp_Application* theApplication):
 922       myApplication(theApplication),
 923       myResult(NULL)
 924     {}
 925
 926     virtual
 927     void
 928     Execute()
 929     {
 930       myResult = myApplication->getViewManager(TViewer::Type(), false);
 931       if (!myResult) {
 932         myResult = myApplication->getViewManager(TViewer::Type(), true);
 933         myResult->closeAllViews();
 934       }
 935     }
 936   };
 937
 938   //===========================================================================
 939   XYPlot_i::XYPlot_i (SalomeApp_Application* theApplication)
 940     : View_i(theApplication, NULL)
 941   {
 942     if (MYDEBUG) MESSAGE("XYPlot_i::XYPlot_i");
 943     if (theApplication) {
 944       myViewManager = ProcessEvent(new TNewSpecViewEvent<Plot2d_Viewer>(theApplication));
 945     }
 946   }
 947
 948
 949   struct TCreatePlot2dViewEvent: public SALOME_Event
 950   {
 951     SUIT_ViewManager* myViewManager;
 952     XYPlot_i        * myPlot2dView;
 953     int               myNew;
 954
 955     typedef Plot2d_ViewFrame* TResult;
 956     TResult myResult;
 957
 958     TCreatePlot2dViewEvent (SUIT_ViewManager* theViewManager,
 959                             XYPlot_i        * thePlot2dView,
 960                             const int         theNew):
 961       myViewManager(theViewManager),
 962       myPlot2dView(thePlot2dView),
 963       myNew(theNew),
 964       myResult(NULL)
 965     {}
 966
 967     virtual
 968     void
 969     Execute()
 970     {
 971       if (myNew) {
 972         myPlot2dView->myViewWindow = myViewManager->createViewWindow();
 973       } else {
 974         myPlot2dView->myViewWindow = myViewManager->getActiveView();
 975       }
 976       if (myPlot2dView->myViewWindow) {
 977         Plot2d_ViewWindow* aPlot2dVW = dynamic_cast<Plot2d_ViewWindow*>(myPlot2dView->myViewWindow);
 978         if (aPlot2dVW) {
 979           myResult = aPlot2dVW->getViewFrame();
 980           if (myResult) {
 981             myResult->Repaint();
 982           }
 983         }
 984       }
 985     }
 986   };
 987
 988   Storable* XYPlot_i::Create (int theNew)
 989   {
 990     myView = ProcessEvent(new TCreatePlot2dViewEvent(myViewManager, this, theNew));
 991     return this;
 992   }
 993
 994   void XYPlot_i::Update()
 995   {
 996     ProcessVoidEvent(new TVoidMemFunEvent<Plot2d_ViewFrame>(myView,&Plot2d_ViewFrame::Repaint));
 997   }
 998
 999   void XYPlot_i::Close()
1000   {
1001     //jfa: may be need to be enclosed in SALOME_Event?
1002     myViewWindow->close();
1003   }
1004
1005   XYPlot_i::~XYPlot_i() {
1006     if(MYDEBUG) MESSAGE("XYPlot_i::~XYPlot_i");
1007   }
1008
1009   void XYPlot_i::SetTitle (const char* theTitle)
1010   {
1011     ProcessVoidEvent(new TVoidMemFun1ArgEvent<SUIT_ViewWindow,const QString&,QString>
1012                      (myViewWindow, &SUIT_ViewWindow::setCaption, QString(theTitle)));
1013   }
1014   char* XYPlot_i::GetTitle()
1015   {
1016     //jfa: may be need to be enclosed in SALOME_Event?
1017     return CORBA::string_dup(myViewWindow->caption().latin1());
1018   }
1019
1020   void XYPlot_i::SetSubTitle (const char* theTitle)
1021   {
1022     ProcessVoidEvent(new TVoidMemFun1ArgEvent<Plot2d_ViewFrame,const QString&,QString>
1023                      (myView, &Plot2d_ViewFrame::setTitle, QString(theTitle)));
1024   }
1025
1026   char* XYPlot_i::GetSubTitle()
1027   {
1028     //jfa: may be need to be enclosed in SALOME_Event?
1029     return CORBA::string_dup(myView->getTitle());
1030   }
1031
1032   void XYPlot_i::SetCurveType (VISU::XYPlot::CurveType theType)
1033   {
1034     ProcessVoidEvent(new TVoidMemFun2ArgEvent<Plot2d_ViewFrame,int,bool>
1035                      (myView,&Plot2d_ViewFrame::setCurveType,theType,true));
1036   }
1037
1038   VISU::XYPlot::CurveType XYPlot_i::GetCurveType()
1039   {
1040     //jfa: may be need to be enclosed in SALOME_Event?
1041     return (VISU::XYPlot::CurveType)myView->getCurveType();
1042   }
1043
1044   void XYPlot_i::SetMarkerSize (CORBA::Long theSize)
1045   {
1046     ProcessVoidEvent(new TVoidMemFun2ArgEvent<Plot2d_ViewFrame,int,bool>
1047                      (myView,&Plot2d_ViewFrame::setMarkerSize,theSize,true));
1048   }
1049
1050   CORBA::Long XYPlot_i::GetMarkerSize()
1051   {
1052     //jfa: may be need to be enclosed in SALOME_Event?
1053     return myView->getMarkerSize();
1054   }
1055
1056   class TEnableGridEvent: public SALOME_Event
1057   {
1058   public:
1059     typedef void (Plot2d_ViewFrame::* TFun)(bool, const int, bool, const int, bool);
1060     TEnableGridEvent (Plot2d_ViewFrame* theView, TFun theFun,
1061                       CORBA::Boolean theMajor, CORBA::Long theNumMajor,
1062                       CORBA::Boolean theMinor, CORBA::Long theNumMinor):
1063       myView(theView), myFun(theFun),
1064       myMajor(theMajor), myNumMajor(theNumMajor),
1065       myMinor(theMinor), myNumMinor(theNumMinor)
1066     {}
1067
1068     virtual void Execute()
1069     {
1070       (myView->*myFun)(myMajor,myNumMajor,myMinor,myNumMinor,true);
1071     }
1072   protected:
1073     Plot2d_ViewFrame* myView;
1074     TFun myFun;
1075     CORBA::Boolean myMajor, myNumMajor;
1076     CORBA::Boolean myMinor, myNumMinor;
1077   };
1078
1079   void XYPlot_i::EnableXGrid (CORBA::Boolean theMajor, CORBA::Long theNumMajor,
1080                               CORBA::Boolean theMinor, CORBA::Long theNumMinor)
1081   {
1082     ProcessVoidEvent(new TEnableGridEvent(myView,&Plot2d_ViewFrame::setXGrid,
1083                                           theMajor,theNumMajor,theMinor,theNumMinor));
1084   }
1085   void XYPlot_i::EnableYGrid(CORBA::Boolean theMajor, CORBA::Long theNumMajor,
1086                              CORBA::Boolean theMinor, CORBA::Long theNumMinor)
1087   {
1088     //jfa tmp:ProcessVoidEvent(new TEnableGridEvent(myView,&Plot2d_ViewFrame::setYGrid,
1089     //jfa tmp:                                      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 }