Inventor/MP/Xt/SoXtMPGLWidget.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)
**=======================================================================*/

#if defined(_WIN32)
#  include <Inventor/MP/Win/SoWinMPGLWidget.h>
#else // _WIN32

#ifndef _SO_XT_MP_GL_WIDGET_H_
#define _SO_XT_MP_GL_WIDGET_H_

#include <Inventor/helpers/SbGlContextHelper.h>
#include <Inventor/Xt/SoXtComponent.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)

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

class SoGLContext;

//
// Class: SoXtMPGLWidget
//
//

class  SoXtMPGLWidget : public SoXtComponent {

public:

  int getColorMapSize();

  virtual Window getNormalWindow();

  SoGLContext* getNormalContext() { return ctxNormal; }

  SoWidget getNormalWidget() { return (glModes & SO_GLX_DOUBLE) ? doubleBufferWidget : singleBufferWidget; }

  virtual void setNormalVisual(XVisualInfo *vis);

  XVisualInfo *getNormalVisual();

  virtual void setDoubleBuffer(SbBool onOrOff);
  SbBool isDoubleBuffer()
    { return ((glModes & SO_GLX_DOUBLE) ? 1 : 0); }
  //
  // shows/hides a border of thickness 3 around the glx widgets. This
  // if OFF by default, but turned on by the render area.
  //
  void setBorder(SbBool onOrOff);
  SbBool isBorder() const { return borderSize != 0; }

  void setDrawToFrontBufferEnable(SbBool enableFlag);

  SbBool isDrawToFrontBufferEnable() const { return enableDrawToFrontBuffer; }

  SbVec2s getVirtualSize(void) { return mpConfig->getVirtualSize(); }

  SbVec2s winToDC( int x, int y, Window w = NULL ) const;

  SbVec2f DCtoNDC( SbVec2s pos, Window w = NULL ) const;

  private:
  SoGLContext* m_glContext;

 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.

#if 1             SoDEPRECATED
  SbBool makeNormalCurrent();

#endif 
  SbBool bindNormalContext();

  SbBool unbindNormalContext();

  SbBool swapNormalBuffers();

#if 1             SoDEPRECATED
  unsigned long getOverlayTransparentPixel();SoDEPRECATED
  int getOverlayColorMapSize();
SoDEPRECATED
  Window getOverlayWindow();
SoDEPRECATED
  SoGLContext* getOverlayContext() { return ctxOverlay; }
SoDEPRECATED
  SoWidget getOverlayWidget() { return overlayWidget; }

  //
  // Specify exactly what the visual should be for the normal and overlay
  // window. This allows the user to create all possible visuals supported
  // by OpenGL. The XVisualInfo structure should be a valid OpenGL visual
  // returned by glXChooseVisual().
  //
#if defined(sun) || defined(__linux__)
SoDEPRECATED
  virtual void setSunOverlayBackgroundIndex();
#endif
SoDEPRECATED
  virtual void setOverlayVisual(XVisualInfo *vis);
SoDEPRECATED
  XVisualInfo *getOverlayVisual();
SoDEPRECATED
  SbBool makeOverlayCurrent();
SoDEPRECATED
  SbBool swapOverlayBuffers();
#endif 
  void   flush();

  // check if the context is direct
  SbBool ctxIsDirect();

 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.
  SoXtMPGLWidget(SoWidget parent = NULL,
                 const char *name = NULL,
                 SbBool buildInsideParent = TRUE,
                 int glModes = SO_GLX_RGB,
                 SbBool buildNow = TRUE);

#if defined(sun) || defined(__linux__) || defined(__hpux)
  SoXtMPGLWidget(SoWidget parent,
                 const char *name,
                 SbBool buildInsideParent,
                 int glModes,
                 SbBool buildNow,
                 SbBool connectionType);
#endif

  virtual ~SoXtMPGLWidget();

  // 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 SoXtComponent::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, SoXtMPGLWidget *, 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) ? 1 : 0); }

  // returns TRUE if main window is in rgb mode (FALSE if color index)
  SbBool isRGBMode()
    { return ((glModes & SO_GLX_RGB) ? 1 : 0); }

#if defined(sun) || defined(__linux__)
  void allocCell(Display *display, Colormap cmap, XColor *colorcells,
                 int ncolors, int colorMapSize);
#endif

  // 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
  int colorMapSize;
  int overlayColorMapSize;

  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 to enable the SoXtMPRenderArea to use them
  // directly when it needs to build the widget and get its resources.
  SoWidget buildWidget(SoWidget parent);
  SoWidget getGlxMgrWidget() { return mgrWidget; }

  unsigned long transparentPixel;

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

  SbConfig *mpConfig;

  SbBool renderInFrontBuffer;

  virtual void onExpose();
  virtual void onMPExpose();

#if 1             SoDEPRECATED
  virtual void onOverlayExpose();SoDEPRECATED
  virtual void onMPOverlayExpose();
#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
  int *attribList;
  int glModes;
  int borderSize;
  SbBool enableDrawToFrontBuffer;

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

  SbBool directConnection;

  // 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);
#if defined(sun) || defined(__linux__)
  void buildSunOverlayWindow(SoWidget glx, SoXtMPGLWidget *p);
#endif
  void destroyNormalWindows();
  void destroyGLXWidget(SoWidget &w, SoGLContext* &ctx, SbBool normalWindow);

  // callbacks from glx widget
  static void ginitCB(SoWidget, SoXtMPGLWidget *, XtPointer);
  static void overlayGinitCB(SoWidget, SoXtMPGLWidget *, XtPointer);
  static void exposeCB(SoWidget, SoXtMPGLWidget *, XtPointer);
  static void overlayExposeCB(SoWidget, SoXtMPGLWidget *, XtPointer);
  static void resizeCB(SoWidget, SoXtMPGLWidget *, XtPointer);


 private:
  static void mpGinitCB(SoWidget, SoXtMPGLWidget *, XtPointer);
  static void mpExposeCB(SoWidget, SoXtMPGLWidget *, XtPointer);
  static void mpOverlayGinitCB(SoWidget, SoXtMPGLWidget *, XtPointer);
  static void mpOverlayExposeCB(SoWidget, SoXtMPGLWidget *, XtPointer);

  static void mgrDestroyCB(SoWidget, SoXtMPGLWidget *, XtPointer);


};

#endif // _SO_XT_GL_WIDGET_H_

#endif // _WIN32

---

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