SoQtGLWidget.h

Go to the documentation of this file.

/*=======================================================================
 *** THE CONTENT OF THIS WORK IS PROPRIETARY TO FEI S.A.S, (FEI S.A.S.),            ***
 ***              AND IS DISTRIBUTED UNDER A LICENSE AGREEMENT.                     ***
 ***                                                                                ***
 ***  REPRODUCTION, DISCLOSURE,  OR USE,  IN WHOLE OR IN PART,  OTHER THAN AS       ***
 ***  SPECIFIED  IN THE LICENSE ARE  NOT TO BE  UNDERTAKEN  EXCEPT WITH PRIOR       ***
 ***  WRITTEN AUTHORIZATION OF FEI S.A.S.                                           ***
 ***                                                                                ***
 ***                        RESTRICTED RIGHTS LEGEND                                ***
 ***  USE, DUPLICATION, OR DISCLOSURE BY THE GOVERNMENT OF THE CONTENT OF THIS      ***
 ***  WORK OR RELATED DOCUMENTATION IS SUBJECT TO RESTRICTIONS AS SET FORTH IN      ***
 ***  SUBPARAGRAPH (C)(1) OF THE COMMERCIAL COMPUTER SOFTWARE RESTRICTED RIGHT      ***
 ***  CLAUSE  AT FAR 52.227-19  OR SUBPARAGRAPH  (C)(1)(II)  OF  THE RIGHTS IN      ***
 ***  TECHNICAL DATA AND COMPUTER SOFTWARE CLAUSE AT DFARS 52.227-7013.             ***
 ***                                                                                ***
 ***                   COPYRIGHT (C) 1996-2023 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Author      : Alain Dumesny (MMM yyyy)
** Modified by : David Mott (MMM yyyy)
**=======================================================================*/
 
 
#ifndef _SO_QT_GLWIDGET_
#define _SO_QT_GLWIDGET_
 
#include <Inventor/Qt/SoQtComponent.h>
 
#include <Inventor/Qt/OivQtCompat.h>
#include <Inventor/devices/SoGLFormat.h>
 
#include <Inventor/Gui/SoGuiGLWidget.h>
#include <Inventor/nodes/SoFullSceneAntialiasing.h>
 
#include <Qt>
 
// FSAA
typedef std::set<int, std::less<int> > SoSamplesList;
 
#if !defined(_WIN32)
class SoQtRemoteRenderInfo;
#endif // _WIN32
 
#include <QPointer>
#include <QSurfaceFormat>
 
/*
 * Defines used when specifying the glModes flag to the constructor.
 * (used instead of the glx.h defines which do overlap)
 */
#define SO_GLX_RGB (1<<0)
#define SO_GLX_DOUBLE (1<<1)
#define SO_GLX_ZBUFFER (1<<2)
#define SO_GLX_STEREO (1<<4)
#define SO_GLX_STENCIL (1<<5)
 
class QVBoxLayout;
class QCursor;
class SoGLContext;
 
class SoQGLContextProxy;
class SoQGLWidgetProxy;
class QGLFormat;
class QGLContext;
class QOpenGLWindow;
 
class  SoQtGLWidget : public SoQtComponent
{
  Q_OBJECT
 
public:
 
   enum FloatColorBufferSize
   {
    FLOAT_16_COLOR_BUFFER = SoGuiGLWidget::FLOAT_16_COLOR_BUFFER,
    FLOAT_32_COLOR_BUFFER = SoGuiGLWidget::FLOAT_32_COLOR_BUFFER
  };
 
  int getColorMapSize();
 
  void setColorMapSize( int size );
 
  virtual WindowQt getNormalWindow();
 
  QOpenGLContext* getQOpenGLContext();
 
  SoGLContext* getNormalSoContext();
 
  QWidget* getNormalWidget();
 
  QSurfaceFormat getQSurfaceFormat();
 
  virtual void setNormalVisual( QSurfaceFormat vis );
 
  virtual void setNormalVisual( const SoGLFormat& format );
 
  virtual void show();
 
  virtual void hide();
 
