src/XGUI/XGUI_ViewPort.cpp

   1 #include "XGUI_ViewPort.h"
   2 #include "XGUI_ViewWindow.h"
   3 #include "XGUI_Viewer.h"
   4 #include "XGUI_Constants.h"
   5
   6 #include <QPaintEvent>
   7 #include <QPainter>
   8 #include <QFileInfo>
   9 #include <QApplication>
  10
  11 #include <V3d_OrthographicView.hxx>
  12 #include <V3d_PerspectiveView.hxx>
  13 #include <Visual3d_View.hxx>
  14 #include <Graphic3d_GraphicDriver.hxx>
  15
  16 #ifdef WIN32
  17 #include <WNT_Window.hxx>
  18 #else
  19 #include <Xw_Window.hxx>
  20 #endif
  21
  22 #include <GL/gl.h>
  23
  24 static double rx = 0.;
  25 static double ry = 0.;
  26 static int sx = 0;
  27 static int sy = 0;
  28 static Standard_Boolean zRotation = Standard_False;
  29
  30 /*!
  31  Create native view window for CasCade view [ static ]
  32  */
  33 Handle(Aspect_Window) CreateCasWindow(const Handle(V3d_View)& view, WId winId)
  34 {
  35   Aspect_Handle aWindowHandle = (Aspect_Handle) winId;
  36 #ifdef WIN32
  37   Handle(WNT_Window) viewWindow = new WNT_Window(aWindowHandle);
  38 #else
  39   Handle(Aspect_DisplayConnection) aDispConnection = view->Viewer()->Driver()->GetDisplayConnection();
  40   Handle(Xw_Window) viewWindow = new Xw_Window( aDispConnection, aWindowHandle );
  41 #endif
  42   return viewWindow;
  43 }
  44
  45 //************************************************************************
  46 //************************************************************************
  47 //************************************************************************
  48 XGUI_ViewPort::XGUI_ViewPort(XGUI_ViewWindow* theParent, const Handle(V3d_Viewer)& theViewer,
  49                              V3d_TypeOfView theType)
  50     : QWidget(theParent),
  51       myPaintersRedrawing(false),
  52       myScale(1.0),
  53       myIsAdvancedZoomingEnabled(false),
  54       myBgImgHeight(0),
  55       myBgImgWidth(0)
  56 {
  57   setMouseTracking(true);
  58   setBackgroundRole(QPalette::NoRole);
  59
  60   // set focus policy to threat QContextMenuEvent from keyboard
  61   setFocusPolicy(Qt::StrongFocus);
  62   setAttribute(Qt::WA_PaintOnScreen);
  63   setAttribute(Qt::WA_NoSystemBackground);
  64   setAutoFillBackground(false);
  65
  66   if (theType == V3d_ORTHOGRAPHIC) {
  67     myOrthoView = new V3d_OrthographicView(theViewer);
  68     myActiveView = myOrthoView;
  69     myPerspView = 0;
  70   } else {
  71     myPerspView = new V3d_PerspectiveView(theViewer);
  72     myActiveView = myPerspView;
  73   }
  74   myActiveView->SetSurfaceDetail(V3d_TEX_ALL);
  75 }
  76
  77 //***********************************************
  78 XGUI_ViewPort::~XGUI_ViewPort()
  79 {
  80 }
  81
  82 //***********************************************
  83 bool XGUI_ViewPort::mapView(const Handle(V3d_View)& theView)
  84 {
  85   if (!setWindow(theView))
  86     return false;
  87
  88   if (!mapped(theView)) {
  89     theView->SetWindow(myWindow);
  90     //if (theView != activeView())
  91     //theView->View()->Deactivate();
  92   }
  93
  94   /* create static trihedron (16551: EDF PAL 501) */
  95   //OCCViewer_ViewWindow* aVW = dynamic_cast<OCCViewer_ViewWindow*>( parentWidget()->parentWidget()->parentWidget() );
  96   //if ( aVW ) {
  97   //    OCCViewer_Viewer* aViewModel = dynamic_cast<OCCViewer_Viewer*>( aVW->getViewManager()->getViewModel() );
  98   //    if ( aViewModel && aViewModel->isStaticTrihedronDisplayed() ){
  99   //theView->ZBufferTriedronSetup();
 100   theView->TriedronDisplay(Aspect_TOTP_LEFT_LOWER, Quantity_NOC_WHITE, 0.05, V3d_ZBUFFER);
 101   //    }
 102   //}
 103
 104   emit(vpMapped());
 105
 106   return true;
 107 }
 108
 109 //***********************************************
 110 bool XGUI_ViewPort::setWindow(const Handle(V3d_View)& theView)
 111 {
 112   if (!myWindow.IsNull())
 113     return true;
 114
 115   if (theView.IsNull())
 116     return false;
 117
 118   attachWindow(theView, CreateCasWindow(theView, winId()));
 119
 120   myWindow = theView->Window();
 121   return !myWindow.IsNull();
 122 }
 123
 124 //***********************************************
 125 bool XGUI_ViewPort::mapped(const Handle(V3d_View)& theView) const
 126 {
 127   return (!theView.IsNull() && theView->View()->IsDefined());
 128 }
 129
 130 //***********************************************
 131 void XGUI_ViewPort::updateBackground()
 132 {
 133   if (activeView().IsNull())
 134     return;
 135   if (!myBackground.isValid())
 136     return;
 137
 138   // VSR: Important note on below code.
 139   // In OCCT (in version 6.5.2), things about the background drawing
 140   // are not straightforward and not clearly understandable:
 141   // - Horizontal gradient is drawn vertically (!), well ok, from top side to bottom one.
 142   // - Vertical gradient is drawn horizontally (!), from right side to left one (!!!).
 143   // - First and second diagonal gradients are confused.
 144   // - Image texture, once set, can not be removed (!).
 145   // - Texture image fill mode Aspect_FM_NONE is not taken into account (and means the same
 146   //   as Aspect_FM_CENTERED).
 147   // - The only way to cancel gradient background (and get back to single colored) is to
 148   //   set gradient background style to Aspect_GFM_NONE while passing two colors is also needed
 149   //   (see V3d_View::SetBgGradientColors() function).
 150   // - Also, it is impossible to draw texture image above the gradiented background (only above
 151   //   single-colored).
 152   // In OCCT 6.5.3 all above mentioned problems are fixed; so, above comment should be removed as soon
 153   // as SALOME is migrated to OCCT 6.5.3. The same concerns #ifdef statements in the below code
 154   switch (myBackground.mode()) {
 155     case Qtx::ColorBackground: {
 156       QColor c = myBackground.color();
 157       if (c.isValid()) {
 158         // Unset texture should be done here
 159         // ...
 160         Quantity_Color qCol(c.red() / 255., c.green() / 255., c.blue() / 255., Quantity_TOC_RGB);
 161         activeView()->SetBgGradientStyle(Aspect_GFM_NONE);  // cancel gradient background
 162         activeView()->SetBgImageStyle(Aspect_FM_NONE);  // cancel texture background
 163         // then change background color
 164         activeView()->SetBackgroundColor(qCol);
 165         // update viewer
 166         activeView()->Update();
 167       }
 168       break;
 169     }
 170     case Qtx::SimpleGradientBackground: {
 171       QColor c1, c2;
 172       int type = myBackground.gradient(c1, c2);
 173       if (c1.isValid() && type >= XGUI::HorizontalGradient && type <= XGUI::LastGradient) {
 174         // Unset texture should be done here
 175         // ...
 176         // Get colors and set-up gradiented background
 177         if (!c2.isValid())
 178           c2 = c1;
 179         Quantity_Color qCol1(c1.red() / 255., c1.green() / 255., c1.blue() / 255.,
 180                              Quantity_TOC_RGB);
 181         Quantity_Color qCol2(c2.red() / 255., c2.green() / 255., c2.blue() / 255.,
 182                              Quantity_TOC_RGB);
 183         activeView()->SetBgImageStyle(Aspect_FM_NONE);  // cancel texture background
 184         switch (type) {
 185           case XGUI::HorizontalGradient:
 186             activeView()->SetBgGradientColors(qCol1, qCol2, Aspect_GFM_HOR,
 187             Standard_True);
 188             break;
 189           case XGUI::VerticalGradient:
 190             activeView()->SetBgGradientColors(qCol1, qCol2, Aspect_GFM_VER,
 191             Standard_True);
 192             break;
 193           case XGUI::Diagonal1Gradient:
 194             activeView()->SetBgGradientColors(qCol1, qCol2, Aspect_GFM_DIAG1,
 195             Standard_True);
 196             break;
 197           case XGUI::Diagonal2Gradient:
 198             activeView()->SetBgGradientColors(qCol1, qCol2, Aspect_GFM_DIAG2,
 199             Standard_True);
 200             break;
 201           case XGUI::Corner1Gradient:
 202             activeView()->SetBgGradientColors(qCol1, qCol2, Aspect_GFM_CORNER1,
 203             Standard_True);
 204             break;
 205           case XGUI::Corner2Gradient:
 206             activeView()->SetBgGradientColors(qCol1, qCol2, Aspect_GFM_CORNER2,
 207             Standard_True);
 208             break;
 209           case XGUI::Corner3Gradient:
 210             activeView()->SetBgGradientColors(qCol1, qCol2, Aspect_GFM_CORNER3,
 211             Standard_True);
 212             break;
 213           case XGUI::Corner4Gradient:
 214             activeView()->SetBgGradientColors(qCol1, qCol2, Aspect_GFM_CORNER4,
 215             Standard_True);
 216             break;
 217           default:
 218             break;
 219         }
 220       }
 221       break;
 222     }
 223     case Qtx::CustomGradientBackground:
 224       // NOT IMPLEMENTED YET
 225       break;
 226     default:
 227       break;
 228   }
 229   // VSR: In OCCT before v6.5.3 below code can't be used because of very ugly bug - it has been impossible to
 230   // clear the background texture image as soon as it was once set to the viewer.
 231   if (myBackground.isTextureShown()) {
 232     QString fileName;
 233     int textureMode = myBackground.texture(fileName);
 234     QFileInfo fi(fileName);
 235     if (!fileName.isEmpty() && fi.exists()) {
 236       // set texture image: file name and fill mode
 237       switch (textureMode) {
 238         case XGUI::CenterTexture:
 239           activeView()->SetBackgroundImage(fi.absoluteFilePath().toLatin1().constData(),
 240                                            Aspect_FM_CENTERED);
 241           break;
 242         case XGUI::TileTexture:
 243           activeView()->SetBackgroundImage(fi.absoluteFilePath().toLatin1().constData(),
 244                                            Aspect_FM_TILED);
 245           break;
 246         case XGUI::StretchTexture:
 247           activeView()->SetBackgroundImage(fi.absoluteFilePath().toLatin1().constData(),
 248                                            Aspect_FM_STRETCH);
 249           break;
 250         default:
 251           break;
 252       }
 253       activeView()->Update();
 254     }
 255   }
 256 }
 257
 258 //***********************************************
 259 void XGUI_ViewPort::attachWindow(const Handle(V3d_View)& theView,
 260                                  const Handle(Aspect_Window)& theWnd)
 261 {
 262   if (!theView.IsNull()) {
 263     theView->SetWindow(theWnd);
 264     updateBackground();
 265   }
 266 }
 267
 268 //***********************************************
 269 void XGUI_ViewPort::paintEvent(QPaintEvent* theEvent)
 270 {
 271 #ifndef WIN32
 272   /* X11 : map before show doesn't work */
 273   if ( !mapped( activeView() ) )
 274   mapView( activeView() );
 275 #endif
 276   if (!myWindow.IsNull()) {
 277     QApplication::syncX();
 278     QRect rc = theEvent->rect();
 279     //if ( !myPaintersRedrawing ) {
 280     //activeView()->Redraw();
 281     activeView()->Redraw(rc.x(), rc.y(), rc.width(), rc.height());
 282     emit vpUpdated();
 283     //}
 284   }
 285   //if ( myPaintersRedrawing ) {
 286   //    QPainter p( this );
 287   //    //emit vpDrawExternal( &p );
 288   //    myPaintersRedrawing = false;
 289   //}
 290 }
 291
 292 //***********************************************
 293 void XGUI_ViewPort::resizeEvent(QResizeEvent* theEvent)
 294 {
 295 #ifdef WIN32
 296   /* Win32 : map before first show to avoid flicker */
 297   if (!mapped(activeView()))
 298     mapView(activeView());
 299 #endif
 300   QApplication::syncX();
 301   if (!activeView().IsNull()) {
 302     activeView()->MustBeResized();
 303   }
 304   emit resized();
 305 }
 306
 307 //***********************************************
 308 QImage XGUI_ViewPort::dumpView(unsigned char*& theData, QRect theRect, bool toUpdate)
 309 {
 310   Handle(V3d_View) view = getView();
 311   if (view.IsNull())
 312     return QImage();
 313
 314   int aWidth;
 315   int aHeight;
 316   if (theRect.isNull()) {
 317     aWidth = width();
 318     aHeight = height();
 319   } else {
 320     aWidth = theRect.width();
 321     aHeight = theRect.height();
 322   }
 323   QApplication::syncX();
 324
 325   theData = new unsigned char[aWidth * aHeight * 4];
 326
 327   QPoint p;
 328   if (theRect.isNull()) {
 329     if (toUpdate)
 330       view->Redraw();
 331     p = mapFromParent(geometry().topLeft());
 332   } else {
 333     if (toUpdate)
 334       view->Redraw(theRect.x(), theRect.y(), theRect.width(), theRect.height());
 335     p = theRect.topLeft();
 336   }
 337   glReadPixels(p.x(), p.y(), aWidth, aHeight, GL_RGBA, GL_UNSIGNED_BYTE, theData);
 338
 339   QImage anImage(theData, aWidth, aHeight, QImage::Format_ARGB32);
 340   anImage = anImage.mirrored();
 341   anImage = anImage.rgbSwapped();
 342   return anImage;
 343 }
 344
 345 /*!
 346  Inits 'rotation' transformation.
 347  */
 348 void XGUI_ViewPort::startRotation(int x, int y, int theRotationPointType,
 349                                   const gp_Pnt& theSelectedPoint)
 350 {
 351   if (!activeView().IsNull()) {
 352     switch (theRotationPointType) {
 353       case XGUI::GRAVITY:
 354         activeView()->StartRotation(x, y, 0.45);
 355         break;
 356       case XGUI::SELECTED:
 357         sx = x;
 358         sy = y;
 359
 360         double X, Y;
 361         activeView()->Size(X, Y);
 362         rx = Standard_Real(activeView()->Convert(X));
 363         ry = Standard_Real(activeView()->Convert(Y));
 364
 365         activeView()->Rotate(0., 0., 0., theSelectedPoint.X(), theSelectedPoint.Y(),
 366                              theSelectedPoint.Z(),
 367                              Standard_True);
 368
 369         Quantity_Ratio zRotationThreshold;
 370         zRotation = Standard_False;
 371         zRotationThreshold = 0.45;
 372         if (zRotationThreshold > 0.) {
 373           Standard_Real dx = Abs(sx - rx / 2.);
 374           Standard_Real dy = Abs(sy - ry / 2.);
 375           Standard_Real dd = zRotationThreshold * (rx + ry) / 2.;
 376           if (dx > dd || dy > dd)
 377             zRotation = Standard_True;
 378         }
 379         break;
 380       default:
 381         break;
 382     }
 383     activeView()->DepthFitAll();
 384   }
 385 }
 386
 387 /*!
 388  Rotates the viewport.
 389  */
 390 void XGUI_ViewPort::rotate(int x, int y, int theRotationPointType, const gp_Pnt& theSelectedPoint)
 391 {
 392   if (!activeView().IsNull()) {
 393     switch (theRotationPointType) {
 394       case XGUI::GRAVITY:
 395         activeView()->Rotation(x, y);
 396         break;
 397       case XGUI::SELECTED:
 398         double dx, dy, dz;
 399         if (zRotation) {
 400           dz = atan2(Standard_Real(x) - rx / 2., ry / 2. - Standard_Real(y))
 401               - atan2(sx - rx / 2., ry / 2. - sy);
 402           dx = dy = 0.;
 403         } else {
 404           dx = (Standard_Real(x) - sx) * M_PI / rx;
 405           dy = (sy - Standard_Real(y)) * M_PI / ry;
 406           dz = 0.;
 407         }
 408
 409         activeView()->Rotate(dx, dy, dz, theSelectedPoint.X(), theSelectedPoint.Y(),
 410                              theSelectedPoint.Z(),
 411                              Standard_False);
 412         break;
 413       default:
 414         break;
 415     }
 416     emit vpTransformed();
 417   }
 418   //  setZSize( getZSize() );
 419 }
 420
 421 /*!
 422  Resets the viewport after 'rotation'.
 423  */
 424 void XGUI_ViewPort::endRotation()
 425 {
 426   if (!activeView().IsNull()) {
 427     activeView()->ZFitAll(1.);
 428     activeView()->SetZSize(0.);
 429     activeView()->Update();
 430     emit vpTransformed();
 431   }
 432 }
 433
 434 /*!
 435  Inits 'zoom' transformation.
 436  */
 437 void XGUI_ViewPort::startZoomAtPoint(int x, int y)
 438 {
 439   if (!activeView().IsNull()/* && isAdvancedZoomingEnabled() */)
 440     activeView()->StartZoomAtPoint(x, y);
 441 }
 442
 443 /*!
 444  Centers the viewport.
 445  */
 446 void XGUI_ViewPort::setCenter(int x, int y)
 447 {
 448   if (!activeView().IsNull()) {
 449     activeView()->Place(x, y, myScale);
 450     emit vpTransformed();
 451   }
 452 }
 453
 454 /*!
 455  Called at 'pan' transformation.
 456  */
 457 void XGUI_ViewPort::pan(int dx, int dy)
 458 {
 459   if (!activeView().IsNull()) {
 460     activeView()->Pan(dx, dy, 1.0);
 461     emit vpTransformed();
 462   }
 463 }
 464
 465 /*!
 466  Called at 'window fit' transformation.
 467  */
 468 void XGUI_ViewPort::fitRect(const QRect& rect)
 469 {
 470   if (!activeView().IsNull()) {
 471     activeView()->WindowFit(rect.left(), rect.top(), rect.right(), rect.bottom());
 472     emit vpTransformed();
 473   }
 474 }
 475
 476 /*!
 477  Called at 'zoom' transformation.
 478  */
 479 void XGUI_ViewPort::zoom(int x0, int y0, int x, int y)
 480 {
 481   if (!activeView().IsNull()) {
 482     if (isAdvancedZoomingEnabled())
 483       activeView()->ZoomAtPoint(x0, y0, x, y);
 484     else
 485       activeView()->Zoom(x0 + y0, 0, x + y, 0);
 486     emit vpTransformed();
 487   }
 488 }
 489
 490 /*!
 491  Sets the background data
 492  */
 493 void XGUI_ViewPort::setBackground(const Qtx::BackgroundData& bgData)
 494 {
 495   if (bgData.isValid()) {
 496     myBackground = bgData;
 497     updateBackground();
 498     emit vpChangeBackground(myBackground);
 499   }
 500 }
 501
 502 void XGUI_ViewPort::fitAll(bool theKeepScale, bool theWithZ, bool theUpd)
 503 {
 504   if (activeView().IsNull())
 505     return;
 506
 507   if (theKeepScale)
 508     myScale = activeView()->Scale();
 509
 510   Standard_Real aMargin = 0.01;
 511   activeView()->FitAll(aMargin, theWithZ, theUpd);
 512   activeView()->SetZSize(0.);
 513   emit vpTransformed();
 514 }
 515
 516 void XGUI_ViewPort::syncronizeWith(const XGUI_ViewPort* ref)
 517 {
 518   Handle(V3d_View) refView = ref->getView();
 519   Handle(V3d_View) tgtView = getView();
 520
 521   /*  The following params are copied:
 522    - view type( ortho/persp )
 523    - position of view point
 524    - orientation of high point
 525    - position of the eye
 526    - projection vector
 527    - view center ( 2D )
 528    - view twist
 529    - view scale
 530    */
 531
 532   /* we'll update after setting all params */
 533   tgtView->SetImmediateUpdate( Standard_False);
 534
 535   /* perspective */
 536   if (refView->Type() == V3d_PERSPECTIVE)
 537     tgtView->SetFocale(refView->Focale());
 538
 539   /* copy params */
 540   Standard_Real x, y, z;
 541   refView->At(x, y, z);
 542   tgtView->SetAt(x, y, z);
 543   refView->Up(x, y, z);
 544   tgtView->SetUp(x, y, z);
 545   refView->Eye(x, y, z);
 546   tgtView->SetEye(x, y, z);
 547   refView->Proj(x, y, z);
 548   tgtView->SetProj(x, y, z);
 549   refView->Center(x, y);
 550   tgtView->SetCenter(x, y);
 551   tgtView->SetScale(refView->Scale());
 552   tgtView->SetTwist(refView->Twist());
 553
 554   /* update */
 555   tgtView->Update();
 556   tgtView->SetImmediateUpdate( Standard_True);
 557 }