SoNodeKitPath(3IV)

SoNodeKitPath - path that points to a list of hierarchical nodekits

As shipped in IRIX 6.5.30. Added in IRIX 6.5.22.

NAME
     SoNodeKitPath - path that points to a list of hierarchical nodekits

INHERITS FROM
     SoBase > SoPath > SoNodeKitPath

SYNOPSIS
     #include <Inventor/SoNodeKitPath.h>

          Methods from class SoNodeKitPath:

     void                append(SoBaseKit *childKit)
     void                append(const SoNodeKitPath *fromPath)
     void                pop()
     SoNode *            getTail() const
     SoNode *            getNode(int i) const
     SoNode *            getNodeFromTail(int i) const
     int                 getLength() const
     void                truncate(int start)
     SbBool              containsNode(const SoNodeKit *nodeKit) const
     int                 findFork(const SoNodeKitPath *path) const
     friend int          operator ==(const SoNodeKitPath &p1, const
                              SoNodeKitPath &p2)

          Methods from class SoPath:

     void                setHead(SoNode *node)
     SoNode *            getHead() const
     SbBool              containsPath(const SoPath *path) const
     SoPath *            copy(int startFromNodeIndex = 0, int numNodes = 0)
                              const
     static SoPath *     getByName(const SbName &name)
     static int          getByName(const SbName &name, SoPathList &list)

          Methods from class SoBase:

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


DESCRIPTION
     SoNodeKitPath is a subclass of SoPath that lets you look at nodekits
     below the top nodekit in the path. Since nodekits have hidden children,
     when you call getTail() on a regular path, it returns the top-most
     nodekit on the path.  This occurs even though the path might contain
     extra internal information leading to a node far deeper in the scene
     graph. For example, when picking an object inside an SoSceneKit, the
     regular path would end at the scenekit.  But a nodekit path would
     continue further down listing the other nodekits below it in the path.

     Intermediary (private) nodes between nodekits are not included in the
     nodekit path.

     Note that there is no constructor for an SoNodeKitPath, so you can not
     create one. Rather, you cast an (SoPath *) into an (SoNodeKitPath *),
     which returns nodekit-style values from all the same questions as SoPath.

     Also, some methods of SoPath may not be called on an SoNodeKitPath. Any
     methods which take a regular SoNode as an argument (except for setHead())
     are not accessible, and replaced by methods that take an SoBaseKit as an
     argument instead. Methods which allow the programmer to refer to the
     child index of a node beneath its parent are also inaccessible; since a
     SoNodeKitPath only shows nodekits and hides any private parts, successive
     nodekits in the path may not actually be parent and child.

METHODS
     void                append(SoBaseKit *childKit)
          Adds childKit to end of chain; uses first occurrence of childKit as
          a part within current last nodekit. If the path is empty, this is
          equivalent to setHead(childKit).

     void                append(const SoNodeKitPath *fromPath)
          Adds all nodekits in fromPath's chain to end of chain; the head node
          of fromPath must be the same as or a child of the current tail node.

     void                pop()
          Pops the last nodekit off the end of the path.

     SoNode *            getTail() const
          Return the last nodekit in a path chain. Note that getHead() is not
          redefined from SoPath, since an SoNodeKitPath need not begin with a
          nodekit; the restriction is placed only on successive nodes on the
          path.

     SoNode *            getNode(int i) const
          Returns a pointer to the i'th node in the nodekit path.

     SoNode *            getNodeFromTail(int i) const
          Returns a pointer to the i'th nodekit in the chain, counting
          backward from the tail nodekit. Passing 0 for i returns the tail
          nodekit.

     int                 getLength() const
          Returns length of path chain (number of nodekits).

     void                truncate(int start)
          Truncates the path chain, removing all nodes from index start on.
          Calling truncate(0)  empties the path entirely.

     SbBool              containsNode(const SoNodeKit *nodeKit) const
          Returns TRUE if the passed nodekit is found anywhere in the path
          chain.

     int                 findFork(const SoNodeKitPath *path) const
          If the two paths have different head nodes, this returns -1.
          Otherwise, it returns the path chain index of the last nodekit
          (starting at the head) that is the same for both paths.

     friend int          operator ==(const SoNodeKitPath &p1, const
                              SoNodeKitPath &p2)
          Returns TRUE if all node pointers in the two nodekit path chains are
          equal.


SEE ALSO
     SoBaseKit, SoPath, SoRayPickAction, SoSearchAction