SoMFBitMask(3IV)

NAME
     SoMFBitMask (SoMBitMask) - multiple-value field containing any number of
     masks of bit flags

INHERITS FROM
     SoField > SoMField > SoMFEnum > SoMFBitMask

SYNOPSIS
     #include <Inventor_c/fields/SoMFBitMask.h>

     typedef SoMFBitMask  SoMBitMask

          Functions from class SoMFBitMask:

     SoType              SoMBitMaskGetClassTypeId()
     void                SoMBitMaskGetTypeId(const SoMBitMask *this)
     int                 SoMBitMaskGet(const SoMBitMask *this, int i)
     const int *         SoMBitMaskGetN(const SoMBitMask *this, int start)
     int                 SoMBitMaskFind(SoMBitMask *this, int targetValue,
                              SbBool addIfNotFound = FALSE)
     void                SoMBitMaskSetN(SoMBitMask *this, int start, int num,
                              const int *newValues)
     void                SoMBitMaskSet1(SoMBitMask *this, int index, int
                              newValue)
     void                SoMBitMaskSet(SoMBitMask *this, int newValue)
     int                 SoMBitMaskIsEq(const SoMBitMask *this, const
                              SoMFBitMask *f)
     int                 SoMBitMaskIsNEq(const SoMBitMask *this, const
                              SoMFBitMask *f)
     int *               SoMBitMaskStartEdit(SoMBitMask *this)
     void                SoMBitMaskFinishEdit(SoMBitMask *this)

          Functions from class SoMFEnum:

     void                SoMBitMaskSetStr(SoMBitMask *this, const char *name)
     void                SoMBitMaskSet1Str(SoMBitMask *this, int index, const
                              char *name)

          Functions from class SoMField:

     int                 SoMBitMaskGetNum(const SoMBitMask *this)
     void                SoMBitMaskSetNum(SoMBitMask *this, int num)
     void                SoMBitMaskDel(SoMBitMask *this, int start, int num =
                              -1)
     void                SoMBitMaskInsertSpace(SoMBitMask *this, int start,
                              int num)
     void                SoMBitMaskGet1(SoMBitMask *this, int index, SbString
                              *valueString)

          Functions from class SoField:

     void                SoMBitMaskSetIgnored(SoMBitMask *this, SbBool ignore)
     SbBool              SoMBitMaskIsIgnored(const SoMBitMask *this)
     SbBool              SoMBitMaskIsDflt(const SoMBitMask *this)
     SbBool              SoMBitMaskIsOfType(const SoMBitMask *this, SoType
                              type)
     SbBool              SoMBitMaskSetFromStr(SoMBitMask *this, const char
                              *valueString)
     void                SoMBitMaskGetIntoStr(SoMBitMask *this, SbString
                              *valueString)
     void                SoMBitMaskTouch(SoMBitMask *this)
     SbBool              SoMBitMaskConnFromField(SoMBitMask *this, SoField
                              *fromField)
     SbBool              SoMBitMaskConnFrom(SoMBitMask *this, SoEngineOutput
                              *fromEngine)
     void                SoMBitMaskDisconn(SoMBitMask *this)
     SbBool              SoMBitMaskIsConn(const SoMBitMask *this)
     SbBool              SoMBitMaskIsConnFromField(const SoMBitMask *this)
     SbBool              SoMBitMaskGetConnField(const SoMBitMask *this,
                              SoField **writingField)
     SbBool              SoMBitMaskIsConnFromEngine(const SoMBitMask *this)
     SbBool              SoMBitMaskGetConnEngine(const SoMBitMask *this,
                              SoEngineOutput **engineOutput)
     void                SoMBitMaskEnableConn(SoMBitMask *this, SbBool flag)
     SbBool              SoMBitMaskIsConnEnabled(const SoMBitMask *this)
     int                 SoMBitMaskGetForwardConn(const SoMBitMask *this,
                              SoFieldList *list)
     SoFieldContainer *  SoMBitMaskGetContainer(const SoMBitMask *this)


DESCRIPTION
     A multiple-value field that contains any number of masks of bit flags,
     stored as ints. Nodes or engines that use this field class define
     mnemonic names for the bit flags. These names should be used when setting
     or testing the values of the field, even though the values are treated as
     integers in the methods.

     The bit-wise "&" and "|" operators should be used when testing and
     setting flags in a mask.

     SoMFBitMasks are written to file as one or more mnemonic enumerated type
     names, in this format:

          ( flag1 | flag2 | ... )

     If only one flag is used in a mask, the parentheses are optional. These
     names differ among uses of this field in various node or engine classes.
     See the reference pages for specific nodes or engines for the names.

     The field values may also be represented as integers, but this is not
     guaranteed to be portable.

     When more than one value is present, all of the values are enclosed in
     square brackets and separated by commas.

FUNCTIONS
     SoType              SoMBitMaskGetClassTypeId()
     void                SoMBitMaskGetTypeId(const SoMBitMask *this)
          Returns the type for this class or a particular object of this
          class.

     int                 SoMBitMaskGet(const SoMBitMask *this, int i)
          Returns the i'th value of the field. Indexing past the end of the
          field (passing in i greater than getNum()) will return garbage.

     const int *         SoMBitMaskGetN(const SoMBitMask *this, int start)
          Returns a pointer into the array of values in the field, starting at
          index start. The values are read-only; see the
          startEditing()/finishEditing() methods for a way of modifying values
          in place.

     int                 SoMBitMaskFind(SoMBitMask *this, int targetValue,
                              SbBool addIfNotFound = FALSE)
          Finds the given value in the array and returns the index of that
          value in the array. If the value is not found, -1 is returned. If
          addIfNotFound is set, then targetValue is added to the end of the
          array (but -1 is still returned).

     void                SoMBitMaskSetN(SoMBitMask *this, int start, int num,
                              const int *newValues)
          Sets num values starting at index start to the values in newValues.
          The array will be automatically be made larger to accomodate the new
          values, if necessary.

     void                SoMBitMaskSet1(SoMBitMask *this, int index, int
                              newValue)
          Sets the index'th value in the array to newValue. The array will be
          automatically expanded, if necessary.

     void                SoMBitMaskSet(SoMBitMask *this, int newValue)
          Sets the first value in the array to newValue, and deletes the
          second and subsequent values.

     int                 SoMBitMaskIsEq(const SoMBitMask *this, const
                              SoMFBitMask *f)
     int                 SoMBitMaskIsNEq(const SoMBitMask *this, const
                              SoMFBitMask *f)
          Returns TRUE if all of the values of this field equal (do not equal)
          those of the given field. If the fields are different types FALSE
          will always be returned (even if one field is an SoMFFloat with one
          value of 1.0 and the other is an SoMFInt with a value of 1, for
          example).

     int *               SoMBitMaskStartEdit(SoMBitMask *this)

     void                SoMBitMaskFinishEdit(SoMBitMask *this)
          startEditing() returns a pointer to the internally-maintained array
          that can be modified. The values in the array may be changed, but
          values cannot be added or removed. It is illegal to call any other
          editing methods between StartEdit() and FinishEdit() (e.g. Set1(),
          Set(), etc).

          Fields, engines or sensors connected to this field and sensors are
          not notified that this field has changed until FinishEdit() is
          called. Calling FinishEdit() always sets the IsDflt flag to FALSE
          and informs engines and sensors that the field changed, even if none
          of the values actually were changed.