Inventor/Wx/SoWxGLWidget.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-2020 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Author      : T.MEHAMLI (Jul 2007)
**=======================================================================*/

#ifndef SO_WX_GLWIDGET
#define SO_WX_GLWIDGET

//
//  Class: SoWxGLWidget
//

#include <Inventor/Wx/SoWxComponent.h>
#include <Inventor/Wx/SoWxGLX.h>

#include <Inventor/nodes/SoFullSceneAntialiasing.h>

#include <Inventor/Gui/SoGuiGLWidget.h>

#define MGRWIDGET_ID 101
#define ATTRIBLIST_END 0
#define NO_OP -1 // Used in the attribute list passed to the wxGLCanvas as a noop.

typedef std::set<int, std::less<int> > SoSamplesList;

class SoGuiGLWidget;
class SoWxGLX;
class SoGLContext;

class  SoWxGLWidget : public SoWxComponent
{        
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 wxWindow* getNormalWindow();

  wxGLContext* getNormalContext() { return m_wxContextNormal; }

  SoGLContext* getNormalSoContext() { return m_contextNormal; }

  SoWxGLX* getNormalWidget();

#if 1             SoDEPRECATED
  SoWxGLX* getOverlayWidget() { return NULL; }

#if defined(_WIN32)
SoDEPRECATED
  Hdc getOverlayDC() { return m_hdcOverlay; }
#endif
#endif 
#if defined(_WIN32)

  Hdc getNormalDC() { return m_hdcNormal; }
#endif

  virtual void setNormalVisual( int* attribList );

  int* getNormalVisual();

  virtual void show();

  virtual void hide();

  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;

  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();

  SbBool swapNormalBuffers();

  void setFloatingColorBuffer( SbBool enable,
                               FloatColorBufferSize size = FLOAT_16_COLOR_BUFFER );

  void getFloatingColorBuffer( SbBool& enable, FloatColorBufferSize& size );

  bool saveSnapshot( const SbString& filename, bool overwrite = true );

#if 1             SoDEPRECATED
  SbBool isFsaaSupported();
SoDEPRECATED
  SbBool isFullSceneAntialiasingHQAvailable() const;
SoDEPRECATED
  SbBool setFullSceneAntialiasingHQ( SbBool enable );
SoDEPRECATED
  SbBool isFullSceneAntialiasingHQEnabled() const;
SoDEPRECATED
  virtual SbBool makeNormalCurrent();

#endif 
#if 1             SoDEPRECATED
  SbBool setFullSceneAntialiasing( SbBool enable,
                                   float quality = -1.0,
                                   int filterMask = SoFullSceneAntialiasing::ALL );
SoDEPRECATED
  SbBool isFullSceneAntialiasingEnabled() const;
SoDEPRECATED
  SbBool getFullSceneAntialiasing( float& quality );
SoDEPRECATED
  SbBool isFullSceneAntialiasingAvailable() const;

#endif 
private:

  SoGuiGLWidget* getGuiGLWidget() const;


  SbBool isFsaaSupportHighQuality();
  SbBool isFsaaHighQuality();

  // 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);

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();

  static void exposeCB( SoWxGLWidget* p );

  // subclasses can use this routine as the event handler for any
  // devices they wish to get input from.
  static void eventHandler( wxWindow* wxW, SoWxGLWidget* w, wxEvent& wxE, bool* boolean );
  static void showEventHandler( SoWxGLWidget* w, wxShowEvent& wxE );
        
#ifdef _WIN32
  // Set/get thread this context belongs to -- mmh Apr-99
  DWORD getThreadId() { return m_dwThreadId; };
  void setThreadId(DWORD id) { m_dwThreadId = id; };
#endif  
        
  void setCursor( wxCursor newCursor );

  wxCursor getCursor(); 

 private:
        
  SoWxGLWidget( wxWindow* parent = NULL,
                const char* name = NULL, 
                SbBool buildInsideParent = TRUE, 
                int glModes = SO_GLX_RGB, 
                SbBool buildNow = TRUE,
                SbBool sync = TRUE );

