EventSet.h

/***********************************************************************
    created:    21/2/2004
    author:     Paul D Turner

    purpose:    Defines class for a named collection of Event objects
*************************************************************************/
/***************************************************************************
 *   Copyright (C) 2004 - 2010 Paul D Turner & The CEGUI Development Team
 *
 *   Permission is hereby granted, free of charge, to any person obtaining
 *   a copy of this software and associated documentation files (the
 *   "Software"), to deal in the Software without restriction, including
 *   without limitation the rights to use, copy, modify, merge, publish,
 *   distribute, sublicense, and/or sell copies of the Software, and to
 *   permit persons to whom the Software is furnished to do so, subject to
 *   the following conditions:
 *
 *   The above copyright notice and this permission notice shall be
 *   included in all copies or substantial portions of the Software.
 *
 *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 *   IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 *   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 *   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 *   OTHER DEALINGS IN THE SOFTWARE.
 ***************************************************************************/
#ifndef _CEGUIEventSet_h_
#define _CEGUIEventSet_h_

#include "CEGUI/Base.h"
#include "CEGUI/String.h"
#include "CEGUI/Event.h"
#include "CEGUI/IteratorBase.h"
#include <map>

#if defined (_MSC_VER)
#   pragma warning(push)
#   pragma warning(disable : 4251 4521 4522)
#endif

// Start of CEGUI namespace section
namespace CEGUI
{
class CEGUIEXPORT EventSet
{
public:
    EventSet();

    virtual ~EventSet(void);

    void addEvent(const String& name);

    void addEvent(Event& event);

    void removeEvent(const String& name);

    void removeEvent(Event& event);

    void removeAllEvents(void);

    bool isEventPresent(const String& name);

    virtual Event::Connection subscribeEvent(const String& name,
                                             Event::Subscriber subscriber);

    virtual Event::Connection subscribeEvent(const String& name,
                                             Event::Group group,
                                             Event::Subscriber subscriber);

    template<typename Arg1, typename Arg2>
    inline Event::Connection subscribeEvent(const String& name, Arg1 arg1, Arg2 arg2)
    {
        return subscribeEvent(name, Event::Subscriber(arg1, arg2));
    }

    template<typename Arg1, typename Arg2>
    inline Event::Connection subscribeEvent(const String& name, Event::Group group, Arg1 arg1, Arg2 arg2)
    {
        return subscribeEvent(name, group, Event::Subscriber(arg1, arg2));
    }

    virtual Event::Connection subscribeScriptedEvent(const String& name,
                                                     const String& subscriber_name);

    virtual Event::Connection subscribeScriptedEvent(const String& name,
                                                     Event::Group group,
                                                     const String& subscriber_name);

    virtual void fireEvent(const String& name, EventArgs& args,
                           const String& eventNamespace = "");


    bool isMuted(void) const;

    void    setMutedState(bool setting);

    Event* getEventObject(const String& name, bool autoAdd = false);

protected:
    void fireEvent_impl(const String& name, EventArgs& args);
    ScriptModule* getScriptModule() const;

    // Do not allow copying, assignment, or any other usage than simple creation.
    EventSet(EventSet&) {} 
    EventSet(const EventSet&) {}
    EventSet& operator=(EventSet&) { return *this; } 
    EventSet& operator=(const EventSet&) { return *this; }

    typedef std::map<String, Event*, StringFastLessCompare
        CEGUI_MAP_ALLOC(String, Event*)> EventMap;
    EventMap    d_events;

    bool d_muted;    

public:
    /*************************************************************************
        Iterator stuff
    *************************************************************************/
    typedef ConstMapIterator<EventMap> EventIterator;

    EventIterator getEventIterator(void) const;
};

} // End of  CEGUI namespace section


#if defined(_MSC_VER)
#   pragma warning(pop)
#endif

#endif  // end of guard _CEGUIEventSet_h_