  virtual void setDoubleBuffer( SbBool onOrOff );
 
  SbBool isDoubleBuffer() { return m_guiGLWidget->isDoubleBuffer(); }
 
  void  setBorder( SbBool onOrOff );
 
  int getBorderSize() { return m_guiGLWidget->getBorderSize(); }
 
  SbBool isBorder() const { return m_guiGLWidget->isBorder(); }
 
  void setDrawToFrontBufferEnable( SbBool enableFlag );
 
  SbBool isDrawToFrontBufferEnable() const { return m_guiGLWidget->isDrawToFrontBufferEnable(); }
 
  virtual SbBool bindNormalContext();
 
  virtual SbBool unbindNormalContext();
 
  virtual SbBool swapNormalBuffers();
 
  virtual void setCursor( const QCursor& newCursor );
 
  QCursor getCursor() const;
 
  void setAntialiasing(const float quality, const SoSceneManager::AntialiasingMode mode = SoSceneManager::AUTO);
 
  void setAntialiasing(SoAntialiasingParameters* advancedParameters);
 
  float getAntialiasingQuality() const;
 
  SoSceneManager::AntialiasingMode getAntialiasingMode() const;
 
  SoAntialiasingParameters* getAntialiasingParameters() const;
 
  bool saveSnapshot( const SbString& filename, bool overwrite = true );
 
private:
#if !defined(_WIN32) && !defined(__APPLE__) //UNIX
  // WARNING : Workaround only available for Amira/Avizo
  // These methods should be removed when the GraphicConfigs will be implemented for Qt.
  void setAttribList( const int* newAttribList );
  int* getAttribList() const;
#endif // UNIX
 
  SoGuiGLWidget* getGuiGLWidget() const;
 
  // Return the internal QWindow used to do the OpenGL rendering
  QWindow* getInternalQWindow();
 
  // These variables are  public for retro compatibility purposes only.
  // Do not use them directly but call their accessors instead;
  SbBool drawToFrontBuffer;
 
  // These two function are used by SoGui, to call the system dependent version of
  // these functions. data is a SoWinGLWidget handle.
  static SbBool swapNormalBuffersCB( void *data );
  static SbBool bindNormalCurrentCB( void *data );
  static SbBool unbindNormalCurrentCB( void *data );
  static void* getNormalWindowCB( void *data );
  static void* getCurrentDisplayCB(void *data);
 
  float getPixelRatio();
 
  void updateInternalOpenGLWindow( bool immediatUpdate );
 
 private:
 
  // Starting with version 3.0, subclasses should no longer make direct
  // calls to glXMakeCurrent, glXSwapBuffers and glFlush.
  // For RemoteRendering we need to know when MakeCurrent is called
  // (marking the beginning of a frame) and when SwapBuffers or glFlush
  // is called (marking the end of a frame).
  // Subclasses should always use these generic methods.
  void   flush();
 
#if !defined(__APPLE__) && !defined(_WIN32) //UNIX
  // Pbuffers are a limited resource.  By default use of Pbuffers for
  // remote rendering is enabled, but it might make sense to disable
  // it for less important windows (like UI components drawn with OpenGL).
  // Must be called after creating the widget but before it is realized.
  void setRemoteRenderPbufferEnable( SbBool enable )
    { m_remoteRenderPbufferEnable = enable; }
 
  SbBool isRemoteRenderPbufferEnable() const
    { return m_remoteRenderPbufferEnable; }
 
  float getLowResPercent() {return m_lowResPercent;}
#endif
 
private:
 
  SoQtGLWidget( QWidget* parent = NULL,
                const char* name = NULL,
                SbBool buildInsideParent = TRUE,
                int glModes = SO_GLX_RGB,
                SbBool buildNow = TRUE,
                SbBool sync = TRUE );
 
  SoQtGLWidget( QWidget* parent,
                const char* name,
                SbBool buildInsideParent,
                int glModes,
                SbBool buildNow,
                SbBool sync,
                SoGuiGLWidget* guiGLWidget );
 
#if defined(__linux__)
  SoQtGLWidget( QWidget* parent,
                const char* name,
                SbBool buildInsideParent,
                int glModes,
                SbBool buildNow,
                SbBool sync,
                SbBool connectionType );
 
