SoEventCallback(3IV)

NAME
     SoEventCallback (SoEvCB) - node which invokes callbacks for events

INHERITS FROM
     SoBase > SoFieldContainer > SoNode > SoEventCallback

SYNOPSIS
     #include <Inventor_c/nodes/SoEventCallback.h>

     typedef void             SoEventCallbackCB(void *userData,
                                   SoEventCallback *node)
     typedef SoEventCallback  SoEvCB

          Functions from class SoEventCallback:

     SoType                 SoEvCBGetClassTypeId()
     SoEventCallback *      SoEvCBCreate()
     void                   SoEvCBSetPath(SoEvCB *this, SoPath *path)
     const SoPath *         SoEvCBGetPath(SoEvCB *this)
     void                   SoEvCBAddEvCB(SoEvCB *this, SoType eventType,
                                 SoEventCallbackCB *f, void *userData = NULL)
     void                   SoEvCBRemoveEvCB(SoEvCB *this, SoType eventType,
                                 SoEventCallbackCB *f, void *userData = NULL)
     SoHandleEventAction *  SoEvCBGetAct(const SoEvCB *this)
     const SoEvent *        SoEvCBGetEv(const SoEvCB *this)
     const SoPickedPoint *  SoEvCBGetPckPt(const SoEvCB *this)
     void                   SoEvCBSetHandled(SoEvCB *this)
     SbBool                 SoEvCBIsHandled(const SoEvCB *this)
     void                   SoEvCBGrabEv(SoEvCB *this)
     void                   SoEvCBReleaseEv(SoEvCB *this)

          Functions from class SoNode:

     void                SoEvCBSetOverride(SoEvCB *this, SbBool state)
     SbBool              SoEvCBIsOverride(const SoEvCB *this)
     SoNode *            SoEvCBCopy(const SoEvCB *this, SbBool copyConnections
                              = FALSE)
     SbBool              SoEvCBAffectsState(const SoEvCB *this)
     SoNode *            SoEvCBGetByName(const char *name)
     int                 SoEvCBGetByNameList(const char *name, SoNodeList
                              *list)

          Functions from class SoFieldContainer:

     void                SoEvCBSetToDflts(SoEvCB *this)
     SbBool              SoEvCBHasDfltVals(const SoEvCB *this)
     SbBool              SoEvCBFldsAreEq(const SoEvCB *this, const
                              SoFieldContainer *fc)
     void                SoEvCBCopyFieldVals(SoEvCB *this, const
                              SoFieldContainer *fc, SbBool copyConnections =
                              FALSE)

     SbBool              SoEvCBSet(SoEvCB *this, const char *fieldDataString)
     void                SoEvCBGet(SoEvCB *this, SbString *fieldDataString)
     int                 SoEvCBGetFields(const SoEvCB *this, SoFieldList
                              *resultList)
     SoField *           SoEvCBGetField(const SoEvCB *this, const char
                              *fieldName)
     SbBool              SoEvCBGetFieldName(const SoEvCB *this, const SoField
                              *field, SbName *fieldName)
     SbBool              SoEvCBIsNotifyEnabled(const SoEvCB *this)
     SbBool              SoEvCBEnableNotify(SoEvCB *this, SbBool flag)

          Functions from class SoBase:

     void                SoEvCBRef(SoEvCB *this)
     void                SoEvCBUnref(const SoEvCB *this)
     void                SoEvCBUnrefNoDelete(const SoEvCB *this)
     void                SoEvCBTouch(SoEvCB *this)
     SoType              SoEvCBGetTypeId(const SoEvCB *this)
     SbBool              SoEvCBIsOfType(const SoEvCB *this, SoType type)
     void                SoEvCBSetName(SoEvCB *this, const char *name)
     SbName              SoEvCBGetName(const SoEvCB *this)


DESCRIPTION
     SoEventCallback will invoke application supplied callback functions
     during SoHandleEventAction traversal. Methods allow the application to
     specify which Inventor events should trigger callbacks, and which path
     must be picked, if any, for the callback invocation to occur. The
     application callback is able to get information about the event and the
     pick detail, and may grab events, release events, and set whether the
     event was handled.

     If you register more than one callback function in an SoEventCallback
     node, all the callback functions will be invoked when an event occurs,
     even if one of the callbacks handles the event. However, if the event is
     handled by any of the callback functions, no other node in the scene
     graph will see the event.

FUNCTIONS
     SoType                 SoEvCBGetClassTypeId()
          Return the type id for the SoEventCallback class.

     SoEventCallback *      SoEvCBCreate()
          Constructor creates an event callback node with no event interest
          and a NULL path.

     void                   SoEvCBSetPath(SoEvCB *this, SoPath *path)
     const SoPath *         SoEvCBGetPath(SoEvCB *this)
          Set and get the path which must be picked in order for the callbacks
          to be invoked. If the path is NULL, the callbacks will be invoked
          for every interesting event, as specified by  SoEvCBAddEvCB(),
          regardless of what is picked. The SoEvCBSetPath() function makes its
          own copy of the passed path.

     void                   SoEvCBAddEvCB(SoEvCB *this, SoType eventType,
                                 SoEventCallbackCB *f, void *userData = NULL)
     void                   SoEvCBRemoveEvCB(SoEvCB *this, SoType eventType,
                                 SoEventCallbackCB *f, void *userData = NULL)
          Specifies the callback functions to be invoked for different event
          types. When invoked, the callback function will be passed the
          userData, along with a pointer to this SoEventCallback node. For
          example, passing  SoMouseEvGetClassTypeId() means callbacks will be
          invoked only when a mouse button is pressed or released. Passing
          SoEvGetClassTypeId() for the eventType will cause the callback to be
          invoked for every event which passes through this event callback
          node.

     SoHandleEventAction *  SoEvCBGetAct(const SoEvCB *this)
          Returns the SoHandleEventAction currently traversing this node, or
          NULL if traversal is not taking place. This should be called only
          from callback functions.

     const SoEvent *        SoEvCBGetEv(const SoEvCB *this)
          Returns the event currently being handled, or NULL if traversal is
          not taking place. This should be called only from callback
          functions.

     const SoPickedPoint *  SoEvCBGetPckPt(const SoEvCB *this)
          Returns pick information during SoHandleEventAction traversal, or
          NULL if traversal is not taking place. This should be called only
          from callback functions.

     void                   SoEvCBSetHandled(SoEvCB *this)
          Tells the node the event was handled. The callback function is
          responsible for setting whether the event was handled or not. If
          there is more than one callback function registered with an
          SoEventCallback node, all of them will be invoked, regardless of
          whether one has handled the event or not. This should be called only
          from callback functions.

     SbBool                 SoEvCBIsHandled(const SoEvCB *this)
          Returns whether the event has been handled. This should be called
          only from callback functions.

     void                   SoEvCBGrabEv(SoEvCB *this)
     void                   SoEvCBReleaseEv(SoEvCB *this)
          Tells the event callback node to grab events or release the grab.
          While grabbing, the node will consume all events; however, each
          callback function will only be invoked for events of interest.


FILE FORMAT/DEFAULTS
     EventCallback {
     }
SEE ALSO
     SoInteraction, SoSelection, SoHandleEventAction, SoDragger