PDG_EventHandler.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * COMMENTS:
 */

#ifndef __PDG_EVENT_HANDLER_H__
#define __PDG_EVENT_HANDLER_H__

#include "PDG_API.h"

#include "PDG_EventTypes.h"
#include "PDG_RegisteredType.h"

#include <UT/UT_TBBSpinLock.h>

class PDG_Event;
class PDG_EventEmitter;

/*
 * Base class for an event handler that can be assigned to receive events from
 * a PDG_EventEmitter. Handlers are registered with the event queue associated
 * with the emitter.
 */
class PDG_API PDG_EventHandler
{
public:
    /// Constructs a new event handler. The handler keeps track of whether it
    /// was created by user code or internally by Houdini/TOPs/PDG, to make
    /// it possible for user to remove all "user created" handlers without
    /// accidentally removing ones created internally.
                            PDG_EventHandler(
                                PDG_BaseType::Language language=PDG_BaseType::eCpp,
                                bool user_handler=false);

    /// Destroys the handler and removes it from all active emitters, in case
    /// the emitter has outlived the life time of the handler
    virtual                 ~PDG_EventHandler();


    /// Removes the handler from all emitters current in its emitter set
    void                    removeFromAllEmitters();

    /// Returns the set of event emitters that this handler is currently
    /// attached to
    void                    emitters(PDG_EventEmitterSet& emitters) const;


    /// Returns the language that event handler is implemented in. Mostly used
    /// to distinguish between C++ event handler subclasses and ones created
    /// using the PDG Python API.
    PDG_BaseType::Language  language() const
                                { return myLanguage; }

    /// Returns true if this handler was created in user code
    bool                    isUserHandler() const
                                { return myIsUserHandler; }

protected:
    /// The main event handling hook, invoked by the event queue each time an
    /// event for this handler is dispatched. This method must be implemented
    /// by subclasses.
    virtual void            handlePDGEvent(const PDG_Event &) = 0;

    /// Invoke to indicate to subclasses that an emitter is no longer, an has
    /// been removed from the emitter set.
    virtual void            eventEmitterNotAvailable(PDG_EventEmitter *emitter)
                                {};

private:
    friend class PDG_EventQueue;

    void                    registerEventEmitter(PDG_EventEmitter *emitter);
    void                    unregisterEventEmitter(
                                PDG_EventEmitter *emitter,
                                bool notify);

private:
    mutable UT_TBBSpinLock  myEmittersLock;
    PDG_EventEmitterSet     myEmitters;
    PDG_BaseType::Language  myLanguage;
    bool                    myIsUserHandler;
};

#endif