src/GLViewer/GLViewer_Viewer.cxx

   1 // Copyright (C) 2007-2012  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 //  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 mySketcher( 0 ),
  55 myTransformer( 0 ),
  56 mySelMode( NoSelection )
  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( getActiveView()->getViewPort() == o->parent() )
 319       o = o->parent();
 320
 321     bool mouseClickedOutside = ( e->type() == QEvent::MouseButtonPress &&
 322                                  o != getActiveView()->getViewPort() );
 323     bool anyKeyPressed = ( e->type() == QEvent::KeyPress );
 324     if ( mouseClickedOutside || anyKeyPressed )
 325     {   /* terminate all */
 326         activateTransform( NoTransform );
 327         activateSketching( NoSketching );
 328         //cout << "mouseClickedOutside || anyKeyPressed" << endl;
 329     }
 330     return QObject::eventFilter( o, e );
 331 }
 332
 333 /*!
 334     Called when smth is selected in this viewer. [ virtual protected slot ]
 335 */
 336 void GLViewer_Viewer::onSelectionDone( bool bAdded, SelectionChangeStatus status  )
 337 {
 338     emit selectionChanged( status );
 339 }
 340
 341 /*!
 342     Called when selection is cleared in this viewer. [ virtual protected slot ]
 343 */
 344 void GLViewer_Viewer::onSelectionCancel()
 345 {
 346     emit selectionChanged( SCS_Invalid );
 347 }
 348
 349 /*!
 350     Listens to key events of the active view. [ virtual protected slot ]
 351 */
 352 void GLViewer_Viewer::onKeyEvent( SUIT_ViewWindow*, QKeyEvent* )
 353 {
 354 }
 355
 356 /*!
 357     Listens to mouse events of the active view. [ virtual protected slot ]
 358 */
 359 void GLViewer_Viewer::onMouseEvent( SUIT_ViewWindow*, QMouseEvent* e )
 360 {
 361     //cout << "GLViewer_Viewer::onMouseEvent" << endl;
 362     switch( e->type() )
 363     {
 364         case QEvent::MouseButtonPress:
 365             handleMousePress( e );
 366             break;
 367         case QEvent::MouseMove:
 368             handleMouseMove( e );
 369             break;
 370         case QEvent::MouseButtonRelease:
 371             handleMouseRelease( e );
 372             break;
 373         default: break;
 374     }
 375 }
 376
 377 /*!
 378     Listens to mouse events of the active view. [ virtual protected slot ]
 379 */
 380 void GLViewer_Viewer::onWheelEvent( SUIT_ViewWindow*, QWheelEvent* e )
 381 {
 382     //cout << "GLViewer_Viewer::onMouseEvent" << endl;
 383     switch( e->type() )
 384     {
 385         case QEvent::Wheel:
 386             handleWheel( e );
 387             break;
 388         default: break;
 389     }
 390 }
 391
 392 /*!
 393     Enables / disables rectangle sketching. [ virtual protected ]
 394 */
 395 void GLViewer_Viewer::onSelectionModeChanged()
 396 {
 397     bool enable = ( mySelMode == Multiple );
 398     QVector<SUIT_ViewWindow*> views = getViewManager()->getViews();
 399     for ( int i = 0, n = views.count(); i < n; i++ )
 400     {
 401         GLViewer_ViewPort* vp = ((GLViewer_ViewFrame*)views[i])->getViewPort();
 402         if ( vp )
 403             vp->setSketchingEnabled( enable );
 404     }
 405 }
 406
 407 /*!
 408     Updates all views of this viewer. Use 'flags' to customize update process. [ virtual public ]
 409 */
 410 void GLViewer_Viewer::update( int flags )
 411 {
 412     QVector<SUIT_ViewWindow*> views = getViewManager()->getViews();
 413     for ( int i = 0, n = views.count(); i < n; i++ )
 414         ((GLViewer_ViewFrame*)views[i])->onUpdate( flags );
 415 }
 416
 417 /*!
 418     Unhilights the currect detected objects. [ virtual private ]
 419 */
 420 void GLViewer_Viewer::unhilightDetected()
 421 {
 422     if ( getSelector() )
 423         getSelector()->undetectAll();
 424 }
 425
 426 /*!
 427     Mouse press handler. If 'accelKey()' is pressed, activates default
 428     transformations( Zoom or Pan ) in the active viewport. [ private ]
 429 */
 430 void GLViewer_Viewer::handleMousePress( QMouseEvent* e )
 431 {
 432     /* test accel for transforms */
 433     if ( e->modifiers() & GLViewer_ViewTransformer::accelKey() )
 434     {
 435         Qt::MouseButton bs = e->button();
 436         if ( bs == GLViewer_ViewTransformer::zoomButton() )
 437             activateTransform( Zoom );
 438         else if ( bs == GLViewer_ViewTransformer::panButton() )
 439             activateTransform( Pan );
 440     }
 441     else
 442     {
 443         //checking for other operations before selection in release event
 444         startOperations( e );
 445     }
 446
 447     /* we may need it for sketching... */
 448     l_mbPressEvent = new QMouseEvent( *e );
 449
 450     //checking for other operations before selection in release event
 451 //    startOperations( e );
 452
 453     /*e->button() == LeftButton && getSelector() )
 454     {
 455         bool append = bool ( e->state() & GLViewer_Selector::appendKey() );
 456         getSelector()->select( append );
 457     }*/
 458 }
 459
 460 /*!
 461     Mouse move handler. If dragged with MB1, activates rectangle sketching in
 462     the active viewport, otherwise highlights the selectable entities. [ private ]
 463 */
 464 void GLViewer_Viewer::handleMouseMove( QMouseEvent* e )
 465 {
 466     /* Highlight for selection */
 467     bool dragged = ( e->buttons() & ( Qt::LeftButton | Qt::MidButton | Qt::RightButton ) );
 468     if ( !dragged )
 469     {
 470         if ( getSelector() )
 471             getSelector()->detect( e->x(), e->y() );
 472     }
 473     /* Try to activate default sketching
 474     */
 475     else if ( e->button() == GLViewer_ViewSketcher::sketchButton() )
 476     {
 477         activateSketching( Rect );
 478         if ( mySketcher )
 479         {
 480             /*  Activated OK. We should not forget initial mousepress
 481                 event and this mousemove event to start sketching from
 482                 the point of initial click */
 483             if ( l_mbPressEvent )
 484             {
 485                 QApplication::sendEvent( getActiveView()->getViewPort(), l_mbPressEvent );
 486                 delete l_mbPressEvent;
 487                 l_mbPressEvent = 0;
 488             }
 489             QApplication::sendEvent( getActiveView()->getViewPort(), e );
 490         }
 491     }
 492
 493     //Try to activate other operations
 494     updateOperations( e );
 495 }
 496
 497 /*!
 498     Mouse move handler. Activates popup of the active view. [ private ]
 499 */
 500 void GLViewer_Viewer::handleMouseRelease( QMouseEvent* e )
 501 {
 502     /* selection */
 503     /* tmp - in handleMousePress*/
 504     if( e->button() == Qt::LeftButton && !(getActiveView()->getViewPort()->currentBlock() & BS_Selection) )
 505     {
 506         if ( getSelector() )
 507         {
 508             bool append = bool ( e->modifiers() & GLViewer_Selector::appendKey() );
 509             getSelector()->select( append );
 510         }
 511     }
 512
 513     //Try to done active operations
 514     finishOperations( e );
 515
 516     if ( l_mbPressEvent )
 517     {
 518         delete l_mbPressEvent;
 519         l_mbPressEvent = 0;
 520     }
 521 }
 522
 523 /*!
 524     Wheel rolling handler
 525 */
 526 void GLViewer_Viewer::handleWheel( QWheelEvent* e )
 527 {
 528     startOperations( e );
 529 }
 530
 531 int GLViewer_ViewTransformer::panBtn = Qt::MidButton;
 532 int GLViewer_ViewTransformer::zoomBtn = Qt::LeftButton;
 533 int GLViewer_ViewTransformer::fitRectBtn = Qt::LeftButton;
 534 int GLViewer_ViewTransformer::panGlobalBtn = Qt::LeftButton;
 535 int GLViewer_ViewTransformer::acccelKey = Qt::ControlModifier;
 536
 537 /*!
 538     Constructor
 539 */
 540 GLViewer_ViewTransformer::GLViewer_ViewTransformer( GLViewer_Viewer* v, int type )
 541 : QObject( 0 ),
 542 myViewer( v ),
 543 myType( type ),
 544 myMajorBtn( Qt::NoButton ),
 545 myButtonState( 0 ),
 546 myRectBand( 0 )
 547 {
 548     if ( myType == GLViewer_Viewer::Pan ||
 549          myType == GLViewer_Viewer::Zoom ||
 550          myType == GLViewer_Viewer::PanGlobal ||
 551          myType == GLViewer_Viewer::FitRect )
 552     {
 553         /* 'long' transforms need this */
 554         initTransform( true );
 555     }
 556 }
 557
 558 /*!
 559     Destructor
 560 */
 561 GLViewer_ViewTransformer::~GLViewer_ViewTransformer()
 562 {
 563     if ( myType == GLViewer_Viewer::Pan ||
 564          myType == GLViewer_Viewer::Zoom ||
 565          myType == GLViewer_Viewer::PanGlobal ||
 566          myType == GLViewer_Viewer::FitRect )
 567     {
 568         /* 'long' transforms need this */
 569         initTransform( false );
 570     }
 571
 572     //QAD_Application::getDesktop()->clearInfo();
 573
 574     endDrawRect();
 575 }
 576
 577 /*!
 578     Inits long transformations ( Zoom, Pan etc ) [ protected ]
 579
 580     Saves viewport state( cursor etc ) and installs event filter to process
 581     mouse events if 'init' is true. Restores viewport state if 'init' is false.
 582 */
 583 void GLViewer_ViewTransformer::initTransform( bool init )
 584 {
 585     GLViewer_ViewPort* avp = myViewer->getActiveView()->getViewPort();
 586     if ( init )
 587     {
 588         mySavedCursor = avp->cursor();
 589         mySavedMouseTrack = avp->hasMouseTracking();
 590         avp->setMouseTracking( false );
 591         avp->installEventFilter( this );
 592     }
 593     else
 594     {
 595         avp->removeEventFilter( this );
 596         avp->setMouseTracking( mySavedMouseTrack );
 597         avp->setCursor( mySavedCursor );
 598     }
 599 }
 600
 601 /*!
 602     Runs transfomation. Redefine to add your own 'instant' transforms
 603     ( for ex., 'FitAll' is an instant transform ). [ virtual public ]
 604 */
 605 void GLViewer_ViewTransformer::exec()
 606 {
 607     GLViewer_ViewPort* avp = myViewer->getActiveView()->getViewPort();
 608     if( !avp )
 609         return;
 610
 611     switch( myType )
 612     {
 613         case GLViewer_Viewer::Zoom:
 614             myMajorBtn = zoomButton();
 615             avp->setCursor( *avp->getZoomCursor() );
 616             break;
 617         case GLViewer_Viewer::Pan:
 618             myMajorBtn = panButton();
 619             avp->setCursor( *avp->getPanCursor() );
 620             break;
 621         case GLViewer_Viewer::PanGlobal:
 622             myMajorBtn = panGlobalButton();
 623             avp->setCursor( *avp->getPanglCursor() );
 624             avp->fitAll( true, false );  /* view is ready now */
 625             break;
 626         case GLViewer_Viewer::FitRect:
 627             myMajorBtn = fitRectButton();
 628             avp->setCursor( *avp->getHandCursor() );
 629             break;
 630         case GLViewer_Viewer::Reset:
 631             avp->reset(); onTransform( Fin );
 632             break;
 633         case GLViewer_Viewer::FitAll:
 634             avp->fitAll(); onTransform( Fin );
 635             break;
 636         case GLViewer_Viewer::FitSelect:
 637             avp->fitSelect(); onTransform( Fin );
 638             break;
 639         default: break;
 640     }
 641 }
 642
 643 /*!
 644     Catches mouse events for the viewport. [ virtual protected ]
 645 */
 646 bool GLViewer_ViewTransformer::eventFilter( QObject* o, QEvent* e )
 647 {
 648     switch ( e->type() )
 649     {
 650         case QEvent::MouseMove:
 651         case QEvent::MouseButtonPress:
 652         case QEvent::MouseButtonRelease:
 653         {
 654             TransformState state = EnTrain;
 655             QMouseEvent* me = ( QMouseEvent* )e;
 656
 657             myButtonState = me->modifiers();
 658             if ( e->type() == QEvent::MouseButtonPress )
 659                 myButtonState |= me->button();  /* add pressed button */
 660
 661             int mouseOnlyState = ( myButtonState & ( Qt::LeftButton | Qt::MidButton | Qt::RightButton ) );
 662             if ( myStart.isNull() )
 663             {
 664                 state = Debut;
 665                 myStart = me->pos();
 666                 myMajorBtn = mouseOnlyState;
 667             }
 668
 669             if ( e->type() == QEvent::MouseButtonRelease && mouseOnlyState == myMajorBtn )
 670             {
 671                 state = Fin;
 672             }
 673             myCurr = me->pos();
 674             onTransform( state );
 675             return true;
 676         }
 677         default: break;
 678     }
 679     return QObject::eventFilter( o, e );
 680 }
 681
 682 /*!
 683     Transforms the viewport. Used for 'non-instant' transforms
 684     only( ex. Rotate, Pan etc ). [ virtual protected ]
 685 */
 686 void GLViewer_ViewTransformer::onTransform( TransformState state )
 687 {
 688     GLViewer_ViewPort* avp = myViewer->getActiveView()->getViewPort();
 689     bool doTrsf = ( myButtonState & myMajorBtn );
 690     switch ( myType )
 691     {
 692         case GLViewer_Viewer::Zoom:
 693             if ( state != Fin && doTrsf )
 694             {
 695                 avp->zoom( myStart.x(), myStart.y(), myCurr.x(), myCurr.y() );
 696                 myStart = myCurr;
 697             }
 698             break;
 699         case GLViewer_Viewer::Pan:
 700             if ( state != Fin && doTrsf )
 701             {
 702                 avp->pan( myCurr.x() - myStart.x(), myStart.y() - myCurr.y() );
 703                 myStart = myCurr;
 704             }
 705             break;
 706         case GLViewer_Viewer::PanGlobal:
 707         {
 708             if ( state == Fin )
 709             avp->setCenter( myCurr.x(), myCurr.y() );
 710             break;
 711         }
 712         case GLViewer_Viewer::FitRect:
 713         {
 714             if ( doTrsf )
 715             {
 716                 QRect rect( qMin( myStart.x(), myCurr.x() ), qMin( myStart.y(), myCurr.y() ),
 717                             qAbs( myStart.x() - myCurr.x() ), qAbs( myStart.y() - myCurr.y() ) );
 718                 if ( !rect.isEmpty() )
 719                 {
 720                     switch ( state )
 721                     {
 722                         case Fin:
 723                             avp->fitRect( rect );
 724                             break;
 725                         default:
 726                         {
 727                             drawRect( rect );
 728                             break;
 729                         }
 730                     }
 731                 }
 732             }
 733             break;
 734         }
 735         default:
 736             break;
 737     }
 738
 739     if ( state == Fin )
 740         myViewer->activateTransform( GLViewer_Viewer::NoTransform );
 741 }
 742
 743 /*!
 744   Draws rectangle by starting and current points
 745 */
 746 void GLViewer_ViewTransformer::drawRect(const QRect& theRect)
 747 {
 748   if ( !myRectBand ) {
 749     myRectBand = new QRubberBand( QRubberBand::Rectangle, myViewer->getActiveView()->getViewPort() );
 750     QPalette palette;
 751     palette.setColor(myRectBand->foregroundRole(), Qt::white);
 752     myRectBand->setPalette(palette);
 753   }
 754   myRectBand->hide();
 755
 756   myRectBand->setGeometry( theRect );
 757   myRectBand->setVisible( theRect.isValid() );
 758 }
 759
 760 /*!
 761   \brief Delete rubber band on the end on the dragging operation.
 762 */
 763 void GLViewer_ViewTransformer::endDrawRect()
 764 {
 765   if ( myRectBand ) myRectBand->hide();
 766
 767   delete myRectBand;
 768   myRectBand = 0;
 769 }
 770
 771 /*!
 772     Returns the type of the transformer. [ public ]
 773 */
 774 int GLViewer_ViewTransformer::type() const
 775 {
 776     return myType;
 777 }
 778
 779
 780 int GLViewer_ViewSketcher::sketchBtn = Qt::LeftButton;
 781
 782 /*!
 783     Constructor
 784 */
 785 GLViewer_ViewSketcher::GLViewer_ViewSketcher( GLViewer_Viewer* viewer, int type )
 786 : QObject( 0 ),
 787 myViewer( viewer ),
 788 myData( 0 ),
 789 myType( type ),
 790 myRectBand( 0 )
 791 {
 792     if( !myViewer )
 793         return;
 794     GLViewer_ViewPort* avp = myViewer->getActiveView()->getViewPort();
 795     if( !avp )
 796         return;
 797
 798     mySavedCursor = avp->cursor();
 799     avp->setCursor( *GLViewer_ViewPort::getHandCursor() );
 800     avp->installEventFilter( this );
 801
 802     if ( myType == GLViewer_Viewer::Rect )
 803         myData = new QRect();
 804 }
 805
 806 /*!
 807     Destructor
 808 */
 809 GLViewer_ViewSketcher::~GLViewer_ViewSketcher()
 810 {
 811     GLViewer_ViewPort* avp = myViewer->getActiveView()->getViewPort();
 812     avp->removeEventFilter( this );
 813     avp->setCursor( mySavedCursor );
 814
 815     if ( myType == GLViewer_Viewer::Rect )
 816         delete ( QRect* ) myData;
 817
 818     endDrawRect();
 819 }
 820
 821 /*!
 822     Catches mouse events for the viewport. [ virtual protected ]
 823 */
 824 bool GLViewer_ViewSketcher::eventFilter( QObject* o, QEvent* e )
 825 {
 826     switch ( e->type() )
 827     {
 828         case QEvent::MouseMove:
 829         case QEvent::MouseButtonPress:
 830         case QEvent::MouseButtonRelease:
 831         {
 832             SketchState state = EnTrain;
 833             QMouseEvent* me = (QMouseEvent*)e;
 834
 835             myButtonState = me->modifiers();
 836             if ( e->type() == QEvent::MouseButtonPress )
 837                 myButtonState |= me->button();  /* add pressed button */
 838
 839             if ( myStart.isNull() )
 840             {
 841                 state = Debut;
 842                 myStart = me->pos();
 843             }
 844
 845             int mouseOnlyState = ( myButtonState & ( Qt::LeftButton | Qt::MidButton | Qt::RightButton ) );
 846             if ( e->type() == QEvent::MouseButtonRelease && mouseOnlyState == sketchButton() )
 847             {
 848                 state = Fin;
 849             }
 850             myCurr = me->pos();
 851             onSketch( state );
 852             return true;
 853         }
 854         default: break;
 855     }
 856     return QObject::eventFilter( o, e );
 857 }
 858
 859 /*!
 860     Draws in the viewport. [ virtual protected ]
 861 */
 862 void GLViewer_ViewSketcher::onSketch( SketchState state )
 863 {
 864     GLViewer_ViewPort* avp = myViewer->getActiveView()->getViewPort();
 865     if( !avp )
 866         return;
 867
 868     if( myType == GLViewer_Viewer::Rect )
 869     {
 870         QRect* sketchRect = ( QRect* )data();
 871         if ( myButtonState & sketchButton() )
 872         {
 873             QRect rect( qMin( myStart.x(), myCurr.x() ), qMin( myStart.y(), myCurr.y() ),
 874                         qAbs( myStart.x() - myCurr.x() ), qAbs( myStart.y() - myCurr.y() ) );
 875             if ( !rect.isEmpty() )
 876             {
 877                 if ( !sketchRect->isEmpty() && myRectBand )
 878                     myRectBand->hide();    /* erase */
 879                 *sketchRect = rect;
 880                 if ( state != Fin )
 881                     drawRect( *sketchRect );
 882             }
 883         }
 884     }
 885
 886     if ( state == Fin )
 887     {
 888         QApplication::syncX();  /* force rectangle redrawing */
 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 }