SoXtRenderArea(3IV)

SoXtRenderArea (SoXtRA) - Xt Component for rendering Inventor scene graphs

Showing IRIX 6.5.30 (default release). Added in IRIX 6.5.22.

NAME
     SoXtRenderArea (SoXtRA) - Xt Component for rendering Inventor scene
     graphs

INHERITS FROM
     SoXtComponent > SoXtGLWidget > SoXtRenderArea

SYNOPSIS
     #include <Inventor_c/Xt/SoXtRenderArea.h>

     typedef SbBool          SoXtRenderAreaEventCB(void *userData, XAnyEvent
                                  *anyevent)
     typedef SoXtRenderArea  SoXtRA

                                  #define SoXtRACreateStd(parent, name)
                                  SoXtRACreate(parent, name, TRUE, TRUE, TRUE)

          Functions from class SoXtRenderArea:

     SoXtRenderArea *          SoXtRACreate(Widget parent = NULL, const char
                                    *name = NULL, SbBool buildInsideParent =
                                    TRUE, SbBool getMouseInput = TRUE, SbBool
                                    getKeyboardInput = TRUE)
     void                      SoXtRADelete(SoXtRA *this)
     void                      SoXtRASetScene(SoXtRA *this, SoNode *newScene)
     SoNode *                  SoXtRAGetScene(SoXtRA *this)
     void                      SoXtRASetOverScene(SoXtRA *this, SoNode
                                    *newScene)
     SoNode *                  SoXtRAGetOverScene(SoXtRA *this)
     void                      SoXtRARegisterDevice(SoXtRA *this, SoXtDevice
                                    *)
     void                      SoXtRAUnregisterDevice(SoXtRA *this, SoXtDevice
                                    *)
     void                      SoXtRASetBkgCol(SoXtRA *this, const SbColor *c)
     const SbColor *           SoXtRAGetBkgCol(const SoXtRA *this)
     void                      SoXtRASetBkgInd(SoXtRA *this, int index)
     int                       SoXtRAGetBkgInd(const SoXtRA *this)
     void                      SoXtRASetOverBkgInd(SoXtRA *this, int index)
     int                       SoXtRAGetOverBkgInd(const SoXtRA *this)
     void                      SoXtRASetColMap(SoXtRA *this, int startIndex,
                                    int num, const SbColor *colors)
     void                      SoXtRASetOverColMap(SoXtRA *this, int
                                    startIndex, int num, const SbColor
                                    *colors)
     void                      SoXtRASetVPReg(SoXtRA *this, const
                                    SbViewportRegion *newRegion)
     const SbViewportRegion *  SoXtRAGetVPReg(const SoXtRA *this)
     void                      SoXtRASetTranspType(SoXtRA *this,
                                    SoGLRenderAction::TransparencyType type)
     SoGLRenderAction::TransparencyType
                               SoXtRAGetTranspType(const SoXtRA *this)

     void                      SoXtRASetAntialiasing(SoXtRA *this, SbBool
                                    smoothing, int numPasses)
     void                      SoXtRAGetAntialiasing(const SoXtRA *this,
                                    SbBool *smoothing, int *numPasses)
     void                      SoXtRASetClearBeforeRender(SoXtRA *this, SbBool
                                    trueOrFalse)
     SbBool                    SoXtRAIsClearBeforeRender(const SoXtRA *this)
     void                      SoXtRASetClearBeforeOverRender(SoXtRA *this,
                                    SbBool trueOrFalse)
     SbBool                    SoXtRAIsClearBeforeOverRender(const SoXtRA
                                    *this)
     void                      SoXtRASetAutoRedraw(SoXtRA *this, SbBool
                                    trueOrFalse)
     SbBool                    SoXtRAIsAutoRedraw(const SoXtRA *this)
     void                      SoXtRASetRedrawPriority(SoXtRA *this, uint32_t
                                    priority)
     uint32_t                  SoXtRAGetRedrawPriority(const SoXtRA *this)
     uint32_t                  SoXtRAGetDefaultRedrawPriority()
     void                      SoXtRARender(SoXtRA *this)
     void                      SoXtRARenderOverlay(SoXtRA *this)
     void                      SoXtRAScheduleRedraw(SoXtRA *this)
     void                      SoXtRAScheduleOverRedraw(SoXtRA *this)
     void                      SoXtRARedrawOnSelChange(SoXtRA *this,
                                    SoSelection *s)
     void                      SoXtRARedrawOverOnSelChange(SoXtRA *this,
                                    SoSelection *s)
     void                      SoXtRASetEvCB(SoXtRA *this,
                                    SoXtRenderAreaEventCB *fcn, void *userData
                                    = NULL)
     void                      SoXtRASetGLRenderAct(SoXtRA *this,
                                    SoGLRenderAction *ra)
     SoGLRenderAction *        SoXtRAGetGLRenderAct(const SoXtRA *this)
     void                      SoXtRASetOverGLRenderAct(SoXtRA *this,
                                    SoGLRenderAction *ra)
     SoGLRenderAction *        SoXtRAGetOverGLRenderAct(const SoXtRA *this)
     void                      SoXtRASetSceneMgr(SoXtRA *this, SoSceneManager
                                    *sm)
     SoSceneManager *          SoXtRAGetSceneMgr(const SoXtRA *this)
     void                      SoXtRASetOverSceneMgr(SoXtRA *this,
                                    SoSceneManager *sm)
     SoSceneManager *          SoXtRAGetOverSceneMgr(const SoXtRA *this)

          Functions from class SoXtGLWidget:

     void                SoXtRASetBorder(SoXtRA *this, SbBool onOrOff)
     SbBool              SoXtRAIsBorder(const SoXtRA *this)
     void                SoXtRASetDblBuf(SoXtRA *this, SbBool onOrOff)
     SbBool              SoXtRAIsDblBuf(SoXtRA *this)
     Window              SoXtRAGetNormWin(SoXtRA *this)
     Window              SoXtRAGetOverWin(SoXtRA *this)
     GLXContext          SoXtRAGetNormCtx(SoXtRA *this)

     GLXContext          SoXtRAGetOverCtx(SoXtRA *this)
     Widget              SoXtRAGetNormWidget(SoXtRA *this)
     Widget              SoXtRAGetOverWidget(SoXtRA *this)
     void                SoXtRASetNormVis(SoXtRA *this, XVisualInfo *vis)
     XVisualInfo *       SoXtRAGetNormVis(SoXtRA *this)
     void                SoXtRASetOverVis(SoXtRA *this, XVisualInfo *vis)
     XVisualInfo *       SoXtRAGetOverVis(SoXtRA *this)
     void                SoXtRASetDrwFrontBuf(SoXtRA *this, SbBool enableFlag)
     SbBool              SoXtRAIsDrwFrontBuf(const SoXtRA *this)

          Functions from class SoXtComponent:

     void                SoXtRAShow(SoXtRA *this)
     void                SoXtRAHide(SoXtRA *this)
     SbBool              SoXtRAIsVisible(SoXtRA *this)
     Widget              SoXtRAGetWidget(const SoXtRA *this)
     SbBool              SoXtRAIsTopLevelShell(const SoXtRA *this)
     Widget              SoXtRAGetShellWidget(const SoXtRA *this)
     Widget              SoXtRAGetParentWidget(const SoXtRA *this)
     void                SoXtRASetSize(SoXtRA *this, const SbVec2s *size)
     SbVec2s             SoXtRAGetSize(SoXtRA *this)
     Display *           SoXtRAGetDisplay(SoXtRA *this)
     void                SoXtRASetTitle(SoXtRA *this, const char *newTitle)
     const char *        SoXtRAGetTitle(const SoXtRA *this)
     void                SoXtRASetIconTitle(SoXtRA *this, const char
                              *newIconTitle)
     const char *        SoXtRAGetIconTitle(const SoXtRA *this)
     void                SoXtRASetWinCloseCB(SoXtRA *this, SoXtComponentCB
                              *func, void *data = NULL)
     SoXtComponent *     SoXtRAGetComp(Widget w)
     const char *        SoXtRAGetWidgetName(const SoXtRA *this)
     const char *        SoXtRAGetClassName(const SoXtRA *this)


