src/GLViewer/GLViewer_Viewer2d.cxx

   1 // File:      GLViewer_Viewer2d.cxx
   2 // Created:   November, 2004
   3 // Author:    OCC team
   4 // Copyright (C) CEA 2004
   5
   6 /***************************************************************************
   7 **  Class:   GLViewer_Viewer2d
   8 **  Descr:   OpenGL Viewer 2D
   9 **  Module:  GLViewer
  10 **  Created: UI team, 04.09.02
  11 ****************************************************************************/
  12
  13 #include "GLViewer_Viewer2d.h"
  14
  15 #include "GLViewer_Object.h"
  16 #include "GLViewer_Context.h"
  17 #include "GLViewer_Drawer.h"
  18 #include "GLViewer_Selector2d.h"
  19 //#include "GLViewer_Sketcher.h"
  20 #include "GLViewer_ViewPort2d.h"
  21
  22 #include "SUIT_Desktop.h"
  23 #include "SUIT_ViewWindow.h"
  24
  25 #include <OSD_Timer.hxx>
  26 #include <TColStd_MapOfInteger.hxx>
  27
  28 #include <qpointarray.h>
  29 #include <qcolordialog.h>
  30 #include <qpopupmenu.h>
  31
  32 GLViewer_Viewer2d::GLViewer_Viewer2d( const QString& title) :
  33 GLViewer_Viewer( title )
  34 {
  35     myGLContext = new GLViewer_Context( this );
  36     //myGLSketcher = new GLViewer_Sketcher( this );
  37     mySelMode = GLViewer_Viewer::Multiple;
  38     createSelector();
  39     myDrawers.clear();
  40 }
  41
  42 GLViewer_Viewer2d::~GLViewer_Viewer2d()
  43 {
  44     //myGLSketcher = 0;
  45     //delete myGLSketcher;
  46 }
  47
  48 SUIT_ViewWindow* GLViewer_Viewer2d::createView( SUIT_Desktop* theDesktop )
  49 {
  50     return new GLViewer_ViewFrame( theDesktop, this );
  51 }
  52
  53 void GLViewer_Viewer2d::contextMenuPopup( QPopupMenu* thePopup )
  54 {
  55   // "Change background color" menu item is available if there are no selected objects
  56   if ( getSelector() == 0 || getSelector()->numSelected() == 0 )
  57   {
  58     if( thePopup->count() > 0 )
  59         thePopup->insertSeparator();
  60     thePopup->insertItem( tr( "MNU_DUMP_VIEW" ),  this, SLOT( onDumpView() ) );
  61     thePopup->insertItem( tr( "CHANGE_BGCOLOR" ), this, SLOT( onChangeBgColor() ) );
  62   }
  63 }
  64
  65 void GLViewer_Viewer2d::onChangeBgColor()
  66 {
  67   if( !getActiveView() )
  68     return;
  69   GLViewer_ViewPort2d* vp = ( ( GLViewer_ViewPort2d* )getActiveView()->getViewPort() );
  70
  71   QColor selColor = QColorDialog::getColor( vp->backgroundColor(), vp );
  72   if ( selColor.isValid() ) {
  73     vp->setBackgroundColor( selColor );
  74   }
  75 }
  76
  77 void GLViewer_Viewer2d::updateColors( QColor colorH, QColor colorS )
  78 {
  79 //  cout << "GLViewer_Viewer2d::updateColors" << endl;
  80
  81 /*
  82     for ( DrawerMap::Iterator it = myDrawers.begin(); it != myDrawers.end(); ++it )
  83     {
  84         it.key()->setHColor( colorH );
  85         it.key()->setSColor( colorS );
  86     }
  87 */
  88     ObjectMap anObjects = myGLContext->getObjects();
  89     ObjectMap::Iterator beginIt = anObjects.begin();
  90     ObjectMap::Iterator endIt = anObjects.end();
  91     for ( ObjectMap::Iterator it = beginIt; it != endIt; ++it )
  92     {
  93         //GLViewer_Drawer* aDrawer = it.key()->getDrawer();
  94         //aDrawer->setHColor( colorH );
  95         //aDrawer->setSColor( colorS );
  96     }
  97
  98
  99   activateAllDrawers( TRUE );
 100 }
 101
 102 void GLViewer_Viewer2d::updateBorders( const QRect& rect )
 103 {
 104   float xa = rect.left();
 105   float xb = rect.right();
 106   float ya = rect.top();
 107   float yb = rect.bottom();
 108
 109   QPtrVector<SUIT_ViewWindow> views = getViewManager()->getViews();
 110   for ( int i = 0, n = views.count(); i < n; i++ )
 111   {
 112     QRect* border = ( ( GLViewer_ViewPort2d* )((GLViewer_ViewFrame*)views[i])->getViewPort() )->getBorder();
 113
 114     if ( xa < border->left() )   border->setLeft( (int)xa );
 115     if ( xb > border->right() )  border->setRight( (int)xb );
 116     if ( ya < border->top() )    border->setTop( (int)ya );
 117     if ( yb > border->bottom() ) border->setBottom( (int)yb );
 118   }
 119 }
 120
 121 void GLViewer_Viewer2d::updateBorders()
 122 {
 123     QPtrVector<SUIT_ViewWindow> views = getViewManager()->getViews();
 124
 125     ObjectMap anObjects = myGLContext->getObjects();
 126     ObjectMap::Iterator beginIt = anObjects.begin();
 127     ObjectMap::Iterator endIt = anObjects.end();
 128     for ( int i = 0, n = views.count(); i < n; i++ )
 129     {
 130         QRect* border = ( ( GLViewer_ViewPort2d* )((GLViewer_ViewFrame*)views[i])->getViewPort() )->getBorder();
 131         border->setRect( 0, 0, 0, 0 );
 132         for ( ObjectMap::Iterator it = beginIt; it != endIt; ++it )
 133         {
 134             QRect* aRect = it.key()->getRect()->toQRect();
 135             if( !it.key()->getVisible() || aRect->isNull() )
 136                 continue;
 137
 138             if( border->isNull() )
 139                 border->setRect( aRect->left(), aRect->top(), aRect->width(), aRect->height() );
 140             else
 141             {
 142               border->setLeft( QMIN( border->left(), aRect->left() ) );
 143               border->setRight( QMAX( border->right(), aRect->right() ) );
 144               border->setTop( QMIN( border->top(), aRect->top() ) );
 145               border->setBottom( QMAX( border->bottom(), aRect->bottom() ) );
 146             }
 147         }
 148         /*
 149         float gap = QMAX( border->width(), border->height() ) / 20;
 150         border->setLeft( border->left() - gap );
 151         border->setRight( border->right() + gap );
 152         border->setTop( border->top() - gap );
 153         border->setBottom( border->bottom() + gap );
 154         */
 155     }
 156 }
 157
 158 void GLViewer_Viewer2d::updateAll()
 159 {
 160   if ( !getActiveView() )
 161     return;
 162
 163   QPtrVector<SUIT_ViewWindow> views = getViewManager()->getViews();
 164   for ( int i = 0, n = views.count(); i < n; i++ )
 165     ( ( GLViewer_ViewPort2d* )( ( GLViewer_ViewFrame* )views[i] )->getViewPort() )->getGLWidget()->updateGL();
 166 }
 167
 168 void GLViewer_Viewer2d::updateDrawers( GLboolean update, GLfloat scX, GLfloat scY )
 169 {
 170 //  cout << "GLViewer_Viewer2d::updateDrawers" << endl;
 171
 172     //myGLContext->updateScales( scX, scY );
 173     //myGLSketcher->drawContour();
 174     activateAllDrawers( update );
 175 }
 176
 177 void GLViewer_Viewer2d::activateDrawers( TColStd_SequenceOfInteger& sequence, bool onlyUpdate, GLboolean swap )
 178 {
 179 //  cout << "GLViewer_Viewer2d::activateDrawers" << endl;
 180 //  if( onlyUpdate )
 181 //    cout << "Only update" << endl;
 182 //  else
 183 //    cout << "Not only update" << endl;
 184
 185   TColStd_MapOfInteger aMap;
 186   for ( int i = 1, n = sequence.Length(); i <= n; i++)
 187     if ( !aMap.Contains( sequence( i ) ) )
 188       aMap.Add( sequence( i ) );
 189
 190   const ObjectMap& anObjects = myGLContext->getObjects();
 191   const ObjList& objList = myGLContext->getObjList();
 192   ObjList anActiveObjects;
 193   for( ObjList::const_iterator it = objList.begin(); it != objList.end(); ++it )
 194   {
 195     if ( (*it)->getVisible() && aMap.Contains( anObjects[*it] ) )
 196       anActiveObjects.append( *it );
 197   }
 198
 199   activateDrawers( anActiveObjects, onlyUpdate, swap );
 200 }
 201
 202 void GLViewer_Viewer2d::activateDrawers( QValueList<GLViewer_Object*>& theObjects, bool onlyUpdate, GLboolean swap )
 203 {
 204     //cout << "GLViewer_Viewer2d::activateDrawers " << (int)onlyUpdate << " " << (int)swap << endl;
 205     float xScale;
 206     float yScale;
 207
 208     QValueList<GLViewer_Drawer*>::Iterator anIt = myDrawers.begin();
 209     QValueList<GLViewer_Drawer*>::Iterator endDIt = myDrawers.end();
 210     for( ; anIt != endDIt; anIt++ )
 211             (*anIt)->clear();
 212
 213     QValueList<GLViewer_Drawer*> anActiveDrawers;
 214     QValueList<GLViewer_Object*>::Iterator endOIt = theObjects.end();
 215
 216     for( QValueList<GLViewer_Object*>::Iterator oit = theObjects.begin(); oit != endOIt; ++oit )
 217     {
 218         GLViewer_Drawer* aDrawer = (*oit)->getDrawer();
 219         if( !aDrawer )
 220         {
 221             anIt = myDrawers.begin();
 222
 223             for( ; anIt != endDIt; anIt++ )
 224                 if( (*anIt)->getObjectType() == (*oit)->getObjectType() )
 225                 {
 226                     (*oit)->setDrawer( *anIt );
 227                     aDrawer = *anIt;
 228                     break;
 229                 }
 230
 231             if( !aDrawer ) //are not exists
 232             {
 233                 myDrawers.append( (*oit)->createDrawer() );
 234                 aDrawer = (*oit)->getDrawer();
 235             }
 236         }
 237         aDrawer->addObject( (*oit) );
 238         if( anActiveDrawers.findIndex( aDrawer ) == -1 )
 239             anActiveDrawers.append( aDrawer );
 240     }
 241
 242     QValueList<GLViewer_Drawer*>::Iterator aDIt = anActiveDrawers.begin();
 243     QValueList<GLViewer_Drawer*>::Iterator aDEndIt = anActiveDrawers.end();
 244
 245     QPtrVector<SUIT_ViewWindow> views = getViewManager()->getViews();
 246     for ( int i = 0, n = views.count(); i < n; i++ )
 247     {
 248         GLViewer_ViewPort2d* vp = ( GLViewer_ViewPort2d* )((GLViewer_ViewFrame*)views[i])->getViewPort();
 249         vp->getScale( xScale, yScale );
 250         vp->getGLWidget()->makeCurrent();
 251
 252
 253         for( ; aDIt != aDEndIt; aDIt++ )
 254             (*aDIt)->create( xScale, yScale, onlyUpdate );
 255
 256         // tmp
 257         /*
 258         QRect* border = ( ( GLViewer_ViewPort2d* )((GLViewer_ViewFrame*)views[i])->getViewPort() )->getBorder();
 259         float x1 = border->left();
 260         float x2 = border->right();
 261         float y1 = border->bottom();
 262         float y2 = border->top();
 263
 264         QColor color = Qt::blue;
 265         glColor3f( ( GLfloat )color.red() / 255,
 266         ( GLfloat )color.green() / 255,
 267         ( GLfloat )color.blue() / 255 );
 268         glLineWidth( 1.0 );
 269
 270         glBegin( GL_LINE_LOOP );
 271         glVertex2f( x1, y1 );
 272         glVertex2f( x1, y2 );
 273         glVertex2f( x2, y2 );
 274         glVertex2f( x2, y1 );
 275         glEnd();
 276
 277         QString coords = QString::number( border->left() ) + " " + QString::number( border->right() ) + " " +
 278                          QString::number( border->top() ) + " " + QString::number( border->bottom() );
 279         (*aDIt)->drawText( "Border : " + coords, x1, y1+10/yScale, Qt::blue, &QFont( "Courier", 8, QFont::Normal ), 2 );
 280         */
 281         if ( swap )
 282            vp->getGLWidget()->swapBuffers();
 283     }
 284
 285     ( ( GLViewer_ViewPort2d* )getActiveView()->getViewPort() )->getGLWidget()->makeCurrent();
 286 }
 287
 288 void GLViewer_Viewer2d::activateDrawer( int index, bool onlyUpdate, GLboolean swap )
 289 {
 290   GLViewer_Object* anObj = 0;
 291   const ObjectMap& anObjects = myGLContext->getObjects();
 292   for ( ObjectMap::const_iterator it = anObjects.begin(); it != anObjects.end(); ++it )
 293     if ( it.data() == index )
 294     {
 295       anObj = (GLViewer_Object*)it.key();
 296       break;
 297     }
 298
 299   if ( anObj )
 300     activateDrawer( anObj, onlyUpdate, swap );
 301 }
 302
 303 void GLViewer_Viewer2d::activateDrawer( GLViewer_Object* theObject, bool onlyUpdate, GLboolean swap )
 304 {
 305   ObjList aList;
 306   aList.append( theObject );
 307   activateDrawers( aList, onlyUpdate, swap );
 308 }
 309
 310 void GLViewer_Viewer2d::activateAllDrawers( bool onlyUpdate, GLboolean swap )
 311 {
 312     if ( !getActiveView() )
 313       return;
 314
 315     ObjList anActiveObjs;
 316     const ObjList& objs = myGLContext->getObjList();
 317     for( ObjList::const_iterator it = objs.begin(); it != objs.end(); ++it )
 318     {
 319       GLViewer_Object* obj = (GLViewer_Object*)(*it);
 320       if( obj->getVisible() )
 321           anActiveObjs.append( obj );
 322     }
 323
 324     activateDrawers( anActiveObjs, onlyUpdate, swap );
 325 }
 326
 327 void GLViewer_Viewer2d::onCreateGLMarkers( int theMarkersNum, int theMarkersRad )
 328 {
 329     if ( !getActiveView() )
 330       return;
 331
 332     GLViewer_MarkerSet* aMarkerSet = new GLViewer_MarkerSet( theMarkersNum, theMarkersRad );
 333     getGLContext()->insertObject( aMarkerSet );
 334
 335     GLViewer_ViewPort2d* vp = ( GLViewer_ViewPort2d* )getActiveView()->getViewPort();
 336     int vpWidth = vp->getWidth();
 337     int vpHeight = vp->getHeight();
 338
 339     float* aXCoord = new float[ theMarkersNum ];
 340     float* anYCoord = new float[ theMarkersNum ];
 341
 342     srand( 1 );
 343     for ( long i = 0; i < theMarkersNum; i++ )
 344     {
 345         aXCoord[i] = cos( PI * (rand() / (GLfloat)RAND_MAX) ) * ((GLfloat)vpWidth / 2.);
 346         anYCoord[i] = cos( PI * (rand() / (GLfloat)RAND_MAX) ) * ((GLfloat)vpHeight / 2.);
 347     }
 348
 349     aMarkerSet->setXCoord( aXCoord, theMarkersNum );
 350     aMarkerSet->setYCoord( anYCoord, theMarkersNum );
 351     aMarkerSet->compute();
 352
 353     QRect* rect = aMarkerSet->getRect()->toQRect();
 354     updateBorders( *rect );
 355
 356     activateAllDrawers( false );
 357     activateTransform( GLViewer_Viewer::FitAll );
 358
 359     delete[] aXCoord;
 360     delete[] anYCoord;
 361 }
 362
 363 void GLViewer_Viewer2d::onCreateGLPolyline( int theAnglesNum, int theRadius, int thePolylineNumber )
 364 {
 365     if ( !getActiveView() )
 366       return;
 367
 368     GLViewer_ViewPort2d* vp = ( GLViewer_ViewPort2d* )getActiveView()->getViewPort();
 369     int vpWidth = vp->getWidth();
 370     int vpHeight = vp->getHeight();
 371
 372     float* aXCoord = new float[ theAnglesNum ];
 373     float* anYCoord = new float[ theAnglesNum ];
 374
 375     //srand( ( unsigned )time( NULL ) );
 376     srand( 1 );
 377     for( int j = 0; j < thePolylineNumber; j++)
 378     {
 379         GLViewer_Polyline* aPolyline = new GLViewer_Polyline( theAnglesNum, theRadius );
 380         getGLContext()->insertObject( aPolyline );
 381
 382         float aXOffset = cos( PI * (rand() / (GLfloat)RAND_MAX) ) * ((GLfloat)vpWidth / 2.);
 383         float anYOffset = cos( PI * (rand() / (GLfloat)RAND_MAX) ) * ((GLfloat)vpHeight / 2.);
 384         for( int i = 0; i < theAnglesNum; i++ )
 385         {
 386             aXCoord[i] = cos( 2. * PI * i / theAnglesNum ) * theRadius + aXOffset;
 387             anYCoord[i] = sin( 2. * PI * i / theAnglesNum ) * theRadius + anYOffset;
 388         }
 389
 390         aPolyline->setHighSelAll( true );
 391         aPolyline->setClosed( true );
 392         aPolyline->setXCoord( aXCoord, theAnglesNum );
 393         aPolyline->setYCoord( anYCoord, theAnglesNum );
 394         aPolyline->compute();
 395
 396         QRect* rect = aPolyline->getRect()->toQRect();
 397         updateBorders( *rect );
 398     }
 399
 400     activateAllDrawers( false );
 401     activateTransform( GLViewer_Viewer::FitAll );
 402
 403     delete[] aXCoord;
 404     delete[] anYCoord;
 405 }
 406
 407 void GLViewer_Viewer2d::onCreateGLText( QString theStr, int theTextNumber )
 408 {
 409     if ( !getActiveView() )
 410       return;
 411
 412     if( theTextNumber <= 0 )
 413         return;
 414
 415     GLViewer_ViewPort2d* vp = ( GLViewer_ViewPort2d* )getActiveView()->getViewPort();
 416     int vpWidth = vp->getWidth();
 417     int vpHeight = vp->getHeight();
 418
 419     //srand( ( unsigned )time( NULL ) );
 420     srand( 1 );
 421     for( int j = 0; j < theTextNumber; j++)
 422     {
 423         float aXPos = cos( PI * (rand() / (GLfloat)RAND_MAX) ) * ((GLfloat)vpWidth / 2.);
 424         float anYPos = cos( PI * (rand() / (GLfloat)RAND_MAX) ) * ((GLfloat)vpHeight / 2.);
 425         QColor aColor( 255, 0, 255 );
 426
 427         GLViewer_TextObject* aText = new GLViewer_TextObject( theStr, aXPos, anYPos, aColor  );
 428         aText->compute();
 429         getGLContext()->insertObject( aText );
 430
 431         QRect* rect = aText->getRect()->toQRect();
 432         updateBorders( *rect );
 433     }
 434
 435     activateAllDrawers( false );
 436 }
 437
 438 void GLViewer_Viewer2d::transPoint( GLfloat& x, GLfloat& y )
 439 {
 440     if ( !getActiveView() )
 441       return;
 442
 443     GLfloat xScale, yScale;
 444     GLfloat xPan, yPan;
 445
 446     GLViewer_ViewPort2d* curvp = ( GLViewer_ViewPort2d* )getActiveView()->getViewPort();
 447
 448     curvp->getScale( xScale, yScale );
 449     curvp->getPan( xPan, yPan );
 450
 451     GLfloat a = curvp->getGLWidget()->getRotationAngle() * PI / 180.;
 452
 453     x = (  x - ( GLfloat )curvp->getWidth()  / 2 ) / xScale;
 454     y = ( -y + ( GLfloat )curvp->getHeight() / 2 ) / yScale;
 455
 456     GLfloat x1 = x;
 457     GLfloat y1 = y;
 458
 459     x = x1 * cos(a) + y1 * sin(a);
 460     y = -x1 * sin(a) + y1 * cos(a);
 461
 462     x -= xPan;
 463     y -= yPan;
 464 }
 465
 466 QRect* GLViewer_Viewer2d::getWinObjectRect( GLViewer_Object* theObject )
 467 {
 468     if ( !getActiveView() )
 469       return 0;
 470
 471     GLfloat xScale, yScale;
 472     GLfloat xPan, yPan;
 473
 474     GLViewer_ViewPort2d* curvp = ( GLViewer_ViewPort2d* )getActiveView()->getViewPort();
 475     GLfloat aWidth = curvp->getWidth();
 476     GLfloat aHeight = curvp->getHeight();
 477
 478
 479     curvp->getScale( xScale, yScale );
 480     curvp->getPan( xPan, yPan );
 481
 482     QRect* aObjRect = theObject->getRect()->toQRect();
 483     float aLeft = aObjRect->left() + xPan, aRight = aObjRect->right() + xPan;
 484     float aTop = aObjRect->top() + yPan, aBot = aObjRect->bottom() + yPan;
 485
 486     GLfloat anAngle = curvp->getGLWidget()->getRotationAngle() * PI / 180.;
 487
 488     QPointArray aPointArray(4);
 489     int ls = (int)(aLeft*sin(anAngle)),  lc = (int)(aLeft*cos(anAngle)),
 490         rs = (int)(aRight*sin(anAngle)), rc = (int)(aRight*cos(anAngle)),
 491         ts = (int)(aTop*sin(anAngle)),   tc = (int)(aTop*cos(anAngle)),
 492         bs = (int)(aBot*sin(anAngle)),   bc = (int)(aBot*cos(anAngle));
 493     aPointArray[0] = QPoint( lc - ts, ls + tc );
 494     aPointArray[1] = QPoint( rc - ts, rs + tc );
 495     aPointArray[2] = QPoint( rc - bs, rs + bc );
 496     aPointArray[3] = QPoint( lc - bs, ls + bc );
 497
 498     int aMinLeft = aPointArray[0].x(), aMaxRight = aPointArray[0].x(),
 499         aMinTop = aPointArray[0].y(), aMaxBottom = aPointArray[0].y();
 500     for( int i = 1; i < 4; i++ )
 501     {
 502         int x = aPointArray[i].x();
 503         int y = aPointArray[i].y();
 504         aMinLeft = QMIN( aMinLeft,x );
 505         aMaxRight = QMAX( aMaxRight, x );
 506         aMinTop = QMIN( aMinTop, y );
 507         aMaxBottom = QMAX( aMaxBottom, y );
 508     }
 509
 510     aLeft = (aMinLeft/* + xPan*/)*xScale + aWidth / 2;
 511     aRight = (aMaxRight/* + xPan*/)*xScale + aWidth / 2;
 512
 513     aTop = -( (aMaxBottom/* + yPan*/)*yScale - aHeight / 2 );
 514     aBot = -( (aMinTop/* + yPan*/)*yScale - aHeight / 2 );
 515
 516     QRect* newRect = new QRect( (int)aLeft, (int)aTop, (int)(aRight-aLeft), (int)(aBot-aTop) );
 517
 518     return newRect;
 519 }
 520
 521 GLViewer_Rect GLViewer_Viewer2d::getGLVRect( const QRect& theRect ) const
 522 {
 523   if ( !getActiveView() )
 524       return GLViewer_Rect();
 525
 526   GLViewer_ViewPort2d* vp = ( GLViewer_ViewPort2d* )getActiveView()->getViewPort();
 527
 528   if( !vp )
 529     return GLViewer_Rect();
 530
 531   return vp->win2GLV( theRect );
 532 }
 533
 534 QRect GLViewer_Viewer2d::getQRect( const GLViewer_Rect& theRect ) const
 535 {
 536   if ( !getActiveView() )
 537       return QRect();
 538
 539   GLViewer_ViewPort2d* vp = ( GLViewer_ViewPort2d* )getActiveView()->getViewPort();
 540
 541   if( !vp )
 542     return QRect();
 543
 544   return vp->GLV2win( theRect );
 545 }
 546
 547 GLViewer_Selector* GLViewer_Viewer2d::createSelector()
 548 {
 549   return new GLViewer_Selector2d( this, getGLContext() );
 550 }
 551
 552 GLViewer_ViewTransformer* GLViewer_Viewer2d::createTransformer( int type )
 553 {
 554     return new GLViewer_View2dTransformer( this, type );
 555 }
 556 /*
 557 GLViewer_Sketcher* GLViewer_Viewer2d::createGLSketcher( int type )
 558 {
 559     return new GLViewer_Sketcher( this, type );
 560 }
 561
 562 void GLViewer_Viewer2d::activateGLSketching( int type )
 563 {
 564     GLViewer_ViewPort2d* vp = 0;
 565     if ( !getActiveView() || !( vp = ( GLViewer_ViewPort2d* )getActiveView()->getViewPort() ) )
 566         return;
 567
 568     // Finish current sketching
 569     if ( type == None )
 570     {
 571         if ( myGLSketcher->getType() != None )
 572         {
 573             myGLSketcher->setType( None );
 574             finishSketching();
 575         }
 576     }
 577     // Activate new sketching
 578     else
 579     {
 580         activateGLSketching( None );  // concurrency not supported
 581         myGLSketcher->setType( type );
 582         startSketching();
 583     }
 584 }
 585
 586 void GLViewer_Viewer2d::startSketching()
 587 {
 588     GLViewer_ViewPort2d* avp = (GLViewer_ViewPort2d*)getActiveView()->getViewPort();
 589     avp->setCursor( *avp->getSketchCursor() );
 590     //avp->enablePopup( false );
 591     myGLSketcher->startSketching();
 592 }
 593
 594 void GLViewer_Viewer2d::finishSketching()
 595 {
 596     GLViewer_ViewPort2d* avp = (GLViewer_ViewPort2d*)getActiveView()->getViewPort();
 597     avp->setCursor( *avp->getDefaultCursor() );
 598     //avp->enablePopup( true );
 599     myGLSketcher->finishSketching();
 600 }
 601
 602 bool GLViewer_Viewer2d::isSketchingActive()
 603 {
 604     return myGLSketcher->getType() != None;
 605 }
 606
 607 int GLViewer_Viewer2d::getSketchingType()
 608 {
 609     return myGLSketcher->getType();
 610 }
 611
 612 void GLViewer_Viewer2d::onSketchDelObject()
 613 {
 614     GLViewer_ViewPort2d* avp = (GLViewer_ViewPort2d*)getActiveView()->getViewPort();
 615     avp->setCursor( *avp->getDefaultCursor() );
 616     myGLSketcher->finishSketching( true );
 617 }
 618
 619 void GLViewer_Viewer2d::onSketchUndoLast()
 620 {
 621
 622 }
 623
 624 void GLViewer_Viewer2d::onSketchFinish()
 625 {
 626     finishSketching();
 627 }
 628 */
 629 void GLViewer_Viewer2d::onMouseEvent( SUIT_ViewWindow*, QMouseEvent* e )
 630 {
 631     if ( !getActiveView() )
 632         return;
 633
 634     //if ( testRotation( e ) )
 635     //    return;
 636
 637     switch( e->type() )
 638     {
 639         case QEvent::MouseButtonPress :
 640         case QEvent::MouseMove :
 641         case QEvent::MouseButtonRelease :
 642             //if( myGLSketcher->getType() != None )
 643             //    myGLSketcher->sketch( e );
 644         default: break;
 645     }
 646
 647     GLViewer_Viewer::onMouseEvent( 0, e );
 648 }
 649
 650 bool GLViewer_Viewer2d::testRotation( QMouseEvent* e )
 651 {
 652     if ( ( e->button() == GLViewer_View2dTransformer::rotateButton() ) &&
 653          ( e->type() == QEvent::MouseButtonPress ) &&
 654          ( e->state() & GLViewer_ViewTransformer::accelKey() ) )
 655     {
 656         activateTransform( GLViewer_Viewer::Rotate );
 657         return true;
 658     }
 659     return false;
 660 }
 661
 662
 663 void GLViewer_Viewer2d::insertHeader( VectorFileType aType, QFile& hFile )
 664 {
 665     if( aType == POST_SCRIPT )
 666     {
 667         QString header = "%!PS-Adobe-3.0\n";
 668         header += "%%Creator: OpenCascade 2004\n";
 669         header += "%%Title: Our document\n";
 670         header += "%%PageOrder: Ascend\n";
 671         header += "%%Orientation: Portrait\n";
 672         header += "%%LanguageLevel: 2\n";
 673
 674         header += "%%Pages: 1\n";
 675         header += "%%Page: 1\n\n";
 676
 677         hFile.writeBlock( header.ascii(), header.length() );
 678     }
 679     else if( aType == HPGL )
 680     {
 681         QString header = "[Esc].(;\n";
 682         header += "[Esc].I81;;17:\n";
 683         header += "[Esc].N;19:\n";
 684         header += "IN;\n";
 685         header += "SC;\n";
 686         header += "PU;\n";
 687         header += "SP1;\n";
 688         header += "LT;\n";
 689         header += "VS36;\n";
 690
 691         hFile.writeBlock( header.ascii(), header.length() );
 692     }
 693 }
 694
 695 void GLViewer_Viewer2d::insertEnding( VectorFileType aType, QFile& hFile )
 696 {
 697     if( aType == POST_SCRIPT )
 698     {
 699         QString ending = "showpage\n\n%%EOF";
 700         hFile.writeBlock( ending.ascii(), ending.length() );
 701     }
 702     else if( aType == HPGL )
 703     {
 704         QString ending = "PU;PA0,0;SP;EC;PG1;EC1;OE\n";
 705         hFile.writeBlock( ending.ascii(), ending.length() );
 706     }
 707 }
 708
 709 inline void mm2custom( GLViewer_Viewer2d::VectorFileType aType, double& value )
 710 {
 711     if( aType==GLViewer_Viewer2d::POST_SCRIPT )
 712         value*=2.8346; //mm to pt
 713
 714     else if( aType==GLViewer_Viewer2d::HPGL )
 715         value*=40;     //mm to plu (there are 40 plues in mm)
 716 #ifdef WIN32
 717     else if( aType==GLViewer_Viewer2d::ENH_METAFILE )
 718         value*=100;    //this unit is 1/100 mm
 719 #endif
 720 }
 721
 722 bool GLViewer_Viewer2d::translateTo( VectorFileType aType, QString FileName, PaperType aPType,
 723                                   double mmLeft, double mmRight, double mmTop, double mmBottom )
 724 {
 725     if ( !getActiveView() )
 726       return false;
 727
 728         QFile hFile( FileName.ascii() );
 729
 730 #ifdef WIN32
 731     HDC hMetaFileDC;
 732 #endif
 733
 734     GLViewer_ViewPort2d* aCurVP = (GLViewer_ViewPort2d*) getActiveView()->getViewPort();
 735
 736     GLfloat xPan, yPan;
 737     aCurVP->getPan( xPan, yPan );
 738     GLfloat aRotation = aCurVP->getGLWidget()->getRotationAngle() * 3.14159265 / 180.0;
 739
 740     GLViewer_CoordSystem aViewerCS( GLViewer_CoordSystem::Cartesian, xPan, yPan, 1.0, 1.0, aRotation );
 741
 742     double AW = Sizes[2*int(aPType)],
 743            AH = Sizes[2*int(aPType)+1]; //size of Axx paper in mm
 744
 745     mm2custom( aType, mmLeft ); //we translate mm to custom units
 746     mm2custom( aType, mmRight );
 747     mm2custom( aType, mmTop );
 748     mm2custom( aType, mmBottom );
 749     mm2custom( aType, AW );
 750     mm2custom( aType, AH );
 751
 752     float xScale, yScale;
 753     aCurVP->getScale( xScale, yScale );
 754
 755     double VPWidth = aCurVP->getWidth()/xScale,   //the width in reference units
 756            VPHeight = aCurVP->getHeight()/yScale;
 757
 758     double k1 = ( AW-mmLeft-mmRight ) / VPWidth,
 759            k2 = ( AH-mmTop-mmBottom ) / VPHeight;
 760
 761     if( k1>k2 )
 762         k1 = k2; //We select the minimum
 763
 764     double hdelta = ( AW-mmLeft-mmRight - VPWidth * k1 )/2.0, //addition in horizontal
 765            vdelta = ( AH-mmTop-mmBottom - VPHeight * k1 )/2.0; //addition in vertical
 766
 767     mmLeft   += hdelta; //The real free space on the left and right borders
 768     mmRight  += hdelta;
 769     mmTop    += vdelta;
 770     mmBottom += vdelta;
 771
 772     GLViewer_CoordSystem aPaperCS( GLViewer_CoordSystem::Cartesian,
 773         -(mmLeft/k1+VPWidth/2.0), -(mmBottom/k1+VPHeight/2.0), 1/k1, 1/k1 );
 774
 775     if( aType==POST_SCRIPT || aType==HPGL )
 776     {
 777         hFile.open( IO_ReadWrite | IO_Truncate );
 778         hFile.at( 0 );
 779         insertHeader( aType, hFile );
 780     }
 781 #ifdef WIN32
 782     else if( aType==ENH_METAFILE )
 783     {
 784         RECT r;
 785         r.left = 0; r.right = AW;
 786         r.top = 0; r.bottom = AH;
 787         HDC screen_dc = GetDC( 0 ); //The screen device context
 788         HDC bitDC = CreateCompatibleDC ( screen_dc ); //The context compatible with screen
 789
 790         hMetaFileDC = CreateEnhMetaFile( bitDC, FileName.ascii(), &r, "" );
 791         SetMapMode( hMetaFileDC, MM_HIMETRIC );
 792         SetWindowOrgEx( hMetaFileDC, 0, r.bottom, NULL );
 793         HRGN ClipRgn = CreateRectRgn( 0, 0, AW, AH );
 794         SelectClipRgn( hMetaFileDC, ClipRgn );
 795
 796         LOGBRUSH aBrushData;
 797         aBrushData.lbColor = RGB( 255, 255, 255 );
 798         aBrushData.lbStyle = BS_SOLID;
 799
 800         FillRect( hMetaFileDC, &r, CreateBrushIndirect( &aBrushData ) );
 801
 802         ReleaseDC( 0, screen_dc );
 803         DeleteDC( bitDC );
 804
 805         aCurVP->getGLWidget()->translateBackgroundToEMF( hMetaFileDC, &aViewerCS, &aPaperCS );
 806     }
 807 #endif
 808
 809     if( aType==POST_SCRIPT )
 810     {
 811         QString temp = "%1 %2 %3 %4 rectclip\n\n",
 812                 aBuffer = temp.arg( mmLeft ).arg( mmBottom ).
 813                                arg( AW-mmLeft-mmRight ).arg( AH-mmBottom-mmTop );
 814         //It is set clipping path
 815
 816         hFile.writeBlock( aBuffer.ascii(), aBuffer.length() );
 817
 818         aCurVP->getGLWidget()->translateBackgroundToPS( hFile, &aViewerCS, &aPaperCS );
 819     }
 820
 821     bool result = true;
 822     for( int i=0, n=myDrawers.count(); i<n; i++ )
 823         if( aType==POST_SCRIPT )
 824             result &= myDrawers[ i ]->translateToPS( hFile, &aViewerCS, &aPaperCS );
 825         else if( aType==HPGL )
 826             result &= myDrawers[ i ]->translateToHPGL( hFile, &aViewerCS, &aPaperCS );
 827 #ifdef WIN32
 828         else if( aType==ENH_METAFILE )
 829             result &= myDrawers[ i ]->translateToEMF( hMetaFileDC, &aViewerCS, &aPaperCS );
 830 #endif
 831
 832     if( aType==POST_SCRIPT || aType==HPGL )
 833     {
 834         insertEnding( aType, hFile);
 835         hFile.close();
 836     }
 837 #ifdef WIN32
 838     else if( aType==ENH_METAFILE )
 839         DeleteEnhMetaFile( CloseEnhMetaFile( hMetaFileDC ) );
 840 #endif
 841
 842     return true;
 843 }
 844
 845
 846 void GLViewer_Viewer2d::repaintView( GLViewer_ViewFrame* theView, bool makeCurrent )
 847 {
 848     GLViewer_ViewFrame* aCurView;
 849     if( !theView )
 850         aCurView = (GLViewer_ViewFrame*)getActiveView();
 851     else
 852         aCurView = theView;
 853
 854     if ( !aCurView )
 855       return;
 856
 857     ObjList anActiveObjs;
 858     const ObjList& objs = myGLContext->getObjList();
 859     for( ObjList::const_iterator it = objs.begin(); it != objs.end(); ++it )
 860     {
 861       GLViewer_Object* obj = (GLViewer_Object*)(*it);
 862       if( obj->getVisible() )
 863           anActiveObjs.append( obj );
 864     }
 865
 866     float xScale;
 867     float yScale;
 868
 869     QValueList<GLViewer_Drawer*>::Iterator anIt = myDrawers.begin();
 870     QValueList<GLViewer_Drawer*>::Iterator endDIt = myDrawers.end();
 871     for( ; anIt != endDIt; anIt++ )
 872             (*anIt)->clear();
 873
 874     QValueList<GLViewer_Drawer*> anActiveDrawers;
 875     QValueList<GLViewer_Object*>::Iterator endOIt = anActiveObjs.end();
 876
 877     for( QValueList<GLViewer_Object*>::Iterator oit = anActiveObjs.begin(); oit != endOIt; ++oit )
 878     {
 879         GLViewer_Drawer* aDrawer = (*oit)->getDrawer();
 880         if( !aDrawer )
 881         {
 882             anIt = myDrawers.begin();
 883
 884             for( ; anIt != endDIt; anIt++ )
 885                 if( (*anIt)->getObjectType() == (*oit)->getObjectType() )
 886                 {
 887                     (*oit)->setDrawer( *anIt );
 888                     aDrawer = *anIt;
 889                     break;
 890                 }
 891
 892             if( !aDrawer ) //are not exists
 893             {
 894                 myDrawers.append( (*oit)->createDrawer() );
 895                 aDrawer = (*oit)->getDrawer();
 896             }
 897         }
 898         aDrawer->addObject( (*oit) );
 899         if( anActiveDrawers.findIndex( aDrawer ) == -1 )
 900             anActiveDrawers.append( aDrawer );
 901     }
 902
 903     QValueList<GLViewer_Drawer*>::Iterator aDIt = anActiveDrawers.begin();
 904     QValueList<GLViewer_Drawer*>::Iterator aDEndIt = anActiveDrawers.end();
 905
 906     GLViewer_ViewPort2d* vp = ( GLViewer_ViewPort2d* )aCurView->getViewPort();
 907     vp->getScale( xScale, yScale );
 908
 909     if( makeCurrent )
 910         vp->getGLWidget()->makeCurrent();
 911
 912     for( ; aDIt != aDEndIt; aDIt++ )
 913         (*aDIt)->create( xScale, yScale, false );
 914
 915 //    if ( swap )
 916     vp->getGLWidget()->swapBuffers();
 917
 918 //    ( ( GLViewer_ViewPort2d* )getActiveView()->getViewPort() )->getGLWidget()->makeCurrent();
 919 }
 920
 921 void GLViewer_Viewer2d::startOperations( QMouseEvent* e )
 922 {
 923     GLViewer_ViewPort2d* vp = ( GLViewer_ViewPort2d* )((GLViewer_ViewFrame*)getActiveView())->getViewPort();
 924
 925     float x = e->pos().x();
 926     float y = e->pos().y();
 927     transPoint( x, y );
 928     GLViewer_Pnt point( x, y );
 929
 930     if( e->button() == Qt::LeftButton && !myGLContext->getCurrentObject() && vp->startPulling( point ) )
 931         return;
 932
 933     if( e->button() == Qt::LeftButton && !(vp->currentBlock() & BS_Selection) && !myGLContext->getCurrentObject() )
 934         vp->startSelectByRect( e->x(), e->y() );
 935 }
 936
 937 bool GLViewer_Viewer2d::updateOperations( QMouseEvent* e )
 938 {
 939     GLViewer_ViewPort2d* vp = ( GLViewer_ViewPort2d* )((GLViewer_ViewFrame*)getActiveView())->getViewPort();
 940
 941     if( vp->isPulling() )
 942     {
 943         float x = e->pos().x();
 944         float y = e->pos().y();
 945         transPoint( x, y );
 946
 947         vp->drawPulling( GLViewer_Pnt( x, y ) );
 948         updateAll();
 949         return true;
 950     }
 951
 952     if( !myGLContext->getCurrentObject() )
 953     {
 954         vp->drawSelectByRect( e->x(), e->y() );
 955         return true;
 956     }
 957     return false;
 958 }
 959
 960 void GLViewer_Viewer2d::finishOperations( QMouseEvent* e )
 961 {
 962     GLViewer_ViewPort2d* vp = ( GLViewer_ViewPort2d* )((GLViewer_ViewFrame*)getActiveView())->getViewPort();
 963
 964     if( vp->isPulling() )
 965     {
 966         vp->finishPulling();
 967         updateAll();
 968         return;
 969     }
 970
 971     if( !myGLContext->getCurrentObject() )
 972     {
 973         QRect aSelRect = vp->selectionRect();
 974         vp->finishSelectByRect();
 975         if ( getSelector() && !aSelRect.isNull() )
 976         {
 977             bool append = bool ( e->state() & GLViewer_Selector::appendKey() );
 978             getSelector()->select( aSelRect, append );
 979         }
 980     }
 981 }
 982
 983 void GLViewer_Viewer2d::startOperations( QWheelEvent* e )
 984 {
 985     bool zoomIn = e->delta() > 0;
 986     bool update = false;
 987     for( myGLContext->InitSelected(); myGLContext->MoreSelected(); myGLContext->NextSelected() )
 988     {
 989         GLViewer_Object* anObject = myGLContext->SelectedObject();
 990         update = anObject->updateZoom( zoomIn ) || update;
 991     }
 992
 993     if( update )
 994         updateAll();
 995 }
 996
 997 /*!
 998     Processes "Dump view..." context popup menu command
 999 */
