Inventor/MP/Win/SoWinMPGLWidget.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      : VSG (MMM YYYY)
**=======================================================================*/




#ifndef _SO_WIN_MP_GL_WIDGET_H_
#define _SO_WIN_MP_GL_WIDGET_H_

#include <Inventor/sys/port.h>

#include <Inventor/Win/SoWinBeginStrict.h>

#include <Inventor/Win/SoWinComponent.h>

#include <Inventor/MP/Xt/SbConfig.h>

/*
 * 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_OVERLAY  (1<<3)
#define SO_GLX_STEREO   (1<<4)

class SoGLContext;

//
//  Class: SoWinMPGLWidget
//
//

class  SoWinMPGLWidget : public SoWinComponent 
{
 public:
    
  virtual Window getNormalWindow();

  SoGLContext* getNormalContext()      { return ctxNormal; }

  Hdc getNormalDC()  { return hdcNormal; }

#ifndef HIDDEN_FROM_DOC
  // Jim's thing for now, not really public
  Hdc copyWindowBits() ;
#endif // HIDDEN_FROM_DOC

  void setStealFocus( SbBool onOrOff ) { stealFocus = onOrOff; };
  SoWidget      getNormalWidget()       { return (glModes & SO_GLX_DOUBLE) ? doubleBufferWidget : singleBufferWidget; }

  virtual void    setNormalVisual(XVisualInfo *vis);
  XVisualInfo *   getNormalVisual();


  virtual void    setPixelFormat( int format );
  int             getPixelFormat();
    
  void        setDoubleBuffer(SbBool onOrOff);
  SbBool      isDoubleBuffer()            { return (glModes & SO_GLX_DOUBLE); }
    
  void        setBorder(SbBool onOrOff);
  int         getBorderSize() {return borderSize;} ;
  SbBool      isBorder() const            { return borderSize != 0; }
    
  void        setDrawToFrontBufferEnable(SbBool enableFlag);
  SbBool      isDrawToFrontBufferEnable() const   { return enableDrawToFrontBuffer; }

  void setCursor(Cursor newCursor);
  Cursor getCursor();  

  SbBool bindNormalContext();

  SbBool unbindNormalContext();

  SbBool swapNormalBuffers();
 
#if 1             SoDEPRECATED
  Window getOverlayWindow();
SoDEPRECATED
  SoGLContext* getOverlayContext() { return ctxOverlay; }
SoDEPRECATED
  Hdc getOverlayDC() { return hdcOverlay; }
SoDEPRECATED
  SoWidget getOverlayWidget() { return overlayWidget; }
  // Note: On Windows, XVisualInfo is defined as PIXELFORMATDESCRIPTOR.
  // Also note that setOverlayVisual() has no effect on Win32 machines
  // because the overlay is not a separate window.
  //
SoDEPRECATED
  virtual void setOverlayVisual( XVisualInfo *vis );
SoDEPRECATED
  XVisualInfo* getOverlayVisual();
SoDEPRECATED
  SbBool swapOverlayBuffers();
#endif 
#if 1             SoDEPRECATED
  SbBool makeNormalCurrent();

#endif 
private:
  SoGLContext* m_glContext;

private:
    
  // Subclasses can pass in a bitwise OR specifying the GL modes
  // (e.g. SO_GLX_RGB | SO_GLX_DOUBLE | SO_GLX_ZBUFFER | SO_GLX_OVERLAY)
  // If buildNow is FALSE, this will not build its widget tree until
  // buildWidget() is explicity called; else, buildWidget() is called here.
  SoWinMPGLWidget(SoWidget parent = NULL,
                  const char *name = NULL, 
                  SbBool buildInsideParent = TRUE, 
                  int glModes = SO_GLX_RGB, 
                  SbBool buildNow = TRUE);
  virtual ~SoWinMPGLWidget();
    
  // 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;
#if 1             SoDEPRECATED
  virtual void        redrawOverlay();
#endif 
  virtual void        processEvent(XAnyEvent *anyevent);
    
  // 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();
#if 1             SoDEPRECATED
  virtual void        initOverlayGraphic();
#endif 
  virtual void        sizeChanged(const SbVec2s &newSize);
  virtual void        widgetChanged(SoWidget newWidget);
        
  virtual void initViewportRegion(int);
    
  // 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 glxSize; }

  // subclasses can use this routine as the event handler for any
  // devices they wish to get input from.
  static void eventHandler(SoWidget, SoWinMPGLWidget *, XAnyEvent *, Boolean *);
    
  // 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 (glModes & SO_GLX_STEREO); }
    
  // returns TRUE if main window is in rgb mode, else FALSE for color index mode
  SbBool              isRGBMode()         { return (glModes & SO_GLX_RGB); }
    
  // returns the display lists share group for given context:
  int                 getDisplayListShareGroup( SoGLContext* ctx );

  Colormap            colorMap;       // set when color index is used
  Colormap            overlayColorMap; // set when overlay is used

  SbBool              waitForExpose;     // prevent redraws until an expose is received
  SbBool              drawToFrontBuffer; // used by RA to draw new scenes to front buffer
    
  // make those methods protected so enable the SoWinRenderArea to use them
  // directly when it needs to build the widget and get its resources.
  SoWidget              buildWidget(SoWidget parent);
  SoWidget              getGlxMgrWidget()               { return mgrWidget; }

  // Add some convenience functions that reduce the number of ifdef's in
  // viewers by hiding these platform dependent operations.
  // We should add these to the UNIX version too.
  void                changeCursor( Cursor newCursor );
  
  SbConfig * mpConfig;

  int pipeContextIdOffset; // pipes should not reuse context ids
  void raiseMainViewer(SbBool); // raise/lower main viewer

  // Set/get thread this context belongs to.
  DWORD getThreadId() { return dwThreadId; };
  void setThreadId(DWORD id) { dwThreadId=id; };


  virtual void onExpose();

#if 1             SoDEPRECATED
  virtual void onOverlayExpose();
#endif 
 private:
  // local vars
  SoWidget     mgrWidget;
  SoWidget     doubleBufferWidget, singleBufferWidget, overlayWidget;
  SoGLContext* ctxNormal, *ctxOverlay, *ctxSingle, *ctxDouble;

  SbVec2s     glxSize; // size of glx widgets which is always up to date
  SbBool      enableDrawToFrontBuffer;

  // Note for WIN32:
  // 1) All the "SoWidget" values above are actually type "HWND".
  // 2) The "GLXContext" values above are actually type "HGLRC".

  // For WIN32 this struct functionally replaces attribList
  PIXELFORMATDESCRIPTOR pfd;
  int                   m_nPixelFormat;

  // For WIN32 these are saved because XGetVisualInfo doesn't exist...
  PIXELFORMATDESCRIPTOR pfdNormal, pfdOverlay, pfdSingle, pfdDouble;

  // For WIN32 we need a GL context *and* a device context for each
  // GL drawing window (we don't need one for the mgr because we don't
  // plan to ever draw in it).  These correspond to the "ctx..." vars.
  // Note: This plan depends on use of the CS_OWNDC style.

  Hdc hdcNormal, hdcOverlay, hdcSingle, hdcDouble;

  // For WIN32 we also need a logical color palette for each drawing
  // area if we happen to running on an 8bit device...

  // pointers for dynamic allocations
  HPALETTE palNormal, palOverlay, palSingle, palDouble;

  // For WIN32 we also need to remember our parent and our
  // "ancestor" (the toplevel window that we're descended from).
  SoWidget parent;
  SoWidget ancestor;

  // For WIN32 we have to simulate the "focus follows pointer" behavior
  // that X provides for free.  Otherwise the app would have to be
  // responsible for giving focus to the GL window and/or the user
  // would have to keep clicking to get focus in the GL window.  Focus
  // is required for the 1-button mouse viewer behaviors like Ctrl-Left
  // Button and so on.  This variable tracks whether we have focus
  // based on the WM_SETFOCUS/WM_KILLFOCUS messages (see glxWindowProc).
  int haveFocus;

  // This flag tracks whether "focus follows pointer" is enabled.
  int stealFocus;

  // For WIN32 we have to simulate the behavior of X where getting a
  // mouse button down event guarantees you will also get the
  // corresponding button up event.  Otherwise examiner viewer windows
  // get out of sync if a mouse button is released outside the window.
  UINT mouseCaptured;

  // For WIN32 we have to know the handle of the cursor that's supposed
  // to be displayed currently in the drawing window.  The explanation
  // is too long to fit here...  :-)  OK, actually it's because the
  // viewers want to change the cursor periodically but we can't change
  // the cursor in the class defn or it will change for *all* the GL
  // windows (yuck).  So we have to process the WM_SETCURSOR message in
  // the glxWindowProc.
  HCURSOR currentCursor;

  // We also need (globally for the class) the default cursor to use.
  static HCURSOR defaultCursor;

  DWORD dwThreadId; // thread to which this context belongs

  int* attribList;
  int  glModes;
  int  borderSize;
    
  // specify if sizeChanged() should be called when an expose event
  // is received (as opposed to when a resize event is received, where
  // the window hasn't yet been maped to the new size).
  // ??? a GlxDraw bug ?
  SbBool windowResized;
    
  // creates a GLX widget of the correct current type and get the current
  // set of windows, color maps, etc...
  void buildNormalGLXWidget(XVisualInfo *vis = NULL);
  void buildOverlayGLXWidget(XVisualInfo *vis = NULL);
  void destroyNormalWindows();
  void destroyGLXWidget(SoWidget &w, SoGLContext* &ctx, SbBool normalWindow);
    
  // callbacks from glx widget
  static void ginitCB(SoWidget, SoWinMPGLWidget *, XtPointer);
  static void overlayGinitCB(SoWidget, SoWinMPGLWidget *, XtPointer ptr);
  static void exposeCB(SoWidget, SoWinMPGLWidget *, XtPointer);
  static void overlayExposeCB(SoWidget, SoWinMPGLWidget *, XtPointer);
  static void resizeCB(SoWidget, SoWinMPGLWidget *, XtPointer);
  static void mgrStructureNotifyCB(SoWidget, SoWinMPGLWidget *, XAnyEvent *, Boolean *);

#if defined(_WIN32)
  // Window proc for SoWinGL "manager widget" windows
  static LRESULT CALLBACK mgrWindowProc( Hwnd hwnd, UINT message,
                                         WPARAM wParam, LPARAM lParam );

  // Window proc for SoWinGL drawing windows
  static LRESULT CALLBACK glxWindowProc( Hwnd hwnd, UINT message,
                                         WPARAM wParam, LPARAM lParam );
#endif // _WIN32
 private:
  static void mpGinitCB(SoWidget, SoWinMPGLWidget *, XtPointer); 
};

#if defined(_WIN32)
#include <Inventor/Win/SoWinEndStrict.h>
#endif // _WIN32

#endif // _SO_WIN_GL_WIDGET_H_

---

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