PDG_EventEmitter.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_EMITTER_H__
#define __PDG_EVENT_EMITTER_H__

#include "PDG_API.h"

#include "PDG_EventTypes.h"

#include <UT/UT_NonCopyable.h>

class PDG_EventHandler;
class PDG_Event;
class PDG_EventQueue;

class PDG_API PDG_EventEmitter
{
public:
                            PDG_EventEmitter(
                                PDG_EventQueue* event_queue,
                                bool block_destruction);
    virtual                 ~PDG_EventEmitter();

                            UT_NON_COPYABLE(PDG_EventEmitter)

    /// Returns the list of supported event types for this emitter
    virtual const PDG_EventFilter&
                            supportedEventTypes() const = 0;

    /// Returns memory usage for this event emitter instance
    int64                   getMemoryUsage(bool inclusive) const;

    /// Adds an event handlers that listens for all types of events
    bool                    addEventHandler(PDG_EventHandler* handler);

    /// Adds an event handlers that listens for a specific event
    bool                    addEventHandler(
                                PDG_EventHandler* handler,
                                PDG_EventType event);

    /// Adds an event handler with a filter, so that it only listens for
    /// events in the specified list
    bool                    addEventHandler(
                                PDG_EventHandler* handler,
                                const PDG_EventFilter& filter);

    /// Removes an event handler from this emitter
    void                    removeEventHandler(PDG_EventHandler* handler);

    /// Removes all event handlers from this emitter. If user_handler_only
    /// is true, only user-added event handlers are removed.
    void                    removeAllEventHandlers(
                                bool user_handler_only = false);

    /// Emit an event to all handlers
    void                    emitEvent(
                                const PDG_Event& event,
                                bool immediate=false) const;

    /// Safely makes a copy of the list of handlers. If this emitter is
    /// currently being destroyed, the resulting array is empty
    void                    eventHandlers(
                                PDG_EventHandlerArray& handlers) const;

    /// Sets the event queue associated with this event emitter. This method
    /// will also register the emitter with the queue, and unregister it with
    /// the old queue. If the queue is being destroyed then the clearEventQueue
    /// method should be called instead
    void                    setEventQueue(PDG_EventQueue* event_queue);

    /// Clears the emitter's event queue without running any registration or
    /// deregistration logic
    void                    clearEventQueue();

    /// Returns true if the emitter should handle the specified event, and
    /// false if no handler is assigned for it
    bool                    shouldEmit(const PDG_Event& event) const;

private:
    friend class PDG_EventQueue;

    /// Returns a reference to the underlying filter map, which the event
    /// queue is allowed to modify
    PDG_EventFilterMap&     filterMap()
                                { return myFilterMap; }

private:
    static PDG_EventFilter  theAllFilter;
    static PDG_EventFilter  theLogFilter;

    PDG_EventQueue*         myEventQueue;
    PDG_EventFilterMap      myFilterMap;

    bool                    myHasHandlers;
    bool                    myWaitEventsWhenDestroyed;
};

#endif