  SoQtGLWidget( QWidget* parent,
                const char* name,
                SbBool buildInsideParent,
                int glModes,
                SbBool buildNow,
                SbBool sync,
                SbBool connectionType,
                SoGuiGLWidget* guiGLWidget );
#endif
 
  virtual ~SoQtGLWidget();
 
  // EVENTS
 
  virtual void resize( int w, int h );
 
  virtual void closeEvent( QCloseEvent* );
 
  virtual void focusInEvent( QFocusEvent* );
 
  virtual void focusOutEvent( QFocusEvent* );
 
  virtual void showEvent( QShowEvent* );
 
  virtual void hideEvent( QHideEvent* );
 
  virtual void moveEvent( QMoveEvent* );
 
  virtual void keyPressEvent( QKeyEvent* );
 
  virtual void keyReleaseEvent( QKeyEvent* );
 
  virtual void mouseMoveEvent( QMouseEvent* );
  
  virtual void mousePressEvent( QMouseEvent* );
 
  virtual void mouseReleaseEvent( QMouseEvent* );
 
  virtual void mouseDoubleClickEvent( QMouseEvent* );
 
  virtual void wheelEvent( QWheelEvent* );
 
  bool eventFilter( QObject* object, QEvent* event );
 
  // subclasses can use this routine as the event handler for any
  // devices they wish to get input from.
  static void eventHandler( QWidget* w, SoQtGLWidget* glw, QEvent* qe, bool* b );
 
  // This function is overloaded by the render area to set the window element
  virtual void onFocusEvent(SbBool hasFocus);
 
 
 
  // subclasses MUST redefine redraw() to draw in the normal bit planes.
  // processEvent() should be defined if X events are being
  // received (see eventMask).
  virtual void redraw() = 0;
 
  virtual void processEvent( QEvent* anyevent );
 
  void performPaint();
 
  // subclasses can redefine these to do something useful.
  // initGraphic() is called whenever a GLX window gets created
  // sizeChanged() is called whenever the window changes size
  // widgetChanged() is called whenever the widget is changed (i.e. at
  //    initialization or after switching from single->double buffer)
  virtual void initGraphic();
  virtual void sizeChanged( const SbVec2s& size );
  virtual void posChanged( const SbVec2i32&, const SbVec2i32& ) {};
  virtual void widgetChanged( QWidget* w );
 
  // sets/gets the size of the glx widget(s) in pixels - Note this size could be
  // different from the SoWinComponent::getSize() method which return
  // the size of the component, not necessary the same as the glx widget
  // window (because of extra stuff like the decoration in the viewers or pixel ratio).
  void  setGlxSize( SbVec2s newSize );
  const SbVec2s& getGlxSize() const { return m_guiGLWidget->getGlxSize(); }
 
  // set/get stereo buffering visual. This routine (like setDoubleBuffer)
  // can be called interactively, althought slower since a new window
  // with the needed visual is always created on the fly.
  void setStereoBuffer( SbBool flag );
  SbBool isStereoBuffer() { return (m_guiGLWidget->getGLModes() & SO_GLX_STEREO); }
 
  // returns TRUE if main window is in rgb mode (FALSE if color index)
  SbBool isRGBMode() { return (m_guiGLWidget->getGLModes() & SO_GLX_RGB); }
 
#if defined(__linux__)
  void allocCell( Display* display, Colormap cmap, XColorPointer colorcells,
                  int ncolors, int colorMapSize );
#endif
 
  SbBool waitForExpose;
 
  QWidget* buildWidget( QWidget* parent );
  void changeCursor( QCursor newCursor );
  QWidget* getGlxMgrWidget() { return m_containerWidget; }
 
  virtual void onExpose();
 
