Provided by: libsoqt-dev-common_1.5.0-2_amd64 bug


       SoQtViewer -

       The SoQtViewer class is the top level base viewer class.

       This is an abstract class, which adds the following features to it's SoQtRenderArea
       superclass: convenient methods for camera handling, an automatic headlight configuration.


       #include <Inventor/Qt/viewers/SoQtViewer.h>

       Inherits SoQtRenderArea.

       Inherited by SoQtFullViewer.

   Public Types
       enum Type { BROWSER, EDITOR }
       enum DrawType { STILL =  0, INTERACTIVE }
       enum AutoClippingStrategy { VARIABLE_NEAR_PLANE, CONSTANT_NEAR_PLANE }

   Public Member Functions
       virtual void setCamera (SoCamera *camera)
       SoCamera * getCamera (void) const
       virtual void setCameraType (SoType type)
       SoType getCameraType (void) const
       virtual void toggleCameraType (void)
       virtual void viewAll (void)
       virtual void saveHomePosition (void)
       virtual void resetToHomePosition (void)
       virtual void setHeadlight (SbBool enable)
       SbBool isHeadlight (void) const
       SoDirectionalLight * getHeadlight (void) const
       virtual void setDrawStyle (SoQtViewer::DrawType type, SoQtViewer::DrawStyle style)
       SoQtViewer::DrawStyle getDrawStyle (const SoQtViewer::DrawType type) const
       virtual void setBufferingType (SoQtViewer::BufferType type)
       SoQtViewer::BufferType getBufferingType (void) const
       virtual void setViewing (SbBool enable)
       SbBool isViewing (void) const
       virtual void setCursorEnabled (SbBool enable)
       SbBool isCursorEnabled (void) const
       void setAutoClipping (SbBool enable)
       SbBool isAutoClipping (void) const
       void setAutoClippingStrategy (const AutoClippingStrategy strategy, const float value=0.6f,
           SoQtAutoClippingCB *cb=NULL, void *cbuserdata=NULL)
       virtual void setStereoViewing (SbBool enable)
       SbBool isStereoViewing (void) const
       virtual void setStereoOffset (const float dist)
       float getStereoOffset (void) const
       SbBool setStereoType (SoQtViewer::StereoType s)
       SoQtViewer::StereoType getStereoType (void) const
       void setAnaglyphStereoColorMasks (const SbBool left[3], const SbBool right[3])
       void getAnaglyphStereoColorMasks (SbBool left[3], SbBool right[3])
       void setDetailSeek (const SbBool enable)
       SbBool isDetailSeek (void) const
       void setSeekTime (const float seconds)
       float getSeekTime (void) const
       void addStartCallback (SoQtViewerCB *func, void *data=NULL)
       void addFinishCallback (SoQtViewerCB *func, void *data=NULL)
       void removeStartCallback (SoQtViewerCB *func, void *data=NULL)
       void removeFinishCallback (SoQtViewerCB *func, void *data=NULL)
       void setWireframeOverlayColor (const SbColor &color)
       const SbColor & getWireframeOverlayColor (void) const
       virtual void setDoubleBuffer (const SbBool enable)
       virtual void setSceneGraph (SoNode *root)
       virtual SoNode * getSceneGraph (void)

   Protected Member Functions
       SoQtViewer (QWidget *parent, const char *name, SbBool embed, Type type, SbBool build)
       ~SoQtViewer ()
       virtual void sizeChanged (const SbVec2s &size)
       virtual void setSeekMode (SbBool enable)
       SbBool isSeekMode (void) const
       SbBool seekToPoint (const SbVec2s screenpos)
       void seekToPoint (const SbVec3f &scenepos)
       virtual void computeSeekFinalOrientation (void)
       virtual void actualRedraw (void)
       virtual SbBool processSoEvent (const SoEvent *const event)
       void interactiveCountInc (void)
       void interactiveCountDec (void)
       int getInteractiveCount (void) const
       void setSeekDistance (const float distance)
       float getSeekDistance (void) const
       void setSeekValueAsPercentage (const SbBool on)
       SbBool isSeekValuePercentage (void) const
       virtual void changeCameraValues (SoCamera *camera)
       void addSuperimposition (SoNode *scene)
       void removeSuperimposition (SoNode *scene)
       void setSuperimpositionEnabled (SoNode *scene, const SbBool enable)
       SbBool getSuperimpositionEnabled (SoNode *scene) const

       class SoQtViewerP
       class SoQtPlaneViewer

