event.h

Go to the documentation of this file.

/*
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef OMGUI_EVENT_H
#define OMGUI_EVENT_H

#include <omgui/dllimpexp.h>
#include <omgui/event-id.h>
#include <omgui/types.h>

#include <map>
#include <list>
#include <queue>

namespace omgui {

class Event;
class ConnectionBody;
class ConnectionImpl;

const event_id EVENT_ID_ANY = 0;

class OMGUI_API SlotBase : public RefCounted
{
public:
    virtual ~SlotBase() { }

    virtual bool operator() (const Event &e) = 0;
};

template<typename E> class PointerSlot : public SlotBase
{
public:
    typedef E event_type;
    typedef bool(*function_type)(const event_type&);

    PointerSlot(const function_type& f): func(f) { }

    bool operator() (const Event &e) {
        return func(dynamic_cast<const event_type&>(e));    
    }

private:
    function_type func;
};

template<typename E, typename T> class MemberSlot : public SlotBase
{
public:
    typedef E event_type;
    typedef bool(T::*function_type)(const event_type &e);

    MemberSlot(const function_type &function, T &t): func(function), instance(t) { }

    bool operator() (const Event &e) {
        return (instance.*func)(dynamic_cast<const event_type&>(e));
    }

private:
    function_type func;
    T &instance;
};

template<typename E, typename T> class ConstMemberSlot : public SlotBase
{
public:
    typedef E event_type;
    typedef bool(T::*function_type)(const event_type &e) const;

    ConstMemberSlot(const function_type &function, T &t): func(function), instance(t) { }

    bool operator() (const Event &e) {
        return (instance.*func)(dynamic_cast<const event_type&>(e));
    }

private:
    function_type func;
    T &instance;
};

template<typename E, typename F> class FunctorSlot : public SlotBase
{
public:
    typedef E event_type;
    typedef F function_type;

    FunctorSlot(const function_type& f): func(f) { }

    bool operator() (const Event &e) {
        return func(dynamic_cast<const event_type&>(e));
    }

private:
    function_type func;
};

class OMGUI_API Connection
{
public:
    Connection();
    ~Connection();

    void disconnect();

    bool connected() const;

    void block(bool b = true);

    void unblock() { block(false); }

    bool blocked() const;

private:
    Connection(const Pointer<ConnectionBody> &body);

    Pointer<ConnectionBody> body;

    friend class Signal;
};

class ConnectionBody : public RefCounted
{
public:
    virtual ~ConnectionBody() { }

    virtual void disconnect() = 0;

    virtual bool connected() const = 0;

    virtual void block(bool) = 0;

    virtual bool blocked() const = 0;
};

class OMGUI_API Signal
{
public:
    typedef Pointer<SlotBase> slot_type;

    Signal();

    ~Signal();

    Connection connect(const slot_type &slot);

    bool operator() (const Event&);

    void disconnect_all();

private:
    friend class ConnectionImpl;
    typedef std::list< Pointer<ConnectionImpl> > Slots;
    typedef std::queue<Slots::iterator> DisconnectedSlots;

    void disconnect(const Slots::iterator &it);

    Slots slots;
    DisconnectedSlots disconnected_slots;
    int signaling_;
};

class ConnectionImpl : public ConnectionBody
{
public:
    ConnectionImpl(Signal &signal, Signal::slot_type slot);

    void set_iterator(const Signal::Slots::iterator &it);

    void disconnect();

    bool connected() const;

    void block(bool b = true);
    bool blocked() const;

    SlotBase &get_slot() const;

    bool operator==(const ConnectionImpl &other) const;

private:
    enum {
        CONNECTED = 1,
        BLOCKED = 2,
    };

    int state_;
    Signal::slot_type slot_;
    Signal &signal_;
    Signal::Slots::iterator it_;
};

const int SIGNAL_PRIORITY_RUN_FIRST = 1;
const int SIGNAL_PRIORITY_HIGHER = 9;
const int SIGNAL_PRIORITY_NORMAL = 10;
const int SIGNAL_PRIORITY_LOWER = 11;
const int SIGNAL_PRIORITY_RUN_LAST = 20;

class OMGUI_API EventManager
{
public:
    static Connection connect(object_id object, event_id event, SlotBase* slot, int priority = SIGNAL_PRIORITY_NORMAL);

    static void disconnect_all(object_id object);

    static bool send_event(const Event &event);

    static void disconnect_all();

private:
    typedef std::map<event_id, Signal> EventSignals;
    typedef std::map<object_id, EventSignals> ObjectEventSignals;

    struct SignalsGroup
    {
        // Signals raised on any event from any object
        //Signal signals;
        //EventSignals event_signals;
        ObjectEventSignals object_event_signals;

        void disconnect_all()
        {
            //signals.disconnect_all();
            //event_signals.clear();
            object_event_signals.clear();
        }
    };

    typedef std::map<int, SignalsGroup> Signals;
    static Signals signals;
    static int sending_event;
    struct ObjectEventEraseBufferData
    {
        ObjectEventEraseBufferData(ObjectEventSignals &container, ObjectEventSignals::iterator iterator): container(container), iterator(iterator) { }
        ObjectEventSignals &container;
        ObjectEventSignals::iterator iterator;
    };
    static std::deque<ObjectEventEraseBufferData> object_event_erase_buffer;

    static bool send_event(SignalsGroup &group, const Event &event, bool &processed);
};

template<typename E> 
SlotBase *make_slot(typename PointerSlot<E>::function_type const &func)
{
    return new PointerSlot<E>(func);
}

template<typename E, typename T>
SlotBase *make_slot(typename MemberSlot<E,T>::function_type func, T &instance)
{
    return new MemberSlot<E, T>(func, instance);
}

template<typename E, typename T>
SlotBase *make_slot(typename ConstMemberSlot<E,T>::function_type func, T &instance)
{
    return new ConstMemberSlot<E, T>(func, instance);
}

template<typename E, typename Functor> 
SlotBase *make_slot(const Functor &func)
{
    return new FunctorSlot<E, Functor>(func);
}

/*******************************************
 *       Event Object Declarations         *
 *******************************************/