  SoWxGLWidget( wxWindow* parent,
                const char* name, 
                SbBool buildInsideParent, 
                int glModes, 
                SbBool buildNow,
                SbBool sync,
                SoGuiGLWidget* guiGLWidget );
        
  virtual ~SoWxGLWidget();
        
  // subclasses MUST redefine redraw() to draw in the normal bit planes.
  // redrawOverlay() should be defined if the overlay planes are being
  // used, and processEvent() should be defined if X events are being 
  // received (see eventMask).
  virtual void redraw() = 0;
  virtual void processEvent( wxEvent& anyEvent );
  virtual void visibilityChangeCB( wxShowEvent& showEvent );
        
  // 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& ) { /* Do nothing */ };
  virtual void widgetChanged( wxWindow* w );
  virtual void onFocusEvent( SbBool );
    
  // sets/gets the size of the glx widget(s) - 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).
  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); }
        
  // returns the display lists share group for given context:
  int getDisplayListShareGroup( SoGLContext* ctx );
        
  SbBool waitForExpose;
        
  wxPanel* buildWidget( wxWindow* parent, int* attribList = 0 );
  void changeCursor( wxCursor newCursor );
  wxPanel* getGlxMgrWidget() { return m_mgrWidget; }

  bool eventFilter( wxEvent& anEvent );
        
  virtual void onExpose();

SoINTERNAL private:
  SbBool m_initialFsaaEnable;
  int m_initialFsaaFilterMask;
  SbBool m_initialFsaaValueChanged;
  SbBool m_isFsaaEnable;    // is FSAA is active


 private:

  void constructorCommon( int glModes, SbBool buildNow, SbBool connectionType );
  SoGuiGLWidget* m_guiGLWidget; //Implementation class for SoXxGLWidget

  // Functions used to redirect specific events to eventFilter which takes wxEvents
  void keyboardEvents( wxKeyEvent& redirectedEvent );
  void moveEvents( wxMoveEvent& redirectedEvent );
  void sizeEvents( wxSizeEvent& redirectedEvent );
  void showEvents( wxShowEvent& redirectedEvent );

  // Process close events to invalidate SoGLContexts drawables.
  void internalClose( wxCommandEvent& ce );
        
  // local vars
  wxPanel* m_mgrWidget;
  SoWxGLX* m_doubleBufferWidget; 
  SoWxGLX* m_singleBufferWidget; 
  SoGLContext* m_contextNormal;
  SoGLContext* m_contextSingle;
  SoGLContext* m_contextDouble;

  wxGLContext* m_wxContextNormal;
  wxGLContext* m_wxContextSingle;
  wxGLContext* m_wxContextDouble;
 
#if defined(_WIN32)
  Hdc m_hdcNormal, m_hdcOverlay, m_hdcSingle, m_hdcDouble;
  DWORD m_dwThreadId; // thread to which this context belongs -- mmh Apr-99
#endif // _WIN32
    
  SbBool m_directConnection;

  wxCursor m_currentCursor;
  int* m_attribList; 
  SbBool m_windowResized;
        
  // set of windows, color maps, etc...
  void buildNormalGLXWidget( int* attribList = NULL );

  void destroyNormalWindows();
  void destroyGLXWidget( SoWxGLX* &w, SoGLContext*& ctx, SbBool normalCall );
  void changeGLX();

  // callbacks from glx widget
  static void ginitCB( SoWxGLX* w, SoWxGLWidget* p, void* d );
  static void resizeCB( wxWindow* w, SoWxGLWidget* p, void* d );

  //FSAA
  int getNumSamples(size_t n);
  int findSampleIndex(int findInt);
  void listFSAAMaxSamples();
  SoSamplesList m_samplesParseTab;

  //ginit
  SbBool m_initGLX;
  //changeGLX
  wxFrame* m_dummyFrame;

  // wxWidgets specific : macro that declares an event table
  DECLARE_EVENT_TABLE()
};


#endif // SO_WX_GLWIDGET

---

Open Inventor Toolkit reference manual, generated on 12 Feb 2024
Copyright © Thermo Fisher Scientific All rights reserved. http://www.openinventor.com/