src/OCCViewer/OCCViewer_ViewWindow.cxx

   1 // Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 // File   : OCCViewer_ViewWindow.cxx
  24 // Author :
  25
  26 #include "OCCViewer_ViewWindow.h"
  27 #include "OCCViewer_ViewModel.h"
  28 #include "OCCViewer_ViewPort3d.h"
  29 #include "OCCViewer_ViewManager.h"
  30 #include "OCCViewer_ViewSketcher.h"
  31 #include "OCCViewer_CreateRestoreViewDlg.h"
  32 #include "OCCViewer_ClipPlane.h"
  33 #include "OCCViewer_SetRotationPointDlg.h"
  34 #include "OCCViewer_AxialScaleDlg.h"
  35 #include "OCCViewer_CubeAxesDlg.h"
  36 #include "OCCViewer_ClippingDlg.h"
  37 #include "OCCViewer_RayTracingDlg.h"
  38 #include "OCCViewer_EnvTextureDlg.h"
  39 #include "OCCViewer_LightSourceDlg.h"
  40 #include "OCCViewer_Utilities.h"
  41
  42 #include <SUIT_Desktop.h>
  43 #include <SUIT_Session.h>
  44 #include <SUIT_ViewManager.h>
  45 #include <SUIT_Tools.h>
  46 #include <SUIT_ResourceMgr.h>
  47 #include <SUIT_MessageBox.h>
  48 #include <SUIT_Application.h>
  49
  50 #include <QtxActionToolMgr.h>
  51 #include <QtxMultiAction.h>
  52 #include <QtxRubberBand.h>
  53
  54 #include <Basics_OCCTVersion.hxx>
  55
  56 #include <QPainter>
  57 #include <QTime>
  58 #include <QImage>
  59 #include <QKeyEvent>
  60 #include <QMouseEvent>
  61 #include <QApplication>
  62 #include <QActionGroup>
  63 #include <QMenu>
  64
  65 #include <AIS_ListOfInteractive.hxx>
  66 #include <AIS_ListIteratorOfListOfInteractive.hxx>
  67 #include <AIS_Shape.hxx>
  68
  69 #include <BRep_Tool.hxx>
  70 #include <BRepBndLib.hxx>
  71 #include <BRepGProp.hxx>
  72 #include <GProp_GProps.hxx>
  73 #include <TopoDS.hxx>
  74
  75 #include <Graphic3d_SequenceOfHClipPlane.hxx>
  76 #include <Graphic3d_ClipPlane.hxx>
  77 #include <OpenGl_GraphicDriver.hxx>
  78 #include <OpenGLUtils_FrameBuffer.h>
  79
  80 #include <Graphic3d_MapIteratorOfMapOfStructure.hxx>
  81 #include <Graphic3d_MapOfStructure.hxx>
  82 #include <Graphic3d_Structure.hxx>
  83 #include <Graphic3d_ExportFormat.hxx>
  84 #if OCC_VERSION_LARGE > 0x06090000
  85 #include <Graphic3d_StereoMode.hxx>
  86 #include <Graphic3d_RenderingParams.hxx>
  87 #endif
  88
  89 #if OCC_VERSION_MAJOR < 7
  90   #include <Visual3d_View.hxx>
  91 #endif
  92
  93 #include <V3d_Plane.hxx>
  94 #include <V3d_Light.hxx>
  95
  96 #include <gp_Dir.hxx>
  97 #include <gp_Pln.hxx>
  98 #include <gp_GTrsf.hxx>
  99 #include <TColgp_Array1OfPnt2d.hxx>
 100
 101 #include <Image_PixMap.hxx>
 102
 103 #include <Standard_Version.hxx>
 104
 105 #include "utilities.h"
 106
 107 // // OpenCV includes
 108 // #include <cv.h>
 109 // #include <highgui.h>
 110
 111 static QEvent* l_mbPressEvent = 0;
 112
 113 //#ifdef WIN32
 114 //# include <QWindowsStyle>
 115 //#endif
 116
 117 #include <GL/gl.h>
 118
 119 // To avoid conflict between KeyPress from the X.h (define KeyPress 2)
 120 // and QEvent::KeyPress (qevent.h)
 121 #ifdef KeyPress
 122 #undef KeyPress
 123 #endif
 124
 125 // Enable ray tracing features
 126 #define ENABLE_RAY_TRACING
 127
 128 const char* imageZoomCursor[] = {
 129 "32 32 3 1",
 130 ". c None",
 131 "a c #000000",
 132 "# c #ffffff",
 133 "................................",
 134 "................................",
 135 ".#######........................",
 136 "..aaaaaaa.......................",
 137 "................................",
 138 ".............#####..............",
 139 "...........##.aaaa##............",
 140 "..........#.aa.....a#...........",
 141 ".........#.a.........#..........",
 142 ".........#a..........#a.........",
 143 "........#.a...........#.........",
 144 "........#a............#a........",
 145 "........#a............#a........",
 146 "........#a............#a........",
 147 "........#a............#a........",
 148 ".........#...........#.a........",
 149 ".........#a..........#a.........",
 150 ".........##.........#.a.........",
 151 "........#####.....##.a..........",
 152 ".......###aaa#####.aa...........",
 153 "......###aa...aaaaa.......#.....",
 154 ".....###aa................#a....",
 155 "....###aa.................#a....",
 156 "...###aa...............#######..",
 157 "....#aa.................aa#aaaa.",
 158 ".....a....................#a....",
 159 "..........................#a....",
 160 "...........................a....",
 161 "................................",
 162 "................................",
 163 "................................",
 164 "................................"};
 165
 166 const char* imageRotateCursor[] = {
 167 "32 32 3 1",
 168 ". c None",
 169 "a c #000000",
 170 "# c #ffffff",
 171 "................................",
 172 "................................",
 173 "................................",
 174 "................................",
 175 "........#.......................",
 176 ".......#.a......................",
 177 "......#######...................",
 178 ".......#aaaaa#####..............",
 179 "........#..##.a#aa##........##..",
 180 ".........a#.aa..#..a#.....##.aa.",
 181 ".........#.a.....#...#..##.aa...",
 182 ".........#a.......#..###.aa.....",
 183 "........#.a.......#a..#aa.......",
 184 "........#a.........#..#a........",
 185 "........#a.........#a.#a........",
 186 "........#a.........#a.#a........",
 187 "........#a.........#a.#a........",
 188 ".........#.........#a#.a........",
 189 "........##a........#a#a.........",
 190 "......##.a#.......#.#.a.........",
 191 "....##.aa..##.....##.a..........",
 192 "..##.aa.....a#####.aa...........",
 193 "...aa.........aaa#a.............",
 194 "................#.a.............",
 195 "...............#.a..............",
 196 "..............#.a...............",
 197 "...............a................",
 198 "................................",
 199 "................................",
 200 "................................",
 201 "................................",
 202 "................................"};
 203
 204 const char* imageCrossCursor[] = {
 205   "32 32 3 1",
 206   ". c None",
 207   "a c #000000",
 208   "# c #ffffff",
 209   "................................",
 210   "................................",
 211   "................................",
 212   "................................",
 213   "................................",
 214   "................................",
 215   "................................",
 216   "...............#................",
 217   "...............#a...............",
 218   "...............#a...............",
 219   "...............#a...............",
 220   "...............#a...............",
 221   "...............#a...............",
 222   "...............#a...............",
 223   "...............#a...............",
 224   ".......#################........",
 225   "........aaaaaaa#aaaaaaaaa.......",
 226   "...............#a...............",
 227   "...............#a...............",
 228   "...............#a...............",
 229   "...............#a...............",
 230   "...............#a...............",
 231   "...............#a...............",
 232   "...............#a...............",
 233   "................a...............",
 234   "................................",
 235   "................................",
 236   "................................",
 237   "................................",
 238   "................................",
 239   "................................",
 240   "................................"};
 241
 242
 243 /*!
 244   \brief Constructor
 245   \param theDesktop main window of application
 246   \param theModel OCC 3D viewer
 247 */
 248 OCCViewer_ViewWindow::OCCViewer_ViewWindow( SUIT_Desktop*     theDesktop,
 249                                             OCCViewer_Viewer* theModel )
 250 : SUIT_ViewWindow( theDesktop )
 251 {
 252   myModel = theModel;
 253   myRestoreFlag = 0;
 254   myEnableDrawMode = false;
 255   myDrawRectEnabled = true;
 256   myDrawRect=false;
 257   updateEnabledDrawMode();
 258   myScalingDlg = 0;
 259   mySetRotationPointDlg = 0;
 260   myRectBand = 0;
 261
 262   IsSketcherStyle = false;
 263   myIsKeyFree = false;
 264
 265   mypSketcher = 0;
 266   myCurSketch = -1;
 267   my2dMode = No2dMode;
 268
 269   myInteractionStyle = SUIT_ViewModel::STANDARD;
 270   myPreselectionEnabled = true;
 271   mySelectionEnabled = true;
 272
 273   myCursorIsHand = false;
 274
 275   clearViewAspects();
 276 }
 277
 278 /*!
 279   \brief Destructor.
 280 */
 281 OCCViewer_ViewWindow::~OCCViewer_ViewWindow()
 282 {
 283   endDrawRect();
 284   qDeleteAll( mySketchers );
 285 }
 286
 287 /*!
 288   \brief Internal initialization.
 289 */
 290 void OCCViewer_ViewWindow::initLayout()
 291 {
 292   myViewPort = new OCCViewer_ViewPort3d( this, myModel->getViewer3d(), V3d_ORTHOGRAPHIC );
 293   myViewPort->installEventFilter(this);
 294   setCentralWidget(myViewPort);
 295   myOperation = NOTHING;
 296
 297   myCurrPointType = GRAVITY;
 298   myPrevPointType = GRAVITY;
 299   mySelectedPoint = gp_Pnt(0.,0.,0.);
 300   myRotationPointSelection = false;
 301
 302   setTransformRequested ( NOTHING );
 303   setTransformInProcess ( false );
 304
 305   createActions();
 306   createToolBar();
 307
 308   switch (my2dMode) {
 309   case XYPlane:
 310     onTopView();
 311     break;
 312   case XZPlane:
 313     onLeftView();
 314     break;
 315   case YZPlane:
 316     onFrontView();
 317     break;
 318   }
 319
 320   // Graduated axes dialog
 321   QtxAction* anAction = dynamic_cast<QtxAction*>( toolMgr()->action( GraduatedAxesId ) );
 322   myCubeAxesDlg = new OCCViewer_CubeAxesDlg( anAction, this, "OCCViewer_CubeAxesDlg" );
 323   myCubeAxesDlg->initialize();
 324
 325   connect( myViewPort, SIGNAL( vpTransformed( OCCViewer_ViewPort* ) ), this, SLOT( emitViewModified() ) );
 326 }
 327
 328 OCCViewer_ViewWindow* OCCViewer_ViewWindow::getView( const int mode ) const
 329 {
 330   return mode == get2dMode() ? const_cast<OCCViewer_ViewWindow*>( this ) : 0;
 331 }
 332
 333 /*!
 334   \brief Detect viewer operation according the the mouse button pressed
 335   and key modifiers used.
 336   \param theEvent mouse event
 337   \return type of the operation
 338 */
 339 OCCViewer_ViewWindow::OperationType
 340 OCCViewer_ViewWindow::getButtonState( QMouseEvent* theEvent, int theInteractionStyle )
 341 {
 342   OperationType aOp = NOTHING;
 343   SUIT_ViewModel::InteractionStyle aStyle = (SUIT_ViewModel::InteractionStyle)theInteractionStyle;
 344   if( (theEvent->modifiers() == SUIT_ViewModel::myStateMap[aStyle][SUIT_ViewModel::ZOOM]) &&
 345       (theEvent->buttons() == SUIT_ViewModel::myButtonMap[aStyle][SUIT_ViewModel::ZOOM]) )
 346     aOp = ZOOMVIEW;
 347   else if( (theEvent->modifiers() == SUIT_ViewModel::myStateMap[aStyle][SUIT_ViewModel::PAN]) &&
 348            (theEvent->buttons() == SUIT_ViewModel::myButtonMap[aStyle][SUIT_ViewModel::PAN]) )
 349     aOp = PANVIEW;
 350   else if( (theEvent->modifiers()  == SUIT_ViewModel::myStateMap[aStyle][SUIT_ViewModel::ROTATE]) &&
 351            (theEvent->buttons() == SUIT_ViewModel::myButtonMap[aStyle][SUIT_ViewModel::ROTATE]) &&
 352            (my2dMode == No2dMode))
 353     aOp = ROTATE;
 354
 355   return aOp;
 356 }
 357
 358 /*!
 359   \brief Customize event handling
 360   \param watched event receiver object
 361   \param e event
 362   \return \c true if the event processing should be stopped
 363 */
 364 bool OCCViewer_ViewWindow::eventFilter( QObject* watched, QEvent* e )
 365 {
 366   if ( watched == myViewPort ) {
 367     int aType = e->type();
 368     switch(aType) {
 369     case QEvent::MouseButtonPress:
 370       vpMousePressEvent((QMouseEvent*) e);
 371       return true;
 372
 373     case QEvent::MouseButtonRelease:
 374       vpMouseReleaseEvent((QMouseEvent*) e);
 375       return true;
 376
 377     case QEvent::MouseMove:
 378       vpMouseMoveEvent((QMouseEvent*) e);
 379       return true;
 380
 381     case QEvent::MouseButtonDblClick:
 382       emit mouseDoubleClicked(this, (QMouseEvent*)e);
 383       return true;
 384
 385     case QEvent::Wheel:
 386       {
 387         QWheelEvent* aEvent = (QWheelEvent*) e;
 388
 389         if ( aEvent->modifiers().testFlag(Qt::ControlModifier) ) {
 390           Handle(AIS_InteractiveContext) ic = myModel->getAISContext();
 391           if ( isPreselectionEnabled() && ic->HasOpenedContext() ) {
 392             if ( aEvent->delta() > 0 ) {
 393               ic->HilightNextDetected( myViewPort->getView() );
 394             } else {
 395               ic->HilightPreviousDetected( myViewPort->getView() );
 396             }
 397           }
 398         }
 399         else {
 400           emit vpTransformationStarted ( ZOOMVIEW );
 401           myViewPort->startZoomAtPoint( aEvent->x(), aEvent->y() );
 402           double delta = (double)( aEvent->delta() ) / ( 15 * 8 );
 403           int x  = aEvent->x();
 404           int y  = aEvent->y();
 405           int x1 = (int)( aEvent->x() + width()*delta/100 );
 406           int y1 = (int)( aEvent->y() + height()*delta/100 );
 407           myViewPort->zoom( x, y, x1, y1 );
 408           myViewPort->getView()->ZFitAll();
 409           emit vpTransformationFinished ( ZOOMVIEW );
 410         }
 411       }
 412       return true;
 413
 414     case QEvent::ContextMenu:
 415       {
 416         QContextMenuEvent * aEvent = (QContextMenuEvent*)e;
 417         if ( aEvent->reason() != QContextMenuEvent::Mouse )
 418           emit contextMenuRequested( aEvent );
 419       }
 420       return true;
 421
 422     case QEvent::KeyPress:
 423       emit keyPressed(this, (QKeyEvent*) e);
 424       return true;
 425
 426     default:
 427       break;
 428     }
 429   }
 430   return SUIT_ViewWindow::eventFilter(watched, e);
 431 }
 432
 433 /*!
 434   \brief Enable / disable draw rect (rubber band) mode
 435 */
 436 bool OCCViewer_ViewWindow::enableDrawMode( bool on )
 437 {
 438   bool prev = myDrawRectEnabled;
 439   myDrawRectEnabled = on;
 440   updateEnabledDrawMode();
 441   return prev;
 442 }
 443
 444 /*!
 445   \brief Update state of enable draw mode state.
 446 */
 447 void OCCViewer_ViewWindow::updateEnabledDrawMode()
 448 {
 449   myEnableDrawMode = myDrawRectEnabled;
 450   if ( myModel )
 451     myEnableDrawMode = myEnableDrawMode && myModel->isSelectionEnabled() && myModel->isMultiSelectionEnabled();
 452 }
 453
 454 /*!
 455   \brief Handle mouse press event
 456   \param theEvent mouse event
 457 */
 458 void OCCViewer_ViewWindow::vpMousePressEvent( QMouseEvent* theEvent )
 459 {
 460   myStartX = theEvent->x();
 461   myStartY = theEvent->y();
 462   int anInteractionStyle = interactionStyle();
 463
 464   // in "key free" interaction style zoom operation is activated by two buttons (simultaneously pressed),
 465   // which are assigned for pan and rotate - these operations are activated immediately after pressing
 466   // of the first button, so it is necessary to switch to zoom when the second button is pressed
 467   bool aSwitchToZoom = false;
 468   if ( anInteractionStyle == SUIT_ViewModel::KEY_FREE &&
 469        ( myOperation == PANVIEW || myOperation == ROTATE ) ) {
 470     aSwitchToZoom = getButtonState( theEvent, anInteractionStyle ) == ZOOMVIEW;
 471   }
 472
 473   switch ( myOperation ) {
 474   case WINDOWFIT:
 475     if ( theEvent->button() == Qt::LeftButton )
 476       emit vpTransformationStarted ( WINDOWFIT );
 477     break;
 478
 479   case PANGLOBAL:
 480     if ( theEvent->button() == Qt::LeftButton )
 481       emit vpTransformationStarted ( PANGLOBAL );
 482     break;
 483
 484   case ZOOMVIEW:
 485     if ( theEvent->button() == Qt::LeftButton ) {
 486       myViewPort->startZoomAtPoint( myStartX, myStartY );
 487       emit vpTransformationStarted ( ZOOMVIEW );
 488     }
 489     break;
 490
 491   case PANVIEW:
 492     if ( aSwitchToZoom ) {
 493       myViewPort->startZoomAtPoint( myStartX, myStartY );
 494       activateZoom();
 495     }
 496     else if ( theEvent->button() == Qt::LeftButton )
 497       emit vpTransformationStarted ( PANVIEW );
 498     break;
 499
 500   case ROTATE:
 501     if ( aSwitchToZoom ) {
 502       myViewPort->startZoomAtPoint( myStartX, myStartY );
 503       activateZoom();
 504     }
 505     else if ( theEvent->button() == Qt::LeftButton ) {
 506       myViewPort->startRotation(myStartX, myStartY, myCurrPointType, mySelectedPoint);
 507       emit vpTransformationStarted ( ROTATE );
 508     }
 509     break;
 510
 511   default:
 512   /*  Try to activate a transformation */
 513     OperationType aState;
 514     if ( interactionStyle() == SUIT_ViewModel::STANDARD )
 515       aState = getButtonState(theEvent, anInteractionStyle);
 516     else {
 517       aState = OCCViewer_ViewWindow::NOTHING;
 518       myIsKeyFree = true;
 519     }
 520     switch ( aState ) {
 521     case ZOOMVIEW:
 522       myViewPort->startZoomAtPoint( myStartX, myStartY );
 523       activateZoom();
 524       break;
 525     case PANVIEW:
 526       activatePanning();
 527       break;
 528     case ROTATE:
 529       activateRotation();
 530       myViewPort->startRotation(myStartX, myStartY, myCurrPointType, mySelectedPoint);
 531       break;
 532     default:
 533       if ( myRotationPointSelection )
 534       {
 535         if ( theEvent->button() == Qt::LeftButton )
 536         {
 537           Handle(AIS_InteractiveContext) ic = myModel->getAISContext();
 538           ic->Select();
 539           for ( ic->InitSelected(); ic->MoreSelected(); ic->NextSelected() )
 540           {
 541             TopoDS_Shape aShape = ic->SelectedShape();
 542             GProp_GProps aSystem;
 543             gp_Pnt aPnt;
 544             if ( !aShape.IsNull() && aShape.ShapeType() == TopAbs_VERTEX )
 545             {
 546               aPnt = BRep_Tool::Pnt( TopoDS::Vertex( aShape ) );
 547             }
 548             else if ( !aShape.IsNull() && aShape.ShapeType() == TopAbs_EDGE )
 549             {
 550               BRepGProp::LinearProperties( aShape, aSystem );
 551               aPnt = aSystem.CentreOfMass();
 552             }
 553             else if ( !aShape.IsNull() && aShape.ShapeType() == TopAbs_FACE )
 554             {
 555               BRepGProp::SurfaceProperties( aShape, aSystem );
 556               aPnt = aSystem.CentreOfMass();
 557             }
 558             else if ( !aShape.IsNull() && aShape.ShapeType() == TopAbs_SOLID )
 559             {
 560               BRepGProp::VolumeProperties( aShape, aSystem );
 561               aPnt = aSystem.CentreOfMass();
 562             }
 563             else
 564             {
 565               myCurrPointType = myPrevPointType;
 566               break;
 567             }
 568
 569             if ( mySetRotationPointDlg )
 570             {
 571               myRotationPointSelection = false;
 572               mySetRotationPointDlg->setCoords(aPnt.X(), aPnt.Y(), aPnt.Z());
 573             }
 574           }
 575           if ( ic->NbSelected() == 0 ) myCurrPointType = myPrevPointType;
 576           if ( mySetRotationPointDlg ) mySetRotationPointDlg->toggleChange();
 577           ic->CloseAllContexts();
 578           myOperation = NOTHING;
 579           myViewPort->setCursor( myCursor );
 580           myCursorIsHand = false;
 581           myRotationPointSelection = false;
 582         }
 583       }
 584       else
 585         emit mousePressed(this, theEvent);
 586       break;
 587     }
 588     /* notify that we start a transformation */
 589     if ( transformRequested() )
 590       emit vpTransformationStarted ( myOperation );
 591   }
 592   if ( transformRequested() )
 593     setTransformInProcess( true );
 594
 595   /* we may need it for sketching... */
 596   if ( l_mbPressEvent )
 597     delete l_mbPressEvent;
 598   l_mbPressEvent = new QMouseEvent( *theEvent );
 599 }
 600
 601
 602 /*!
 603   \brief Start zooming operation.
 604
 605   Sets the corresponding cursor for the widget.
 606 */
 607 void OCCViewer_ViewWindow::activateZoom()
 608 {
 609   if ( !transformRequested() && !myCursorIsHand )
 610     saveCursor();                /* save old cursor */
 611
 612   if ( myOperation != ZOOMVIEW ) {
 613     QPixmap zoomPixmap (imageZoomCursor);
 614     QCursor zoomCursor (zoomPixmap);
 615     if( setTransformRequested ( ZOOMVIEW ) )
 616       myViewPort->setCursor( zoomCursor );
 617   }
 618 }
 619
 620
 621 /*!
 622   \brief Start panning operation.
 623
 624   Sets the corresponding cursor for the widget.
 625 */
 626 void OCCViewer_ViewWindow::activatePanning()
 627 {
 628   if ( !transformRequested() && !myCursorIsHand )
 629     saveCursor();                // save old cursor
 630
 631   if ( myOperation != PANVIEW ) {
 632     QCursor panCursor (Qt::SizeAllCursor);
 633     if( setTransformRequested ( PANVIEW ) )
 634       myViewPort->setCursor( panCursor );
 635   }
 636 }
 637
 638 /*!
 639   \brief Start rotation operation
 640
 641   Sets the corresponding cursor for the widget.
 642 */
 643 void OCCViewer_ViewWindow::activateRotation()
 644 {
 645   if ( !transformRequested() && !myCursorIsHand )
 646     saveCursor();                // save old cursor
 647
 648   if ( myOperation != ROTATE ) {
 649     QPixmap rotatePixmap (imageRotateCursor);
 650     QCursor rotCursor (rotatePixmap);
 651     if( setTransformRequested ( ROTATE ) )
 652       myViewPort->setCursor( rotCursor );
 653   }
 654 }
 655
 656 /*!
 657   \brief Compute the gravity center.
 658   \param theX used to return X coordinate of the gravity center
 659   \param theY used to return Y coordinate of the gravity center
 660   \param theZ used to return Z coordinate of the gravity center
 661   \return \c true if the gravity center is computed
 662 */
 663 bool OCCViewer_ViewWindow::computeGravityCenter( double& theX, double& theY, double& theZ )
 664 {
 665   Handle(V3d_View) aView3d = myViewPort->getView();
 666
 667   // Project boundaries points and add to avergae gravity
 668   // the ones which lie within the screen limits
 669   Standard_Real aScreenLimits[4] = { 0.0, 0.0, 0.0, 0.0 };
 670
 671 #if OCC_VERSION_LARGE > 0x06070100
 672   // NDC space screen limits
 673   aScreenLimits[0] = -1.0;
 674   aScreenLimits[1] =  1.0;
 675   aScreenLimits[2] = -1.0;
 676   aScreenLimits[3] =  1.0;
 677 #else
 678   aView3d->View()->ViewMapping().WindowLimit( aScreenLimits[0],
 679                                               aScreenLimits[1],
 680                                               aScreenLimits[2],
 681                                               aScreenLimits[3] );
 682 #endif
 683
 684   Standard_Integer aPointsNb = 0;
 685
 686   Standard_Real aXmin = 0.0;
 687   Standard_Real aYmin = 0.0;
 688   Standard_Real aZmin = 0.0;
 689   Standard_Real aXmax = 0.0;
 690   Standard_Real aYmax = 0.0;
 691   Standard_Real aZmax = 0.0;
 692
 693   Graphic3d_MapOfStructure aSetOfStructures;
 694   aView3d->View()->DisplayedStructures( aSetOfStructures );
 695   Graphic3d_MapIteratorOfMapOfStructure aStructureIt( aSetOfStructures );
 696
 697   for( ; aStructureIt.More(); aStructureIt.Next() ) {
 698     const Handle(Graphic3d_Structure)& aStructure = aStructureIt.Key();
 699     if ( aStructure->IsEmpty() || !aStructure->IsVisible() || aStructure->CStructure()->IsForHighlight )
 700       continue;
 701
 702 #if OCC_VERSION_LARGE > 0x06070100
 703     Bnd_Box aBox = aStructure->MinMaxValues();
 704     aXmin = aBox.IsVoid() ? RealFirst() : aBox.CornerMin().X();
 705     aYmin = aBox.IsVoid() ? RealFirst() : aBox.CornerMin().Y();
 706     aZmin = aBox.IsVoid() ? RealFirst() : aBox.CornerMin().Z();
 707     aXmax = aBox.IsVoid() ? RealLast()  : aBox.CornerMax().X();
 708     aYmax = aBox.IsVoid() ? RealLast()  : aBox.CornerMax().Y();
 709     aZmax = aBox.IsVoid() ? RealLast()  : aBox.CornerMax().Z();
 710 #else
 711     aStructure->MinMaxValues( aXmin, aYmin, aZmin, aXmax, aYmax, aZmax );
 712 #endif
 713
 714     // Infinite structures are skipped
 715     Standard_Real aLIM = ShortRealLast() - 1.0;
 716     if ( Abs( aXmin ) > aLIM || Abs( aYmin ) > aLIM || Abs( aZmin ) > aLIM
 717       || Abs( aXmax ) > aLIM || Abs( aYmax ) > aLIM || Abs( aZmax ) > aLIM ) {
 718       continue;
 719     }
 720
 721     gp_Pnt aPoints[8] = {
 722       gp_Pnt( aXmin, aYmin, aZmin ), gp_Pnt( aXmin, aYmin, aZmax ),
 723       gp_Pnt( aXmin, aYmax, aZmin ), gp_Pnt( aXmin, aYmax, aZmax ),
 724       gp_Pnt( aXmax, aYmin, aZmin ), gp_Pnt( aXmax, aYmin, aZmax ),
 725       gp_Pnt( aXmax, aYmax, aZmin ), gp_Pnt( aXmax, aYmax, aZmax )
 726     };
 727
 728     for ( Standard_Integer aPointIt = 0; aPointIt < 8; ++aPointIt ) {
 729       const gp_Pnt& aBBPoint = aPoints[aPointIt];
 730
 731 #if OCC_VERSION_LARGE > 0x06070100
 732       gp_Pnt aProjected = aView3d->Camera()->Project( aBBPoint );
 733       const Standard_Real& U = aProjected.X();
 734       const Standard_Real& V = aProjected.Y();
 735 #else
 736       Standard_Real U = 0.0;
 737       Standard_Real V = 0.0;
 738       Standard_Real W = 0.0;
 739       aView3d->View()->Projects( aBBPoint.X(), aBBPoint.Y(), aBBPoint.Z(), U, V, W );
 740 #endif
 741
 742       if (U >= aScreenLimits[0]
 743        && U <= aScreenLimits[1]
 744        && V >= aScreenLimits[2]
 745        && V <= aScreenLimits[3])
 746       {
 747         aPointsNb++;
 748         theX += aBBPoint.X();
 749         theY += aBBPoint.Y();
 750         theZ += aBBPoint.Z();
 751       }
 752     }
 753   }
 754
 755   if ( aPointsNb > 0 )
 756   {
 757     theX /= aPointsNb;
 758     theY /= aPointsNb;
 759     theZ /= aPointsNb;
 760   }
 761   return true;
 762 }
 763
 764 /*!
 765   \brief Set the gravity center as a rotation point.
 766 */
 767 void OCCViewer_ViewWindow::activateSetRotationGravity()
 768 {
 769   if ( myRotationPointSelection )
 770   {
 771     Handle(AIS_InteractiveContext) ic = myModel->getAISContext();
 772     ic->CloseAllContexts();
 773     myOperation = NOTHING;
 774     myViewPort->setCursor( myCursor );
 775     myCursorIsHand = false;
 776     myRotationPointSelection = false;
 777   }
 778
 779   myPrevPointType = myCurrPointType;
 780   myCurrPointType = GRAVITY;
 781
 782   Standard_Real Xcenter, Ycenter, Zcenter;
 783   if ( computeGravityCenter( Xcenter, Ycenter, Zcenter ) )
 784     mySetRotationPointDlg->setCoords( Xcenter, Ycenter, Zcenter );
 785 }
 786
 787 /*!
 788   \brief Update gravity center in the "Set Rotation Point" dialog box.
 789   \sa OCCViewer_SetRotationPointDlg class
 790 */
 791 void OCCViewer_ViewWindow::updateGravityCoords()
 792 {
 793   if ( mySetRotationPointDlg && mySetRotationPointDlg->isVisible() && myCurrPointType == GRAVITY )
 794   {
 795     Standard_Real Xcenter, Ycenter, Zcenter;
 796     if ( computeGravityCenter( Xcenter, Ycenter, Zcenter ) )
 797       mySetRotationPointDlg->setCoords( Xcenter, Ycenter, Zcenter );
 798   }
 799 }
 800
 801 /*!
 802   \brief Set the point selected by the user as a rotation point.
 803   \param theX X coordinate of the rotation point
 804   \param theY Y coordinate of the rotation point
 805   \param theZ Z coordinate of the rotation point
 806 */
 807 void OCCViewer_ViewWindow::activateSetRotationSelected( double theX, double theY, double theZ )
 808 {
 809   if ( myRotationPointSelection )
 810   {
 811     Handle(AIS_InteractiveContext) ic = myModel->getAISContext();
 812     ic->CloseAllContexts();
 813     myOperation = NOTHING;
 814     myViewPort->setCursor( myCursor );
 815     myCursorIsHand = false;
 816     myRotationPointSelection = false;
 817   }
 818
 819   myPrevPointType = myCurrPointType;
 820   myCurrPointType = SELECTED;
 821   mySelectedPoint.SetCoord(theX,theY,theZ);
 822 }
 823
 824 /*!
 825   \brief Start the shape selection process.
 826 */
 827 void OCCViewer_ViewWindow::activateStartPointSelection( TopAbs_ShapeEnum theShapeType )
 828 {
 829   myPrevPointType = myCurrPointType;
 830   myCurrPointType = SELECTED;
 831
 832   // activate selection ------>
 833   Handle(AIS_InteractiveContext) ic = myModel->getAISContext();
 834
 835   ic->OpenLocalContext();
 836
 837   AIS_ListOfInteractive aList;
 838   ic->DisplayedObjects( aList );
 839   for ( AIS_ListIteratorOfListOfInteractive it( aList ); it.More(); it.Next() )
 840   {
 841     Handle(AIS_InteractiveObject) anObj = it.Value();
 842     if ( !anObj.IsNull() && anObj->HasPresentation() &&
 843          anObj->IsKind( STANDARD_TYPE(AIS_Shape) ) )
 844     {
 845       ic->Load(anObj,-1);
 846       ic->Activate(anObj,AIS_Shape::SelectionMode(theShapeType));
 847      }
 848   }
 849   // activate selection <------
 850
 851   if ( !myCursorIsHand )
 852   {
 853     QCursor handCursor (Qt::PointingHandCursor);
 854     myCursorIsHand = true;
 855     saveCursor();
 856     myViewPort->setCursor( handCursor );
 857   }
 858   myRotationPointSelection = true;
 859 }
 860
 861 /*!
 862   \brief Start global panning operation
 863
 864   Sets the corresponding cursor for the widget.
 865 */
 866 void OCCViewer_ViewWindow::activateGlobalPanning()
 867 {
 868   Handle(V3d_View) aView3d = myViewPort->getView();
 869   if ( !aView3d.IsNull() ) {
 870     QPixmap globalPanPixmap (imageCrossCursor);
 871     QCursor glPanCursor (globalPanPixmap);
 872     myCurScale = aView3d->Scale();
 873     aView3d->FitAll(0.01, false);
 874     saveCursor();                // save old cursor
 875     myViewPort->fitAll(); // fits view before selecting a new scene center
 876     if( setTransformRequested( PANGLOBAL ) )
 877       myViewPort->setCursor( glPanCursor );
 878   }
 879 }
 880
 881 /*!
 882   \brief Starts fit operation.
 883
 884   Sets the corresponding cursor for the widget.
 885 */
 886 void OCCViewer_ViewWindow::activateWindowFit()
 887 {
 888   if ( !transformRequested() && !myCursorIsHand )
 889     saveCursor();                /* save old cursor */
 890
 891   if ( myOperation != WINDOWFIT ) {
 892     QCursor handCursor (Qt::PointingHandCursor);
 893     if( setTransformRequested ( WINDOWFIT ) )
 894     {
 895       myViewPort->setCursor ( handCursor );
 896       myCursorIsHand = true;
 897     }
 898   }
 899 }
 900
 901 /*!
 902   \brief Start delayed viewer operation.
 903 */
 904 bool OCCViewer_ViewWindow::setTransformRequested( OperationType op )
 905 {
 906   bool ok = transformEnabled( op );
 907   myOperation = ok ? op : NOTHING;
 908   myViewPort->setMouseTracking( myOperation == NOTHING );
 909   return ok;
 910 }
 911
 912 /*!
 913   \brief Handle mouse move event.
 914   \param theEvent mouse event
 915 */
 916 void OCCViewer_ViewWindow::vpMouseMoveEvent( QMouseEvent* theEvent )
 917 {
 918   if ( myIsKeyFree && interactionStyle() == SUIT_ViewModel::KEY_FREE ) {
 919     myIsKeyFree = false;
 920     switch ( getButtonState( theEvent, interactionStyle() ) ) {
 921     case ZOOMVIEW:
 922       myViewPort->startZoomAtPoint( myStartX, myStartY );
 923       activateZoom();
 924       break;
 925     case PANVIEW:
 926       activatePanning();
 927       break;
 928     case ROTATE:
 929       activateRotation();
 930       myViewPort->startRotation(myStartX, myStartY, myCurrPointType, mySelectedPoint);
 931       break;
 932     default:
 933       break;
 934     }
 935   }
 936
 937   myCurrX = theEvent->x();
 938   myCurrY = theEvent->y();
 939   switch (myOperation) {
 940   case ROTATE:
 941     myViewPort->rotate(myCurrX, myCurrY, myCurrPointType, mySelectedPoint);
 942     break;
 943
 944   case ZOOMVIEW:
 945     myViewPort->zoom(myStartX, myStartY, myCurrX, myCurrY);
 946     myStartX = myCurrX;
 947     myStartY = myCurrY;
 948     break;
 949
 950   case PANVIEW:
 951     myViewPort->pan(myCurrX - myStartX, myStartY - myCurrY);
 952     myStartX = myCurrX;
 953     myStartY = myCurrY;
 954     break;
 955
 956 /*    case WINDOWFIT:
 957     myDrawRect = true;
 958     repaint();
 959     break;
 960 */
 961   case PANGLOBAL:
 962     break;
 963
 964   default:
 965     if ( myRotationPointSelection || isSketcherStyle() )
 966     {
 967       emit mouseMoving( this, theEvent );
 968     }
 969     else
 970     {
 971       int aState = theEvent->modifiers();
 972       int aButton = theEvent->buttons();
 973       int anInteractionStyle = interactionStyle();
 974       if ( ( anInteractionStyle == SUIT_ViewModel::STANDARD &&
 975            aButton == Qt::LeftButton && ( aState == Qt::NoModifier || Qt::ShiftModifier ) ) ||
 976          ( anInteractionStyle == SUIT_ViewModel::KEY_FREE &&
 977          aButton == Qt::LeftButton && ( aState == Qt::ControlModifier || aState == ( Qt::ControlModifier|Qt::ShiftModifier ) ) ) ) {
 978         myDrawRect = myEnableDrawMode;
 979         if ( myDrawRect ) {
 980           drawRect();
 981           if ( !myCursorIsHand )        {   // we are going to sketch a rectangle
 982             QCursor handCursor (Qt::PointingHandCursor);
 983             myCursorIsHand = true;
 984             saveCursor();
 985             myViewPort->setCursor( handCursor );
 986           }
 987         }
 988         emit mouseMoving( this, theEvent );
 989       }
 990       else if ( ( anInteractionStyle == SUIT_ViewModel::STANDARD &&
 991                 aButton == Qt::RightButton && ( aState == Qt::NoModifier || Qt::ShiftModifier ) ) ||
 992                 ( anInteractionStyle == SUIT_ViewModel::KEY_FREE &&
 993                 aButton == Qt::RightButton && ( aState == Qt::ControlModifier || aState == ( Qt::ControlModifier|Qt::ShiftModifier ) ) ) ) {
 994         OCCViewer_ViewSketcher* sketcher = 0;
 995         QList<OCCViewer_ViewSketcher*>::Iterator it;
 996         for ( it = mySketchers.begin(); it != mySketchers.end() && !sketcher; ++it )
 997         {
 998           OCCViewer_ViewSketcher* sk = (*it);
 999           if( sk->isDefault() && sk->sketchButton() == aButton )
1000             sketcher = sk;
1001         }
1002         if ( sketcher && myCurSketch == -1 )
1003         {
1004           activateSketching( sketcher->type() );
1005           if ( mypSketcher )
1006           {
1007             myCurSketch = mypSketcher->sketchButton();
1008
1009             if ( l_mbPressEvent )
1010             {
1011               QApplication::sendEvent( getViewPort(), l_mbPressEvent );
1012               delete l_mbPressEvent;
1013               l_mbPressEvent = 0;
1014             }
1015             QApplication::sendEvent( getViewPort(), theEvent );
1016           }
1017         }
1018       }
1019       else
1020         emit mouseMoving( this, theEvent );
1021     }
1022   }
1023 }
1024
1025 /*!
1026   \brief Handle mouse release event.
1027   \param theEvent mouse event
1028 */
1029 void OCCViewer_ViewWindow::vpMouseReleaseEvent(QMouseEvent* theEvent)
1030 {
1031   switch ( myOperation ) {
1032   case NOTHING:
1033     {
1034       int prevState = myCurSketch;
1035       if(theEvent->button() == Qt::RightButton)
1036       {
1037         QList<OCCViewer_ViewSketcher*>::Iterator it;
1038         for ( it = mySketchers.begin(); it != mySketchers.end() && myCurSketch != -1; ++it )
1039         {
1040           OCCViewer_ViewSketcher* sk = (*it);
1041           if( ( sk->sketchButton() & theEvent->button() ) && sk->sketchButton() == myCurSketch )
1042             myCurSketch = -1;
1043         }
1044       }
1045
1046       emit mouseReleased(this, theEvent);
1047       if(theEvent->button() == Qt::RightButton && prevState == -1)
1048       {
1049         QContextMenuEvent aEvent( QContextMenuEvent::Mouse,
1050                                   theEvent->pos(), theEvent->globalPos() );
1051         emit contextMenuRequested( &aEvent );
1052       }
1053     }
1054     break;
1055   case ROTATE:
1056     myViewPort->endRotation();
1057     resetState();
1058     break;
1059
1060   case PANVIEW:
1061   case ZOOMVIEW:
1062     myViewPort->getView()->ZFitAll();
1063     resetState();
1064     break;
1065
1066   case PANGLOBAL:
1067     if ( theEvent->button() == Qt::LeftButton ) {
1068       myViewPort->setCenter( theEvent->x(), theEvent->y() );
1069       myViewPort->getView()->SetScale(myCurScale);
1070       resetState();
1071     }
1072     break;
1073
1074   case WINDOWFIT:
1075     if ( theEvent->button() == Qt::LeftButton ) {
1076       myCurrX = theEvent->x();
1077       myCurrY = theEvent->y();
1078       drawRect();
1079       QRect rect = SUIT_Tools::makeRect(myStartX, myStartY, myCurrX, myCurrY);
1080       if ( !rect.isEmpty() ) myViewPort->fitRect(rect);
1081       endDrawRect();
1082       resetState();
1083     }
1084     break;
1085   }
1086
1087   // NOTE: viewer 3D detects a rectangle of selection using this event
1088   // so we must emit it BEFORE resetting the selection rectangle
1089
1090   if ( theEvent->button() == Qt::LeftButton && myDrawRect ) {
1091     drawRect();
1092     endDrawRect();
1093     resetState();
1094     myViewPort->update();
1095   }
1096
1097   if ( l_mbPressEvent )
1098   {
1099     delete l_mbPressEvent;
1100     l_mbPressEvent = 0;
1101   }
1102 }
1103
1104 /*!
1105   \brief Reset the viewport to its initial state
1106   ( no transformations in process etc. )
1107 */
1108 void OCCViewer_ViewWindow::resetState()
1109 {
1110   myDrawRect = false;
1111
1112   if ( myRotationPointSelection )
1113   {
1114     QCursor handCursor (Qt::PointingHandCursor);
1115     myViewPort->setCursor( handCursor );
1116   }
1117   else
1118   {
1119     if ( transformRequested() || myCursorIsHand )
1120       myViewPort->setCursor( myCursor );
1121     myCursorIsHand = false;
1122   }
1123
1124   if ( transformRequested() )
1125     emit vpTransformationFinished (myOperation);
1126
1127   setTransformInProcess( false );
1128   setTransformRequested( NOTHING );
1129 }
1130
1131
1132 /*!
1133   \brief Draw rubber band rectangle.
1134 */
1135 void OCCViewer_ViewWindow::drawRect()
1136 {
1137   if ( !myRectBand ) {
1138     myRectBand = new QtxRectRubberBand( myViewPort );
1139     //QPalette palette;
1140     //palette.setColor(myRectBand->foregroundRole(), Qt::white);
1141     //myRectBand->setPalette(palette);
1142   }
1143   //myRectBand->hide();
1144
1145   myRectBand->setUpdatesEnabled ( false );
1146   QRect aRect = SUIT_Tools::makeRect(myStartX, myStartY, myCurrX, myCurrY);
1147   myRectBand->initGeometry( aRect );
1148
1149   if ( !myRectBand->isVisible() )
1150     myRectBand->show();
1151
1152   myRectBand->setUpdatesEnabled ( true );
1153   //myRectBand->repaint();
1154
1155   //myRectBand->setVisible( aRect.isValid() );
1156   //if ( myRectBand->isVisible() )
1157   //  myRectBand->repaint();
1158   //else
1159   //  myRectBand->show();
1160   //myRectBand->repaint();
1161 }
1162
1163 /*!
1164   \brief Clear rubber band rectangle on the end on the dragging operation.
1165 */
1166 void OCCViewer_ViewWindow::endDrawRect()
1167 {
1168   //delete myRectBand;
1169   //myRectBand = 0;
1170   if ( myRectBand )
1171     {
1172       myRectBand->clearGeometry();
1173       myRectBand->hide();
1174     }
1175 }
1176
1177 /*!
1178   \brief Create actions.
1179 */
1180 void OCCViewer_ViewWindow::createActions()
1181 {
1182   if( !toolMgr()->isEmpty() )
1183     return;
1184
1185   SUIT_ResourceMgr* aResMgr = SUIT_Session::session()->resourceMgr();
1186   if( !aResMgr )
1187     return;
1188
1189   QtxAction* aAction;
1190
1191   // Dump view
1192   aAction = new QtxAction(tr("MNU_DUMP_VIEW"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_VIEW_DUMP" ) ),
1193                            tr( "MNU_DUMP_VIEW" ), 0, this);
1194   aAction->setStatusTip(tr("DSC_DUMP_VIEW"));
1195   connect(aAction, SIGNAL(triggered()), this, SLOT(onDumpView()));
1196   toolMgr()->registerAction( aAction, DumpId );
1197
1198   // FitAll
1199   aAction = new QtxAction(tr("MNU_FITALL"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_VIEW_FITALL" ) ),
1200                            tr( "MNU_FITALL" ), 0, this);
1201   aAction->setStatusTip(tr("DSC_FITALL"));
1202   connect(aAction, SIGNAL(triggered()), this, SLOT(onFitAll()));
1203   toolMgr()->registerAction( aAction, FitAllId );
1204
1205   // FitRect
1206   aAction = new QtxAction(tr("MNU_FITRECT"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_VIEW_FITAREA" ) ),
1207                            tr( "MNU_FITRECT" ), 0, this);
1208   aAction->setStatusTip(tr("DSC_FITRECT"));
1209   connect(aAction, SIGNAL(triggered()), this, SLOT(activateWindowFit()));
1210   toolMgr()->registerAction( aAction, FitRectId );
1211
1212   // FitSelection
1213   aAction = new QtxAction(tr("MNU_FITSELECTION"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_VIEW_FITSELECTION" ) ),
1214                            tr( "MNU_FITSELECTION" ), 0, this);
1215   aAction->setStatusTip(tr("DSC_FITSELECTION"));
1216   connect(aAction, SIGNAL(triggered()), this, SLOT(onFitSelection()));
1217   toolMgr()->registerAction( aAction, FitSelectionId );
1218
1219   // Zoom
1220   aAction = new QtxAction(tr("MNU_ZOOM_VIEW"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_VIEW_ZOOM" ) ),
1221                            tr( "MNU_ZOOM_VIEW" ), 0, this);
1222   aAction->setStatusTip(tr("DSC_ZOOM_VIEW"));
1223   connect(aAction, SIGNAL(triggered()), this, SLOT(activateZoom()));
1224   toolMgr()->registerAction( aAction, ZoomId );
1225
1226   // Panning
1227   aAction = new QtxAction(tr("MNU_PAN_VIEW"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_VIEW_PAN" ) ),
1228                            tr( "MNU_PAN_VIEW" ), 0, this);
1229   aAction->setStatusTip(tr("DSC_PAN_VIEW"));
1230   connect(aAction, SIGNAL(triggered()), this, SLOT(activatePanning()));
1231   toolMgr()->registerAction( aAction, PanId );
1232
1233   // Global Panning
1234   aAction = new QtxAction(tr("MNU_GLOBALPAN_VIEW"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_VIEW_GLOBALPAN" ) ),
1235                            tr( "MNU_GLOBALPAN_VIEW" ), 0, this);
1236   aAction->setStatusTip(tr("DSC_GLOBALPAN_VIEW"));
1237   connect(aAction, SIGNAL(triggered()), this, SLOT(activateGlobalPanning()));
1238   toolMgr()->registerAction( aAction, GlobalPanId );
1239
1240   // Rotation Point
1241   mySetRotationPointAction = new QtxAction(tr("MNU_CHANGINGROTATIONPOINT_VIEW"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_VIEW_ROTATION_POINT" ) ),
1242                            tr( "MNU_CHANGINGROTATIONPOINT_VIEW" ), 0, this);
1243   mySetRotationPointAction->setStatusTip(tr("DSC_CHANGINGROTATIONPOINT_VIEW"));
1244   mySetRotationPointAction->setCheckable( true );
1245   connect(mySetRotationPointAction, SIGNAL(toggled( bool )), this, SLOT(onSetRotationPoint( bool )));
1246   toolMgr()->registerAction( mySetRotationPointAction, ChangeRotationPointId );
1247
1248   // Rotation
1249   aAction = new QtxAction(tr("MNU_ROTATE_VIEW"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_VIEW_ROTATE" ) ),
1250                            tr( "MNU_ROTATE_VIEW" ), 0, this);
1251   aAction->setStatusTip(tr("DSC_ROTATE_VIEW"));
1252   connect(aAction, SIGNAL(triggered()), this, SLOT(activateRotation()));
1253   toolMgr()->registerAction( aAction, RotationId );
1254
1255   // Projections
1256   aAction = new QtxAction(tr("MNU_FRONT_VIEW"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_VIEW_FRONT" ) ),
1257                            tr( "MNU_FRONT_VIEW" ), 0, this, false, "Viewers:Front view");
1258   aAction->setStatusTip(tr("DSC_FRONT_VIEW"));
1259   connect(aAction, SIGNAL(triggered()), this, SLOT(onFrontView()));
1260   this->addAction(aAction);
1261   toolMgr()->registerAction( aAction, FrontId );
1262
1263   aAction = new QtxAction(tr("MNU_BACK_VIEW"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_VIEW_BACK" ) ),
1264                            tr( "MNU_BACK_VIEW" ), 0, this, false, "Viewers:Back view");
1265   aAction->setStatusTip(tr("DSC_BACK_VIEW"));
1266   connect(aAction, SIGNAL(triggered()), this, SLOT(onBackView()));
1267   this->addAction(aAction);
1268   toolMgr()->registerAction( aAction, BackId );
1269
1270   aAction = new QtxAction(tr("MNU_TOP_VIEW"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_VIEW_TOP" ) ),
1271                            tr( "MNU_TOP_VIEW" ), 0, this, false, "Viewers:Top view");
1272   aAction->setStatusTip(tr("DSC_TOP_VIEW"));
1273   connect(aAction, SIGNAL(triggered()), this, SLOT(onTopView()));
1274   this->addAction(aAction);
1275   toolMgr()->registerAction( aAction, TopId );
1276
1277   aAction = new QtxAction(tr("MNU_BOTTOM_VIEW"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_VIEW_BOTTOM" ) ),
1278                            tr( "MNU_BOTTOM_VIEW" ), 0, this, false, "Viewers:Bottom view");
1279   aAction->setStatusTip(tr("DSC_BOTTOM_VIEW"));
1280   connect(aAction, SIGNAL(triggered()), this, SLOT(onBottomView()));
1281   this->addAction(aAction);
1282   toolMgr()->registerAction( aAction, BottomId );
1283
1284   aAction = new QtxAction(tr("MNU_LEFT_VIEW"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_VIEW_LEFT" ) ),
1285                            tr( "MNU_LEFT_VIEW" ), 0, this, false, "Viewers:Left view");
1286   aAction->setStatusTip(tr("DSC_LEFT_VIEW"));
1287   connect(aAction, SIGNAL(triggered()), this, SLOT(onLeftView()));
1288   this->addAction(aAction);
1289   toolMgr()->registerAction( aAction, LeftId );
1290
1291   aAction = new QtxAction(tr("MNU_RIGHT_VIEW"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_VIEW_RIGHT" ) ),
1292                            tr( "MNU_RIGHT_VIEW" ), 0, this, false, "Viewers:Right view");
1293   aAction->setStatusTip(tr("DSC_RIGHT_VIEW"));
1294   connect(aAction, SIGNAL(triggered()), this, SLOT(onRightView()));
1295   this->addAction(aAction);
1296   toolMgr()->registerAction( aAction, RightId );
1297
1298   // rotate anticlockwise
1299   aAction = new QtxAction(tr("MNU_ANTICLOCKWISE_VIEW"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_VIEW_ANTICLOCKWISE" ) ),
1300                            tr( "MNU_ANTICLOCKWISE_VIEW" ), 0, this, false, "Viewers:Rotate anticlockwise");
1301   aAction->setStatusTip(tr("DSC_ANTICLOCKWISE_VIEW"));
1302   connect(aAction, SIGNAL(triggered()), this, SLOT(onAntiClockWiseView()));
1303   this->addAction(aAction);
1304   toolMgr()->registerAction( aAction, AntiClockWiseId );
1305
1306   // rotate clockwise
1307   aAction = new QtxAction(tr("MNU_CLOCKWISE_VIEW"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_VIEW_CLOCKWISE" ) ),
1308                            tr( "MNU_CLOCKWISE_VIEW" ), 0, this, false, "Viewers:Rotate clockwise");
1309   aAction->setStatusTip(tr("DSC_CLOCKWISE_VIEW"));
1310   connect(aAction, SIGNAL(triggered()), this, SLOT(onClockWiseView()));
1311   this->addAction(aAction);
1312   toolMgr()->registerAction( aAction, ClockWiseId );
1313
1314   // Projection mode group
1315
1316   // - orthographic projection
1317   aAction = new QtxAction(tr("MNU_ORTHOGRAPHIC_MODE"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_ORTHOGRAPHIC" ) ),
1318                           tr( "MNU_ORTHOGRAPHIC_MODE" ), 0, this);
1319   aAction->setStatusTip(tr("DSC_ORTHOGRAPHIC_MODE"));
1320   aAction->setCheckable(true);
1321   toolMgr()->registerAction( aAction, OrthographicId );
1322
1323   // - perspective projection
1324   aAction = new QtxAction(tr("MNU_PERSPECTIVE_MODE"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_PERSPECTIVE" ) ),
1325                           tr( "MNU_PERSPECTIVE_MODE" ), 0, this);
1326   aAction->setStatusTip(tr("DSC_PERSPECTIVE_MODE"));
1327   aAction->setCheckable(true);
1328   toolMgr()->registerAction( aAction, PerspectiveId );
1329 #if OCC_VERSION_LARGE > 0x06090000
1330   // - stereo projection
1331   aAction = new QtxAction(tr("MNU_STEREO_MODE"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_STEREO" ) ),
1332                           tr( "MNU_STEREO_MODE" ), 0, this);
1333   aAction->setStatusTip(tr("DSC_STEREO_MODE"));
1334   aAction->setCheckable(true);
1335   toolMgr()->registerAction( aAction, StereoId );
1336   connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onStereoType(bool)));
1337 #endif
1338   // - add exclusive action group
1339   QActionGroup* aProjectionGroup = new QActionGroup( this );
1340   aProjectionGroup->addAction( toolMgr()->action( OrthographicId ) );
1341   aProjectionGroup->addAction( toolMgr()->action( PerspectiveId ) );
1342   connect(aProjectionGroup, SIGNAL(triggered(QAction*)), this, SLOT(onProjectionType(QAction*)));
1343
1344   // Reset
1345   aAction = new QtxAction(tr("MNU_RESET_VIEW"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_VIEW_RESET" ) ),
1346                            tr( "MNU_RESET_VIEW" ), 0, this, false, "Viewers:Reset view");
1347   aAction->setStatusTip(tr("DSC_RESET_VIEW"));
1348   connect(aAction, SIGNAL(triggered()), this, SLOT(onResetView()));
1349   this->addAction(aAction);
1350   toolMgr()->registerAction( aAction, ResetId );
1351
1352   // Clone
1353   aAction = new QtxAction(tr("MNU_CLONE_VIEW"),
1354                           aResMgr->loadPixmap("OCCViewer", tr("ICON_OCCVIEWER_CLONE_VIEW")),
1355                           tr("MNU_CLONE_VIEW"), 0, this);
1356   aAction->setStatusTip(tr("DSC_CLONE_VIEW"));
1357   connect(aAction, SIGNAL(triggered()), this, SLOT(onCloneView()));
1358   toolMgr()->registerAction( aAction, CloneId );
1359
1360   aAction = new QtxAction (tr("MNU_CLIPPING"), aResMgr->loadPixmap ("OCCViewer", tr("ICON_OCCVIEWER_CLIPPING")),
1361                                       tr("MNU_CLIPPING"), 0, this);
1362   aAction->setStatusTip (tr("DSC_CLIPPING"));
1363   aAction->setCheckable (true);
1364   connect (aAction, SIGNAL (toggled (bool)), this, SLOT (onClipping (bool)));
1365   toolMgr()->registerAction (aAction, ClippingId);
1366
1367   aAction = new QtxAction(tr("MNU_SHOOT_VIEW"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_SHOOT_VIEW" ) ),
1368                            tr( "MNU_SHOOT_VIEW" ), 0, this);
1369   aAction->setStatusTip(tr("DSC_SHOOT_VIEW"));
1370   connect(aAction, SIGNAL(triggered()), this, SLOT(onMemorizeView()));
1371   toolMgr()->registerAction( aAction, MemId );
1372
1373   aAction = new QtxAction(tr("MNU_PRESETS_VIEW"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_PRESETS_VIEW" ) ),
1374                            tr( "MNU_PRESETS_VIEW" ), 0, this);
1375   aAction->setStatusTip(tr("DSC_PRESETS_VIEW"));
1376   connect(aAction, SIGNAL(triggered()), this, SLOT(onRestoreView()));
1377   toolMgr()->registerAction( aAction, RestoreId );
1378
1379   if (myModel->trihedronActivated()) {
1380     aAction = new QtxAction(tr("MNU_SHOW_TRIHEDRE"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_VIEW_TRIHEDRON" ) ),
1381                              tr( "MNU_SHOW_TRIHEDRE" ), 0, this);
1382     aAction->setCheckable( true );
1383     aAction->setChecked( true );
1384     aAction->setStatusTip(tr("DSC_SHOW_TRIHEDRE"));
1385     connect(aAction, SIGNAL(toggled(bool)), this, SLOT(onTrihedronShow(bool)));
1386     toolMgr()->registerAction( aAction, TrihedronShowId );
1387   }
1388
1389   // Scale
1390   aAction = new QtxAction(tr("MNU_SCALING"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_SCALING" ) ),
1391                            tr( "MNU_SCALING" ), 0, this);
1392   aAction->setStatusTip(tr("DSC_SCALING"));
1393   connect(aAction, SIGNAL(triggered()), this, SLOT(onAxialScale()));
1394   toolMgr()->registerAction( aAction, AxialScaleId );
1395
1396   // Enable/disable preselection
1397   aAction = new QtxAction(tr("MNU_ENABLE_PRESELECTION"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_PRESELECTION" ) ),
1398                           tr( "MNU_ENABLE_PRESELECTION" ), 0, this);
1399   aAction->setStatusTip(tr("DSC_ENABLE_PRESELECTION"));
1400   aAction->setCheckable(true);
1401   connect(aAction, SIGNAL(toggled(bool)), this, SLOT(onSwitchPreselection(bool)));
1402   toolMgr()->registerAction( aAction, SwitchPreselectionId );
1403
1404   // Enable/disable selection
1405   aAction = new QtxAction(tr("MNU_ENABLE_SELECTION"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_SELECTION" ) ),
1406                           tr( "MNU_ENABLE_SELECTION" ), 0, this);
1407   aAction->setStatusTip(tr("DSC_ENABLE_SELECTION"));
1408   aAction->setCheckable(true);
1409   connect(aAction, SIGNAL(toggled(bool)), this, SLOT(onSwitchSelection(bool)));
1410   toolMgr()->registerAction( aAction, SwitchSelectionId );
1411
1412   // Graduated axes
1413   aAction = new QtxAction(tr("MNU_GRADUATED_AXES"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_GRADUATED_AXES" ) ),
1414                            tr( "MNU_GRADUATED_AXES" ), 0, this);
1415   aAction->setStatusTip(tr("DSC_GRADUATED_AXES"));
1416   connect(aAction, SIGNAL(triggered()), this, SLOT(onGraduatedAxes()));
1417   toolMgr()->registerAction( aAction, GraduatedAxesId );
1418
1419   // Active only ambient light or not
1420   aAction = new QtxAction(tr("MNU_AMBIENT"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_AMBIENT" ) ),
1421                            tr( "MNU_AMBIENT" ), 0, this);
1422   aAction->setStatusTip(tr("DSC_AMBIENT"));
1423   connect(aAction, SIGNAL(triggered()), this, SLOT(onAmbientToogle()));
1424   toolMgr()->registerAction( aAction, AmbientId );
1425
1426   // Switch between interaction styles
1427   aAction = new QtxAction(tr("MNU_STYLE_SWITCH"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_STYLE_SWITCH" ) ),
1428                           tr( "MNU_STYLE_SWITCH" ), 0, this);
1429   aAction->setStatusTip(tr("DSC_STYLE_SWITCH"));
1430   aAction->setCheckable(true);
1431   connect(aAction, SIGNAL(toggled(bool)), this, SLOT(onSwitchInteractionStyle(bool)));
1432   toolMgr()->registerAction( aAction, SwitchInteractionStyleId );
1433
1434   // Switch between zooming styles
1435   aAction = new QtxAction(tr("MNU_ZOOMING_STYLE_SWITCH"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_ZOOMING_STYLE_SWITCH" ) ),
1436                           tr( "MNU_ZOOMING_STYLE_SWITCH" ), 0, this);
1437   aAction->setStatusTip(tr("DSC_ZOOMING_STYLE_SWITCH"));
1438   aAction->setCheckable(true);
1439   connect(aAction, SIGNAL(toggled(bool)), this, SLOT(onSwitchZoomingStyle(bool)));
1440   toolMgr()->registerAction( aAction, SwitchZoomingStyleId );
1441
1442   // Maximized view
1443   aAction = new QtxAction(tr("MNU_MINIMIZE_VIEW"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_MINIMIZE" ) ),
1444                           tr( "MNU_MINIMIZE_VIEW" ), 0, this );
1445   aAction->setStatusTip(tr("DSC_MINIMIZE_VIEW"));
1446   connect(aAction, SIGNAL(triggered()), this, SLOT(onMaximizedView()));
1447   toolMgr()->registerAction( aAction, MaximizedId );
1448
1449   // Return to 3d view
1450   if (my2dMode!=No2dMode){
1451     aAction = new QtxAction(tr("MNU_RETURN_3D_VIEW"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_RETURN_3D_VIEW" ) ),
1452                             tr( "MNU_RETURN_3D_VIEW" ), 0, this );
1453     aAction->setStatusTip(tr("DSC_RETURN_3D_VIEW"));
1454     connect(aAction, SIGNAL(triggered()), this, SLOT(returnTo3dView()));
1455     toolMgr()->registerAction( aAction, ReturnTo3dViewId );
1456   }
1457
1458   // Synchronize View
1459   toolMgr()->registerAction( synchronizeAction(), SynchronizeId );
1460 #ifdef ENABLE_RAY_TRACING
1461   // Ray tracing
1462   aAction = new QtxAction( tr("MNU_RAY_TRACING"), aResMgr->loadPixmap( "OCCViewer", tr("ICON_OCCVIEWER_RAY_TRACING") ),
1463                            tr("MNU_RAY_TRACING"), 0, this );
1464   aAction->setStatusTip( tr("DSC_RAY_TRACING") );
1465   connect( aAction, SIGNAL( triggered() ), this, SLOT( onRayTracing() ) );
1466   toolMgr()->registerAction( aAction, RayTracingId );
1467
1468   // Environment texture
1469   aAction = new QtxAction( tr("MNU_ENV_TEXTURE"), aResMgr->loadPixmap( "OCCViewer", tr("ICON_OCCVIEWER_ENV_TEXTURE") ),
1470                            tr("MNU_ENV_TEXTURE"), 0, this );
1471   aAction->setStatusTip( tr("DSC_ENV_TEXTURE") );
1472   connect( aAction, SIGNAL( triggered() ), this, SLOT( onEnvTexture() ) );
1473   toolMgr()->registerAction( aAction, EnvTextureId );
1474
1475   // Light source
1476   aAction = new QtxAction( tr("MNU_LIGHT_SOURCE"), aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_LIGHT_SOURCE" ) ),
1477                            tr( "MNU_LIGHT_SOURCE" ), 0, this );
1478   aAction->setStatusTip( tr("DSC_LIGHT_SOURCE") );
1479   connect( aAction, SIGNAL( triggered() ), this, SLOT( onLightSource() ) );
1480   toolMgr()->registerAction( aAction, LightSourceId );
1481 #endif
1482 }
1483
1484 /*!
1485   \brief Create toolbar.
1486 */
1487 void OCCViewer_ViewWindow::createToolBar()
1488 {
1489   static const char* titles[] = {
1490     "LBL_3DTOOLBAR_LABEL",
1491     "LBL_XYTOOLBAR_LABEL",
1492     "LBL_XZTOOLBAR_LABEL",
1493     "LBL_YZTOOLBAR_LABEL",
1494   };
1495   static const char* names[] = {
1496     "OCCViewer3DViewOperations",
1497     "OCCViewerXYViewOperations",
1498     "OCCViewerXZViewOperations",
1499     "OCCViewerYZViewOperations",
1500   };
1501   int tid = toolMgr()->createToolBar( tr( titles[my2dMode] ),        // title (language-dependant)
1502                                       QString( names[my2dMode] ),    // name (language-independant)
1503                                       false );                       // disable floatable toolbar
1504   if ( my2dMode != No2dMode ){
1505     toolMgr()->append( ReturnTo3dViewId, tid );
1506     toolMgr()->append( toolMgr()->separator(), tid );
1507   }
1508   toolMgr()->append( DumpId, tid );
1509   toolMgr()->append( SwitchInteractionStyleId, tid );
1510   toolMgr()->append( SwitchZoomingStyleId, tid );
1511   toolMgr()->append( SwitchPreselectionId, tid );
1512   toolMgr()->append( SwitchSelectionId, tid );
1513   if( myModel->trihedronActivated() )
1514     toolMgr()->append( TrihedronShowId, tid );
1515
1516   QtxMultiAction* aScaleAction = new QtxMultiAction( this );
1517   aScaleAction->insertAction( toolMgr()->action( FitAllId ) );
1518   aScaleAction->insertAction( toolMgr()->action( FitRectId ) );
1519 #if OCC_VERSION_LARGE > 0x06090000
1520   aScaleAction->insertAction( toolMgr()->action( FitSelectionId ) );
1521 #endif
1522   aScaleAction->insertAction( toolMgr()->action( ZoomId ) );
1523   toolMgr()->append( aScaleAction, tid );
1524
1525   QtxMultiAction* aPanningAction = new QtxMultiAction( this );
1526   aPanningAction->insertAction( toolMgr()->action( PanId ) );
1527   aPanningAction->insertAction( toolMgr()->action( GlobalPanId ) );
1528   toolMgr()->append( aPanningAction, tid );
1529
1530   if (my2dMode == No2dMode) {
1531     toolMgr()->append( ChangeRotationPointId, tid );
1532     toolMgr()->append( RotationId, tid );
1533
1534     QtxMultiAction* aViewsAction = new QtxMultiAction( this );
1535     aViewsAction->insertAction( toolMgr()->action( FrontId ) );
1536     aViewsAction->insertAction( toolMgr()->action( BackId ) );
1537     aViewsAction->insertAction( toolMgr()->action( TopId ) );
1538     aViewsAction->insertAction( toolMgr()->action( BottomId ) );
1539     aViewsAction->insertAction( toolMgr()->action( LeftId ) );
1540     aViewsAction->insertAction( toolMgr()->action( RightId ) );
1541     toolMgr()->append( aViewsAction, tid );
1542
1543     toolMgr()->append( AntiClockWiseId, tid );
1544     toolMgr()->append( ClockWiseId, tid );
1545
1546     toolMgr()->append( OrthographicId, tid );
1547     toolMgr()->append( PerspectiveId, tid );
1548 #if OCC_VERSION_LARGE > 0x06090000
1549     toolMgr()->append( StereoId, tid );
1550 #endif
1551
1552     toolMgr()->append( ResetId, tid );
1553   }
1554
1555   QtxMultiAction* aMemAction = new QtxMultiAction( this );
1556   aMemAction->insertAction( toolMgr()->action( MemId ) );
1557   aMemAction->insertAction( toolMgr()->action( RestoreId ) );
1558   toolMgr()->append( aMemAction, tid );
1559
1560   toolMgr()->append( toolMgr()->separator(), tid );
1561   toolMgr()->append( CloneId, tid );
1562
1563   toolMgr()->append( toolMgr()->separator(), tid );
1564   toolMgr()->append( ClippingId, tid );
1565   toolMgr()->append( AxialScaleId, tid );
1566   toolMgr()->append( GraduatedAxesId, tid );
1567   toolMgr()->append( AmbientId, tid );
1568
1569   toolMgr()->append( MaximizedId, tid );
1570   toolMgr()->append( SynchronizeId, tid );
1571 #ifdef ENABLE_RAY_TRACING
1572   toolMgr()->append( RayTracingId, tid );
1573   toolMgr()->append( EnvTextureId, tid );
1574   toolMgr()->append( LightSourceId, tid );
1575 #endif
1576 }
1577
1578 /*!
1579   \brief Perform 'fit all' operation.
1580 */
1581 void OCCViewer_ViewWindow::onViewFitAll()
1582 {
1583   myViewPort->fitAll();
1584 }
1585
1586 /*!
1587   \brief Perform "front view" transformation.
1588 */
1589 void OCCViewer_ViewWindow::onFrontView()
1590 {
1591   emit vpTransformationStarted ( FRONTVIEW );
1592   Handle(V3d_View) aView3d = myViewPort->getView();
1593   if ( !aView3d.IsNull() ) aView3d->SetProj (V3d_Xpos);
1594   onViewFitAll();
1595   emit vpTransformationFinished ( FRONTVIEW );
1596 }
1597
1598 /*!
1599   \brief Perform "back view" transformation.
1600 */
1601 void OCCViewer_ViewWindow::onBackView()
1602 {
1603   emit vpTransformationStarted ( BACKVIEW );
1604   Handle(V3d_View) aView3d = myViewPort->getView();
1605   if ( !aView3d.IsNull() ) aView3d->SetProj (V3d_Xneg);
1606   onViewFitAll();
1607   emit vpTransformationFinished ( BACKVIEW );
1608 }
1609
1610 /*!
1611   \brief Perform "top view" transformation.
1612 */
1613 void OCCViewer_ViewWindow::onTopView()
1614 {
1615   emit vpTransformationStarted ( TOPVIEW );
1616   Handle(V3d_View) aView3d = myViewPort->getView();
1617   if ( !aView3d.IsNull() ) aView3d->SetProj (V3d_Zpos);
1618   onViewFitAll();
1619   emit vpTransformationFinished ( TOPVIEW );
1620 }
1621
1622 /*!
1623   \brief Perform "bottom view" transformation.
1624 */
1625 void OCCViewer_ViewWindow::onBottomView()
1626 {
1627   emit vpTransformationStarted ( BOTTOMVIEW );
1628   Handle(V3d_View) aView3d = myViewPort->getView();
1629   if ( !aView3d.IsNull() ) aView3d->SetProj (V3d_Zneg);
1630   onViewFitAll();
1631   emit vpTransformationFinished ( BOTTOMVIEW );
1632 }
1633
1634 /*!
1635   \brief Perform "left view" transformation.
1636 */
1637 void OCCViewer_ViewWindow::onLeftView()
1638 {
1639   emit vpTransformationStarted ( LEFTVIEW );
1640   Handle(V3d_View) aView3d = myViewPort->getView();
1641   if ( !aView3d.IsNull() ) aView3d->SetProj (V3d_Yneg);
1642   onViewFitAll();
1643   emit vpTransformationFinished ( LEFTVIEW );
1644 }
1645
1646 /*!
1647   \brief Perform "right view" transformation.
1648 */
1649 void OCCViewer_ViewWindow::onRightView()
1650 {
1651   emit vpTransformationStarted ( RIGHTVIEW );
1652   Handle(V3d_View) aView3d = myViewPort->getView();
1653   if ( !aView3d.IsNull() ) aView3d->SetProj (V3d_Ypos);
1654   onViewFitAll();
1655   emit vpTransformationFinished ( RIGHTVIEW );
1656 }
1657
1658 /*!
1659   \brief Rotate view 90 degrees clockwise
1660 */
1661 void OCCViewer_ViewWindow::onClockWiseView()
1662 {
1663   emit vpTransformationStarted ( CLOCKWISEVIEW );
1664   myViewPort->rotateXY( 90. );
1665   emit vpTransformationFinished ( CLOCKWISEVIEW );
1666 }
1667
1668 /*!
1669   \brief Rotate view 90 degrees conterclockwise
1670 */
1671 void OCCViewer_ViewWindow::onAntiClockWiseView()
1672 {
1673   emit vpTransformationStarted ( ANTICLOCKWISEVIEW );
1674   myViewPort->rotateXY( -90. );
1675   emit vpTransformationFinished ( ANTICLOCKWISEVIEW );
1676 }
1677
1678 /*!
1679   \brief Perform "reset view" transformation.
1680
1681   Sets default orientation of the viewport camera.
1682 */
1683 void OCCViewer_ViewWindow::onResetView()
1684 {
1685   emit vpTransformationStarted( RESETVIEW );
1686   bool upd = myViewPort->getView()->SetImmediateUpdate( false );
1687   myViewPort->getView()->Reset( false );
1688   myViewPort->fitAll( false, true, false );
1689   myViewPort->getView()->SetImmediateUpdate( upd );
1690   onProjectionType(); // needed to apply projection type properly after reset
1691   myViewPort->getView()->Update();
1692   emit vpTransformationFinished( RESETVIEW );
1693 }
1694
1695 /*!
1696   \brief Set the given projection mode.
1697
1698   Set the given projection mode: Orthographic or Perspective.
1699 */
1700 void OCCViewer_ViewWindow::onProjectionType( QAction* theAction )
1701 {
1702   Handle(V3d_View) aView3d = myViewPort->getView();
1703   if ( !aView3d.IsNull() ) {
1704     Handle(Graphic3d_Camera) aCamera = aView3d->Camera();
1705     if (theAction == toolMgr()->action( OrthographicId )) {
1706       myModel->setProjectionType(Orthographic);
1707       aCamera->SetProjectionType ( Graphic3d_Camera::Projection_Orthographic );
1708       aCamera->SetFOVy(45.0);
1709     }
1710     else if (theAction == toolMgr()->action( PerspectiveId )) {
1711       myModel->setProjectionType(Perspective);
1712       aCamera->SetProjectionType ( Graphic3d_Camera::Projection_Perspective );
1713       aCamera->SetFOVy(30.0);
1714     }
1715 #if OCC_VERSION_LARGE > 0x06090000
1716     if (toolMgr()->action( StereoId )->isChecked()) {
1717       aCamera->SetProjectionType ( Graphic3d_Camera::Projection_Stereo );
1718       aCamera->SetFOVy(30.0);
1719     }
1720 #endif
1721     aView3d->Redraw();
1722     onViewFitAll();
1723   }
1724 }
1725
1726 /*!
1727   \brief Sets Stereo projection mode.
1728
1729   Sets Stereo projection mode.
1730 */
1731 void OCCViewer_ViewWindow::onStereoType( bool activate )
1732 {
1733 #if OCC_VERSION_LARGE > 0x06090000
1734   Handle(V3d_View) aView3d = myViewPort->getView();
1735   if ( !aView3d.IsNull() ) {
1736     Handle(Graphic3d_Camera) aCamera = aView3d->Camera();
1737     if (activate) {
1738       toolMgr()->action( PerspectiveId )->setChecked(true);
1739       aCamera->SetProjectionType(Graphic3d_Camera::Projection_Perspective);
1740       toolMgr()->action( PerspectiveId )->actionGroup()->setEnabled(false);
1741
1742       aCamera->SetProjectionType ( Graphic3d_Camera::Projection_Stereo );
1743       SUIT_ResourceMgr* aResMgr = SUIT_Session::session()->resourceMgr();
1744       setStereoType( aResMgr->integerValue( "OCCViewer", "stereo_type", 0 ) );
1745       setAnaglyphFilter( aResMgr->integerValue( "OCCViewer", "anaglyph_filter", 0 ) );
1746       setReverseStereo( aResMgr->booleanValue( "OCCViewer", "reverse_stereo", false ) );
1747       setVSync( aResMgr->booleanValue( "OCCViewer", "enable_vsync", true ) );
1748       setQuadBufferSupport( aResMgr->booleanValue( "OCCViewer", "enable_quad_buffer_support", false ) );
1749     }
1750     else {
1751       toolMgr()->action( PerspectiveId )->actionGroup()->setEnabled(true);
1752       if (myModel->projectionType() == Orthographic) {
1753         toolMgr()->action( OrthographicId )->setChecked(true);
1754         aCamera->SetProjectionType(Graphic3d_Camera::Projection_Orthographic);
1755       }
1756       else if (myModel->projectionType() == Perspective) {
1757         toolMgr()->action( PerspectiveId )->setChecked(true);
1758         aCamera->SetProjectionType(Graphic3d_Camera::Projection_Perspective);
1759       }
1760     }
1761     aView3d->Redraw();
1762     onViewFitAll();
1763   }
1764
1765   if ( isQuadBufferSupport() && !isOpenGlStereoSupport() && stereoType() == QuadBuffer &&
1766        toolMgr()->action( StereoId )->isChecked() )
1767     SUIT_MessageBox::warning( 0, tr( "WRN_WARNING" ),  tr( "WRN_SUPPORT_QUAD_BUFFER" ) );
1768 #endif
1769 }
1770
1771 /*!
1772   \brief Restore the view.
1773
1774   Restore the projection mode based on tool-buttons states.
1775 */
1776 void OCCViewer_ViewWindow::onProjectionType()
1777 {
1778   emit vpTransformationStarted( PROJECTION );
1779   if (toolMgr()->action( OrthographicId )->isChecked())
1780     setProjectionType( Orthographic );
1781   if (toolMgr()->action( PerspectiveId )->isChecked())
1782     setProjectionType( Perspective );
1783 #if OCC_VERSION_LARGE > 0x06090000
1784   if (toolMgr()->action( StereoId )->isChecked())
1785     setProjectionType( Stereo );
1786 #endif
1787   emit vpTransformationFinished( PROJECTION );
1788 }
1789
1790 void OCCViewer_ViewWindow::setProjectionType( int mode )
1791 {
1792   QtxAction* anOrthographicAction = dynamic_cast<QtxAction*>( toolMgr()->action( OrthographicId ) );
1793   QtxAction* aPerspectiveAction = dynamic_cast<QtxAction*>( toolMgr()->action( PerspectiveId ) );
1794 #if OCC_VERSION_LARGE > 0x06090000
1795   QtxAction* aStereoAction = dynamic_cast<QtxAction*>( toolMgr()->action( StereoId ) );
1796 #endif
1797   switch ( mode ) {
1798     case Orthographic:
1799       onProjectionType( anOrthographicAction );
1800       break;
1801     case Perspective:
1802       onProjectionType( aPerspectiveAction );
1803       break;
1804     case Stereo:
1805       onStereoType( true );
1806       break;
1807   }
1808   // update action state if method is called outside
1809   if ( mode == Orthographic && !anOrthographicAction->isChecked() ) {
1810           anOrthographicAction->setChecked( true );
1811     #if OCC_VERSION_LARGE > 0x06090000
1812           aStereoAction->setChecked( false );
1813     #endif
1814   }
1815   if ( mode == Perspective && !aPerspectiveAction->isChecked() ) {
1816           aPerspectiveAction->setChecked( true );
1817     #if OCC_VERSION_LARGE > 0x06090000
1818           aStereoAction->setChecked( false );
1819     #endif
1820   }
1821 #if OCC_VERSION_LARGE > 0x06090000
1822   if ( mode == Stereo ) {
1823     aStereoAction->setChecked( true );
1824     if ( anOrthographicAction->isEnabled() ) {
1825       anOrthographicAction->setEnabled( false );
1826       anOrthographicAction->setChecked( false );
1827       aStereoAction->setChecked( false );
1828     }
1829     else {
1830       anOrthographicAction->setEnabled( true );
1831       aStereoAction->setChecked( false );
1832       anOrthographicAction->setChecked(myModel->projectionType() == Orthographic);
1833     }
1834     if ( aPerspectiveAction->isEnabled() ) {
1835       aPerspectiveAction->setEnabled( false );
1836       aPerspectiveAction->setChecked( true );
1837       if ( isQuadBufferSupport() && !isOpenGlStereoSupport() && stereoType() == QuadBuffer &&
1838            toolMgr()->action( StereoId )->isChecked() )
1839         SUIT_MessageBox::warning( 0, tr( "WRN_WARNING" ),  tr( "WRN_SUPPORT_QUAD_BUFFER" ) );
1840     }
1841     else {
1842       aPerspectiveAction->setEnabled( true );
1843       aStereoAction->setChecked( false );
1844       aPerspectiveAction->setChecked(myModel->projectionType() == Perspective);
1845       onProjectionType();
1846     }
1847   }
1848   else {
1849     if ( !anOrthographicAction->isEnabled() )
1850       anOrthographicAction->setEnabled( true );
1851     if ( !aPerspectiveAction->isEnabled() )
1852       aPerspectiveAction->setEnabled( true );
1853   }
1854 #endif
1855 }
1856
1857 /*!
1858   \brief Perform "fit all" transformation.
1859 */
1860 void OCCViewer_ViewWindow::onFitAll()
1861 {
1862   emit vpTransformationStarted( FITALLVIEW );
1863   myViewPort->fitAll();
1864   emit vpTransformationFinished( FITALLVIEW );
1865 }
1866
1867 /*!
1868   \brief Perform "fit selection" transformation.
1869 */
1870 void OCCViewer_ViewWindow::onFitSelection()
1871 {
1872   emit vpTransformationStarted( FITSELECTION );
1873 #if OCC_VERSION_LARGE > 0x06090000
1874   myModel->getAISContext()->FitSelected( getViewPort()->getView() );
1875 #endif
1876   emit vpTransformationFinished( FITSELECTION );
1877 }
1878
1879 /*!
1880   \brief Called if 'change rotation point' operation is activated.
1881   \param on action state
1882 */
1883 void OCCViewer_ViewWindow::onSetRotationPoint( bool on )
1884 {
1885   if (on)
1886   {
1887     if (!mySetRotationPointDlg)
1888     {
1889       mySetRotationPointDlg = new OCCViewer_SetRotationPointDlg (this);
1890       mySetRotationPointDlg->SetAction(mySetRotationPointAction);
1891     }
1892
1893     if (!mySetRotationPointDlg->isVisible())
1894     {
1895       //if (mySetRotationPointDlg->IsFirstShown())
1896       if (myCurrPointType == GRAVITY)
1897       {
1898         Standard_Real Xcenter, Ycenter, Zcenter;
1899         if (computeGravityCenter(Xcenter, Ycenter, Zcenter))
1900           mySetRotationPointDlg->setCoords(Xcenter, Ycenter, Zcenter);
1901       }
1902       mySetRotationPointDlg->show();
1903     }
1904   }
1905   else
1906   {
1907     if (mySetRotationPointDlg->isVisible())
1908       mySetRotationPointDlg->hide();
1909   }
1910 }
1911
1912 /*!
1913    \brief Create one more window with same content.
1914 */
1915 void OCCViewer_ViewWindow::onCloneView()
1916 {
1917   SUIT_ViewWindow* vw = myManager->createViewWindow();
1918   //vw->show();
1919   emit viewCloned( vw );
1920 }
1921
1922 /*!
1923   Creates one more window with same content
1924 */
1925 void OCCViewer_ViewWindow::onAxialScale()
1926 {
1927   if ( !myScalingDlg )
1928     myScalingDlg = new OCCViewer_AxialScaleDlg( this );
1929
1930   if ( !myScalingDlg->isVisible() )
1931   {
1932     myScalingDlg->Update();
1933     myScalingDlg->show();
1934   }
1935 }
1936
1937 /*!
1938   Shows Graduated Axes dialog
1939 */
1940 void OCCViewer_ViewWindow::onGraduatedAxes()
1941 {
1942   myCubeAxesDlg->Update();
1943   myCubeAxesDlg->show();
1944 }
1945
1946 void OCCViewer_ViewWindow::onAmbientToogle()
1947 {
1948   Handle(V3d_Viewer) viewer = myViewPort->getViewer();
1949   viewer->InitDefinedLights();
1950   while(viewer->MoreDefinedLights())
1951     {
1952       Handle(V3d_Light) light = viewer->DefinedLight();
1953       if(light->Type() != V3d_AMBIENT)
1954         {
1955           Handle(V3d_View) aView3d = myViewPort->getView();
1956           if( aView3d->IsActiveLight(light) ) viewer->SetLightOff(light);
1957           else viewer->SetLightOn(light);
1958         }
1959       viewer->NextDefinedLights();
1960     }
1961   viewer->Update();
1962 }
1963
1964 /*!
1965   \brief Store view parameters.
1966 */
1967 void OCCViewer_ViewWindow::onMemorizeView()
1968 {
1969   appendViewAspect( getViewParams() );
1970 }
1971
1972 /*!
1973   \brief Restore view parameters.
1974 */
1975 void OCCViewer_ViewWindow::onRestoreView()
1976 {
1977   OCCViewer_CreateRestoreViewDlg* aDlg = new OCCViewer_CreateRestoreViewDlg( centralWidget(), this );
1978   connect( aDlg, SIGNAL( dlgOk() ), this, SLOT( setRestoreFlag() ) );
1979   aDlg->exec();
1980   updateViewAspects( aDlg->parameters() );
1981   if( myRestoreFlag && aDlg->parameters().count() )
1982     performRestoring( aDlg->currentItem() );
1983 }
1984
1985 /*!
1986   \brief Restore view parameters.
1987   \param anItem view parameters
1988 */
1989 void OCCViewer_ViewWindow::performRestoring( const viewAspect& anItem, bool baseParamsOnly )
1990 {
1991   Handle(V3d_View) aView3d = myViewPort->getView();
1992
1993   Standard_Boolean prev = aView3d->SetImmediateUpdate( Standard_False );
1994   aView3d->SetScale( anItem.scale );
1995   aView3d->SetTwist( anItem.twist );
1996   aView3d->SetAt( anItem.atX, anItem.atY, anItem.atZ );
1997   aView3d->SetImmediateUpdate( prev );
1998   aView3d->SetEye( anItem.eyeX, anItem.eyeY, anItem.eyeZ );
1999   aView3d->SetProj( anItem.projX, anItem.projY, anItem.projZ );
2000   aView3d->SetAxialScale( anItem.scaleX, anItem.scaleY, anItem.scaleZ );
2001
2002 #if OCC_VERSION_LARGE > 0x06070100
2003   if ( anItem.centerX != 0.0 || anItem.centerY != 0.0 )
2004   {
2005     double anUpX = 0.0, anUpY = 0.0, anUpZ = 0.0;
2006
2007     // "eye" and "at" require conversion to represent center panning
2008     // up direction is only available after setting angle of twist and
2009     // other view parameters
2010     aView3d->Up( anUpX, anUpY, anUpZ );
2011
2012     gp_Dir aProj( -anItem.projX, -anItem.projY, -anItem.projZ );
2013     gp_Dir anUp( anUpX, anUpY, anUpZ );
2014     gp_Pnt anAt( anItem.atX, anItem.atY, anItem.atZ );
2015     gp_Pnt anEye( anItem.eyeX, anItem.eyeY, anItem.eyeZ );
2016     gp_Dir aSide = aProj ^ anUp;
2017
2018     anAt.Translate( gp_Vec( aSide ) * anItem.centerX );
2019     anAt.Translate( gp_Vec( anUp  ) * anItem.centerY );
2020
2021     aView3d->SetAt( anAt.X(), anAt.Y(), anAt.Z() );
2022     aView3d->SetProj( anItem.projX, anItem.projY, anItem.projZ );
2023   }
2024 #else
2025   aView3d->SetCenter( anItem.centerX, anItem.centerY );
2026 #endif
2027
2028   if ( !baseParamsOnly ) {
2029
2030     myModel->setTrihedronShown( anItem.isVisible );
2031     myModel->setTrihedronSize( anItem.size );
2032
2033     // graduated trihedron
2034     bool anIsVisible = anItem.gtIsVisible;
2035     OCCViewer_AxisWidget::AxisData anAxisData[3];
2036     anAxisData[0].DrawName = anItem.gtDrawNameX;
2037     anAxisData[1].DrawName = anItem.gtDrawNameZ;
2038     anAxisData[2].DrawName = anItem.gtDrawNameZ;
2039     anAxisData[0].Name = anItem.gtNameX;
2040     anAxisData[1].Name = anItem.gtNameZ;
2041     anAxisData[2].Name = anItem.gtNameZ;
2042     anAxisData[0].NameColor = QColor( anItem.gtNameColorRX,
2043               anItem.gtNameColorGX,
2044               anItem.gtNameColorBX );
2045     anAxisData[1].NameColor = QColor( anItem.gtNameColorRY,
2046               anItem.gtNameColorGY,
2047               anItem.gtNameColorBY );
2048     anAxisData[2].NameColor = QColor( anItem.gtNameColorRZ,
2049               anItem.gtNameColorGZ,
2050               anItem.gtNameColorBZ );
2051     anAxisData[0].DrawValues = anItem.gtDrawValuesX;
2052     anAxisData[1].DrawValues = anItem.gtDrawValuesY;
2053     anAxisData[2].DrawValues = anItem.gtDrawValuesZ;
2054     anAxisData[0].NbValues = anItem.gtNbValuesX;
2055     anAxisData[1].NbValues = anItem.gtNbValuesY;
2056     anAxisData[2].NbValues = anItem.gtNbValuesZ;
2057     anAxisData[0].Offset = anItem.gtOffsetX;
2058     anAxisData[1].Offset = anItem.gtOffsetY;
2059     anAxisData[2].Offset = anItem.gtOffsetZ;
2060     anAxisData[0].Color = QColor( anItem.gtColorRX,
2061           anItem.gtColorGX,
2062           anItem.gtColorBX );
2063     anAxisData[1].Color = QColor( anItem.gtColorRY,
2064           anItem.gtColorGY,
2065           anItem.gtColorBY );
2066     anAxisData[2].Color = QColor( anItem.gtColorRZ,
2067           anItem.gtColorGZ,
2068           anItem.gtColorBZ );
2069     anAxisData[0].DrawTickmarks = anItem.gtDrawTickmarksX;
2070     anAxisData[1].DrawTickmarks = anItem.gtDrawTickmarksY;
2071     anAxisData[2].DrawTickmarks = anItem.gtDrawTickmarksZ;
2072     anAxisData[0].TickmarkLength = anItem.gtTickmarkLengthX;
2073     anAxisData[1].TickmarkLength = anItem.gtTickmarkLengthY;
2074     anAxisData[2].TickmarkLength = anItem.gtTickmarkLengthZ;
2075
2076     myCubeAxesDlg->SetData( anIsVisible, anAxisData );
2077     myCubeAxesDlg->ApplyData( aView3d );
2078
2079   } // if ( !baseParamsOnly )
2080
2081   myRestoreFlag = 0;
2082 }
2083
2084 /*!
2085   \brief Set restore flag.
2086 */
2087 void OCCViewer_ViewWindow::setRestoreFlag()
2088 {
2089   myRestoreFlag = 1;
2090 }
2091
2092 /*!
2093   \brief Called when action "show/hide trihedron" is activated.
2094 */
2095 void OCCViewer_ViewWindow::onTrihedronShow(bool show)
2096 {
2097   myModel->setTrihedronShown(show);
2098 }
2099
2100 /*!
2101   \brief Toggles preselection (highlighting) on/off
2102 */
2103 void OCCViewer_ViewWindow::onSwitchPreselection( bool on )
2104 {
2105   myPreselectionEnabled = on;
2106   myModel->setSelectionOptions( isPreselectionEnabled(), myModel->isSelectionEnabled() );
2107
2108   // unhighlight all highlighted objects
2109   /*if ( !on ) {
2110     myModel->unHighlightAll( true, false );
2111   }*/
2112
2113   // update action state if method is called outside
2114   QtxAction* a = dynamic_cast<QtxAction*>( toolMgr()->action( SwitchPreselectionId ) );
2115   if ( a && a->isChecked() != on ) {
2116     a->setChecked( on );
2117   }
2118 }
2119
2120 /*!
2121   \brief Toggles selection on/off
2122 */
2123 void OCCViewer_ViewWindow::onSwitchSelection( bool on )
2124 {
2125   mySelectionEnabled = on;
2126   myModel->setSelectionOptions( myModel->isPreselectionEnabled(), isSelectionEnabled() );
2127
2128   // update action state if method is called outside
2129
2130   // preselection
2131   QtxAction* a = dynamic_cast<QtxAction*>( toolMgr()->action( SwitchPreselectionId ) );
2132   if ( a ) {
2133     a->setEnabled( on );
2134   }
2135
2136   // selection
2137   a = dynamic_cast<QtxAction*>( toolMgr()->action( SwitchSelectionId ) );
2138   if ( a && a->isChecked() != on ) {
2139     a->setChecked( on );
2140   }
2141 }
2142
2143 /*!
2144   \brief Switches "keyboard free" interaction style on/off
2145 */
2146 void OCCViewer_ViewWindow::onSwitchInteractionStyle( bool on )
2147 {
2148   myInteractionStyle = on ? (int)SUIT_ViewModel::KEY_FREE : (int)SUIT_ViewModel::STANDARD;
2149
2150   // update action state if method is called outside
2151   QtxAction* a = dynamic_cast<QtxAction*>( toolMgr()->action( SwitchInteractionStyleId ) );
2152   if ( a && a->isChecked() != on )
2153     a->setChecked( on );
2154 }
2155
2156 /*!
2157   \brief Toogles advanced zooming style (relatively to the cursor position) on/off
2158 */
2159 void OCCViewer_ViewWindow::onSwitchZoomingStyle( bool on )
2160 {
2161   myViewPort->setAdvancedZoomingEnabled( on );
2162
2163   // update action state if method is called outside
2164   QtxAction* a = dynamic_cast<QtxAction*>( toolMgr()->action( SwitchZoomingStyleId ) );
2165   if ( a && a->isChecked() != on )
2166     a->setChecked( on );
2167 }
2168
2169 /*!
2170   \brief Get current interaction style
2171   \return interaction style
2172 */
2173 int OCCViewer_ViewWindow::interactionStyle() const
2174 {
2175   return myInteractionStyle;
2176 }
2177
2178 /*!
2179   \brief Set current interaction style
2180   \param theStyle interaction style
2181 */
2182 void OCCViewer_ViewWindow::setInteractionStyle( const int theStyle )
2183 {
2184   onSwitchInteractionStyle( theStyle == (int)SUIT_ViewModel::KEY_FREE );
2185 }
2186
2187 /*!
2188   \brief Get current zooming style
2189   \return zooming style
2190 */
2191 int OCCViewer_ViewWindow::zoomingStyle() const
2192 {
2193   return myViewPort->isAdvancedZoomingEnabled() ? 1 : 0;
2194 }
2195
2196 /*!
2197   \brief Set current zooming style
2198   \param theStyle zooming style
2199 */
2200 void OCCViewer_ViewWindow::setZoomingStyle( const int theStyle )
2201 {
2202   onSwitchZoomingStyle( theStyle == 1 );
2203 }
2204
2205 /*!
2206   \brief Dump view window contents to the pixmap.
2207   \return pixmap containing all scene rendered in the window
2208 */
2209 QImage OCCViewer_ViewWindow::dumpView()
2210 {
2211   Handle(V3d_View) view = myViewPort->getView();
2212   if ( view.IsNull() )
2213     return QImage();
2214
2215   int aWidth = myViewPort->width();
2216   int aHeight = myViewPort->height();
2217
2218   // rnv: An old approach to dump the OCCViewer content
2219   //      Now used OCCT built-in procedure.
2220   /*
2221   QApplication::syncX();
2222   view->Redraw(); // In order to reactivate GL context
2223   //view->Update();
2224
2225 #ifndef DISABLE_GLVIEWER
2226   OpenGLUtils_FrameBuffer aFrameBuffer;
2227   if( aFrameBuffer.init( aWidth, aHeight ) )
2228   {
2229     QImage anImage( aWidth, aHeight, QImage::Format_RGB32 );
2230
2231     glPushAttrib( GL_VIEWPORT_BIT );
2232     glViewport( 0, 0, aWidth, aHeight );
2233     aFrameBuffer.bind();
2234
2235     // draw scene
2236     view->Redraw();
2237
2238     aFrameBuffer.unbind();
2239     glPopAttrib();
2240
2241     aFrameBuffer.bind();
2242     glReadPixels( 0, 0, aWidth, aHeight, GL_RGBA, GL_UNSIGNED_BYTE, anImage.bits() );
2243     aFrameBuffer.unbind();
2244
2245     anImage = anImage.rgbSwapped();
2246     anImage = anImage.mirrored();
2247     return anImage;
2248   }
2249   // if frame buffers are unsupported, use old functionality
2250   //view->Redraw();
2251
2252   unsigned char* data = new unsigned char[ aWidth*aHeight*4 ];
2253
2254   QPoint p = myViewPort->mapFromParent(myViewPort->geometry().topLeft());
2255
2256   glReadPixels( p.x(), p.y(), aWidth, aHeight, GL_RGBA, GL_UNSIGNED_BYTE,
2257                 data);
2258 #endif
2259   */
2260
2261   Image_PixMap aPix;
2262   view->ToPixMap(aPix,aWidth, aHeight,Graphic3d_BT_RGBA);
2263
2264   QImage anImage( aPix.Data(), aWidth, aHeight, QImage::Format_ARGB32 );
2265   anImage = anImage.mirrored();
2266   return anImage;
2267 }
2268
2269 bool OCCViewer_ViewWindow::dumpViewToFormat( const QImage& img,
2270                                              const QString& fileName,
2271                                              const QString& format )
2272 {
2273   bool res = false;
2274   QApplication::setOverrideCursor( Qt::WaitCursor );
2275   if ( format != "PS" && format != "EPS")
2276    res = myViewPort->getView()->Dump( fileName.toStdString().c_str() );
2277
2278 #if OCC_VERSION_MAJOR < 7
2279   Handle(Visual3d_View) a3dView = myViewPort->getView()->View();
2280 #else
2281   Handle(Graphic3d_CView) a3dView = myViewPort->getView()->View();
2282 #endif
2283
2284   if (format == "PS")
2285     res = a3dView->Export(strdup(qPrintable(fileName)), Graphic3d_EF_PostScript);
2286   else if (format == "EPS")
2287     res = a3dView->Export(strdup(qPrintable(fileName)), Graphic3d_EF_EnhPostScript);
2288
2289   QApplication::restoreOverrideCursor();
2290   return res;
2291 }
2292
2293
2294 QString OCCViewer_ViewWindow::filter() const
2295 {
2296   return tr( "OCC_IMAGE_FILES" );
2297 }
2298
2299
2300 /*!
2301   \brief Set parameters of the cutting plane
2302   \param on if \c true, cutting plane is enabled
2303   \param x X position of plane point
2304   \param y Y position of plane point
2305   \param z Z position of plane point
2306   \param dx X coordinate of plane normal
2307   \param dy Y coordinate of plane normal
2308   \param dz Z coordinate of plane normal
2309 */
2310 void OCCViewer_ViewWindow::setCuttingPlane( bool on, const double x,  const double y,  const double z,
2311                                             const double dx, const double dy, const double dz )
2312 {
2313   Handle(V3d_View) view = myViewPort->getView();
2314   if ( view.IsNull() )
2315     return;
2316
2317   if ( on ) {
2318     Handle(V3d_Viewer) viewer = myViewPort->getViewer();
2319
2320     // try to use already existing plane or create a new one
2321     Handle(V3d_Plane) clipPlane;
2322
2323     // calculate new a,b,c,d values for the plane
2324     gp_Pln pln (gp_Pnt(x, y, z), gp_Dir(dx, dy, dz));
2325     double a, b, c, d;
2326     pln.Coefficients(a, b, c, d);
2327
2328     Graphic3d_SequenceOfHClipPlane aPlanes = view->GetClipPlanes();
2329     if(aPlanes.Size() > 0 ) {
2330       Graphic3d_SequenceOfHClipPlane::Iterator anIter (aPlanes);
2331       Handle(Graphic3d_ClipPlane) aClipPlane = anIter.Value();
2332       aClipPlane->SetEquation(pln);
2333       aClipPlane->SetOn(Standard_True);
2334     } else {
2335       view->AddClipPlane( myModel->createClipPlane( pln, Standard_True ) );
2336     }
2337   }
2338   else {
2339     Graphic3d_SequenceOfHClipPlane aPlanes = view->GetClipPlanes();
2340     Graphic3d_SequenceOfHClipPlane::Iterator anIter (aPlanes);
2341     for( ;anIter.More();anIter.Next() ){
2342       Handle(Graphic3d_ClipPlane) aClipPlane = anIter.Value();
2343       aClipPlane->SetOn(Standard_False);
2344     }
2345   }
2346
2347   view->Update();
2348   view->Redraw();
2349 }
2350
2351 void OCCViewer_ViewWindow::setCuttingPlane( bool on, const gp_Pln pln )
2352 {
2353   gp_Dir aDir = pln.Axis().Direction();
2354   gp_Pnt aPnt = pln.Location();
2355   setCuttingPlane(on, aPnt.X(), aPnt.Y(), aPnt.Z(), aDir.X(), aDir.Y(), aDir.Z());
2356 }
2357
2358
2359 /*!
2360   \brief Check if any cutting plane is enabled
2361   \return \c true if at least one cutting plane is enabled
2362 */
2363 bool OCCViewer_ViewWindow::isCuttingPlane()
2364 {
2365   Handle(V3d_View) view = myViewPort->getView();
2366   bool res = false;
2367   Graphic3d_SequenceOfHClipPlane aPlanes = view->GetClipPlanes();
2368   Graphic3d_SequenceOfHClipPlane::Iterator anIter (aPlanes);
2369   for( ;anIter.More();anIter.Next() ) {
2370     Handle(Graphic3d_ClipPlane) aClipPlane = anIter.Value();
2371     if(aClipPlane->IsOn()) {
2372       res = true;
2373       break;
2374     }
2375   }
2376   return res;
2377 }
2378
2379 /*!
2380   \brief Get the visual parameters of the view window.
2381   \return visual parameters of view window
2382 */
2383 viewAspect OCCViewer_ViewWindow::getViewParams() const
2384 {
2385   double projX, projY, projZ, twist;
2386   double atX, atY, atZ, eyeX, eyeY, eyeZ;
2387   double aScaleX, aScaleY, aScaleZ;
2388
2389   Handle(V3d_View) aView3d = myViewPort->getView();
2390
2391   aView3d->Proj( projX, projY, projZ );
2392   aView3d->At( atX, atY, atZ );
2393   aView3d->Eye( eyeX, eyeY, eyeZ );
2394   twist = aView3d->Twist();
2395
2396   aView3d->AxialScale(aScaleX,aScaleY,aScaleZ);
2397
2398   bool isShown = myModel->isTrihedronVisible();
2399   double size = myModel->trihedronSize();
2400
2401   QString aName = QTime::currentTime().toString() + QString::fromLatin1( " h:m:s" );
2402
2403   viewAspect params;
2404   params.scale    = aView3d->Scale();
2405   params.projX    = projX;
2406   params.projY    = projY;
2407   params.projZ    = projZ;
2408   params.twist    = twist;
2409   params.atX      = atX;
2410   params.atY      = atY;
2411   params.atZ      = atZ;
2412   params.eyeX     = eyeX;
2413   params.eyeY     = eyeY;
2414   params.eyeZ     = eyeZ;
2415   params.scaleX   = aScaleX;
2416   params.scaleY   = aScaleY;
2417   params.scaleZ   = aScaleZ;
2418   params.name     = aName;
2419   params.isVisible= isShown;
2420   params.size     = size;
2421
2422 #if OCC_VERSION_LARGE <= 0x06070100 // the property is deprecated after OCCT 6.7.1
2423   aView3d->Center( params.centerX, params.centerY );
2424 #endif
2425
2426   // graduated trihedron
2427   bool anIsVisible = false;
2428   OCCViewer_AxisWidget::AxisData anAxisData[3];
2429   myCubeAxesDlg->GetData( anIsVisible, anAxisData );
2430
2431   params.gtIsVisible = anIsVisible;
2432   params.gtDrawNameX = anAxisData[0].DrawName;
2433   params.gtDrawNameY = anAxisData[1].DrawName;
2434   params.gtDrawNameZ = anAxisData[2].DrawName;
2435   params.gtNameX = anAxisData[0].Name;
2436   params.gtNameY = anAxisData[1].Name;
2437   params.gtNameZ = anAxisData[2].Name;
2438   params.gtNameColorRX = anAxisData[0].NameColor.red();
2439   params.gtNameColorGX = anAxisData[0].NameColor.green();
2440   params.gtNameColorBX = anAxisData[0].NameColor.blue();
2441   params.gtNameColorRY = anAxisData[1].NameColor.red();
2442   params.gtNameColorGY = anAxisData[1].NameColor.green();
2443   params.gtNameColorBY = anAxisData[1].NameColor.blue();
2444   params.gtNameColorRZ = anAxisData[2].NameColor.red();
2445   params.gtNameColorGZ = anAxisData[2].NameColor.green();
2446   params.gtNameColorBZ = anAxisData[2].NameColor.blue();
2447   params.gtDrawValuesX = anAxisData[0].DrawValues;
2448   params.gtDrawValuesY = anAxisData[1].DrawValues;
2449   params.gtDrawValuesZ = anAxisData[2].DrawValues;
2450   params.gtNbValuesX = anAxisData[0].NbValues;
2451   params.gtNbValuesY = anAxisData[1].NbValues;
2452   params.gtNbValuesZ = anAxisData[2].NbValues;
2453   params.gtOffsetX = anAxisData[0].Offset;
2454   params.gtOffsetY = anAxisData[1].Offset;
2455   params.gtOffsetZ = anAxisData[2].Offset;
2456   params.gtColorRX = anAxisData[0].Color.red();
2457   params.gtColorGX = anAxisData[0].Color.green();
2458   params.gtColorBX = anAxisData[0].Color.blue();
2459   params.gtColorRY = anAxisData[1].Color.red();
2460   params.gtColorGY = anAxisData[1].Color.green();
2461   params.gtColorBY = anAxisData[1].Color.blue();
2462   params.gtColorRZ = anAxisData[2].Color.red();
2463   params.gtColorGZ = anAxisData[2].Color.green();
2464   params.gtColorBZ = anAxisData[2].Color.blue();
2465   params.gtDrawTickmarksX = anAxisData[0].DrawTickmarks;
2466   params.gtDrawTickmarksY = anAxisData[1].DrawTickmarks;
2467   params.gtDrawTickmarksZ = anAxisData[2].DrawTickmarks;
2468   params.gtTickmarkLengthX = anAxisData[0].TickmarkLength;
2469   params.gtTickmarkLengthY = anAxisData[1].TickmarkLength;
2470   params.gtTickmarkLengthZ = anAxisData[2].TickmarkLength;
2471
2472   return params;
2473 }
2474
2475 /*!
2476   \brief Get visual parameters of this view window.
2477   \return visual parameters of view window
2478 */
2479 QString OCCViewer_ViewWindow::getVisualParameters()
2480 {
2481   viewAspect params = getViewParams();
2482
2483   QStringList data;
2484
2485   data << QString( "scale=%1" )    .arg( params.scale,   0, 'e', 12 );
2486 #if OCC_VERSION_LARGE <= 0x06070100 // the property is deprecated after OCCT 6.7.1
2487   data << QString( "centerX=%1" )  .arg( params.centerX, 0, 'e', 12 );
2488   data << QString( "centerY=%1" )  .arg( params.centerY, 0, 'e', 12 );
2489 #endif
2490   data << QString( "projX=%1" )    .arg( params.projX,   0, 'e', 12 );
2491   data << QString( "projY=%1" )    .arg( params.projY,   0, 'e', 12 );
2492   data << QString( "projZ=%1" )    .arg( params.projZ,   0, 'e', 12 );
2493   data << QString( "twist=%1" )    .arg( params.twist,   0, 'e', 12 );
2494   data << QString( "atX=%1" )      .arg( params.atX,     0, 'e', 12 );
2495   data << QString( "atY=%1" )      .arg( params.atY,     0, 'e', 12 );
2496   data << QString( "atZ=%1" )      .arg( params.atZ,     0, 'e', 12 );
2497   data << QString( "eyeX=%1" )     .arg( params.eyeX,    0, 'e', 12 );
2498   data << QString( "eyeY=%1" )     .arg( params.eyeY,    0, 'e', 12 );
2499   data << QString( "eyeZ=%1" )     .arg( params.eyeZ,    0, 'e', 12 );
2500   data << QString( "scaleX=%1" )   .arg( params.scaleX,  0, 'e', 12 );
2501   data << QString( "scaleY=%1" )   .arg( params.scaleY,  0, 'e', 12 );
2502   data << QString( "scaleZ=%1" )   .arg( params.scaleZ,  0, 'e', 12 );
2503   data << QString( "isVisible=%1" ).arg( params.isVisible );
2504   data << QString( "size=%1" )     .arg( params.size,    0, 'f',  2 );
2505
2506   ClipPlanesList aPlanes =  myModel->getClipPlanes();
2507   for ( int i=0; i < aPlanes.size(); i++ )
2508   {
2509     OCCViewer_ClipPlane& aPlane = aPlanes[i];
2510     QString ClippingPlane = QString( "ClippingPlane%1=").arg( i+1 );
2511     ClippingPlane +=  QString( "Mode~%1;").arg( (int)aPlane.Mode );
2512     ClippingPlane +=  QString( "IsActive~%1;").arg( aPlane.IsOn );
2513     switch ( aPlane.Mode )
2514     {
2515       case OCCViewer_ClipPlane::Absolute :
2516       {
2517         ClippingPlane += QString( "AbsoluteOrientation~%1;" ).arg( aPlane.OrientationType );
2518
2519         if ( aPlane.OrientationType == OCCViewer_ClipPlane::AbsoluteCustom )
2520         {
2521           ClippingPlane += QString( "Dx~%1;" ).arg( aPlane.AbsoluteOrientation.Dx );
2522           ClippingPlane += QString( "Dy~%1;" ).arg( aPlane.AbsoluteOrientation.Dy );
2523           ClippingPlane += QString( "Dz~%1;" ).arg( aPlane.AbsoluteOrientation.Dz );
2524         }
2525         else
2526         {
2527           ClippingPlane += QString( "IsInvert~%1;" ).arg( aPlane.AbsoluteOrientation.IsInvert );
2528         }
2529       }
2530       break;
2531
2532       case OCCViewer_ClipPlane::Relative :
2533       {
2534         ClippingPlane += QString( "RelativeOrientation~%1;" ).arg( aPlane.OrientationType );
2535         ClippingPlane += QString( "Rotation1~%1;" ).arg( aPlane.RelativeOrientation.Rotation1 );
2536         ClippingPlane += QString( "Rotation2~%1" ).arg( aPlane.RelativeOrientation.Rotation2 );
2537       }
2538       break;
2539     }
2540
2541     ClippingPlane +=  QString( "X~%1;" ).arg( aPlane.X );
2542     ClippingPlane +=  QString( "Y~%1;" ).arg( aPlane.Y );
2543     ClippingPlane +=  QString( "Z~%1;" ).arg( aPlane.Z );
2544     data << ClippingPlane;
2545   }
2546
2547   // graduated trihedron
2548   data << QString( "gtIsVisible=%1" )      .arg( params.gtIsVisible );
2549   data << QString( "gtDrawNameX=%1" )      .arg( params.gtDrawNameX );
2550   data << QString( "gtDrawNameY=%1" )      .arg( params.gtDrawNameY );
2551   data << QString( "gtDrawNameZ=%1" )      .arg( params.gtDrawNameZ );
2552   data << QString( "gtNameX=%1" )          .arg( params.gtNameX );
2553   data << QString( "gtNameY=%1" )          .arg( params.gtNameY );
2554   data << QString( "gtNameZ=%1" )          .arg( params.gtNameZ );
2555   data << QString( "gtNameColorRX=%1" )    .arg( params.gtNameColorRX );
2556   data << QString( "gtNameColorGX=%1" )    .arg( params.gtNameColorGX );
2557   data << QString( "gtNameColorBX=%1" )    .arg( params.gtNameColorBX );
2558   data << QString( "gtNameColorRY=%1" )    .arg( params.gtNameColorRY );
2559   data << QString( "gtNameColorGY=%1" )    .arg( params.gtNameColorGY );
2560   data << QString( "gtNameColorBY=%1" )    .arg( params.gtNameColorBY );
2561   data << QString( "gtNameColorRZ=%1" )    .arg( params.gtNameColorRZ );
2562   data << QString( "gtNameColorGZ=%1" )    .arg( params.gtNameColorGZ );
2563   data << QString( "gtNameColorBZ=%1" )    .arg( params.gtNameColorBZ );
2564   data << QString( "gtDrawValuesX=%1" )    .arg( params.gtDrawValuesX );
2565   data << QString( "gtDrawValuesY=%1" )    .arg( params.gtDrawValuesY );
2566   data << QString( "gtDrawValuesZ=%1" )    .arg( params.gtDrawValuesZ );
2567   data << QString( "gtNbValuesX=%1" )      .arg( params.gtNbValuesX );
2568   data << QString( "gtNbValuesY=%1" )      .arg( params.gtNbValuesY );
2569   data << QString( "gtNbValuesZ=%1" )      .arg( params.gtNbValuesZ );
2570   data << QString( "gtOffsetX=%1" )        .arg( params.gtOffsetX );
2571   data << QString( "gtOffsetY=%1" )        .arg( params.gtOffsetY );
2572   data << QString( "gtOffsetZ=%1" )        .arg( params.gtOffsetZ );
2573   data << QString( "gtColorRX=%1" )        .arg( params.gtColorRX );
2574   data << QString( "gtColorGX=%1" )        .arg( params.gtColorGX );
2575   data << QString( "gtColorBX=%1" )        .arg( params.gtColorBX );
2576   data << QString( "gtColorRY=%1" )        .arg( params.gtColorRY );
2577   data << QString( "gtColorGY=%1" )        .arg( params.gtColorGY );
2578   data << QString( "gtColorBY=%1" )        .arg( params.gtColorBY );
2579   data << QString( "gtColorRZ=%1" )        .arg( params.gtColorRZ );
2580   data << QString( "gtColorGZ=%1" )        .arg( params.gtColorGZ );
2581   data << QString( "gtColorBZ=%1" )        .arg( params.gtColorBZ );
2582   data << QString( "gtDrawTickmarksX=%1" ) .arg( params.gtDrawTickmarksX );
2583   data << QString( "gtDrawTickmarksY=%1" ) .arg( params.gtDrawTickmarksY );
2584   data << QString( "gtDrawTickmarksZ=%1" ) .arg( params.gtDrawTickmarksZ );
2585   data << QString( "gtTickmarkLengthX=%1" ).arg( params.gtTickmarkLengthX );
2586   data << QString( "gtTickmarkLengthY=%1" ).arg( params.gtTickmarkLengthY );
2587   data << QString( "gtTickmarkLengthZ=%1" ).arg( params.gtTickmarkLengthZ );
2588
2589   // ray tracing parameters
2590   Graphic3d_RenderingParams rendParams = this->getViewPort()->getView()->RenderingParams();
2591   if ( rendParams.Method == Graphic3d_RM_RAYTRACING ) {
2592     QString RayTracing = "rayTracing=";
2593     RayTracing += QString( "rtDepth~%1;" ).arg( rendParams.RaytracingDepth );
2594     RayTracing += QString( "rtReflection~%1;" ).arg( rendParams.IsReflectionEnabled );
2595     RayTracing += QString( "rtAntialiasing~%1;" ).arg( rendParams.IsAntialiasingEnabled );
2596     RayTracing += QString( "rtShadow~%1;" ).arg( rendParams.IsShadowEnabled );
2597     RayTracing += QString( "rtTransShadow~%1;" ).arg( rendParams.IsTransparentShadowEnabled );
2598     data << RayTracing;
2599   }
2600
2601   // environment texture parameters
2602   Handle(Graphic3d_TextureEnv) aTexture = this->getViewPort()->getView()->TextureEnv();
2603   if ( !aTexture.IsNull() ) {
2604     QString EnvTexture = "envTexture=";
2605     if ( aTexture->Name() == Graphic3d_NOT_ENV_UNKNOWN ) {
2606       TCollection_AsciiString aFileName;
2607       aTexture->Path().SystemName( aFileName );
2608       EnvTexture += QString( "etFile~%1;" ).arg( aFileName.ToCString() );
2609     }
2610     else
2611       EnvTexture += QString( "etNumber~%1;" ).arg( aTexture->Name() );
2612     data << EnvTexture;
2613   }
2614
2615   // light source parameters
2616   myModel->getViewer3d()->InitDefinedLights();
2617   while ( myModel->getViewer3d()->MoreDefinedLights() )
2618   {
2619     Handle(V3d_Light) aLight = myModel->getViewer3d()->DefinedLight();
2620     if ( aLight->Type() != V3d_AMBIENT ) {
2621       QString LightSource = QString( "lightSource=" );
2622       LightSource += QString( "lightType~%1;" ).arg( aLight->Type() );
2623       double aX, aY, aZ;
2624       if ( aLight->Type() == V3d_DIRECTIONAL )
2625         Handle(V3d_DirectionalLight)::DownCast( aLight )->Direction( aX, aY, aZ );
2626       else if ( aLight->Type() == V3d_POSITIONAL )
2627         Handle(V3d_PositionalLight)::DownCast( aLight )->Position( aX, aY, aZ );
2628       LightSource += QString( "lightX~%1;" ).arg( aX );
2629       LightSource += QString( "lightY~%1;" ).arg( aY );
2630       LightSource += QString( "lightZ~%1;" ).arg( aZ );
2631       LightSource += QString( "lightColorR~%1;" ).arg( aLight->Color().Red() );
2632       LightSource += QString( "lightColorG~%1;" ).arg( aLight->Color().Green() );
2633       LightSource += QString( "lightColorB~%1;" ).arg( aLight->Color().Blue() );
2634       LightSource += QString( "lightHeadlight~%1;" ).arg( aLight->Headlight() );
2635       data << LightSource;
2636     }
2637     myModel->getViewer3d()->NextDefinedLights();
2638   }
2639
2640   QString bg = Qtx::backgroundToString( background() ).replace( "=", "$" );
2641   data << QString( "background=%1" ).arg( bg );
2642
2643   return data.join("*");
2644 }
2645
2646 /*!
2647   \brief Restore visual parameters of the view window.
2648   \param parameters visual parameters of view window
2649 */
2650 void OCCViewer_ViewWindow::setVisualParameters( const QString& parameters )
2651 {
2652   viewAspect params;
2653   ClipPlanesList aClipPlanes;
2654   QStringList data = parameters.split( '*' );
2655   Qtx::BackgroundData bgData;
2656   if ( parameters.contains( '=' )  ) // new format - "scale=1.000e+00*centerX=0.000e+00..."
2657   {
2658     foreach( QString param, data ) {
2659       QString paramName  = param.section( '=', 0, 0 ).trimmed();
2660       QString paramValue = param.section( '=', 1, 1 ).trimmed();
2661       if      ( paramName == "scale" )             params.scale             = paramValue.toDouble();
2662       else if ( paramName == "centerX" )           params.centerX           = paramValue.toDouble();
2663       else if ( paramName == "centerY" )           params.centerY           = paramValue.toDouble();
2664       else if ( paramName == "projX" )             params.projX             = paramValue.toDouble();
2665       else if ( paramName == "projY" )             params.projY             = paramValue.toDouble();
2666       else if ( paramName == "projZ" )             params.projZ             = paramValue.toDouble();
2667       else if ( paramName == "twist" )             params.twist             = paramValue.toDouble();
2668       else if ( paramName == "atX" )               params.atX               = paramValue.toDouble();
2669       else if ( paramName == "atY" )               params.atY               = paramValue.toDouble();
2670       else if ( paramName == "atZ" )               params.atZ               = paramValue.toDouble();
2671       else if ( paramName == "eyeX" )              params.eyeX              = paramValue.toDouble();
2672       else if ( paramName == "eyeY" )              params.eyeY              = paramValue.toDouble();
2673       else if ( paramName == "eyeZ" )              params.eyeZ              = paramValue.toDouble();
2674       else if ( paramName == "scaleX" )            params.scaleX            = paramValue.toDouble();
2675       else if ( paramName == "scaleY" )            params.scaleY            = paramValue.toDouble();
2676       else if ( paramName == "scaleZ" )            params.scaleZ            = paramValue.toDouble();
2677       else if ( paramName == "isVisible" )         params.isVisible         = paramValue.toInt();
2678       else if ( paramName == "size" )              params.size              = paramValue.toDouble();
2679       else if ( paramName.contains( "ClippingPlane" ) )
2680       {
2681         QStringList ClipPlaneData = paramValue.split( ';' );
2682         OCCViewer_ClipPlane aPlane;
2683         foreach( QString ClipPlaneParam, ClipPlaneData )
2684         {
2685           QString ClipPlane_paramName  = ClipPlaneParam.section( '~', 0, 0 ).trimmed();
2686           QString ClipPlane_paramValue = ClipPlaneParam.section( '~', 1, 1 ).trimmed();
2687           if ( ClipPlane_paramName == "Mode" )
2688           {
2689             aPlane.Mode = ( OCCViewer_ClipPlane::PlaneMode ) ClipPlane_paramValue.toInt();
2690           }
2691           else if ( ClipPlane_paramName == "IsActive" ) aPlane.IsOn = ClipPlane_paramValue.toInt();
2692           else if ( ClipPlane_paramName == "X" )        aPlane.X    = ClipPlane_paramValue.toDouble();
2693           else if ( ClipPlane_paramName == "Y" )        aPlane.Y    = ClipPlane_paramValue.toDouble();
2694           else if ( ClipPlane_paramName == "Z" )        aPlane.Z    = ClipPlane_paramValue.toDouble();
2695           else
2696           {
2697             switch ( aPlane.Mode )
2698             {
2699               case OCCViewer_ClipPlane::Absolute :
2700                 if      ( ClipPlane_paramName == "Dx" ) aPlane.AbsoluteOrientation.Dx = ClipPlane_paramValue.toDouble();
2701                 else if ( ClipPlane_paramName == "Dy" ) aPlane.AbsoluteOrientation.Dy = ClipPlane_paramValue.toDouble();
2702                 else if ( ClipPlane_paramName == "Dz" ) aPlane.AbsoluteOrientation.Dz = ClipPlane_paramValue.toDouble();
2703                 else if ( ClipPlane_paramName == "IsInvert" ) aPlane.AbsoluteOrientation.IsInvert = ClipPlane_paramValue.toInt();
2704                 else if ( ClipPlane_paramName == "AbsoluteOrientation" ) aPlane.OrientationType = ClipPlane_paramValue.toInt();
2705                 break;
2706
2707               case OCCViewer_ClipPlane::Relative :
2708                 if      ( ClipPlane_paramName == "RelativeOrientation" ) aPlane.OrientationType = ClipPlane_paramValue.toInt();
2709                 else if ( ClipPlane_paramName == "Rotation1" )           aPlane.RelativeOrientation.Rotation1 = ClipPlane_paramValue.toDouble();
2710                 else if ( ClipPlane_paramName == "Rotation2" )           aPlane.RelativeOrientation.Rotation2 = ClipPlane_paramValue.toDouble();
2711                 break;
2712             }
2713           }
2714         }
2715         aClipPlanes.push_back(aPlane);
2716       }
2717       // graduated trihedron
2718       else if ( paramName == "gtIsVisible" )       params.gtIsVisible       = paramValue.toInt();
2719       else if ( paramName == "gtDrawNameX" )       params.gtDrawNameX       = paramValue.toInt();
2720       else if ( paramName == "gtDrawNameY" )       params.gtDrawNameY       = paramValue.toInt();
2721       else if ( paramName == "gtDrawNameZ" )       params.gtDrawNameZ       = paramValue.toInt();
2722       else if ( paramName == "gtNameX" )           params.gtNameX           = paramValue;
2723       else if ( paramName == "gtNameY" )           params.gtNameY           = paramValue;
2724       else if ( paramName == "gtNameZ" )           params.gtNameZ           = paramValue;
2725       else if ( paramName == "gtNameColorRX" )     params.gtNameColorRX     = paramValue.toInt();
2726       else if ( paramName == "gtNameColorGX" )     params.gtNameColorGX     = paramValue.toInt();
2727       else if ( paramName == "gtNameColorBX" )     params.gtNameColorBX     = paramValue.toInt();
2728       else if ( paramName == "gtNameColorRY" )     params.gtNameColorRY     = paramValue.toInt();
2729       else if ( paramName == "gtNameColorGY" )     params.gtNameColorGY     = paramValue.toInt();
2730       else if ( paramName == "gtNameColorBY" )     params.gtNameColorBY     = paramValue.toInt();
2731       else if ( paramName == "gtNameColorRZ" )     params.gtNameColorRZ     = paramValue.toInt();
2732       else if ( paramName == "gtNameColorGZ" )     params.gtNameColorGZ     = paramValue.toInt();
2733       else if ( paramName == "gtNameColorBZ" )     params.gtNameColorBZ     = paramValue.toInt();
2734       else if ( paramName == "gtDrawValuesX" )     params.gtDrawValuesX     = paramValue.toInt();
2735       else if ( paramName == "gtDrawValuesY" )     params.gtDrawValuesY     = paramValue.toInt();
2736       else if ( paramName == "gtDrawValuesZ" )     params.gtDrawValuesZ     = paramValue.toInt();
2737       else if ( paramName == "gtNbValuesX" )       params.gtNbValuesX       = paramValue.toInt();
2738       else if ( paramName == "gtNbValuesY" )       params.gtNbValuesY       = paramValue.toInt();
2739       else if ( paramName == "gtNbValuesZ" )       params.gtNbValuesZ       = paramValue.toInt();
2740       else if ( paramName == "gtOffsetX" )         params.gtOffsetX         = paramValue.toInt();
2741       else if ( paramName == "gtOffsetY" )         params.gtOffsetY         = paramValue.toInt();
2742       else if ( paramName == "gtOffsetZ" )         params.gtOffsetZ         = paramValue.toInt();
2743       else if ( paramName == "gtColorRX" )         params.gtColorRX         = paramValue.toInt();
2744       else if ( paramName == "gtColorGX" )         params.gtColorGX         = paramValue.toInt();
2745       else if ( paramName == "gtColorBX" )         params.gtColorBX         = paramValue.toInt();
2746       else if ( paramName == "gtColorRY" )         params.gtColorRY         = paramValue.toInt();
2747       else if ( paramName == "gtColorGY" )         params.gtColorGY         = paramValue.toInt();
2748       else if ( paramName == "gtColorBY" )         params.gtColorBY         = paramValue.toInt();
2749       else if ( paramName == "gtColorRZ" )         params.gtColorRZ         = paramValue.toInt();
2750       else if ( paramName == "gtColorGZ" )         params.gtColorGZ         = paramValue.toInt();
2751       else if ( paramName == "gtColorBZ" )         params.gtColorBZ         = paramValue.toInt();
2752       else if ( paramName == "gtDrawTickmarksX" )  params.gtDrawTickmarksX  = paramValue.toInt();
2753       else if ( paramName == "gtDrawTickmarksY" )  params.gtDrawTickmarksY  = paramValue.toInt();
2754       else if ( paramName == "gtDrawTickmarksZ" )  params.gtDrawTickmarksZ  = paramValue.toInt();
2755       else if ( paramName == "gtTickmarkLengthX" ) params.gtTickmarkLengthX = paramValue.toInt();
2756       else if ( paramName == "gtTickmarkLengthY" ) params.gtTickmarkLengthY = paramValue.toInt();
2757       else if ( paramName == "gtTickmarkLengthZ" ) params.gtTickmarkLengthZ = paramValue.toInt();
2758       else if ( paramName == "rayTracing" )
2759       {
2760         Graphic3d_RenderingParams& rendParams = this->getViewPort()->getView()->ChangeRenderingParams();
2761         rendParams.Method = Graphic3d_RM_RAYTRACING;
2762         QStringList rtData = paramValue.split( ';' );
2763         foreach( QString rtParam, rtData )
2764         {
2765           QString rt_paramName  = rtParam.section( '~', 0, 0 ).trimmed();
2766           QString rt_paramValue = rtParam.section( '~', 1, 1 ).trimmed();
2767           if ( rt_paramName == "rtDepth" ) rendParams.RaytracingDepth = rt_paramValue.toInt();
2768           else if ( rt_paramName == "rtReflection" ) rendParams.IsReflectionEnabled = rt_paramValue.toInt();
2769           else if ( rt_paramName == "rtAntialiasing" ) rendParams.IsAntialiasingEnabled = rt_paramValue.toInt();
2770           else if ( rt_paramName == "rtShadow" ) rendParams.IsShadowEnabled = rt_paramValue.toInt();
2771           else if ( rt_paramName == "rtTransShadow" ) rendParams.IsTransparentShadowEnabled = rt_paramValue.toInt();
2772         }
2773       }
2774       else if ( paramName == "envTexture" )
2775       {
2776         Handle(Graphic3d_TextureEnv) aTexture;
2777         QStringList etData = paramValue.split( ';' );
2778         foreach( QString etParam, etData )
2779         {
2780           QString et_paramName  = etParam.section( '~', 0, 0 ).trimmed();
2781           QString et_paramValue = etParam.section( '~', 1, 1 ).trimmed();
2782           if ( et_paramName == "etNumber" )
2783             aTexture = new Graphic3d_TextureEnv( Graphic3d_NameOfTextureEnv( et_paramValue.toInt() ) );
2784           else if ( et_paramName == "etFile" )
2785             aTexture = new Graphic3d_TextureEnv( TCollection_AsciiString( et_paramValue.toStdString().c_str() ) );
2786           Handle(V3d_View) aView = this->getViewPort()->getView();
2787           aView->SetTextureEnv( aTexture );
2788 #if OCC_VERSION_LARGE <= 0x07000000
2789           aView->SetSurfaceDetail( V3d_TEX_ENVIRONMENT );
2790 #endif
2791         }
2792       }
2793       else if ( paramName == "lightSource" )
2794       {
2795         myModel->getViewer3d()->InitDefinedLights();
2796         while ( myModel->getViewer3d()->MoreDefinedLights() )
2797         {
2798           Handle(V3d_Light) aLight = myModel->getViewer3d()->DefinedLight();
2799           if( aLight->Type() != V3d_AMBIENT )
2800             myModel->getViewer3d()->DelLight( aLight );
2801           myModel->getViewer3d()->NextDefinedLights();
2802         }
2803         double aX, aY, aZ;
2804         double cR, cG, cB;
2805         V3d_TypeOfLight aType;
2806         bool isHeadlight;
2807         QStringList lsData = paramValue.split( ';' );
2808         foreach( QString lsParam, lsData )
2809         {
2810           QString ls_paramName  = lsParam.section( '~', 0, 0 ).trimmed();
2811           QString ls_paramValue = lsParam.section( '~', 1, 1 ).trimmed();
2812           if ( ls_paramName == "lightType" ) aType = V3d_TypeOfLight( ls_paramValue.toInt() );
2813           else if ( ls_paramName == "lightX" ) aX = ls_paramValue.toDouble();
2814           else if ( ls_paramName == "lightY" ) aY = ls_paramValue.toDouble();
2815           else if ( ls_paramName == "lightZ" ) aZ = ls_paramValue.toDouble();
2816           else if ( ls_paramName == "lightColorR" ) cR = ls_paramValue.toDouble();
2817           else if ( ls_paramName == "lightColorG" ) cG = ls_paramValue.toDouble();
2818           else if ( ls_paramName == "lightColorB" ) cB = ls_paramValue.toDouble();
2819           else if ( ls_paramName == "lightHeadlight" ) isHeadlight = ls_paramValue.toInt();
2820         }
2821         Quantity_Color aColor = Quantity_Color( cR, cG, cB, Quantity_TOC_RGB );
2822         if( aType == V3d_DIRECTIONAL ) {
2823           Handle(V3d_DirectionalLight) aLight = new V3d_DirectionalLight( myModel->getViewer3d() );
2824           aLight->SetDirection( aX, aY, aZ );
2825           aLight->SetColor( aColor );
2826           aLight->SetHeadlight( isHeadlight );
2827           myModel->getViewer3d()->SetLightOn( aLight );
2828         }
2829         else if( aType == V3d_POSITIONAL ) {
2830           Handle(V3d_PositionalLight) aLight = new V3d_PositionalLight( myModel->getViewer3d(), aX, aY, aZ, aColor.Name() );
2831           aLight->SetHeadlight( isHeadlight );
2832           myModel->getViewer3d()->SetLightOn( aLight );
2833         }
2834       }
2835       else if ( paramName == "background" )        {
2836   QString bg = paramValue.replace( "$", "=" );
2837   bgData = Qtx::stringToBackground( bg );
2838       }
2839     }
2840   }
2841   else // old format - "1.000e+00*0.000e+00..."
2842   {
2843     int idx = 0;
2844     params.scale     = data.count() > idx ? data[idx++].toDouble() : 1.0;
2845     params.centerX   = data.count() > idx ? data[idx++].toDouble() : 0.0;
2846     params.centerY   = data.count() > idx ? data[idx++].toDouble() : 0.0;
2847     params.projX     = data.count() > idx ? data[idx++].toDouble() : sqrt(1./3);
2848     params.projY     = data.count() > idx ? data[idx++].toDouble() : -sqrt(1./3);
2849     params.projZ     = data.count() > idx ? data[idx++].toDouble() : sqrt(1./3);
2850     params.twist     = data.count() > idx ? data[idx++].toDouble() : 0.0;
2851     params.atX       = data.count() > idx ? data[idx++].toDouble() : 0.0;
2852     params.atY       = data.count() > idx ? data[idx++].toDouble() : 0.0;
2853     params.atZ       = data.count() > idx ? data[idx++].toDouble() : 0.0;
2854     params.eyeX      = data.count() > idx ? data[idx++].toDouble() : sqrt(250000./3);
2855     params.eyeY      = data.count() > idx ? data[idx++].toDouble() : -sqrt(250000./3);
2856     params.eyeZ      = data.count() > idx ? data[idx++].toDouble() : sqrt(250000./3);
2857     params.scaleX    = data.count() > idx ? data[idx++].toDouble() : 1.0;
2858     params.scaleY    = data.count() > idx ? data[idx++].toDouble() : 1.0;
2859     params.scaleZ    = data.count() > idx ? data[idx++].toDouble() : 1.0;
2860     params.isVisible = data.count() > idx ? data[idx++].toInt()    : 1;
2861     params.size      = data.count() > idx ? data[idx++].toDouble() : 100.0;
2862   }
2863   performRestoring( params );
2864   setBackground( bgData );
2865   myModel->setClipPlanes(aClipPlanes);
2866 }
2867
2868 /*!
2869   \brief Handle show event.
2870
2871   Emits Show() signal.
2872
2873   \param theEvent show event
2874 */
2875 void OCCViewer_ViewWindow::showEvent( QShowEvent* theEvent )
2876 {
2877   emit Show( theEvent );
2878 }
2879
2880 /*!
2881   \brief Handle hide event.
2882
2883   Emits Hide() signal.
2884
2885   \param theEvent hide event
2886 */
2887 void OCCViewer_ViewWindow::hideEvent( QHideEvent* theEvent )
2888 {
2889   emit Hide( theEvent );
2890 }
2891
2892
2893 /*!
2894     Save old cursor. [ protected ]
2895 */
2896 void OCCViewer_ViewWindow::saveCursor()
2897 {
2898   QCursor* aCursor = NULL;
2899   if ( myViewPort )
2900     aCursor = myViewPort->getDefaultCursor();
2901   myCursor = ( aCursor ? *aCursor : cursor() );
2902 }
2903
2904
2905 /*!
2906     Creates default sketcher. [ virtual protected ]
2907 */
2908 OCCViewer_ViewSketcher* OCCViewer_ViewWindow::createSketcher( int type )
2909 {
2910   if ( type == Rect )
2911     return new OCCViewer_RectSketcher( this, type );
2912   if ( type == Polygon )
2913     return new OCCViewer_PolygonSketcher( this, type );
2914   return 0;
2915 }
2916
2917 void OCCViewer_ViewWindow::initSketchers()
2918 {
2919   if ( mySketchers.isEmpty() )
2920   {
2921     mySketchers.append( createSketcher( Rect ) );
2922     mySketchers.append( createSketcher( Polygon ) );
2923   }
2924 }
2925
2926 OCCViewer_ViewSketcher* OCCViewer_ViewWindow::getSketcher( const int typ )
2927 {
2928   OCCViewer_ViewSketcher* sketcher = 0;
2929   QList<OCCViewer_ViewSketcher*>::Iterator it;
2930   for ( it = mySketchers.begin(); it != mySketchers.end() && !sketcher; ++it )
2931   {
2932     OCCViewer_ViewSketcher* sk = (*it);
2933     if ( sk->type() == typ )
2934       sketcher = sk;
2935   }
2936   return sketcher;
2937 }
2938
2939 /*!
2940     Handles requests for sketching in the active view. [ virtual public ]
2941 */
2942 void OCCViewer_ViewWindow::activateSketching( int type )
2943 {
2944   OCCViewer_ViewPort3d* vp = getViewPort();
2945   if ( !vp )
2946     return;
2947
2948   if ( !vp->isSketchingEnabled() )
2949     return;
2950
2951   /* Finish current sketching */
2952   if ( type == NoSketching )
2953   {
2954     if ( mypSketcher )
2955     {
2956       onSketchingFinished();
2957       mypSketcher->deactivate();
2958       mypSketcher = 0;
2959     }
2960   }
2961   /* Activate new sketching */
2962   else
2963   {
2964     activateSketching( NoSketching );  /* concurrency not suported */
2965     mypSketcher = getSketcher( type );
2966     if ( mypSketcher )
2967     {
2968       mypSketcher->activate();
2969       onSketchingStarted();
2970     }
2971   }
2972 }
2973
2974 /*!
2975     Unhilights detected entities. [ virtual protected ]
2976 */
2977 void OCCViewer_ViewWindow::onSketchingStarted()
2978 {
2979 }
2980
2981 /*!
2982     Selection by rectangle or polygon. [ virtual protected ]
2983 */
2984 void OCCViewer_ViewWindow::onSketchingFinished()
2985 {
2986   MESSAGE("OCCViewer_ViewWindow::onSketchingFinished()")
2987   if ( mypSketcher && mypSketcher->result() == OCCViewer_ViewSketcher::Accept )
2988   {
2989     Handle(AIS_InteractiveContext) ic = myModel->getAISContext();
2990     bool append = bool( mypSketcher->buttonState() && mypSketcher->isHasShift() );
2991     switch( mypSketcher->type() )
2992     {
2993     case Rect:
2994       {
2995         QRect* aRect = (QRect*)mypSketcher->data();
2996         if( aRect )
2997         {
2998           int aLeft = aRect->left();
2999           int aRight = aRect->right();
3000           int aTop = aRect->top();
3001           int aBottom = aRect->bottom();
3002 //           myRect = aRect;
3003
3004           if( append )
3005             ic->ShiftSelect( aLeft, aBottom, aRight, aTop, getViewPort()->getView(), Standard_False );
3006           else
3007             ic->Select( aLeft, aBottom, aRight, aTop, getViewPort()->getView(), Standard_False );
3008         }
3009       }
3010       break;
3011     case Polygon:
3012       {
3013         QPolygon* aPolygon = (QPolygon*)mypSketcher->data();
3014         if( aPolygon )
3015         {
3016           int size = aPolygon->size();
3017           TColgp_Array1OfPnt2d anArray( 1, size );
3018
3019           QPolygon::Iterator it = aPolygon->begin();
3020           QPolygon::Iterator itEnd = aPolygon->end();
3021           for( int index = 1; it != itEnd; ++it, index++ )
3022           {
3023             QPoint aPoint = *it;
3024             anArray.SetValue( index, gp_Pnt2d( aPoint.x(), aPoint.y() ) );
3025           }
3026
3027           if( append )
3028             ic->ShiftSelect( anArray, getViewPort()->getView(), Standard_False );
3029           else
3030             ic->Select( anArray, getViewPort()->getView(), Standard_False );
3031         }
3032       }
3033       break;
3034     default:
3035       break;
3036     }
3037
3038     OCCViewer_ViewManager* aViewMgr = ( OCCViewer_ViewManager* )getViewManager();
3039     aViewMgr->getOCCViewer()->performSelectionChanged();
3040   }
3041 }
3042
3043 OCCViewer_ViewPort3d* OCCViewer_ViewWindow::getViewPort()
3044 {
3045   return myViewPort;
3046 }
3047
3048 bool OCCViewer_ViewWindow::transformRequested() const
3049 {
3050   return ( myOperation != NOTHING );
3051 }
3052
3053 bool OCCViewer_ViewWindow::transformInProcess() const
3054 {
3055   return myEventStarted;
3056 }
3057
3058 void OCCViewer_ViewWindow::setTransformInProcess( bool bOn )
3059 {
3060   myEventStarted = bOn;
3061 }
3062
3063 /*!
3064   Set enabled state of transformation (rotate, zoom, etc)
3065 */
3066 void OCCViewer_ViewWindow::setTransformEnabled( const OperationType id, const bool on )
3067 {
3068   if ( id != NOTHING ) myStatus.insert( id, on );
3069 }
3070
3071 /*!
3072   \return enabled state of transformation (rotate, zoom, etc)
3073 */
3074 bool OCCViewer_ViewWindow::transformEnabled( const OperationType id ) const
3075 {
3076   return myStatus.contains( id ) ? myStatus[ id ] : true;
3077 }
3078
3079 void OCCViewer_ViewWindow::onMaximizedView()
3080 {
3081   setMaximized(!isMaximized());
3082 }
3083
3084 void OCCViewer_ViewWindow::returnTo3dView()
3085 {
3086   setReturnedTo3dView( true );
3087 }
3088
3089 void OCCViewer_ViewWindow::setReturnedTo3dView(bool isVisible3dView)
3090 {
3091   if ( !toolMgr()->action( ReturnTo3dViewId ) ||
3092     toolMgr()->isShown(ReturnTo3dViewId) != isVisible3dView ) return;
3093   if ( !isVisible3dView )
3094     toolMgr()->show( ReturnTo3dViewId );
3095   else
3096     toolMgr()->hide( ReturnTo3dViewId );
3097   if ( isVisible3dView ) emit returnedTo3d( );
3098 }
3099
3100
3101 void OCCViewer_ViewWindow::setMaximized(bool toMaximize, bool toSendSignal)
3102 {
3103   QAction* anAction =  toolMgr()->action( MaximizedId );
3104   QAction* anAction2 =  toolMgr()->action( ReturnTo3dViewId );
3105   SUIT_ResourceMgr* aResMgr = SUIT_Session::session()->resourceMgr();
3106   if ( toMaximize ) {
3107     anAction->setText( tr( "MNU_MINIMIZE_VIEW" ) );
3108     anAction->setToolTip( tr( "MNU_MINIMIZE_VIEW" ) );
3109     anAction->setIcon( aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_MINIMIZE" ) ) );
3110     anAction->setStatusTip( tr( "DSC_MINIMIZE_VIEW" ) );
3111     if ( anAction2 && my2dMode != No2dMode ) toolMgr()->show( ReturnTo3dViewId );
3112     if (toSendSignal) {
3113       emit maximized( this, true );
3114     }
3115   }
3116   else {
3117     anAction->setText( tr( "MNU_MAXIMIZE_VIEW" ) );
3118     anAction->setToolTip( tr( "MNU_MAXIMIZE_VIEW" ) );
3119     anAction->setIcon( aResMgr->loadPixmap( "OCCViewer", tr( "ICON_OCCVIEWER_MAXIMIZE" ) ) );
3120     anAction->setStatusTip( tr( "DSC_MAXIMIZE_VIEW" ) );
3121     if ( anAction2 && my2dMode != No2dMode ) toolMgr()->hide( ReturnTo3dViewId );
3122     if (toSendSignal) {
3123       emit maximized( this, false );
3124     }
3125   }
3126 }
3127
3128 bool OCCViewer_ViewWindow::isMaximized() const
3129 {
3130   return !(toolMgr()->action( MaximizedId )->text() == tr( "MNU_MAXIMIZE_VIEW" ));
3131 }
3132
3133 void OCCViewer_ViewWindow::setSketcherStyle( bool enable )
3134 {
3135   IsSketcherStyle = enable;
3136 }
3137
3138 bool OCCViewer_ViewWindow::isSketcherStyle() const
3139 {
3140   return IsSketcherStyle;
3141 }
3142
3143
3144 void OCCViewer_ViewWindow::set2dMode(Mode2dType theType)
3145 {
3146   my2dMode = theType;
3147 }
3148
3149 int OCCViewer_ViewWindow::projectionType() const
3150 {
3151   int mode = Orthographic;
3152   Handle(V3d_View) aView3d = myViewPort->getView();
3153   if ( !aView3d.IsNull() ) {
3154     Handle(Graphic3d_Camera) aCamera = aView3d->Camera();
3155     if (aCamera->ProjectionType() == Graphic3d_Camera::Projection_Perspective)
3156       mode = Perspective;
3157     if (aCamera->ProjectionType() == Graphic3d_Camera::Projection_Orthographic)
3158       mode = Orthographic;
3159   #if OCC_VERSION_LARGE > 0x06090000
3160     if (aCamera->ProjectionType() == Graphic3d_Camera::Projection_Stereo)
3161       mode = Stereo;
3162   #endif
3163   }
3164   return mode;
3165 }
3166
3167 void OCCViewer_ViewWindow::setStereoType( int type )
3168 {
3169   Handle(V3d_View) aView3d = myViewPort->getView();
3170   if ( !aView3d.IsNull() ) {
3171   #if OCC_VERSION_LARGE > 0x06090000
3172     Graphic3d_RenderingParams* aParams = &aView3d->ChangeRenderingParams();
3173     aParams->StereoMode = (Graphic3d_StereoMode)type;
3174   #endif
3175   }
3176 }
3177
3178 int OCCViewer_ViewWindow::stereoType() const
3179 {
3180   int type = QuadBuffer;
3181   Handle(V3d_View) aView3d = myViewPort->getView();
3182   if ( !aView3d.IsNull() ) {
3183   #if OCC_VERSION_LARGE > 0x06090000
3184     Graphic3d_RenderingParams* aParams = &aView3d->ChangeRenderingParams();
3185     type = (OCCViewer_ViewWindow::StereoType)aParams->StereoMode;
3186   #endif
3187   }
3188   return type;
3189 }
3190
3191 void OCCViewer_ViewWindow::setAnaglyphFilter( int type )
3192 {
3193   Handle(V3d_View) aView3d = myViewPort->getView();
3194   if ( !aView3d.IsNull() ) {
3195   #if OCC_VERSION_LARGE > 0x06090000
3196     Graphic3d_RenderingParams* aParams = &aView3d->ChangeRenderingParams();
3197     if (type == RedCyan)
3198       aParams->AnaglyphFilter = Graphic3d_RenderingParams::Anaglyph_RedCyan_Optimized;
3199     if (type == YellowBlue)
3200       aParams->AnaglyphFilter = Graphic3d_RenderingParams::Anaglyph_YellowBlue_Optimized;
3201     if (type == GreenMagenta)
3202       aParams->AnaglyphFilter = Graphic3d_RenderingParams::Anaglyph_GreenMagenta_Simple;
3203   #endif
3204   }
3205 }
3206
3207 int OCCViewer_ViewWindow::anaglyphFilter() const
3208 {
3209   int type = RedCyan;
3210   Handle(V3d_View) aView3d = myViewPort->getView();
3211   if ( !aView3d.IsNull() ) {
3212   #if OCC_VERSION_LARGE > 0x06090000
3213     Graphic3d_RenderingParams* aParams = &aView3d->ChangeRenderingParams();
3214     if (aParams->AnaglyphFilter == Graphic3d_RenderingParams::Anaglyph_RedCyan_Optimized)
3215       type = RedCyan;
3216     if (aParams->AnaglyphFilter == Graphic3d_RenderingParams::Anaglyph_YellowBlue_Optimized)
3217       type = YellowBlue;
3218     if (aParams->AnaglyphFilter == Graphic3d_RenderingParams::Anaglyph_GreenMagenta_Simple)
3219       type = GreenMagenta;
3220   #endif
3221   }
3222   return type;
3223 }
3224
3225 void OCCViewer_ViewWindow::setStereographicFocus( int type, double value )
3226 {
3227   Handle(V3d_View) aView3d = myViewPort->getView();
3228   if ( !aView3d.IsNull() ) {
3229   #if OCC_VERSION_LARGE > 0x06090000
3230     Handle(Graphic3d_Camera) aCamera = aView3d->Camera();
3231     aCamera->SetZFocus( (Graphic3d_Camera::FocusType) type, value );
3232   #endif
3233   }
3234 }
3235
3236 int OCCViewer_ViewWindow::stereographicFocusType() const
3237 {
3238   int type = Relative;
3239   Handle(V3d_View) aView3d = myViewPort->getView();
3240   if ( !aView3d.IsNull() ) {
3241   #if OCC_VERSION_LARGE > 0x06090000
3242     Handle(Graphic3d_Camera) aCamera = aView3d->Camera();
3243     type = (OCCViewer_ViewWindow::FocusIODType)aCamera->ZFocusType();
3244   #endif
3245   }
3246   return type;
3247 }
3248
3249 double OCCViewer_ViewWindow::stereographicFocusValue() const
3250 {
3251   double value = 1.0;
3252   Handle(V3d_View) aView3d = myViewPort->getView();
3253   if ( !aView3d.IsNull() ) {
3254   #if OCC_VERSION_LARGE > 0x06090000
3255     Handle(Graphic3d_Camera) aCamera = aView3d->Camera();
3256     value = aCamera->ZFocus();
3257   #endif
3258   }
3259   return value;
3260 }
3261
3262 void OCCViewer_ViewWindow::setInterocularDistance( int type, double value )
3263 {
3264   Handle(V3d_View) aView3d = myViewPort->getView();
3265   if ( !aView3d.IsNull() ) {
3266   #if OCC_VERSION_LARGE > 0x06090000
3267     Handle(Graphic3d_Camera) aCamera = aView3d->Camera();
3268     aCamera->SetIOD( (Graphic3d_Camera::IODType) type, value );
3269   #endif
3270   }
3271 }
3272
3273 int OCCViewer_ViewWindow::interocularDistanceType() const
3274 {
3275   int type = Relative;
3276   Handle(V3d_View) aView3d = myViewPort->getView();
3277   if ( !aView3d.IsNull() ) {
3278   #if OCC_VERSION_LARGE > 0x06090000
3279     Handle(Graphic3d_Camera) aCamera = aView3d->Camera();
3280     type = (OCCViewer_ViewWindow::FocusIODType)aCamera->GetIODType();
3281   #endif
3282   }
3283   return type;
3284 }
3285
3286 double OCCViewer_ViewWindow::interocularDistanceValue() const
3287 {
3288   double value = 0.05;
3289   Handle(V3d_View) aView3d = myViewPort->getView();
3290   if ( !aView3d.IsNull() ) {
3291   #if OCC_VERSION_LARGE > 0x06090000
3292     Handle(Graphic3d_Camera) aCamera = aView3d->Camera();
3293     value = aCamera->IOD();
3294   #endif
3295   }
3296   return value;
3297 }
3298
3299 void OCCViewer_ViewWindow::setReverseStereo( bool reverse )
3300 {
3301   Handle(V3d_View) aView3d = myViewPort->getView();
3302   if ( !aView3d.IsNull() ) {
3303   #if OCC_VERSION_LARGE > 0x06090000
3304     Graphic3d_RenderingParams* aParams = &aView3d->ChangeRenderingParams();
3305     aParams->ToReverseStereo = reverse;
3306   #endif
3307   }
3308 }
3309
3310 bool OCCViewer_ViewWindow::isReverseStereo() const
3311 {
3312   int reverse = false;
3313   Handle(V3d_View) aView3d = myViewPort->getView();
3314   if ( !aView3d.IsNull() ) {
3315   #if OCC_VERSION_LARGE > 0x06090000
3316     Graphic3d_RenderingParams* aParams = &aView3d->ChangeRenderingParams();
3317     reverse = aParams->ToReverseStereo;
3318   #endif
3319   }
3320   return reverse;
3321 }
3322
3323 void OCCViewer_ViewWindow::setVSync( bool enable )
3324 {
3325   Handle(AIS_InteractiveContext) anIntCont = myModel->getAISContext();
3326   if ( !anIntCont.IsNull() ) {
3327   #if OCC_VERSION_LARGE > 0x06090000
3328     Handle(OpenGl_GraphicDriver) aDriver = Handle(OpenGl_GraphicDriver)::DownCast(anIntCont->CurrentViewer()->Driver());
3329     OpenGl_Caps* aCaps = &aDriver->ChangeOptions();
3330     aCaps->swapInterval = enable;
3331   #endif
3332   }
3333 }
3334
3335 bool OCCViewer_ViewWindow::isVSync() const
3336 {
3337   int enable = true;
3338   Handle(AIS_InteractiveContext) anIntCont = myModel->getAISContext();
3339   if ( !anIntCont.IsNull() ) {
3340   #if OCC_VERSION_LARGE > 0x06090000
3341     Handle(OpenGl_GraphicDriver) aDriver = Handle(OpenGl_GraphicDriver)::DownCast(anIntCont->CurrentViewer()->Driver());
3342     OpenGl_Caps* aCaps = &aDriver->ChangeOptions();
3343     enable = aCaps->swapInterval;
3344   #endif
3345   }
3346   return enable;
3347 }
3348
3349 void OCCViewer_ViewWindow::setQuadBufferSupport( bool enable )
3350 {
3351   Handle(AIS_InteractiveContext) anIntCont = myModel->getAISContext();
3352   if ( !anIntCont.IsNull() ) {
3353   #if OCC_VERSION_LARGE > 0x06090000
3354     Handle(OpenGl_GraphicDriver) aDriver = Handle(OpenGl_GraphicDriver)::DownCast(anIntCont->CurrentViewer()->Driver());
3355     OpenGl_Caps* aCaps = &aDriver->ChangeOptions();
3356     aCaps->contextStereo = enable;
3357   #endif
3358   }
3359 }
3360
3361 bool OCCViewer_ViewWindow::isQuadBufferSupport() const
3362 {
3363   int enable = true;
3364   Handle(AIS_InteractiveContext) anIntCont = myModel->getAISContext();
3365   if ( !anIntCont.IsNull() ) {
3366   #if OCC_VERSION_LARGE > 0x06090000
3367     Handle(OpenGl_GraphicDriver) aDriver = Handle(OpenGl_GraphicDriver)::DownCast(anIntCont->CurrentViewer()->Driver());
3368     OpenGl_Caps* aCaps = &aDriver->ChangeOptions();
3369     enable = aCaps->contextStereo;
3370   #endif
3371   }
3372   return enable;
3373 }
3374
3375
3376 bool OCCViewer_ViewWindow::isOpenGlStereoSupport() const
3377 {
3378   GLboolean support[1];
3379   glGetBooleanv (GL_STEREO, support);
3380   if ( support[0] )
3381     return true;
3382   return false;
3383 }
3384
3385 // obsolete
3386 QColor OCCViewer_ViewWindow::backgroundColor() const
3387 {
3388   return myViewPort ? myViewPort->backgroundColor() : Qt::black;
3389 }
3390
3391 // obsolete
3392 void OCCViewer_ViewWindow::setBackgroundColor( const QColor& theColor )
3393 {
3394   if ( myViewPort ) myViewPort->setBackgroundColor( theColor );
3395 }
3396
3397 Qtx::BackgroundData OCCViewer_ViewWindow::background() const
3398 {
3399   return myViewPort ? myViewPort->background() : Qtx::BackgroundData();
3400 }
3401
3402 void OCCViewer_ViewWindow::setBackground( const Qtx::BackgroundData& theBackground )
3403 {
3404   if ( myViewPort ) myViewPort->setBackground( theBackground );
3405 }
3406
3407 void OCCViewer_ViewWindow::showStaticTrihedron( bool on )
3408 {
3409   if ( myViewPort ) myViewPort->showStaticTrihedron( on );
3410 }
3411
3412 /*!
3413   Clears view aspects
3414 */
3415 void OCCViewer_ViewWindow::clearViewAspects()
3416 {
3417   myViewAspects.clear();
3418 }
3419
3420 /*!
3421   \return const reference to list of view aspects
3422 */
3423 const viewAspectList& OCCViewer_ViewWindow::getViewAspects()
3424 {
3425   return myViewAspects;
3426 }
3427
3428 /*!
3429   Appends new view aspect
3430   \param aParams - new view aspects
3431 */
3432 void OCCViewer_ViewWindow::appendViewAspect( const viewAspect& aParams )
3433 {
3434   myViewAspects.append( aParams );
3435 }
3436
3437 /*!
3438   Replaces old view aspects by new ones
3439   \param aViewList - list of new view aspects
3440 */
3441 void OCCViewer_ViewWindow::updateViewAspects( const viewAspectList& aViewList )
3442 {
3443   myViewAspects = aViewList;
3444 }
3445
3446 /*!
3447   Get camera properties for the OCC view window.
3448   \return shared pointer on camera properties.
3449 */
3450 SUIT_CameraProperties OCCViewer_ViewWindow::cameraProperties()
3451 {
3452   SUIT_CameraProperties aProps;
3453
3454   Handle(V3d_View) aSourceView = getViewPort()->getView();
3455   if ( aSourceView.IsNull() )
3456     return aProps;
3457
3458   if ( get2dMode() == No2dMode ) {
3459     aProps.setDimension( SUIT_CameraProperties::Dim3D );
3460   }
3461   else {
3462     aProps.setDimension( SUIT_CameraProperties::Dim2D );
3463     aProps.setViewSide( (SUIT_CameraProperties::ViewSide)(int)get2dMode() );
3464   }
3465
3466   // read common properites of the view
3467   Standard_Real anUp[3];
3468   Standard_Real anAt[3];
3469   Standard_Real anEye[3];
3470   Standard_Real aProj[3];
3471   Standard_Real anAxialScale[3];
3472
3473   aSourceView->Up( anUp[0], anUp[1], anUp[2] );
3474   aSourceView->At( anAt[0], anAt[1], anAt[2] );
3475   aSourceView->Proj( aProj[0], aProj[1], aProj[2] );
3476   getViewPort()->getAxialScale( anAxialScale[0], anAxialScale[1], anAxialScale[2] );
3477
3478   aProps.setAxialScale( anAxialScale[0], anAxialScale[1], anAxialScale[2] );
3479   aProps.setViewUp( anUp[0], anUp[1], anUp[2] );
3480
3481 #if OCC_VERSION_LARGE > 0x06070100
3482   aSourceView->Eye( anEye[0], anEye[1], anEye[2] );
3483
3484   // store camera properties "as is": it is up to synchronized
3485   // view classes to provide necessary property conversion.
3486   aProps.setPosition( anEye[0], anEye[1], anEye[2] );
3487   aProps.setFocalPoint( anAt[0], anAt[1], anAt[2] );
3488
3489   if ( aSourceView->Camera()->IsOrthographic() )
3490   {
3491     aProps.setProjection( SUIT_CameraProperties::PrjOrthogonal );
3492     aProps.setViewAngle( 0.0 );
3493   }
3494   else
3495   {
3496     aProps.setProjection( SUIT_CameraProperties::PrjPerspective );
3497     aProps.setViewAngle( aSourceView->Camera()->FOVy() );
3498   }
3499   aProps.setMappingScale( aSourceView->Camera()->Scale() );
3500 #else
3501   Standard_Real aCameraDepth = aSourceView->Depth() + aSourceView->ZSize() * 0.5;
3502
3503   // generate view orientation matrix for transforming OCC projection reference point
3504   // into a camera (eye) position.
3505   gp_Dir aLeftDir = gp_Dir( anUp[0], anUp[1], anUp[2] ) ^ gp_Dir( aProj[0], aProj[1], aProj[2] );
3506
3507   gp_GTrsf aTrsf;
3508   aTrsf.SetValue( 1, 1, aLeftDir.X() );
3509   aTrsf.SetValue( 2, 1, aLeftDir.Y() );
3510   aTrsf.SetValue( 3, 1, aLeftDir.Z() );
3511
3512   aTrsf.SetValue( 1, 2, anUp[0] );
3513   aTrsf.SetValue( 2, 2, anUp[1] );
3514   aTrsf.SetValue( 3, 2, anUp[2] );
3515
3516   aTrsf.SetValue( 1, 3, aProj[0] );
3517   aTrsf.SetValue( 2, 3, aProj[1] );
3518   aTrsf.SetValue( 3, 3, aProj[2] );
3519
3520   aTrsf.SetValue( 1, 4, anAt[0] );
3521   aTrsf.SetValue( 2, 4, anAt[1] );
3522   aTrsf.SetValue( 3, 4, anAt[2] );
3523
3524   Graphic3d_Vertex aProjRef = aSourceView->ViewMapping().ProjectionReferencePoint();
3525
3526   // transform to world-space coordinate system
3527   gp_XYZ aPosition( aProjRef.X(), aProjRef.Y(), aCameraDepth );
3528   aTrsf.Transforms( aPosition );
3529
3530   // compute focal point
3531   double aFocalPoint[3];
3532
3533   aFocalPoint[0] = aPosition.X() - aProj[0] * aCameraDepth;
3534   aFocalPoint[1] = aPosition.Y() - aProj[1] * aCameraDepth;
3535   aFocalPoint[2] = aPosition.Z() - aProj[2] * aCameraDepth;
3536
3537   aProps.setFocalPoint( aFocalPoint[0], aFocalPoint[1], aFocalPoint[2] );
3538   aProps.setPosition( aPosition.X(), aPosition.Y(), aPosition.Z() );
3539
3540   Standard_Real aViewScale[2];
3541   aSourceView->Size( aViewScale[0], aViewScale[1] );
3542   aProps.setMappingScale( aViewScale[1] );
3543 #endif
3544
3545   return aProps;
3546 }
3547
3548 /*!
3549   Synchronize views.
3550   This implementation synchronizes OCC view's camera propreties.
3551 */
3552 void OCCViewer_ViewWindow::synchronize( SUIT_ViewWindow* theView )
3553 {
3554   bool blocked = blockSignals( true );
3555
3556   SUIT_CameraProperties aProps = theView->cameraProperties();
3557   if ( !cameraProperties().isCompatible( aProps ) ) {
3558     // other view, this one is being currently synchronized to, seems has become incompatible
3559     // we have to break synchronization
3560     updateSyncViews();
3561     return;
3562   }
3563
3564   Handle(V3d_View) aDestView = getViewPort()->getView();
3565
3566   aDestView->SetImmediateUpdate( Standard_False );
3567
3568   double anUpDir[3];
3569   double aPosition[3];
3570   double aFocalPoint[3];
3571   double anAxialScale[3];
3572
3573   // get common properties
3574   aProps.getFocalPoint( aFocalPoint[0], aFocalPoint[1], aFocalPoint[2] );
3575   aProps.getPosition( aPosition[0], aPosition[1], aPosition[2] );
3576   aProps.getViewUp( anUpDir[0], anUpDir[1], anUpDir[2] );
3577   aProps.getAxialScale( anAxialScale[0], anAxialScale[1], anAxialScale[2] );
3578
3579 #if OCC_VERSION_LARGE > 0x06070100
3580   aDestView->SetAt( aFocalPoint[0], aFocalPoint[1], aFocalPoint[2] );
3581   aDestView->SetEye( aPosition[0], aPosition[1], aPosition[2] );
3582   aDestView->SetUp( anUpDir[0], anUpDir[1], anUpDir[2] );
3583   aDestView->Camera()->SetScale( aProps.getMappingScale() );
3584 #else
3585   gp_Dir aProjDir( aPosition[0] - aFocalPoint[0],
3586                    aPosition[1] - aFocalPoint[1],
3587                    aPosition[2] - aFocalPoint[2] );
3588
3589   // get custom view translation
3590   Standard_Real aTranslation[3];
3591   aDestView->At( aTranslation[0], aTranslation[1], aTranslation[2] );
3592
3593   gp_Dir aLeftDir = gp_Dir( anUpDir[0], anUpDir[1], anUpDir[2] )
3594                   ^ gp_Dir( aProjDir.X(), aProjDir.Y(), aProjDir.Z() );
3595
3596   gp_GTrsf aTrsf;
3597   aTrsf.SetValue( 1, 1, aLeftDir.X() );
3598   aTrsf.SetValue( 2, 1, aLeftDir.Y() );
3599   aTrsf.SetValue( 3, 1, aLeftDir.Z() );
3600
3601   aTrsf.SetValue( 1, 2, anUpDir[0] );
3602   aTrsf.SetValue( 2, 2, anUpDir[1] );
3603   aTrsf.SetValue( 3, 2, anUpDir[2] );
3604
3605   aTrsf.SetValue( 1, 3, aProjDir.X() );
3606   aTrsf.SetValue( 2, 3, aProjDir.Y() );
3607   aTrsf.SetValue( 3, 3, aProjDir.Z() );
3608
3609   aTrsf.SetValue( 1, 4, aTranslation[0] );
3610   aTrsf.SetValue( 2, 4, aTranslation[1] );
3611   aTrsf.SetValue( 3, 4, aTranslation[2] );
3612   aTrsf.Invert();
3613
3614   // transform to view-space coordinate system
3615   gp_XYZ aProjRef( aPosition[0], aPosition[1], aPosition[2] );
3616   aTrsf.Transforms( aProjRef );
3617
3618   // set view camera properties using low-level approach. this is done
3619   // in order to avoid interference with static variables in v3d view used
3620   // when rotation is in process in another view.
3621   Visual3d_ViewMapping aMapping = aDestView->View()->ViewMapping();
3622   Visual3d_ViewOrientation anOrientation = aDestView->View()->ViewOrientation();
3623
3624   Graphic3d_Vector aMappingProj( aProjDir.X(), aProjDir.Y(), aProjDir.Z() );
3625   Graphic3d_Vector aMappingUp( anUpDir[0], anUpDir[1], anUpDir[2] );
3626
3627   aMappingProj.Normalize();
3628   aMappingUp.Normalize();
3629
3630   anOrientation.SetViewReferencePlane( aMappingProj );
3631   anOrientation.SetViewReferenceUp( aMappingUp );
3632
3633   aDestView->SetViewMapping( aMapping );
3634   aDestView->SetViewOrientation( anOrientation );
3635
3636   // set panning
3637   aDestView->SetCenter( aProjRef.X(), aProjRef.Y() );
3638
3639   // set mapping scale
3640   double aMapScaling = aProps.getMappingScale();
3641   Standard_Real aWidth, aHeight;
3642   aDestView->Size( aWidth, aHeight );
3643   aDestView->SetSize ( aWidth > aHeight ? aMapScaling * (aWidth / aHeight) : aMapScaling );
3644 #endif
3645
3646   getViewPort()->setAxialScale( anAxialScale[0], anAxialScale[1], anAxialScale[2] );
3647
3648   aDestView->ZFitAll();
3649   aDestView->SetImmediateUpdate( Standard_True );
3650   aDestView->Redraw();
3651
3652   blockSignals( blocked );
3653 }
3654
3655 /*!
3656   \brief Indicates whether preselection is enabled
3657   \return true if preselection is enabled
3658 */
3659 bool OCCViewer_ViewWindow::isPreselectionEnabled() const
3660 {
3661   return myPreselectionEnabled;
3662 }
3663
3664 /*!
3665   \brief Enables/disables preselection
3666   \param theIsToEnable if true - preselection will be enabled
3667 */
3668 void OCCViewer_ViewWindow::enablePreselection( bool theIsToEnable )
3669 {
3670   onSwitchPreselection( theIsToEnable );
3671 }
3672
3673 /*!
3674   \brief Indicates whether selection is enabled
3675   \return true if selection is enabled
3676 */
3677 bool OCCViewer_ViewWindow::isSelectionEnabled() const
3678 {
3679   return mySelectionEnabled;
3680 }
3681
3682 /*!
3683   \brief Enables/disables selection
3684   \param theIsToEnable if true - selection will be enabled
3685 */
3686 void OCCViewer_ViewWindow::enableSelection( bool theIsToEnable )
3687 {
3688   onSwitchSelection( theIsToEnable );
3689 }
3690
3691
3692 /*!
3693   \brief called if clipping operation is activated / deactivated.
3694
3695   Enables/disables clipping plane displaying.
3696
3697   \parma on action state
3698 */
3699 void OCCViewer_ViewWindow::onClipping (bool theIsOn)
3700 {
3701   if(!myModel) return;
3702   OCCViewer_ClippingDlg* aClippingDlg = myModel->getClippingDlg();
3703
3704   if (theIsOn) {
3705     if (!aClippingDlg) {
3706       aClippingDlg = new OCCViewer_ClippingDlg (this, myModel);
3707       myModel->setClippingDlg(aClippingDlg);
3708     }
3709     if (!aClippingDlg->isVisible())
3710       aClippingDlg->show();
3711   } else {
3712     if ( aClippingDlg ) {
3713       aClippingDlg->close();
3714       myModel->setClippingDlg(0);
3715     }
3716   }
3717
3718   SUIT_ViewManager* mgr = getViewManager();
3719   if( mgr ) {
3720     QVector<SUIT_ViewWindow*> aViews = mgr->getViews();
3721     for(int i = 0, iEnd = aViews.size(); i < iEnd; i++) {
3722       if(SUIT_ViewWindow* aViewWindow = aViews.at(i)) {
3723         QtxActionToolMgr* mgr = aViewWindow->toolMgr();
3724         if(!mgr) continue;
3725         QAction* a = toolMgr()->action( ClippingId );
3726         if(!a) continue;
3727         if(theIsOn != a->isChecked()){
3728           disconnect (a, SIGNAL (toggled (bool)), aViewWindow, SLOT (onClipping (bool)));
3729           a->setChecked(theIsOn);
3730           connect (a, SIGNAL (toggled (bool)), aViewWindow, SLOT (onClipping (bool)));
3731         }
3732       }
3733     }
3734   }
3735 }
3736
3737 void OCCViewer_ViewWindow::onRayTracing()
3738 {
3739   if( !OCCViewer_Utilities::isDialogOpened( this, OCCViewer_RayTracingDlg::getName() ) ) {
3740     QDialog* aDlg = new OCCViewer_RayTracingDlg( this );
3741     if ( aDlg != NULL )
3742       aDlg->show();
3743   }
3744 }
3745
3746 void OCCViewer_ViewWindow::onEnvTexture()
3747 {
3748   if( !OCCViewer_Utilities::isDialogOpened( this, OCCViewer_EnvTextureDlg::getName() ) ) {
3749     QDialog* aDlg = new OCCViewer_EnvTextureDlg( this );
3750     if ( aDlg != NULL )
3751       aDlg->show();
3752   }
3753 }
3754
3755 void OCCViewer_ViewWindow::onLightSource()
3756 {
3757   if( !OCCViewer_Utilities::isDialogOpened( this, OCCViewer_LightSourceDlg::getName() ) ) {
3758     QDialog* aDlg = new OCCViewer_LightSourceDlg( this, myModel );
3759     if ( aDlg != NULL )
3760       aDlg->show();
3761   }
3762 }