DESCRIPTION
     This class provides Inventor rendering and event handling inside a GLX
     Motif widget. There is a routine to specify the scene to render. The
     scene is automatically rendered whenever anything under it changes (a
     data sensor is attached to the root of the scene), unless explicitly told
     not to do so (manual redraws). Users can also set Inventor rendering
     attributes such as the transparency type, antialiasing on or off, etc.
     This class employs an SoSceneManager to manage rendering and event
     handling.

     X events that occur in the render area can be handled by the application,
     by the viewer (if this is really a viewer) or by the nodes in the scene
     graph. When an event occurs, it is first passed to the application event
     callback function registered with the setEventCallback() method on
     SoXtRenderArea. If this function does not exist or returns FALSE, the X
     event is either used directly by the viewer or translated to an SoEvent
     for further scene graph processing. If the viewer does not handle the
     event, and an overlay scene graph exists, the SoEvent is sent to that
     scene graph by way of an SoHandleEventAction. If no node in the overlay
     scene graph handles the event (i.e., calls setHandled() on the
     SoHandleEventAction), the SoEvent is passed to the normal scene graph in
     the same manner.

FUNCTIONS
     SoXtRenderArea *          SoXtRACreate(Widget parent = NULL, const char
                                    *name = NULL, SbBool buildInsideParent =
                                    TRUE, SbBool getMouseInput = TRUE, SbBool
                                    getKeyboardInput = TRUE)
     void                      SoXtRADelete(SoXtRA *this)
          Constructor which is passed arguments which tell it whether to
          register the mouse and keyboard devices by default (SoXtMouse and
          SoXtKeyboard). For a constructor short cut look at the
          SoXtRACreateStd #define.

     void                      SoXtRASetScene(SoXtRA *this, SoNode *newScene)
     SoNode *                  SoXtRAGetScene(SoXtRA *this)
          Set/get the scene graph to be rendered in this component's window.

     void                      SoXtRASetOverScene(SoXtRA *this, SoNode
                                    *newScene)
     SoNode *                  SoXtRAGetOverScene(SoXtRA *this)
          Sets/gets the scene graph to render in the overlay bit planes.

          Note: since the overlay bit planes are in color index mode, single
          buffer with a limited number of colors, the user should limit
          rendering in the overlay planes to simple objects.

          Typically rendering in color index mode is done using the
          SoColorIndex node with a SoLightModel set to BASE_COLOR.

     void                      SoXtRARegisterDevice(SoXtRA *this, SoXtDevice
                                    *)
     void                      SoXtRAUnregisterDevice(SoXtRA *this, SoXtDevice
                                    *)
          Register/unregister interest in devices. When a device is
          registered, events from that device will be processed by the render
          area, and passed into the scene graph. Events from unregistered
          devices will be ignored.

     void                      SoXtRASetBkgCol(SoXtRA *this, const SbColor *c)
     const SbColor *           SoXtRAGetBkgCol(const SoXtRA *this)
          Set/get the background color for this window. Default is black
          (0,0,0).

     void                      SoXtRASetBkgInd(SoXtRA *this, int index)
     int                       SoXtRAGetBkgInd(const SoXtRA *this)
          Sets/gets the window background color when in color index mode.
          (default to black (index 0)).

     void                      SoXtRASetOverBkgInd(SoXtRA *this, int index)
     int                       SoXtRAGetOverBkgInd(const SoXtRA *this)
          Sets/gets the overlay window background color index. (default to 0
          (clear color)).

     void                      SoXtRASetColMap(SoXtRA *this, int startIndex,
                                    int num, const SbColor *colors)
          Sets the colors to use when displaying in color index mode. This
          will load the color map with the given colors at the starting index.

     void                      SoXtRASetOverColMap(SoXtRA *this, int
                                    startIndex, int num, const SbColor
                                    *colors)
          Sets the colors to use for overlay bit planes.This will load the
          color map with the given colors at the starting index.

     void                      SoXtRASetVPReg(SoXtRA *this, const
                                    SbViewportRegion *newRegion)
     const SbViewportRegion *  SoXtRAGetVPReg(const SoXtRA *this)
          Sets/gets current viewport region to use for rendering

     void                      SoXtRASetTranspType(SoXtRA *this,
                                    SoGLRenderAction::TransparencyType type)
     SoGLRenderAction::TransparencyType
                               SoXtRAGetTranspType(const SoXtRA *this)
          Set/get the quality level for rendering transparent objects. See
          SoGLRenderAction for possible transparency types.

     void                      SoXtRASetAntialiasing(SoXtRA *this, SbBool
                                    smoothing, int numPasses)
     void                      SoXtRAGetAntialiasing(const SoXtRA *this,
                                    SbBool *smoothing, int *numPasses)
          Set/get the antialiasing for rendering. There are two kinds of
          antialiasing available: smoothing and multipass antialiasing. If
          smoothing is set to TRUE, smoothing is enabled. Smoothing uses
          OpenGL's line- and point-smoothing features to provide cheap
          antialiasing of lines and points. The value of numPasses controls
          multipass antialiasing. Each time a render action is applied,
          Inventor renders the scene numPasses times from slightly different
          camera positions, averaging the results. numPasses can be from one
          to 255, inclusive. Setting numPasses to one disables multipass
          antialiasing. You can use either, both, or neither of these
          antialiasing techniques. By default, both smoothing and multipass
          antialiasing are disabled.

     void                      SoXtRASetClearBeforeRender(SoXtRA *this, SbBool
                                    trueOrFalse)
     SbBool                    SoXtRAIsClearBeforeRender(const SoXtRA *this)
          Enable/prevent window clearing from happening before a rendering
          starts (default is clear TRUE). This can be useful to limit
          flickering when doing single buffering and geometry covers the
          entire window (used in the material editor).
     void                      SoXtRASetClearBeforeOverRender(SoXtRA *this,
                                    SbBool trueOrFalse)
     SbBool                    SoXtRAIsClearBeforeOverRender(const SoXtRA
                                    *this)
          Enable/prevent overlay window clearing from happening before a
          rendering starts (default is clear TRUE).

     void                      SoXtRASetAutoRedraw(SoXtRA *this, SbBool
                                    trueOrFalse)
     SbBool                    SoXtRAIsAutoRedraw(const SoXtRA *this)
          The render area will automatically redraw whenever something in the
          scene graph changes. Passing FALSE will disable this feature.

     void                      SoXtRASetRedrawPriority(SoXtRA *this, uint32_t
                                    priority)
     uint32_t                  SoXtRAGetRedrawPriority(const SoXtRA *this)
     uint32_t                  SoXtRAGetDefaultRedrawPriority()
          Sets/gets the priority of the redraw sensor and get the default
          priority number.

     void                      SoXtRARender(SoXtRA *this)
     void                      SoXtRARenderOverlay(SoXtRA *this)
          Calling this forces the render area to be redrawn now. It is not
          necessary to call this method if auto redraw is enabled (which is
          the default).

     void                      SoXtRAScheduleRedraw(SoXtRA *this)
     void                      SoXtRAScheduleOverRedraw(SoXtRA *this)
          Schedule a redraw to happen sometime soon (as opposed to
          immediately). This can be used to compress multiple redraws.

     void                      SoXtRARedrawOnSelChange(SoXtRA *this,
                                    SoSelection *s)
     void                      SoXtRARedrawOverOnSelChange(SoXtRA *this,
                                    SoSelection *s)
          Call this convenience method to have this render area redraw
          whenever the selection list changes in the passed node. This is
          useful if using a highlight render action like the
          SoBoxHighlightRenderAction to correctly render whenever the
          selection changes. Pass NULL to turn this off.

     void                      SoXtRASetEvCB(SoXtRA *this,
                                    SoXtRenderAreaEventCB *fcn, void *userData
                                    = NULL)
          X events which occur in the render area window are either directly
          handled by the viewer (when this is really a viewer) or
          automatically translated to SoEvents, then passed into the scene
          graph (via the SoHandleEventAction) so that live scene graph objects
          can handle the event (when viewers are not in viewing mode). This
          function allows the application to register a callback for handling
          events that occur in the window, instead of sending them to the
          viewers or down the graph. The callback is passed the X event, and
          should return TRUE if it handled the event. If the callback returns
          FALSE, then the event will be handled by the render area.

     void                      SoXtRASetGLRenderAct(SoXtRA *this,
                                    SoGLRenderAction *ra)
     SoGLRenderAction *        SoXtRAGetGLRenderAct(const SoXtRA *this)
          Sets/gets the GL render action to use. This is used to set selection
          highlighting with the SoBoxHighlightRenderAction and
          SoLineHighlightRenderAction classes.

     void                      SoXtRASetOverGLRenderAct(SoXtRA *this,
                                    SoGLRenderAction *ra)
     SoGLRenderAction *        SoXtRAGetOverGLRenderAct(const SoXtRA *this)
          Sets/gets the GL render action for the overlay window.

     void                      SoXtRASetSceneMgr(SoXtRA *this, SoSceneManager
                                    *sm)
     SoSceneManager *          SoXtRAGetSceneMgr(const SoXtRA *this)
     void                      SoXtRASetOverSceneMgr(SoXtRA *this,
                                    SoSceneManager *sm)
     SoSceneManager *          SoXtRAGetOverSceneMgr(const SoXtRA *this)
          Sets/gets the normal and overlay plane scene managers.

          Note: for convenience most of the SoSceneManager methods have
          already been added to this class.


RESOURCES
          *SoXtRenderArea*BackgroundColor: black (color name or hex value)



SEE ALSO
     SoXtGLWidget, SoXtComponent, SoXtViewer, SoSceneManager,
     SoBoxHighlightRenderAction, SoLineHighlightRenderAction