NAME

       SoNodeKitListPart — group node with restricted children

INHERITS FROM

       SoBase > SoFieldContainer > SoNode > SoNodeKitListPart

SYNOPSIS

       #include <Inventor/nodekits/SoNodeKitListPart.h>

          Methods from class SoNodeKitListPart:

                         SoNodeKitListPart()
     SoType              getContainerType() const
     void                setContainerType(SoType newContainerType )
     const SoTypeList &  getChildTypes() const
     void                addChildType(SoType typeToAdd )
     SbBool              isTypePermitted(SoType typeToCheck ) const
     SbBool              isChildPermitted(const SoNode *child ) const
     void                containerSet(const char *fieldDataString )
     void                lockTypes()
     SbBool              isTypeLocked() const
     void                addChild(SoNode *child )
     void                insertChild(SoNode *child, int childIndex )
     SoNode *            getChild(int index ) const
     int                 findChild(SoNode *child) const
     int                 getNumChildren() const
     void                removeChild(int index)
     void                removeChild(SoNode *child)
     void                replaceChild(int index, SoNode *newChild)
     void                replaceChild(SoNode *oldChild, SoNode *newChild)
     static SoType       getClassTypeId()

          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 =
                              FALSE)
     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

DESCRIPTION

       This node class  is  very  similar  to  SoGroup  with  the  exception  that  it  specifies
       restrictions  on  the  type of children that it allows. It is used by nodekits to restrict
       child types within list parts (see the reference page for SoBaseKit).

       By default, any kind of child may be added. Methods of this class allow  you  to  restrict
       the  type  of allowable children, and to lock down the types so that this type list may no
       longer be altered.

       Inside the SoNodeKitListPart is a container node, which in turn contains the children. The
       container  node  is  a  hidden  child,  and  the  type  of  node  used  may  be  set  with
       setContainerType(). In this way, you can make the  nodekitlist  behave  like  a  group,  a
       separator,  or  any  other  subclass of group. The container is not accessible so that the
       nodekitlist may retain control over what kinds of children are added.

METHODS

                         SoNodeKitListPart()
          Constructor.

     SoType              getContainerType() const
     void                setContainerType(SoType newContainerType )
          Gets and sets the type of node used as the container.

     const SoTypeList &  getChildTypes() const
          Returns the permitted child node types. By default, any type of node is  permitted,  so
          the list contains one entry of type SoNode.

     void                addChildType(SoType typeToAdd )
          Permits the node type typeToAdd as a child. The first time the addChildType() method is
          called, the default of SoNode is overridden and only the new typeToAdd is permitted. In
          subsequent calls to addChildType(), the typeToAdd is added to the existing types.

     SbBool              isTypePermitted(SoType typeToCheck ) const
          Returns whether a node of type typeToCheck may be added as a child.

     SbBool              isChildPermitted(const SoNode *child ) const
          Returns  whether the node child may be added to this list. This will return TRUE if the
          type of child is one of the permissible child types.

     void                containerSet(const char *fieldDataString )
          Sends a string to the set() method on the container node. This is how you can  set  the
          value of a switch node if the container node is an SoSwitch, for example.

     void                lockTypes()
          This  function  permanently  locks  the  permitted  child  types and the container type
          permanently. Calls to setContainerType() and addChildType() will have no  effect  after
          this function is called.

     SbBool              isTypeLocked() const
          Returns  whether  the  permitted  child  types  and the container type are locked (i.e.
          cannot be changed). See lockTypes()

     void                addChild(SoNode *child )
     void                insertChild(SoNode *child, int childIndex )
     SoNode *            getChild(int index ) const
     int                 findChild(SoNode *child) const
     int                 getNumChildren() const
     void                removeChild(int index)
     void                removeChild(SoNode *child)
     void                replaceChild(int index, SoNode *newChild)
     void                replaceChild(SoNode *oldChild, SoNode *newChild)
          These are the functions used to edit the children.  They  parallel  those  of  SoGroup,
          except  that they always check the child types against those which are permissible. See
          SoGroup for details.

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

FILE FORMAT/DEFAULTS

       NodeKitListPart {
          containerTypeName  "Group"
          childTypeNames     ""
          containerNode      NULL
     }

SEE ALSO

       SoBaseKit,  SoNodeKit,  SoNodeKitDetail,  SoNodeKitPath,   SoNodekitCatalog,   SoSceneKit,
       SoSeparatorKit, SoShapeKit, SoWrapperKit

                                                                         SoNodeKitListPart(3IV)()