class OMGUI_API Event
{
public:
    Event(event_id id, object_id obj);

    Event(const Event &other);

    virtual ~Event();

    event_id get_id() const;

    object_id get_object_id() const;

    void veto(bool v = true) const;

    bool get_veto() const;

    virtual bool can_veto() const;

private:
    const event_id m_id;
    const object_id m_obj_id;
    mutable bool m_veto;
};

class OMGUI_API MouseEvent : public Event
{
public:
    MouseEvent(event_id id, object_id obj, const omgui::Point &pos, int button_flags, int key_flags);
    MouseEvent(const MouseEvent &other);

    enum KEY_FLAGS {
        NONE =      0x0,
        SHIFT =     0x1,
        ALT =       0x2,
        CONTROL =   0x4,
    };

    enum BUTTON_FLAGS {
        LEFT =      0x1,
        RIGHT =     0x2,
        MIDDLE =    0x4
    };

    int get_button_flags() const;

    bool get_button_state(BUTTON_FLAGS button) const;

    int get_key_flags() const;

    bool get_key_state(KEY_FLAGS key) const;

    omgui::Point get_position() const;

private:
    omgui::Point m_position;

    int m_button_flags;

    int m_key_flags;
};

class WindowCloseEvent : public Event
{
public:
    WindowCloseEvent(event_id id, object_id obj, bool vetoable = true);
    WindowCloseEvent(const WindowCloseEvent &other);

    bool can_veto() const;

private:
    bool m_vetoable;
};

class NotebookEvent : public Event
{
public:
    NotebookEvent(event_id id, object_id obj, omgui::NotebookPage current_page);
    NotebookEvent(const NotebookEvent &other);

    omgui::NotebookPage get_current_page() const;

    bool can_veto() const;

private:
    omgui::NotebookPage m_current_page;
};

class MenuEvent : public Event
{
public:
    MenuEvent(event_id e_id, object_id obj, menu_id m_id);

    menu_id get_menu_id() const;

protected:
    menu_id m_menu_id;
};

} // omgui

#endif // OMGUI_EVENT_H

---