Detailed Description

       The SoQtViewer class is the top level base viewer class.

       This is an abstract class, which adds the following features to it's SoQtRenderArea
       superclass: convenient methods for camera handling, an automatic headlight configuration.

       As for the camera handling: when setting a new scenegraph for the viewer, the scenegraph
       will automatically be scanned for a node derived from SoCamera. If not found, the viewer
       will itself set up a camera for the scene. The camera can then be conveniently controlled
       by the application programmers in many aspects:

       · camera type: toggle between using an orthographic camera and a perspective camera with
       · zoom out to exactly encompass all scene geometry within the view by using
       · tag a specific position and orientation for the camera as the 'home' position with
         SoQtViewer::saveHomePosition(), which one can then return to by using
       · automatically fit the near and far clipping planes of the camera around the scene's
         geometry by using SoQtViewer::setAutoClipping()
       · control stereo viewing parameters
       Note that there is no dragger or manipulator attached to the scene camera. The camera
       transform manipulation is calculated in a more direct manner in the non-abstract viewer
       classes inheriting SoQtViewer by reading mouse and keyboard events and interpreting how
       these should influence the camera. The calculations results in new values for
       SoCamera::position, SoCamera::orientation, and the other SoCamera field values for the
       camera designated to be the viewer viewpoint camera. These values are then inserted
       directly into the viewer's SoCamera node.
       See e.g. the source code for SoQtExaminerViewer::processSoEvent() for the details.
       The SoQtViewer class automatically adds a headlight to the scene, which will always point
       in the approximate same direction as the current viewer camera, thereby securing that the
       scene geometry is always lighted and visible. (If you don't want the constant headlight,
       but rather want to light the scene on your own, this behavior can be turned off with
       SoQtViewer-derived viewers all inherit the following keyboard controls from this class
       (but only when the viewer is in 'examine
         mode', ie SoQtViewer::isViewing() returns TRUE):
       · arrow keys: moves camera slightly left, right, up or down

Member Enumeration Documentation

   enum SoQtViewer::Type Hints about what context the viewer will be used in. Usually not very
       interesting for the application programmer, it doesn't matter much which value is used for
       the viewer type. This 'feature' of the viewer is included just to be compatible with the
       old SGI Inventor API.
              If a user-supplied scenegraph passed into the setSceneGraph() function does not
              contain a camera, setting the viewer type to BROWSER will make the viewer in that
              case automatically set up a camera outside the scene, as part of the viewer's
              private and hidden 'supergraph'.
       EDITOR If a user-supplied scenegraph passed into the setSceneGraph() function does not
              contain a camera, setting the viewer type to EDITOR will make the viewer in that
              case automatically set up a camera in the user-supplied scene.
       So if you want to avoid having the SoQtViewer class muck about with your supplied
       scenegraph, set the type-flag to SoQtViewer::BROWSER instead, which makes an inserted
       camera node go into the viewer's own 'wrapper' scene graph instead.
   enum SoQtViewer::DrawStyle Decides drawstyle for a scene with either a still camera or an
       animating camera.
       See also:
           SoQtViewer::setDrawStyle(), SoQtViewer::DrawType
              Normal rendering, draws all scene geometry in it's original style.
              Draw scene in 'hidden line' mode: that is, as wireframe with no 'see-through'.
       Note that this is actually an expensive way to render, as the scene must be rendered twice
       to achieve the effect of hiding lines behind the invisible geometry.
              Render scene without textures.
              Render all 'complex' shape types with low complexity to improve rendering
              View all polygon geometry in wireframe mode.
              Render only the vertex positions of the geometry.
              View the scene's bounding boxes, instead of rendering the full geometry.
       A very efficient way of optimizing rendering performance for scenes with high primitive
       counts while moving the camera about is to set this mode for the SoQtViewer::INTERACTIVE
              Render as wireframe and don't bother with getting them rendered correctly in depth.
              Render as vertex points and don't bother with getting them rendered correctly in
              Always render a scene with an animating camera (ie SoQtViewer::INTERACTIVE
              DrawType) in the same manner as scene with a still camera.
              Render the scene as normal, but overlay a set of lines showing the contours of all
   enum SoQtViewer::DrawType Contains valid values for the first argument to the
       SoQtViewer::setDrawStyle() call. Decides the effect of the second argument.
       See also:
           SoQtViewer::setDrawStyle(), SoQtViewer::DrawStyle
       STILL  If this value is passed as the first argument of SoQtViewer::setDrawStyle(), the
              second argument decides which draw style to use when the viewer camera is standing
              still in the same position with the same orientation -- i.e. when the end user is
              not interacting with the scene camera.
              If this value is passed as the first argument of SoQtViewer::setDrawStyle(), the
              second argument decides which draw style to use when the end user is interacting
              with the scene camera, causing continuous animation redraws.
   enum SoQtViewer::BufferType Set of valid values for SoQtViewer::setBufferingType().
              Change underlying OpenGL canvas to be single-buffered.
              Change underlying OpenGL canvas to be double-buffered.
              Set up so animation rendering is done in a double-buffered OpenGL canvas, but
              ordinary rendering happens directly in the front-buffer.
       This mode can be useful with absurdly large scenes, as the rendering will visibly
       progress, and one will avoid having the end user wonder why nothing is happening while the
       scene is rendered to the back buffer in the default SoQtViewer::BUFFER_DOUBLE mode.
   enum SoQtViewer::AutoClippingStrategy Enum for auto clipping strategy.
       See also:
              Variable near plane auto clipping strategy. Explained in detail in the
              documentation for the SoQtViewer::setAutoClippingStrategy() method.
              Constant near plane auto clipping strategy. Explained in detail in the
              documentation for the SoQtViewer::setAutoClippingStrategy() method.
   enum SoQtViewer::StereoType Contains list of supported stereo rendering techniques.
       See also:
              Use monoscopic rendering.
              Render stereo by superimposing two images of the same scene, but with different
              color filters over the left and right view (or 'eye').
       This is a way of rendering stereo which works on any display, using color-filter glasses.
       Such glasses are usually cheap and easy to come by.
       See also:
              Render stereo by using OpenGL quad-buffers. This is the most common interface for
              stereo rendering for more expensive hardware devices, such as shutter glasses and
              polarized glasses.
       The well known Crystal Eyes glasses are commonly used with this type of stereo display.
              Interleaving / interlacing rows from the left and right eye is another stereo
              rendering method requiring special hardware. One example of a provider of shutter
              glasses working with interleaved glasses is VRex:
              Same basic technique as SoQtViewer::STEREO_INTERLEAVED_ROWS, only it is vertical
              lines that are interleaved / interlaced, instead of horizontal lines.

Constructor & Destructor Documentation

   SoQtViewer::SoQtViewer (QWidget *parent, const char *name, SbBoolembed, SoQtViewer::Typet,
       SbBoolbuild) [protected] Constructor. parent, name and embed are passed on to
       SoQtRenderArea, so see the documentation for our parent constructor for for more
       information on those.
       The t type setting hints about what context the viewer will be used in. Usually not very
       interesting for the application programmer, but if you want to make sure the SoQtViewer
       class doesn't muck about with your supplied scenegraph, set the type-flag to
       SoQtViewer::BROWSER. (This 'feature' of the viewer is included just to be compatible with
       the old SGI Inventor API.)
       The build flag decides whether or not to delay building the widgets / window which is
       going to make up the components of the viewer.
       References addFinishCallback(), addStartCallback(), BUFFER_DOUBLE, BUFFER_SINGLE,
       SoQtRenderArea::buildWidget(), SoQtObject::getClassTypeId(),
       SoQtComponent::getParentWidget(), INTERACTIVE, SoQtGLWidget::isDoubleBuffer(),
       SoQtComponent::setBaseWidget(), SoQtComponent::setClassName(), STILL, VIEW_AS_IS, and
   SoQtViewer::~SoQtViewer () [protected] Destructor.
       References removeSuperimposition(), and setSceneGraph().

Member Function Documentation

   void SoQtViewer::setCamera (SoCamera *cam) [virtual] Set the camera we want the viewer to
       manipulate when interacting with the viewer controls.
       The camera passed in as an argument to this method must already be part of the viewer's
       scenegraph. You do not inject viewpoint cameras to the viewer with this method.
       You should rather insert a camera into the scene graph first (if necessary, often one will
       be present already), then register it as the camera used by the viewer controls with this
       If the application code doesn't explicitly set up a camera through this method, the viewer
       will automatically scan through the scenegraph to find a camera to use. If no camera is
       available in the scenegraph at all, it will set up it's own camera.
       See also:
       Reimplemented in SoQtExaminerViewer, SoQtFlyViewer, SoQtPlaneViewer, and
       References saveHomePosition().
       Referenced by setCameraType(), and setSceneGraph().
   SoCamera * SoQtViewer::getCamera (void) const Returns the camera currently used by the viewer
       for the user's main viewpoint.
       It is possible that this function returns NULL, for instance if there's no scenegraph
       present in the viewer. (This is mostly meant as a note for developers extending the SoQt
       library, as application programmers usually controls if and when a viewer contains a
       scenegraph, and therefore know in advance if this method will return a valid camera
       See also:
       Referenced by SoQtFlyViewer::actualRedraw(), actualRedraw(),
       SoQtPlaneViewer::bottomWheelMotion(), changeCameraValues(),
       SoQtConstrainedViewer::checkForCameraUpConstrain(), SoQtPlaneViewer::leftWheelMotion(),
       SoQtPlaneViewer::processSoEvent(), SoQtExaminerViewer::processSoEvent(),
       SoQtPlaneViewer::rightWheelMotion(), SoQtExaminerViewer::rightWheelMotion(),
       setSceneGraph(), SoQtConstrainedViewer::setUpDirection(), and
   void SoQtViewer::setCameraType (SoTypet) [virtual] When the viewer has to make its own camera
       as a result of the graph passed to setSceneGraph() not containing any camera nodes, this
       call can be made in advance to decide which type the camera will be of.
       Default is to use an SoPerspectiveCamera.
       If this method is called when there is a scene graph and a camera already set up, it will
       delete the old camera and set up a camera with the new type if the t type is different
       from that of the current camera.
       See also:
       Reimplemented in SoQtFlyViewer.
       References SoQtObject::getClassTypeId(), and setCamera().
       Referenced by toggleCameraType().
   SoType SoQtViewer::getCameraType (void) const Returns camera type which will be used when the
       viewer has to make its own camera.
       Note that this call does not return the current cameratype, as one might expect. Use
       getCamera() and SoType::getTypeId() for that inquiry.
       See also:
       Referenced by SoQtPlaneViewer::createViewerButtons(), and
   void SoQtViewer::toggleCameraType (void) [virtual] If the current camera is of perspective
       type, switch to orthographic, and vice versa.
       Automatically calls SoQtViewer::setCameraType() so the change will immediately take place.
       References SoQtObject::getClassTypeId(), and setCameraType().
   void SoQtViewer::viewAll (void) [virtual] Reposition the current camera so we can see the
       complete scene.
       Reimplemented in SoQtFlyViewer.
       References SoQtRenderArea::getViewportRegion().
   void SoQtViewer::saveHomePosition (void) [virtual] Store the current camera settings for later
       retrieval with resetToHomePosition().
       See also:
       Reimplemented in SoQtConstrainedViewer.
       Referenced by setCamera().
   void SoQtViewer::resetToHomePosition (void) [virtual] Restore the saved camera settings.
       See also:
       Reimplemented in SoQtFlyViewer, and SoQtConstrainedViewer.
       Referenced by processSoEvent().
   void SoQtViewer::setHeadlight (SbBoolon) [virtual] Turn the camera headlight on or off.
       Default is to have a headlight turned on.
       See also:
           isHeadlight(), getHeadlight()
   SbBool SoQtViewer::isHeadlight (void) const Returns status of the viewer headlight, whether it
       is on or off.
       See also:
           setHeadlight(), getHeadlight()
   SoDirectionalLight * SoQtViewer::getHeadlight (void) const Returns the a pointer to the
       directional light node which is the viewer headlight.
       The fields of the node is available for user editing.
       See also:
           isHeadlight(), setHeadlight()
   void SoQtViewer::setDrawStyle (SoQtViewer::DrawTypetype, SoQtViewer::DrawStylestyle) [virtual]
       Set up a drawing style. The type argument specifies if the given style should be
       interpreted as the drawstyle during animation or when the camera is static.
       Default values for the drawing style is to render the scene 'as is' in both still mode and
       while the camera is moving.
       See the documentation for the DrawType and DrawStyle for more information.
       See also:
       References getDrawStyle(), INTERACTIVE, and STILL.
   SoQtViewer::DrawStyle SoQtViewer::getDrawStyle (const SoQtViewer::DrawTypetype) const Return
       current drawstyles for the given type (STILL or INTERACTIVE).
       See also:
       References INTERACTIVE, and STILL.
       Referenced by setDrawStyle().
   void SoQtViewer::setBufferingType (SoQtViewer::BufferTypetype) [virtual] Set the viewer's
       buffer type. Available types are SoQtViewer::BUFFER_SINGLE, SoQtViewer::BUFFER_DOUBLE and
       (With a buffer type of SoQtViewer::BUFFER_INTERACTIVE, the viewer will render with
       doublebuffering during user interaction and with single buffering otherwise.)
       Default is SoQtViewer::BUFFER_DOUBLE.
       See also:
       References BUFFER_DOUBLE, BUFFER_INTERACTIVE, BUFFER_SINGLE, and setDoubleBuffer().
   SoQtViewer::BufferType SoQtViewer::getBufferingType (void) const Return the viewer's buffer
       See also:
   void SoQtViewer::setViewing (SbBoolenable) [virtual] Set view mode.
       If the view mode is on, user events will be caught and used to influence the camera
       position / orientation. If view mode is off, all events in the viewer canvas (like for
       instance keypresses or mouseclicks and -movements) will be passed along to the scene
       Default is to have the view mode active.
       See also:
       Reimplemented in SoQtExaminerViewer, SoQtFullViewer, SoQtFlyViewer, and SoQtPlaneViewer.
       References SoQtRenderArea::getGLRenderAction().
       Referenced by processSoEvent().
   SbBool SoQtViewer::isViewing (void) const Return state of view mode.
       TRUE means that the mode of the viewer is set such that user interaction with the mouse is
       used to modify the position and orientation of the camera.
       See also:
       Referenced by SoQtFlyViewer::actualRedraw(), SoQtFullViewer::createViewerButtons(),
       SoQtPlaneViewer::processSoEvent(), SoQtFlyViewer::processSoEvent(),
       SoQtExaminerViewer::processSoEvent(), SoQtFullViewer::processSoEvent(), processSoEvent(),
       SoQtExaminerViewer::setFeedbackSize(), SoQtExaminerViewer::setFeedbackVisibility(),
       SoQtPlaneViewer::setSeekMode(), SoQtExaminerViewer::setSeekMode(), setSeekMode(),
       SoQtPlaneViewer::setViewing(), SoQtFlyViewer::setViewing(), SoQtFullViewer::setViewing(),
       SoQtExaminerViewer::setViewing(), and SoQtExaminerViewer::stopAnimating().
   void SoQtViewer::setCursorEnabled (SbBoolon) [virtual] Set whether or not the mouse cursor
       representation should be visible in the viewer canvas.
       Default value is on.
       See also:
       Reimplemented in SoQtExaminerViewer, SoQtFlyViewer, and SoQtPlaneViewer.
   SbBool SoQtViewer::isCursorEnabled (void) const Returns visibility status of mouse cursor.
       See also:
   void SoQtViewer::setAutoClipping (SbBoolenable) Turn on or off continuous automatic
       adjustments of the near and far clipping planes.
       If on, the distance from the camera position to the near and far planes will be calculated
       to be a 'best fit' around the geometry in the scene, to maximize the 'stretch' of values
       for the visible geometry in the z-buffer. This is important, as z-buffer resolution is
       usually limited enough that one will quickly see flickering in the rasterization of close
       polygons upon lousy utilization of the z-buffer.
       Automatic calculations of near and far clip planes are on as default.
       For better control over what happens in boundary conditions (for instance when the
       distance between near and far planes get very far, or if geometry gets very close to the
       camera position), it is possible to use the SoQtViewer::setAutoClippingStrategy() method
       to fine-tune the near/far clipping plane settings.
       On a major note, be aware that turning auto-updating of near and far clip planes off have
       a potentially serious detrimental effect on performance, due to an important side effect:
       updating the near and far clip planes triggers an SoGetBoundingBoxAction to traverse the
       scene graph, which causes bounding boxes to be calculated and stored in caches. The
       bounding box caches are then used by the SoGLRenderAction traversal for view frustum
       culling operations. With no bounding box caches, the rendering will not do culling, which
       can cause much worse performance. Kongsberg Oil & Gas Technologies are working on
       correcting this problem properly from within the Coin library.
       On a minor note, be aware that notifications will be temporarily turned off for the
       scene's SoCamera when changing the near and far clipping planes (which is done right
       before each redraw). This is done to avoid notifications being sent through the scene
       graph right before rendering, as that causes some latency. It is mentioned here in case
       you have any client code which for some reason needs to sense all changes to the scene
       camera. This is however unlikely, so you can very probably ignore this.
       See also:
       References SoQtRenderArea::scheduleRedraw().
   SbBool SoQtViewer::isAutoClipping (void) const Return value of the automatic near/far
       clipplane adjustment indicator.
       See also:
   void SoQtViewer::setAutoClippingStrategy (const AutoClippingStrategystrategy, const floatvalue
       = 0.6f, SoQtAutoClippingCB *cb = NULL, void *cbuserdata = NULL) Set the strategy used for
       automatic updates of the distances to the near and far clipping planes.
       When auto clipping is enabled, the near plane distance is calculated so that it is just in
       front of the scene bounding box. If this near plane is behind or very close to the
       projection point, one of the following strategies will be used to calculate the new
       clipping plane.
       The VARIABLE_NEAR_PLANE strategy considers the number of z buffer bits available for the
       current OpenGL context, and uses value to calculate the number of bits that is lost
       because of the far/near ratio. value should be in the range [0.0, 1.0]. A higher value
       will increase the z-buffer precision, but also push the near plane further away from the
       projection point.
       The CONSTANT_NEAR_PLANE strategy simply sets the near plane to value. If value at some
       point approaches the far clipping plane distance, the near plane distance will be set to
       far plane distance divided by 5000.0.
       The default strategy is VARIABLE_NEAR_PLANE.
       It is also possible to register a callback method cb, which will then be invoked after the
       near and far clipping planes has been calculated by the SoQtViewer code. The callback can
       then adjust the values for the distance to the near and far planes to exactly match the
       needs of the application (for instance at specific parts in the scene), to limit the
       distance to either plane, or whatever else needs to be controlled.
       The signature of the SoQtAutoClippingCB callback must match:
         SbVec2f myfunc(void * data, const SbVec2f & nearfar);

       The first argument is the cbuserdata passed in along with the callback function pointer
       itself (ie the callback function's closure). The second argument is the near and far
       clipping plane distances from the camera position, as calculated internally by the viewer,
       including 'slack'.
       The function callback can then modify the near and far clipping plane distances to what
       will actually be used by the viewer. These values will then be used unmodified for the
       viewer's camera.
       This is a good way of dynamically modifying the near and far distances such that they at
       all times exactly matches the specific layout of the application scene, for instance with
       regard to the trade-off between z-buffer resolution and how early geometry is clipped at
       the near plane (or at the far plane).
       Note that the internal near/far calculations should be good enough for the vast majority
       of scenes. Application programmers should only need to set up their own adjustments upon
       'unusual' scenes, like for instance scenes with a large world space, but where one would
       still like to be able to get up extremely close on details in some parts of the scene.
       See also:
       References SoQtRenderArea::scheduleRedraw(), and VARIABLE_NEAR_PLANE.
   void SoQtViewer::setStereoViewing (SbBoolenable) [virtual] Turn stereo viewing on or off.
       Note: this function is being obsoleted, you should use the setStereoType() function
       Coin does 'correct' stereo rendering, using the method known as 'parallel axis asymmetric
       frustum perspective projection'. For more information, see this link:
       See also:
           isStereoViewing(), setStereoType()
       References SoQtRenderArea::scheduleRedraw().
       Referenced by setStereoType().
   SbBool SoQtViewer::isStereoViewing (void) const Returns a boolean indicating whether or not
       we're in stereo viewing mode.
       NOTE: in the original InventorXt API, this method was virtual. It is not virtual here.
       See also:
           setStereoViewing(), getStereoType()
       Referenced by getStereoType().
   void SoQtViewer::setStereoOffset (const floatdist) [virtual] Set the offset between the two
       viewpoints when in stereo mode. Default value is 0.1.
       NOTE: In the original InventorXt API, this method was not virtual.
       See also:
       References SoQtRenderArea::scheduleRedraw().
   float SoQtViewer::getStereoOffset (void) const Return the offset distance between the two
       viewpoints when in stereo mode.
       See also:
   SbBool SoQtViewer::setStereoType (SoQtViewer::StereoTypes) Set up stereo rendering.
       Coin does 'correct' stereo rendering, using the method known as 'parallel axis asymmetric
       frustum perspective projection'. For more information, see this link:
       Note: it is prefered that one uses this function for control of which type of stereo
       rendering to use, instead of the older SoQtViewer::setStereoViewing() and
       SoQtGLWidget::setQuadBufferStereo() functions.
       The default is to do monoscopic rendering, i.e. the default SoQtViewer::StereoType value
       is SoQtViewer::STEREO_NONE.
       See also:
           SoQtViewer::StereoType, SoCamera::setStereoAdjustment
           SoQt 1.2
       References SoQtGLWidget::getStencilBuffer(), getStereoType(),
       SoQtGLWidget::isQuadBufferStereo(), SoQtGLWidget::setQuadBufferStereo(),
       SoQtGLWidget::setStencilBuffer(), setStereoViewing(), STEREO_ANAGLYPH,
   SoQtViewer::StereoType SoQtViewer::getStereoType (void) const Returns the current type of
       stereo rendering used (or SoQtViewer::STEREO_NONE if monoscopic).
       References SoQtGLWidget::isQuadBufferStereo(), isStereoViewing(), STEREO_ANAGLYPH, and
       Referenced by actualRedraw(), and setStereoType().
   void SoQtViewer::setAnaglyphStereoColorMasks (const SbBoolleft[3], const SbBoolright[3]) If
       display is configured to render in anaglyph stereo, this function can be used to control
       which filter is used for each eye.
       The default filters are red (i.e. color vector [TRUE,FALSE,FALSE]) for the left eye, and
       cyan (color vector [FALSE,TRUE,TRUE]) for the right eye.
       See also:
           SoQtViewer::StereoType, setStereoType()
       References SoQtRenderArea::scheduleRedraw().
   void SoQtViewer::getAnaglyphStereoColorMasks (SbBoolleft[3], SbBoolright[3]) Returns color
       masks for left and right eye filters in anaglyph stereo.
       See also:
   void SoQtViewer::setDetailSeek (const SbBoolon) Toggle between seeking to a point or seeking
       to an object.
       Default is to seek to a point.
       See also:
   SbBool SoQtViewer::isDetailSeek (void) const Returns a value indicating whether or not seeks
       will be performed to the exact point of picking or just towards the picked object.
       See also:
   void SoQtViewer::setSeekTime (const floatseconds) Set the duration of animating the camera
       repositioning after a successful seek. Call with seconds equal to 0.0 to make the camera
       jump immediately to the correct spot.
       Default value is 2 seconds.
       See also:
   float SoQtViewer::getSeekTime (void) const Returns the camera repositioning duration following
       a seek action.
       See also:
   void SoQtViewer::addStartCallback (SoQtViewerCB *func, void *data = NULL) Add a function to
       call when user interaction with the scene starts.
       See also:
           removeStartCallback(), addFinishCallback()
       Referenced by SoQtViewer().
   void SoQtViewer::addFinishCallback (SoQtViewerCB *func, void *data = NULL) Add a function to
       call when user interaction with the scene ends.
       See also:
           removeFinishCallback(), addStartCallback()
       Referenced by SoQtViewer().
   void SoQtViewer::removeStartCallback (SoQtViewerCB *func, void *data = NULL) Remove one of the
       functions which has been set up to be called when user interaction with the scene starts.
       See also:
           addStartCallback(), removeFinishCallback()
   void SoQtViewer::removeFinishCallback (SoQtViewerCB *func, void *data = NULL) Remove one of
       the functions which has been set up to be called when user interaction with the scene
       See also:
           addFinishCallback(), removeStartCallback()
   void SoQtViewer::setWireframeOverlayColor (const SbColor &color) Set the color of the overlay
       wireframe to color.
       See also:
       References SoQtRenderArea::scheduleRedraw().
   const SbColor & SoQtViewer::getWireframeOverlayColor (void) const Returns the current color of
       the overlay wireframe. The default color is [1,0,0], ie pure red.
       See also:
   void SoQtViewer::setDoubleBuffer (const SbBoolon) [virtual] Overloaded to update the local
       bufferingtype variable.
       See also:
           setBufferingType(), getBufferingType()
       Reimplemented from SoQtGLWidget.
       References BUFFER_DOUBLE, and BUFFER_SINGLE.
       Referenced by setBufferingType().
   void SoQtViewer::setSceneGraph (SoNode *root) [virtual] Give the viewer a scenegraph to render
       and interact with. Overridden from parent class so the viewer can add it's own nodes to
       control rendering in different styles, rendering with a headlight, etc.
       The root node will be inserted under the viewer's root node, which also covers the nodes
       necessary to implement the different preferences drawing style settings.
       If no camera is part of the scene graph under root, one will automatically be instantiated
       and added. You can get a reference to this camera by using the SoQtViewer::getCamera()
       See also:
           getSceneGraph(), setCameraType()
       Reimplemented from SoQtRenderArea.
       References BROWSER, getCamera(), SoQtObject::getClassTypeId(),
       SoQtRenderArea::getViewportRegion(), and setCamera().
       Referenced by ~SoQtViewer().
   SoNode * SoQtViewer::getSceneGraph (void) [virtual] This method returns a reference to the
       scene graph root node as set by the user.
       See also:
       Reimplemented from SoQtRenderArea.
   void SoQtViewer::sizeChanged (const SbVec2s &size) [protected, virtual] Called internally from
       within the SoQt library when the widget embedded in a component changes it size, which is
       usually triggered by end-user interaction.
       This method is then invoked to notify the component that the size has changed. It is
       called from the top and all the way down to the bottom, the size being adjusted to take
       into account extra decorations having been added at each level in the component class
       Reimplemented from SoQtRenderArea.
       Reimplemented in SoQtFullViewer.
   void SoQtViewer::setSeekMode (SbBoolenable) [protected, virtual] Put the viewer in or out of
       'waiting-to-seek' mode.
       If the user performs a mouse button click when the viewer is in 'waiting-to-seek' mode,
       the camera will be repositioned so the camera focal point lies on the point of the
       geometry under the mouse cursor.
       See also:
           isSeekMode(), setDetailSeek()
       Reimplemented in SoQtExaminerViewer, SoQtFlyViewer, and SoQtPlaneViewer.
       References interactiveCountDec(), and isViewing().
       Referenced by processSoEvent(), and seekToPoint().
   SbBool SoQtViewer::isSeekMode (void) const [protected] Return a flag which indicates whether
       or not the viewer is in 'waiting-to-seek' mode.
       (The actual animated translation will not occur until the end user really starts the seek
       operation, typically by clicking with the left mousebutton.)
       See also:
       Referenced by SoQtPlaneViewer::processSoEvent(), SoQtFlyViewer::processSoEvent(),
       SoQtExaminerViewer::processSoEvent(), processSoEvent(), SoQtPlaneViewer::setSeekMode(),
       SoQtFlyViewer::setSeekMode(), and SoQtExaminerViewer::setSeekMode().
   SbBool SoQtViewer::seekToPoint (const SbVec2sscreenpos) [protected] Call this method to
       initiate a seek action towards the 3D intersection of the scene and the ray from the
       screen coordinate's point and in the same direction as the camera is pointing.
       Returns TRUE if the ray from the screenpos position intersect with any parts of the
       onscreen geometry, otherwise FALSE.
       References SoQtRenderArea::getViewportRegion(), interactiveCountInc(), and setSeekMode().
       Referenced by SoQtPlaneViewer::processSoEvent(), SoQtExaminerViewer::processSoEvent(), and
   void SoQtViewer::seekToPoint (const SbVec3f &scenepos) [protected] Call this method to
       initiate a seek action towards the give 3D world coordinate point in the scene, scenepos.
           SoQt 1.3.0
       References computeSeekFinalOrientation(), interactiveCountDec(), and
   void SoQtViewer::computeSeekFinalOrientation (void) [protected, virtual] This method can be
       overridden in subclasses if the final orientation of the camera after a seek should be
       something other than what is computed in SoQtViewer::seekToPoint(const SbVec3f & scenepos)
       Reimplemented in SoQtPlaneViewer.
       Referenced by seekToPoint().
   void SoQtViewer::actualRedraw (void) [protected, virtual] This method instantly redraws the
       normal (non-overlay) scenegraph by calling SoSceneManager::render().
       Subclasses may override this method to add their own rendering before or after Coin
       renders it's scenegraph.
       The following is a complete example that demonstrates one way of adding both a background
       image and foreground (overlay) geometry to the 'normal' rendering:
         // This example shows how to put a permanent background image on
         // your viewer canvas, below the 3D graphics, plus overlay
         // foreground geometry.  Written by mortene.
         // Copyright Kongsberg Oil & Gas Technologies 2002.

         // *************************************************************************

         #include <Inventor/Qt/SoQt.h>
         #include <Inventor/Qt/viewers/SoQtExaminerViewer.h>
         #include <Inventor/nodes/SoBaseColor.h>
         #include <Inventor/nodes/SoCone.h>
         #include <Inventor/nodes/SoCube.h>
         #include <Inventor/nodes/SoImage.h>
         #include <Inventor/nodes/SoLightModel.h>
         #include <Inventor/nodes/SoOrthographicCamera.h>
         #include <Inventor/nodes/SoRotationXYZ.h>
         #include <Inventor/nodes/SoSeparator.h>
         #include <Inventor/nodes/SoTranslation.h>

         #include <GL/gl.h>

         // *************************************************************************

         class MyExaminerViewer : public SoQtExaminerViewer {

           MyExaminerViewer(QWidget * parent, const char * filename);

           virtual void actualRedraw(void);

           SoSeparator * bckgroundroot;
           SoSeparator * foregroundroot;
           SoRotationXYZ * arrowrotation;

         MyExaminerViewer::MyExaminerViewer(QWidget * parent, const char * filename)
           : SoQtExaminerViewer(parent)
           // Coin should not clear the pixel-buffer, so the background image
           // is not removed.
           this->setClearBeforeRender(FALSE, TRUE);

           // Set up background scenegraph with image in it.

           this->bckgroundroot = new SoSeparator;

           SoOrthographicCamera * cam = new SoOrthographicCamera;
           cam->position = SbVec3f(0, 0, 1);
           cam->height = 1;
           // SoImage will be at z==0.0.
           cam->nearDistance = 0.5;
           cam->farDistance = 1.5;

           SoImage * img = new SoImage;
           img->vertAlignment = SoImage::HALF;
           img->horAlignment = SoImage::CENTER;
           img->filename = filename;


           // Set up foreground, overlayed scenegraph.

           this->foregroundroot = new SoSeparator;

           SoLightModel * lm = new SoLightModel;
           lm->model = SoLightModel::BASE_COLOR;

           SoBaseColor * bc = new SoBaseColor;
           bc->rgb = SbColor(1, 1, 0);

           cam = new SoOrthographicCamera;
           cam->position = SbVec3f(0, 0, 5);
           cam->height = 10;
           cam->nearDistance = 0;
           cam->farDistance = 10;

           const double ARROWSIZE = 2.0;

           SoTranslation * posit = new SoTranslation;
           posit->translation = SbVec3f(-2.5 * ARROWSIZE, 1.5 * ARROWSIZE, 0);

           arrowrotation = new SoRotationXYZ;
           arrowrotation->axis = SoRotationXYZ::Z;

           SoTranslation * offset = new SoTranslation;
           offset->translation = SbVec3f(ARROWSIZE/2.0, 0, 0);

           SoCube * cube = new SoCube;
           cube->width = ARROWSIZE;
           cube->height = ARROWSIZE/15.0;



           // Must set up the OpenGL viewport manually, as upon resize
           // operations, Coin won't set it up until the SoGLRenderAction is
           // applied again. And since we need to do glClear() before applying
           // the action..
           const SbViewportRegion vp = this->getViewportRegion();
           SbVec2s origin = vp.getViewportOriginPixels();
           SbVec2s size = vp.getViewportSizePixels();
           glViewport(origin[0], origin[1], size[0], size[1]);

           const SbColor col = this->getBackgroundColor();
           glClearColor(col[0], col[1], col[2], 0.0f);

           // Render our scenegraph with the image.
           SoGLRenderAction * glra = this->getGLRenderAction();

           // Render normal scenegraph.

           // Increase arrow angle with 1/1000 ° every frame.
           arrowrotation->angle = arrowrotation->angle.getValue() + (0.001 / M_PI * 180);
           // Render overlay front scenegraph.

         // *************************************************************************

         main(int argc, char ** argv)
           if (argc != 2) {
             (void)fprintf(stderr, '0sage: %s <image-filename>0, argv[0]);

           QWidget * window = SoQt::init(argv[0]);

           MyExaminerViewer * viewer = new MyExaminerViewer(window, argv[1]);

           viewer->setSceneGraph(new SoCone);


           delete viewer;
           return 0;

         // *************************************************************************
       Reimplemented from SoQtRenderArea.
       Reimplemented in SoQtExaminerViewer, SoQtFlyViewer, and SoQtPlaneViewer.
       References SoQtRenderArea::getBackgroundColor(), getCamera(),
       SoQtRenderArea::getSceneManager(), getStereoType(), SoQtRenderArea::isClearBeforeRender(),
       SoQtRenderArea::isClearZBufferBeforeRender(), SoQtGLWidget::isDoubleBuffer(),
   SbBool SoQtViewer::processSoEvent (const SoEvent *constevent) [protected, virtual] Toolkit-
       native events are attempted converted to Coin-generic events in the
       SoQtRenderArea::processEvent() method. If this succeeds, they are forwarded to this
       This is a virtual method, and is overridden in it's subclasses to catch events of
       particular interest to the viewer classes, for instance.
       Return TRUE iff the event was processed. If not it should be passed on further up in the
       inheritance hierarchy by the caller. This last point is extremely important to take note
       of if you are expanding the toolkit with your own viewer class.
       This method is not part of the original SGI InventorXt API. Note that you can still
       override the toolkit-native processEvent() method instead of this 'generic' method.
       Reimplemented from SoQtRenderArea.
       Reimplemented in SoQtFullViewer, SoQtExaminerViewer, SoQtFlyViewer, and SoQtPlaneViewer.
       References isSeekMode(), isViewing(), resetToHomePosition(), seekToPoint(), setSeekMode(),
       and setViewing().
   void SoQtViewer::interactiveCountInc (void) [protected] To be able to trigger callback
       functions when user interaction starts and/or stops, we need to keep track of the viewer
       state (i.e. are we in still mode or in animation mode?).
       SoQtViewer automatically adds callbacks to switch between still and moving draw style, and
       to switch between single/double buffer when the buffer type is INTERACTIVE.
       See also:
           interactiveCountDec(), getInteractiveCount()
           addStartCallback(), addFinishCallback()
           removeStartCallback(), removeFinishCallback()
           setDrawStyle(), setBufferingType()
       Referenced by SoQtFullViewer::bottomWheelStart(), SoQtFullViewer::leftWheelStart(),
       SoQtFullViewer::rightWheelStart(), and seekToPoint().
   void SoQtViewer::interactiveCountDec (void) [protected] To be able to trigger callback
       functions when user interaction starts and/or stops, we need to keep track of the viewer
       state (i.e. are we in still mode or in animation mode?).
       SoQtViewer automatically adds callbacks to switch between still and moving draw style, and
       to switch between single/double buffer when the buffer type is INTERACTIVE.
       See also:
           interactiveCountInc(), getInteractiveCount()
           addStartCallback(), addFinishCallback()
           removeStartCallback(), removeFinishCallback()
           setDrawStyle(), setBufferingType()
       Referenced by SoQtFullViewer::bottomWheelFinish(), SoQtFullViewer::leftWheelFinish(),
       SoQtFullViewer::rightWheelFinish(), seekToPoint(), and setSeekMode().
   int SoQtViewer::getInteractiveCount (void) const [protected] Return current interaction count
       nesting. If equal to zero, the viewer is in animation mode, otherwise the camera is still.
       See also:
           interactiveCountInc(), interactiveCountDec()
   void SoQtViewer::setSeekDistance (const floatdistance) [protected] Set the value used for
       calculating how close the camera and intersection hit point should be made at the end of a
       seek operation.
       The value can be interpreted as an absolute value in the given world unit (which typically
       is meters) or as a percentage value of the distance between the camera starting position
       and the intersection hit point. This can be controlled through the
       setSeekValueAsPercentage() method. It is as default used as an absolute value.
       Default value is 50 (absolute distance or percent).
       See also:
           getSeekDistance(), setSeekValueAsPercentage(), setSeekTime()
   float SoQtViewer::getSeekDistance (void) const [protected] Returns the current seek distance.
       Value given as an absolute scalar length or as a percentage value of the original distance
       between the hitpoint and the camera starting position.
       See also:
           setSeekDistance(), isSeekValueAsPercentage()
   void SoQtViewer::setSeekValueAsPercentage (const SbBoolon) [protected] Control whether or not
       the seek distance value should be interpreted as a percentage value or as an absolute
       distance. See documentation on setSeekDistance() for more information.
       See also:
           setSeekDistance(), isSeekValueAsPercentage()
       References isSeekValuePercentage().
   SbBool SoQtViewer::isSeekValuePercentage (void) const [protected] Returns an boolean which
       indicates if the seek distance value from getSeekDistance() should be interpreted as a
       percentage value or as an absolute value.
       See also:
           setSeekValuePercentage(), getSeekDistance()
       Referenced by setSeekValueAsPercentage().
   void SoQtViewer::changeCameraValues (SoCamera *camera) [protected, virtual] Copies the
       settings of camera into our current camera. Cameras must be of the same class type.
       Reimplemented in SoQtConstrainedViewer.
       References getCamera().
   void SoQtViewer::addSuperimposition (SoNode *scene) [protected] This method is for setting up
       a superimposed scene graph on top of the viewer scene graph. It will be used for adding
       spin-rotation coordinate systems, fly-viewer speed indicators and similar things.
       This method is not part of the original InventorXt API.
   void SoQtViewer::removeSuperimposition (SoNode *scene) [protected] This method is not part of
       the original InventorXt API.
       Referenced by SoQtFlyViewer::~SoQtFlyViewer(), and ~SoQtViewer().
   void SoQtViewer::setSuperimpositionEnabled (SoNode *scene, const SbBoolenable) [protected]
       This method sets whether the superimposed scene graph should be traversed or not.
       This method is not part of the original InventorXt API.
       Referenced by SoQtFlyViewer::setViewing().
   SbBool SoQtViewer::getSuperimpositionEnabled (SoNode *scene) const [protected] This method
       returns whether the superimposed scene is rendered or not.
       This method is not part of the original InventorXt API.


       Generated automatically by Doxygen for SoQt from the source code.