Provided by: inventor-doc_2.1.5-10-18_all bug


       SoTransformManip — base class for all transform Nodes with built-in 3D user interfaces


       SoBase > SoFieldContainer > SoNode > SoTransformation > SoTransform > SoTransformManip


       #include <Inventor/manips/SoTransformManip.h>

          Fields from class SoTransform:

     SoSFVec3f           translation
     SoSFRotation        rotation
     SoSFVec3f           scaleFactor
     SoSFRotation        scaleOrientation
     SoSFVec3f           center

          Methods from class SoTransformManip:

     SoDragger *         getDragger()
     SbBool              replaceNode(SoPath *p )
     SbBool              replaceManip(SoPath *p, SoTransform *newOne ) const
     static SoType       getClassTypeId()

          Methods from class SoTransform:

     void                pointAt(const SbVec3f &fromPoint, const SbVec3f &toPoint)
     void                getScaleSpaceMatrix(SbMatrix &mat, SbMatrix &inv) const
     void                getRotationSpaceMatrix(SbMatrix &mat, SbMatrix &inv) const
     void                getTranslationSpaceMatrix(SbMatrix &mat, SbMatrix &inv) const
     void                multLeft(const SbMatrix &mat)
     void                multRight(const SbMatrix &mat)
     void                combineLeft(SoTransformation *nodeOnRight)
     void                combineRight(SoTransformation *nodeOnLeft)
     void                setMatrix(const SbMatrix &mat)
     void                recenter(const SbVec3f &newCenter)

          Methods from class SoNode:

     void                setOverride(SbBool state)
     SbBool              isOverride() const
     SoNode *            copy(SbBool copyConnections = FALSE) const
     virtual SbBool      affectsState() const
     static SoNode *     getByName(const SbName &name)
     static int          getByName(const SbName &name, SoNodeList &list)

          Methods from class SoFieldContainer:

     void                setToDefaults()
     SbBool              hasDefaultValues() const
     SbBool              fieldsAreEqual(const SoFieldContainer *fc) const
     void                copyFieldValues(const  SoFieldContainer  *fc,  SbBool  copyConnections =
     SbBool              set(const char *fieldDataString)
     void                get(SbString &fieldDataString)
     virtual int         getFields(SoFieldList &resultList) const
     virtual SoField *   getField(const SbName &fieldName) const
     SbBool              getFieldName(const SoField *field, SbName &fieldName) const
     SbBool              isNotifyEnabled() const
     SbBool              enableNotify(SbBool flag)

          Methods from class SoBase:

     void                ref()
     void                unref() const
     void                unrefNoDelete() const
     void                touch()
     virtual SoType      getTypeId() const
     SbBool              isOfType(SoType type) const
     virtual void        setName(const SbName &name)
     virtual SbName      getName() const


       SoTransformManip is the base class for all SoTransform nodes that have a built-in 3D  user
       interface.  Since  it is derived from SoTransform, any changes to its fields result in the
       rotation, scaling, and/or translation of nodes that follow it in the scene graph.

       Typically, you will want to replace a regular SoTransform  with  an  SoTransformManip  (as
       when  the  user  selects  an  object  to  be  moved), or vice versa (as when the object is
       deselected, and the motion interface should go away). Use  the  replaceNode()  method   to
       insert  a manipulator into a scene graph, and the replaceManip() method  to remove it when

       Every subclass of SoTransformManip utilizes a  dragger  of  some  sort  to  provide  a  3D
       interface.  (This  class  does  not  have  dragger;  but all the subclasses do.) However a
       manipulator differs from a dragger; it influences other objects in the scene  because,  as
       an  SoTransform,  it alters the state. The fields values and movement of a dragger, on the
       other hand, affect only the dragger itself.

       Each SoTransformManip subclass utilizes its dragger by adding it as a hidden  child.  When
       an  action  is  applied  to  the  manipulator,  such  as rendering or handling events, the
       manipulator first traverses the dragger, and then the manipulator adds its  transformation
       matrix  to  the  state.  When you click-drag-release over the manipulator, it passes these
       events down to the dragger, which moves as a result ("I can't help it, I'm a dragger!").

       The manipulator maintains consistency between the  fields  of  the  dragger  and  its  own
       fields.  Let's  say  you  use  the  mouse to rotate the dragger. Callbacks insure that the
       rotation field of the manipulator will  change  by  the  same  amount,  resulting  in  the
       rotation  of  nodes  which  follow  in  the  scene graph. Similarly, if you set any of the
       SoTransformManip fields the manipulator will move the dragger  accordingly.  You  can  use
       this  feature  to impose contraints on a manipulator: If the user moves the manipulator so
       that a field value becomes too large, you can set the field back to your desired  maximum,
       and the whole thing will move back to where you specified.

       Since each SoTransformManip uses a dragger to provide its interface, you will generally be
       told to look at the dragger's reference page for details of how  it  moves  and  what  the
       different  parts are for. The interface for the dragger and the manipulator will always be
       exactly the same. Usually, a SoTransformManip will surround the objects that it influences
       (i.e.,  those  that  move  along  with  it).  This is because the manipulator turns on the
       surroundScale part of its dragger; so the dragger geometry expands to envelope  the  other
       objects (see the reference page for SoSurroundScale).

       Because the dragger is a hidden child, you can see the dragger on screen and interact with
       it, but the dragger does not show up when you write the manipulator  to  file.  Also,  any
       SoPath  will end at the manipulator. (See the Actions section of this reference page for a
       complete description of when the dragger is traversed).

       If you want to get a pointer to the dragger you can get it from the manipulator using  the
       getDragger()  method.  You  will  need  to do this if you want to change the geometry of a
       manipulator, since the geometry actually belongs to the dragger.



     SoDragger *         getDragger()
          Returns a pointer to the dragger being used by this manipulator.  Given  this  pointer,
          you  can  customize  the  dragger just like you would any other dragger. You can change
          geometry using the setPart() method, or add callbacks using the methods  found  in  the
          SoDragger reference page.

     SbBool              replaceNode(SoPath *p )
          Replaces  the  tail  of the path with this manipulator. The tail of the path must be an
          SoTransform node (or subclass thereof). If the path has a nodekit, this will try to use
          setPart()  to insert the manipulator. Otherwise, the manipulator requires that the next
          to last node in the path chain be a group.

          The field values from the transform node will be copied to this  manipulator,  and  the
          transform will be replaced.

          The  manipulator  will  not  call  ref() on the node it is replacing. The old node will
          disappear if it has no references other than from the input  path  p  and  its  parent,
          since  this  manipulator  will  be  replacing  it in both of those places. Nor will the
          manipulator make any changes to field connections of the old node. The calling  process
          is thus responsible for keeping track of its own nodes and field connections.

     SbBool              replaceManip(SoPath *p, SoTransform *newOne ) const
          Replaces  the  tail  of  the  path,  which  must  be  this  manipulator, with the given
          SoTransform node. If the path has a nodekit, this will try to use setPart()  to  insert
          the  new  node.  Otherwise,  the manipulator requires that the next to last node in the
          path chain be a group.

          The field values from the manipulator will be copied to the  transform  node,  and  the
          manipulator will be replaced.

          The  manipulator will not call ref() or unref()  on the node which is replacing it, nor
          will it make any changes to field connections. The calling process is thus  responsible
          for keeping track of its own nodes and field connections.

     static SoType       getClassTypeId()
          Returns type identifier for this class.


       SoGLRenderAction,     SoCallbackAction,     SoGetBoundingBoxAction,     SoGetMatrixAction,
       SoHandleEventAction, SoRayPickAction
          First, traverses the dragger the way an SoGroup would. All draggers place themselves in
          space,  but  leave  the  current  transformation  unchanged  when  finished.  Then  the
          SoTransformManip accumulates a transformation into the current transformation just like
          its base class, SoTransform.

          Searches  just  like  an  SoTransform.  Does  not search the dragger, which is a hidden

          Writes out just like an SoTransform. Does not write the  dragger,  which  is  a  hidden
          child.  If  you  really  need  to write valuable information about the dragger, such as
          customized geometry, you can retrieve the dragger with the getDragger() method and then
          write it out separately.


       TransformManip {
          translation       0 0 0
          rotation          0 0 1  0
          scaleFactor       1 1 1
          scaleOrientation  0 0 1  0
          center            0 0 0


       SoDragger, SoTransform, SoCenterballManip, SoHandleBoxManip, SoJackManip, SoSurroundScale,
       SoTabBoxManip, SoTrackballManip, SoTransformBoxManip, SoTransformerManip