1000 void GLViewer_Viewer2d::onDumpView()
1001 {
1002   if ( getActiveView() )
1003     getActiveView()->onDumpView();
1004 }
1005
1006 /****************************************************************
1007 **  Class: GLViewer_View2dTransformer
1008 **
1009 *****************************************************************/
1010
1011 int GLViewer_View2dTransformer::rotateBtn = RightButton;
1012
1013 GLViewer_View2dTransformer::GLViewer_View2dTransformer( GLViewer_Viewer* viewer, int typ )
1014 : GLViewer_ViewTransformer( viewer, typ )
1015 {
1016     if ( type() == GLViewer_Viewer::Rotate )
1017         initTransform( true );
1018 }
1019
1020 GLViewer_View2dTransformer::~GLViewer_View2dTransformer()
1021 {
1022     if ( type() == GLViewer_Viewer::Rotate )
1023         initTransform( false );
1024 }
1025
1026 /*!
1027     Redefined to provide specific 3D transfomations. [ virtual public ]
1028 */
1029 void GLViewer_View2dTransformer::exec()
1030 {
1031     if ( !myViewer->getActiveView() )
1032       return;
1033
1034     /* additional transforms */
1035     GLViewer_ViewPort* vp = myViewer->getActiveView()->getViewPort();
1036     //QAD_ASSERT( vp->inherits( "QAD_ViewPort3d" ) );
1037     GLViewer_ViewPort2d* avp = (GLViewer_ViewPort2d*)vp;
1038     switch ( myType )
1039     {
1040         case GLViewer_Viewer::Rotate:
1041             myMajorBtn = rotateButton();
1042             avp->setCursor( *avp->getRotCursor() );
1043             break;
1044         default:
1045             GLViewer_ViewTransformer::exec();
1046     }
1047 }
1048
1049 /*!
1050     Handles rotation. [ protected virtual ]
1051 */
1052 void GLViewer_View2dTransformer::onTransform( TransformState state )
1053 {
1054     if ( !myViewer->getActiveView() )
1055       return;
1056
1057     GLViewer_ViewPort* vp = myViewer->getActiveView()->getViewPort();
1058     //QAD_ASSERT( vp->inherits( "QAD_ViewPort3d" ) );
1059     GLViewer_ViewPort2d* avp = (GLViewer_ViewPort2d*)vp;
1060     if ( type() == GLViewer_Viewer::Rotate )
1061     {
1062         switch ( state )
1063         {
1064             case Debut:
1065                 if ( myButtonState & myMajorBtn )
1066                     avp->startRotation( myStart.x(), myStart.y() );
1067                 break;
1068             case EnTrain:
1069                 if ( myButtonState & myMajorBtn )
1070                     avp->rotate( myCurr.x(), myCurr.y() );
1071                 break;
1072             case Fin:
1073                 avp->endRotation();
1074                 break;
1075             default: break;
1076         }
1077     }
1078     GLViewer_ViewTransformer::onTransform( state );
1079 }
1080