src/GLViewer/GLViewer_Viewer.cxx

   1 // Copyright (C) 2007-2024  CEA, EDF, 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 //  Author : OPEN CASCADE
  24 // File:      GLViewer_Viewer.cxx
  25 // Created:   November, 2004
  26 //#include <GLViewerAfx.h>
  27 //
  28 #include "GLViewer_Viewer.h"
  29 #include "GLViewer_Selector.h"
  30 #include "GLViewer_ViewPort.h"
  31 #include "GLViewer_ViewFrame.h"
  32
  33 //#include "SUIT_Desktop.h"
  34 #include "SUIT_ViewWindow.h"
  35 #include "SUIT_ViewManager.h"
  36
  37 #include <QApplication>
  38 #include <QMenu>
  39 #include <QColorDialog>
  40 #include <QMouseEvent>
  41 #include <QWheelEvent>
  42 #include <QRect>
  43 #include <QRubberBand>
  44
  45 /* used for sketching */
  46 static QEvent* l_mbPressEvent = 0;
  47
  48 /*!
  49     Constructor
  50 */
  51 GLViewer_Viewer::GLViewer_Viewer( const QString& /*title*/ )
  52 : SUIT_ViewModel(),
  53 mySelector( 0 ),
  54 mySelMode( NoSelection ),
  55 mySketcher( 0 ),
  56 myTransformer( 0 )
  57 {
  58 }
  59
  60 /*!
  61     Destructor
  62 */
  63 GLViewer_Viewer::~GLViewer_Viewer()
  64 {
  65     delete mySelector;
  66 }
  67
  68 /*!
  69   Sets new view manager
  70   \param theViewManager - new view manager
  71 */
  72 void GLViewer_Viewer::setViewManager(SUIT_ViewManager* theViewManager)
  73 {
  74   SUIT_ViewModel::setViewManager(theViewManager);
  75   if (theViewManager)
  76   {
  77     connect(theViewManager, SIGNAL(mousePress(SUIT_ViewWindow*, QMouseEvent*)),
  78             this, SLOT(onMouseEvent(SUIT_ViewWindow*, QMouseEvent*)));
  79
  80     connect(theViewManager, SIGNAL(mouseMove(SUIT_ViewWindow*, QMouseEvent*)),
  81             this, SLOT(onMouseEvent(SUIT_ViewWindow*, QMouseEvent*)));
  82
  83     connect(theViewManager, SIGNAL(mouseRelease(SUIT_ViewWindow*, QMouseEvent*)),
  84             this, SLOT(onMouseEvent(SUIT_ViewWindow*, QMouseEvent*)));
  85
  86     connect(theViewManager, SIGNAL(wheel(SUIT_ViewWindow*, QWheelEvent*)),
  87             this, SLOT(onWheelEvent(SUIT_ViewWindow*, QWheelEvent*)));
  88   }
  89 }
  90
  91 /*!
  92   Builds popup for GL viewer
  93 */
  94 void GLViewer_Viewer::contextMenuPopup( QMenu* thePopup )
  95 {
  96   if( thePopup->actions().count() > 0 )
  97       thePopup->addSeparator();
  98
  99   thePopup->addAction( tr( "CHANGE_BGCOLOR" ), this, SLOT( onChangeBgColor() ) );
 100 }
 101
 102 /*!
 103     Sets the background color with color selection dialog. [ virtual protected slot ]
 104 */
 105 void GLViewer_Viewer::onChangeBgColor()
 106 {
 107   GLViewer_ViewPort* vp = getActiveView()->getViewPort();
 108   QColor selColor = QColorDialog::getColor( vp->backgroundColor() );
 109
 110   if( selColor.isValid() )
 111     vp->setBackgroundColor( selColor );
 112 }
 113
 114 /*!
 115     Returns the active view. [ public ]
 116 */
 117 GLViewer_ViewFrame* GLViewer_Viewer::getActiveView() const
 118 {
 119   SUIT_ViewManager* aMgr = getViewManager();
 120   return (GLViewer_ViewFrame*)( aMgr != 0 ? aMgr->getActiveView() : 0 );
 121 }
 122
 123
 124 /*!
 125     Sets the selection mode for this viewer. [ public ]
 126 */
 127 void GLViewer_Viewer::setSelectionMode( GLViewer_Viewer::SelectionMode mode )
 128 {
 129     if ( mySelMode != mode )
 130     {
 131         mySelMode = mode;
 132         onSelectionModeChanged();
 133     }
 134 }
 135
 136 /*!
 137     Returns selector of this viewer. [ public ]
 138 */
 139 GLViewer_Selector* GLViewer_Viewer::getSelector() const
 140 {
 141     if ( !mySelector )
 142     {
 143         GLViewer_Viewer* mthis = (GLViewer_Viewer*)this;
 144         mthis->mySelector = mthis->createSelector();
 145         if ( mySelector )
 146         {
 147             connect( mySelector, SIGNAL( selSelectionDone( bool, SelectionChangeStatus ) ), SLOT( onSelectionDone( bool, SelectionChangeStatus ) ) );
 148             connect( mySelector, SIGNAL( selSelectionCancel() ), SLOT( onSelectionCancel() ) );
 149         }
 150     }
 151     return mySelector;
 152 }
 153
 154 /*!
 155     Returns the selection mode of this viewer. [ public ]
 156 */
 157 GLViewer_Viewer::SelectionMode GLViewer_Viewer::getSelectionMode() const
 158 {
 159     return mySelMode;
 160 }
 161
 162 /*!
 163     Handles requests for sketching in the active view. [ virtual public ]
 164 */
 165 void GLViewer_Viewer::activateSketching( int type )
 166 {
 167     GLViewer_ViewPort* vp = 0;
 168     if ( !getActiveView() || !( vp = getActiveView()->getViewPort() ) )
 169         return;
 170
 171     if ( !vp->isSketchingEnabled() )
 172         return;
 173
 174     /* Finish current sketching */
 175     if ( type == NoSketching )
 176     {
 177         if ( mySketcher )
 178         {
 179             onSketchingFinished();
 180             delete mySketcher;
 181             mySketcher = 0;
 182         }
 183     }
 184     /* Activate new sketching */
 185     else
 186     {
 187         activateSketching( NoSketching );  /* concurrency not suported */
 188         mySketcher = createSketcher( type );
 189         onSketchingStarted();
 190     }
 191 }
 192
 193 /*!
 194     Handles requests for transformations in the active view. [ virtual public ]
 195 */
 196 void GLViewer_Viewer::activateTransform( int type )
 197 {
 198     GLViewer_ViewPort* vp = 0;
 199     if ( !getActiveView() || !( vp = getActiveView()->getViewPort() ) )
 200         return;
 201
 202     if ( !vp->isTransformEnabled() )
 203         return;
 204
 205     /* Finish current transform */
 206     if ( type == NoTransform )
 207     {
 208         if ( myTransformer )
 209         {
 210             onTransformationFinished();
 211             delete myTransformer;
 212             myTransformer = 0;
 213         }
 214     }
 215     /* Activate new transform */
 216     else
 217     {
 218         activateTransform( NoTransform );  /* concurrency not suported */
 219         myTransformer = createTransformer( type );
 220         onTransformationStarted();
 221         myTransformer->exec();
 222     }
 223 }
 224
 225 /*!
 226     Creates default transformer. [ virtual protected ]
 227 */
 228 GLViewer_ViewTransformer* GLViewer_Viewer::createTransformer( int type )
 229 {
 230     return new GLViewer_ViewTransformer( this, type );
 231 }
 232
 233 /*!
 234     Creates default sketcher. [ virtual protected ]
 235 */
 236 GLViewer_ViewSketcher* GLViewer_Viewer::createSketcher( int type )
 237 {
 238     return new GLViewer_ViewSketcher( this, type );
 239 }
 240
 241 /*!
 242     Returns null by default. [ virtual protected ]
 243 */
 244 GLViewer_Selector* GLViewer_Viewer::createSelector()
 245 {
 246     return 0;
 247 }
 248
 249 /*!
 250     Unhilights detected entities, lock selection, sets event filter
 251     on the whole application. [ virtual protected ]
 252 */
 253 void GLViewer_Viewer::onTransformationStarted()
 254 {
 255     unhilightDetected();
 256     if ( getSelector() )
 257         getSelector()->lock( true );        /* disable selection */
 258
 259     /*  Watch events: any mouse/key event outside the
 260         viewport will be considered as the end of
 261         transform */
 262     if( !myTransformer )
 263         return;
 264     qApp->installEventFilter( this );
 265 }
 266
 267 /*!
 268     Unlock selection, removes event filter. [ virtual protected ]
 269 */
 270 void GLViewer_Viewer::onTransformationFinished()
 271 {
 272     if ( getSelector() )
 273         getSelector()->lock( false );           /* enable selection */
 274
 275     /* Stop watch events */
 276     if( !myTransformer )
 277         return;
 278     qApp->removeEventFilter( this );
 279 }
 280
 281 /*!
 282     Unhilights detected entities. [ virtual protected ]
 283 */
 284 void GLViewer_Viewer::onSketchingStarted()
 285 {
 286     unhilightDetected();
 287 }
 288
 289 /*!
 290     Selection by rectangle. [ virtual protected ]
 291 */
 292 void GLViewer_Viewer::onSketchingFinished()
 293 {
 294     if ( !getSelector() )
 295         return;
 296
 297     if( !mySketcher )
 298         return;
 299     if ( mySketcher->type() == Rect )
 300     {
 301         QRect* selRect = (QRect*)mySketcher->data();
 302         if ( selRect )
 303         {
 304             bool append = bool( mySketcher->buttonState() & GLViewer_Selector::appendKey() );
 305             getSelector()->select( *selRect, append );
 306         }
 307     }
 308 }
 309
 310 /*!
 311     Installed while 'fit area' and 'global panning' operations are active. [ virtual protected ]
 312 */
 313 bool GLViewer_Viewer::eventFilter( QObject* o, QEvent* e )
 314 {
 315     if( !getActiveView() )
 316         return false;
 317
 318     if (e->type() == QEvent::KeyPress)
 319       {
 320         QKeyEvent* keyEvent = static_cast<QKeyEvent*>(e);
 321         if (keyEvent->key() == Qt::Key_Escape)
 322           {
 323             activateTransform( NoTransform );
 324             activateSketching( NoSketching );
 325           }
 326       }
 327
 328     return QObject::eventFilter( o, e );
 329 }
 330
 331 /*!
 332     Called when smth is selected in this viewer. [ virtual protected slot ]
 333 */
 334 void GLViewer_Viewer::onSelectionDone( bool /*bAdded*/, SelectionChangeStatus status  )
 335 {
 336     emit selectionChanged( status );
 337 }
 338
 339 /*!
 340     Called when selection is cleared in this viewer. [ virtual protected slot ]
 341 */
 342 void GLViewer_Viewer::onSelectionCancel()
 343 {
 344     emit selectionChanged( SCS_Invalid );
 345 }
 346
 347 /*!
 348     Listens to key events of the active view. [ virtual protected slot ]
 349 */
 350 void GLViewer_Viewer::onKeyEvent( SUIT_ViewWindow*, QKeyEvent* )
 351 {
 352 }
 353
 354 /*!
 355     Listens to mouse events of the active view. [ virtual protected slot ]
 356 */
 357 void GLViewer_Viewer::onMouseEvent( SUIT_ViewWindow*, QMouseEvent* e )
 358 {
 359     //cout << "GLViewer_Viewer::onMouseEvent" << endl;
 360     switch( e->type() )
 361     {
 362         case QEvent::MouseButtonPress:
 363             handleMousePress( e );
 364             break;
 365         case QEvent::MouseMove:
 366             handleMouseMove( e );
 367             break;
 368         case QEvent::MouseButtonRelease:
 369             handleMouseRelease( e );
 370             break;
 371         default: break;
 372     }
 373 }
 374
 375 /*!
 376     Listens to mouse events of the active view. [ virtual protected slot ]
 377 */
 378 void GLViewer_Viewer::onWheelEvent( SUIT_ViewWindow*, QWheelEvent* e )
 379 {
 380     //cout << "GLViewer_Viewer::onMouseEvent" << endl;
 381     switch( e->type() )
 382     {
 383         case QEvent::Wheel:
 384             handleWheel( e );
 385             break;
 386         default: break;
 387     }
 388 }
 389
 390 /*!
 391     Enables / disables rectangle sketching. [ virtual protected ]
 392 */
 393 void GLViewer_Viewer::onSelectionModeChanged()
 394 {
 395     bool enable = ( mySelMode == Multiple );
 396     QVector<SUIT_ViewWindow*> views = getViewManager()->getViews();
 397     for ( int i = 0, n = views.count(); i < n; i++ )
 398     {
 399         GLViewer_ViewPort* vp = ((GLViewer_ViewFrame*)views[i])->getViewPort();
 400         if ( vp )
 401             vp->setSketchingEnabled( enable );
 402     }
 403 }
 404
 405 /*!
 406     Updates all views of this viewer. Use 'flags' to customize update process. [ virtual public ]
 407 */
 408 void GLViewer_Viewer::update( int flags )
 409 {
 410     QVector<SUIT_ViewWindow*> views = getViewManager()->getViews();
 411     for ( int i = 0, n = views.count(); i < n; i++ )
 412         ((GLViewer_ViewFrame*)views[i])->onUpdate( flags );
 413 }
 414
 415 /*!
 416     Unhilights the currect detected objects. [ virtual private ]
 417 */
 418 void GLViewer_Viewer::unhilightDetected()
 419 {
 420     if ( getSelector() )
 421         getSelector()->undetectAll();
 422 }
 423
 424 /*!
 425     Mouse press handler. If 'accelKey()' is pressed, activates default
 426     transformations( Zoom or Pan ) in the active viewport. [ private ]
 427 */
 428 void GLViewer_Viewer::handleMousePress( QMouseEvent* e )
 429 {
 430     /* test accel for transforms */
 431     if ( e->modifiers() & GLViewer_ViewTransformer::accelKey() )
 432     {
 433         Qt::MouseButton bs = e->button();
 434         if ( (int)bs == GLViewer_ViewTransformer::zoomButton() ) // todo Qt::MouseButton is unsigned int: comparison of int with uint
 435             activateTransform( Zoom );
 436         else if ( (int)bs == GLViewer_ViewTransformer::panButton() ) // todo Qt::MouseButton is unsigned int: comparison of int with uint
 437             activateTransform( Pan );
 438     }
 439     else
 440     {
 441         //checking for other operations before selection in release event
 442         startOperations( e );
 443     }
 444
 445     /* we may need it for sketching... */
 446     l_mbPressEvent = new QMouseEvent( *e );
 447
 448     //checking for other operations before selection in release event
 449 //    startOperations( e );
 450
 451     /*e->button() == LeftButton && getSelector() )
 452     {
 453         bool append = bool ( e->state() & GLViewer_Selector::appendKey() );
 454         getSelector()->select( append );
 455     }*/
 456 }
 457
 458 /*!
 459     Mouse move handler. If dragged with MB1, activates rectangle sketching in
 460     the active viewport, otherwise highlights the selectable entities. [ private ]
 461 */
 462 void GLViewer_Viewer::handleMouseMove( QMouseEvent* e )
 463 {
 464     /* Highlight for selection */
 465     bool dragged = ( e->buttons() & ( Qt::LeftButton | Qt::MidButton | Qt::RightButton ) );
 466     if ( !dragged )
 467     {
 468         if ( getSelector() )
 469             getSelector()->detect( e->x(), e->y() );
 470     }
 471     /* Try to activate default sketching
 472     */
 473     else if ( (int)e->button() == GLViewer_ViewSketcher::sketchButton() ) // todo Qt::MouseButton is unsigned int: comparison of int with uint
 474     {
 475         activateSketching( Rect );
 476         if ( mySketcher )
 477         {
 478             /*  Activated OK. We should not forget initial mousepress
 479                 event and this mousemove event to start sketching from
 480                 the point of initial click */
 481             if ( l_mbPressEvent )
 482             {
 483                 QApplication::sendEvent( getActiveView()->getViewPort(), l_mbPressEvent );
 484                 delete l_mbPressEvent;
 485                 l_mbPressEvent = 0;
 486             }
 487             QApplication::sendEvent( getActiveView()->getViewPort(), e );
 488         }
 489     }
 490
 491     //Try to activate other operations
 492     updateOperations( e );
 493 }
 494
 495 /*!
 496     Mouse move handler. Activates popup of the active view. [ private ]
 497 */
 498 void GLViewer_Viewer::handleMouseRelease( QMouseEvent* e )
 499 {
 500     /* selection */
 501     /* tmp - in handleMousePress*/
 502     if( e->button() == Qt::LeftButton && !(getActiveView()->getViewPort()->currentBlock() & BS_Selection) )
 503     {
 504         if ( getSelector() )
 505         {
 506             bool append = bool ( e->modifiers() & GLViewer_Selector::appendKey() );
 507             getSelector()->select( append );
 508         }
 509     }
 510
 511     //Try to done active operations
 512     finishOperations( e );
 513
 514     if ( l_mbPressEvent )
 515     {
 516         delete l_mbPressEvent;
 517         l_mbPressEvent = 0;
 518     }
 519 }
 520
 521 /*!
 522     Wheel rolling handler
 523 */
 524 void GLViewer_Viewer::handleWheel( QWheelEvent* e )
 525 {
 526     startOperations( e );
 527 }
 528
 529 int GLViewer_ViewTransformer::panBtn = Qt::MidButton;
 530 int GLViewer_ViewTransformer::zoomBtn = Qt::LeftButton;
 531 int GLViewer_ViewTransformer::fitRectBtn = Qt::LeftButton;
 532 int GLViewer_ViewTransformer::panGlobalBtn = Qt::LeftButton;
 533 int GLViewer_ViewTransformer::acccelKey = Qt::ControlModifier;
 534
 535 /*!
 536     Constructor
 537 */
 538 GLViewer_ViewTransformer::GLViewer_ViewTransformer( GLViewer_Viewer* v, int type )
 539 : QObject( 0 ),
 540 myViewer( v ),
 541 myType( type ),
 542 myButtonState( 0 ),
 543 myMajorBtn( Qt::NoButton ),
 544 myRectBand( 0 )
 545 {
 546     if ( myType == GLViewer_Viewer::Pan ||
 547          myType == GLViewer_Viewer::Zoom ||
 548          myType == GLViewer_Viewer::PanGlobal ||
 549          myType == GLViewer_Viewer::FitRect )
 550     {
 551         /* 'long' transforms need this */
 552         initTransform( true );
 553     }
 554 }
 555
 556 /*!
 557     Destructor
 558 */
 559 GLViewer_ViewTransformer::~GLViewer_ViewTransformer()
 560 {
 561     if ( myType == GLViewer_Viewer::Pan ||
 562          myType == GLViewer_Viewer::Zoom ||
 563          myType == GLViewer_Viewer::PanGlobal ||
 564          myType == GLViewer_Viewer::FitRect )
 565     {
 566         /* 'long' transforms need this */
 567         initTransform( false );
 568     }
 569
 570     //QAD_Application::getDesktop()->clearInfo();
 571
 572     endDrawRect();
 573 }
 574
 575 /*!
 576     Inits long transformations ( Zoom, Pan etc ) [ protected ]
 577
 578     Saves viewport state( cursor etc ) and installs event filter to process
 579     mouse events if 'init' is true. Restores viewport state if 'init' is false.
 580 */
 581 void GLViewer_ViewTransformer::initTransform( bool init )
 582 {
 583     GLViewer_ViewPort* avp = myViewer->getActiveView()->getViewPort();
 584     if ( init )
 585     {
 586         mySavedCursor = avp->cursor();
 587         mySavedMouseTrack = avp->hasMouseTracking();
 588         avp->setMouseTracking( false );
 589         avp->installEventFilter( this );
 590     }
 591     else
 592     {
 593         avp->removeEventFilter( this );
 594         avp->setMouseTracking( mySavedMouseTrack );
 595         avp->setCursor( mySavedCursor );
 596     }
 597 }
 598
 599 /*!
 600     Runs transfomation. Redefine to add your own 'instant' transforms
 601     ( for ex., 'FitAll' is an instant transform ). [ virtual public ]
 602 */
 603 void GLViewer_ViewTransformer::exec()
 604 {
 605     GLViewer_ViewPort* avp = myViewer->getActiveView()->getViewPort();
 606     if( !avp )
 607         return;
 608
 609     switch( myType )
 610     {
 611         case GLViewer_Viewer::Zoom:
 612             myMajorBtn = zoomButton();
 613             avp->setCursor( *avp->getZoomCursor() );
 614             break;
 615         case GLViewer_Viewer::Pan:
 616             myMajorBtn = panButton();
 617             avp->setCursor( *avp->getPanCursor() );
 618             break;
 619         case GLViewer_Viewer::PanGlobal:
 620             myMajorBtn = panGlobalButton();
 621             avp->setCursor( *avp->getPanglCursor() );
 622             avp->fitAll( true, false );  /* view is ready now */
 623             break;
 624         case GLViewer_Viewer::FitRect:
 625             myMajorBtn = fitRectButton();
 626             avp->setCursor( *avp->getHandCursor() );
 627             break;
 628         case GLViewer_Viewer::Reset:
 629             avp->reset(); onTransform( Fin );
 630             break;
 631         case GLViewer_Viewer::FitAll:
 632             avp->fitAll(); onTransform( Fin );
 633             break;
 634         case GLViewer_Viewer::FitSelect:
 635             avp->fitSelect(); onTransform( Fin );
 636             break;
 637         default: break;
 638     }
 639 }
 640
 641 /*!
 642     Catches mouse events for the viewport. [ virtual protected ]
 643 */
 644 bool GLViewer_ViewTransformer::eventFilter( QObject* o, QEvent* e )
 645 {
 646     switch ( e->type() )
 647     {
 648         case QEvent::MouseMove:
 649         case QEvent::MouseButtonPress:
 650         case QEvent::MouseButtonRelease:
 651         {
 652             TransformState state = EnTrain;
 653             QMouseEvent* me = ( QMouseEvent* )e;
 654
 655             myButtonState = me->buttons();
 656             if ( e->type() == QEvent::MouseButtonPress )
 657                 myButtonState |= me->button();  /* add pressed button */
 658
 659             if ( e->type() == QEvent::MouseButtonRelease )
 660                 myButtonState |= me->button();  /* add release button */
 661
 662             int mouseOnlyState = ( myButtonState & ( Qt::LeftButton | Qt::MidButton | Qt::RightButton ) );
 663             if ( myStart.isNull() )
 664             {
 665                 state = Debut;
 666                 myStart = me->pos();
 667                 myMajorBtn = mouseOnlyState;
 668             }
 669
 670             if ( e->type() == QEvent::MouseButtonRelease )
 671             {
 672                 state = Fin;
 673             }
 674             myCurr = me->pos();
 675             onTransform( state );
 676             return true;
 677         }
 678         default: break;
 679     }
 680     return QObject::eventFilter( o, e );
 681 }
 682
 683 /*!
 684     Transforms the viewport. Used for 'non-instant' transforms
 685     only( ex. Rotate, Pan etc ). [ virtual protected ]
 686 */
 687 void GLViewer_ViewTransformer::onTransform( TransformState state )
 688 {
 689     GLViewer_ViewPort* avp = myViewer->getActiveView()->getViewPort();
 690     bool doTrsf = ( myButtonState & myMajorBtn );
 691     switch ( myType )
 692     {
 693         case GLViewer_Viewer::Zoom:
 694             if ( state != Fin && doTrsf )
 695             {
 696                 avp->zoom( myStart.x(), myStart.y(), myCurr.x(), myCurr.y() );
 697                 myStart = myCurr;
 698             }
 699             break;
 700         case GLViewer_Viewer::Pan:
 701             if ( state != Fin && doTrsf )
 702             {
 703                 avp->pan( myCurr.x() - myStart.x(), myStart.y() - myCurr.y() );
 704                 myStart = myCurr;
 705             }
 706             break;
 707         case GLViewer_Viewer::PanGlobal:
 708         {
 709             if ( state == Fin )
 710             avp->setCenter( myCurr.x(), myCurr.y() );
 711             break;
 712         }
 713         case GLViewer_Viewer::FitRect:
 714         {
 715             if ( doTrsf )
 716             {
 717                 QRect rect( qMin( myStart.x(), myCurr.x() ), qMin( myStart.y(), myCurr.y() ),
 718                             qAbs( myStart.x() - myCurr.x() ), qAbs( myStart.y() - myCurr.y() ) );
 719                 if ( !rect.isEmpty() )
 720                 {
 721                     switch ( state )
 722                     {
 723                         case Fin:
 724                             avp->fitRect( rect );
 725                             break;
 726                         default:
 727                         {
 728                             drawRect( rect );
 729                             break;
 730                         }
 731                     }
 732                 }
 733             }
 734             break;
 735         }
 736         default:
 737             break;
 738     }
 739
 740     if ( state == Fin )
 741         myViewer->activateTransform( GLViewer_Viewer::NoTransform );
 742 }
 743
 744 /*!
 745   Draws rectangle by starting and current points
 746 */
 747 void GLViewer_ViewTransformer::drawRect(const QRect& theRect)
 748 {
 749   if ( !myRectBand ) {
 750     myRectBand = new QRubberBand( QRubberBand::Rectangle, myViewer->getActiveView()->getViewPort() );
 751     QPalette palette;
 752     palette.setColor(myRectBand->foregroundRole(), Qt::white);
 753     myRectBand->setPalette(palette);
 754   }
 755   myRectBand->hide();
 756
 757   myRectBand->setGeometry( theRect );
 758   myRectBand->setVisible( theRect.isValid() );
 759 }
 760
 761 /*!
 762   \brief Delete rubber band on the end on the dragging operation.
 763 */
 764 void GLViewer_ViewTransformer::endDrawRect()
 765 {
 766   if ( myRectBand ) myRectBand->hide();
 767
 768   delete myRectBand;
 769   myRectBand = 0;
 770 }
 771
 772 /*!
 773     Returns the type of the transformer. [ public ]
 774 */
 775 int GLViewer_ViewTransformer::type() const
 776 {
 777     return myType;
 778 }
 779
 780
 781 int GLViewer_ViewSketcher::sketchBtn = Qt::LeftButton;
 782
 783 /*!
 784     Constructor
 785 */
 786 GLViewer_ViewSketcher::GLViewer_ViewSketcher( GLViewer_Viewer* viewer, int type )
 787 : QObject( 0 ),
 788 myViewer( viewer ),
 789 myType( type ),
 790 myData( 0 ),
 791 myRectBand( 0 )
 792 {
 793     if( !myViewer )
 794         return;
 795     GLViewer_ViewPort* avp = myViewer->getActiveView()->getViewPort();
 796     if( !avp )
 797         return;
 798
 799     mySavedCursor = avp->cursor();
 800     avp->setCursor( *GLViewer_ViewPort::getHandCursor() );
 801     avp->installEventFilter( this );
 802
 803     if ( myType == GLViewer_Viewer::Rect )
 804         myData = new QRect();
 805 }
 806
 807 /*!
 808     Destructor
 809 */
 810 GLViewer_ViewSketcher::~GLViewer_ViewSketcher()
 811 {
 812     GLViewer_ViewPort* avp = myViewer->getActiveView()->getViewPort();
 813     avp->removeEventFilter( this );
 814     avp->setCursor( mySavedCursor );
 815
 816     if ( myType == GLViewer_Viewer::Rect )
 817         delete ( QRect* ) myData;
 818
 819     endDrawRect();
 820 }
 821
 822 /*!
 823     Catches mouse events for the viewport. [ virtual protected ]
 824 */
 825 bool GLViewer_ViewSketcher::eventFilter( QObject* o, QEvent* e )
 826 {
 827     switch ( e->type() )
 828     {
 829         case QEvent::MouseMove:
 830         case QEvent::MouseButtonPress:
 831         case QEvent::MouseButtonRelease:
 832         {
 833             SketchState state = EnTrain;
 834             QMouseEvent* me = (QMouseEvent*)e;
 835
 836             myButtonState = me->buttons();
 837             if ( e->type() == QEvent::MouseButtonPress )
 838                 myButtonState |= me->button();  /* add pressed button */
 839
 840             if ( myStart.isNull() )
 841             {
 842                 state = Debut;
 843                 myStart = me->pos();
 844             }
 845
 846             int mouseOnlyState = ( myButtonState & ( Qt::LeftButton | Qt::MidButton | Qt::RightButton ) );
 847             if ( e->type() == QEvent::MouseButtonRelease && mouseOnlyState == sketchButton() )
 848             {
 849                 state = Fin;
 850             }
 851             myCurr = me->pos();
 852             onSketch( state );
 853             return true;
 854         }
 855         default: break;
 856     }
 857     return QObject::eventFilter( o, e );
 858 }
 859
 860 /*!
 861     Draws in the viewport. [ virtual protected ]
 862 */
 863 void GLViewer_ViewSketcher::onSketch( SketchState state )
 864 {
 865     GLViewer_ViewPort* avp = myViewer->getActiveView()->getViewPort();
 866     if( !avp )
 867         return;
 868
 869     if( myType == GLViewer_Viewer::Rect )
 870     {
 871         QRect* sketchRect = ( QRect* )data();
 872         if ( myButtonState & sketchButton() )
 873         {
 874             QRect rect( qMin( myStart.x(), myCurr.x() ), qMin( myStart.y(), myCurr.y() ),
 875                         qAbs( myStart.x() - myCurr.x() ), qAbs( myStart.y() - myCurr.y() ) );
 876             if ( !rect.isEmpty() )
 877             {
 878                 if ( !sketchRect->isEmpty() && myRectBand )
 879                     myRectBand->hide();    /* erase */
 880                 *sketchRect = rect;
 881                 if ( state != Fin )
 882                     drawRect( *sketchRect );
 883             }
 884         }
 885     }
 886
 887     if ( state == Fin )
 888     {
 889         myViewer->activateSketching( GLViewer_Viewer::NoSketching );
 890     }
 891 }
 892
 893 /*!
 894   Draws rectangle by starting and current points
 895 */
 896 void GLViewer_ViewSketcher::drawRect(const QRect& theRect)
 897 {
 898   if ( !myRectBand ) {
 899     myRectBand = new QRubberBand( QRubberBand::Rectangle, myViewer->getActiveView()->getViewPort() );
 900     QPalette palette;
 901     palette.setColor(myRectBand->foregroundRole(), Qt::white);
 902     myRectBand->setPalette(palette);
 903   }
 904   myRectBand->hide();
 905
 906   myRectBand->setGeometry( theRect );
 907   myRectBand->setVisible( theRect.isValid() );
 908 }
 909
 910 /*!
 911   \brief Delete rubber band on the end on the dragging operation.
 912 */
 913 void GLViewer_ViewSketcher::endDrawRect()
 914 {
 915   if ( myRectBand ) myRectBand->hide();
 916
 917   delete myRectBand;
 918   myRectBand = 0;
 919 }