  // ----- RemoteRender additions (v3.0) -----
  // FSAA
  SbBool m_initialFsaaValueChanged;
 
#if !defined(_WIN32) && !defined(__APPLE__)
  enum RemoteRenderEnabled  // Possible values for remote rendering
  {
    OFF,                      // Never use remote rendering
    ON,                       // Always try to use remote rendering
    AUTO                      // Use if remote does not support GLX (default)
  };
  RemoteRenderEnabled   m_remoteRenderMode;  // See possible values above
  SoQtRemoteRenderInfo* m_remoteRenderInfo;  // Opaque type for internal state
  SbBool                m_remoteRenderPbufferEnable; // Can we use a Pbuffer?
  SbBool                m_lowResRender;      //Is Low Resolution Render Mode in use?
  float                 m_lowResLowPercent;  //lowest value of m_lowResPercent
  float                 m_lowResHighPercent; //highest value of m_lowResPercent
  float                 m_lowResPercent;    //percent of the window sent thru the network
 
  void remoteRenderInit();                // Init member vars
  void remoteRenderCleanup();             // Free allocated resources
  void remoteRenderGinitCB( QWidget* );     // Create pixmap and other stuff
  GLXContext remoteRenderLowResRenderGinitCB( QWidget* ); //Same for LowResRender configuration : return Remote Context
  void remoteRenderResizeCB();            // Resize pixmap
  void remoteRenderSendImage();           // Send rendered image to remote display
  void remoteRenderSendLowResRender();    // send low Resolution image to remote display
  SbGlContextHelper::VisualInfo remoteRenderChooseVisual();        // Find visual for remote window
  void remoteRenderFatalError( const char* methodName, const char* message );
 
  void setLowResLowPercent( float percent ) { m_lowResLowPercent = percent; }
  void setLowResHighPercent( float percent ) { m_lowResHighPercent = percent; }
  float getLowResLowPercent() const { return m_lowResLowPercent; }
  float getLowResHighPercent() const { return m_lowResHighPercent;}
 
  virtual void setLowResPercent( float newLowres ) { m_lowResPercent = newLowres; }
#endif
 
private:
 
  void constructorCommon( SbBool buildNow, SbBool connectionType );
  SoGuiGLWidget* m_guiGLWidget; //Implementation class for SoXxGLWidget
 
  QPointer<QWidget> m_containerWidget;
  QPointer<QVBoxLayout> m_containerLayout;
  QPointer<QWidget> m_internalWidget;
  QPointer<QWindow> m_internalWindow;
 
  SoQGLContextProxy* m_context;
 
  // Flags used when the stereo is set from environment variables.
  bool m_stereoActiveDelayed; 
  bool m_stereoBufferFlag;
 
#if defined(__linux__)
  SbBool directConnection;
#endif
 
  QCursor currentCursor;
  int* attribList;
 
  SbBool windowResized;
 
  // set of windows, color maps, etc...
  void buildNormalGLXWidget( SoGLFormat* format = NULL );
 
  virtual void initializeGL();
 
  void destroyNormalWindows();
  void destroyGLXWidget( SbBool normalCall );
 
  void destroyNormalWidget( SbBool normalCall );
 
  void notifyProxyDestruction( QWindow* window );
 
  friend class SoQGLWidgetProxy;
 
  // callbacks from glx widget
  static void ginitCB( QWidget* w, SoQtGLWidget* glw, void* v );
  static void exposeCB( QWidget* w, SoQtGLWidget* glw, void* v );
  static void resizeCB( QWidget* w, SoQtGLWidget* glw, void* v );
 
  static SbBool onGLFormatChangeCallback( SoGLFormat& format, void* userData );
 
  SbBool remoteRenderGinitCB_pbuffer( QWidget* );
 
  // Members used to synchronize first rendering (in case of OIV_SYNC_QTWIDGET_FIRSTRENDER == TRUE)
  bool m_firstRenderSync;
  static std::map<SoQtGLWidget*, bool> s_blackRendering;
  static std::map<SoQtGLWidget*, bool> s_widgetRendered;
 
private Q_SLOTS:
  void destroyedQtContext();
};
 
#endif // _SO_QT_GLWIDGET_