event_handlers.hpp

Go to the documentation of this file.

 
#pragma once
#include <ctime>
#include <functional>
 
#include "event.hpp"
 
#define _DERIVE_EVENT(T, FUNC_NAME) \
    inline void FUNC_NAME(std::function<void(T &, const Event &)> callback) { \
        Widget::FUNC_NAME([callback](Widget &widget, const Event &event) { callback(reinterpret_cast<T &>(widget), event); }); \
    } \
    inline void FUNC_NAME(std::function<void(T &)> callback) { \
        Widget::FUNC_NAME([callback](Widget &widget, const Event &) { callback(reinterpret_cast<T &>(widget)); }); \
    }
 
#define _DERIVE_EVENT_TIME(T, FUNC_NAME) \
    inline void FUNC_NAME(std::function<void(T &, const Event &, time_t)> callback) { \
        Widget::FUNC_NAME([callback](Widget &widget, const Event &event, time_t time) { callback(reinterpret_cast<T &>(widget), event, time); }); \
    } \
    inline void FUNC_NAME(std::function<void(T &, const Event &)> callback) { \
        Widget::FUNC_NAME([callback](Widget &widget, const Event &event, time_t) { callback(reinterpret_cast<T &>(widget), event); }); \
    } \
    inline void FUNC_NAME(std::function<void(T &, time_t)> callback) { \
        Widget::FUNC_NAME([callback](Widget &widget, const Event &, time_t time) { callback(reinterpret_cast<T &>(widget), time); }); \
    } \
    inline void FUNC_NAME(std::function<void(T &)> callback) { \
        Widget::FUNC_NAME([callback](Widget &widget, const Event &, time_t) { callback(reinterpret_cast<T &>(widget)); }); \
    }
 
#define DERIVE_EVENT_HANDLERS(T) \
    using Widget::onpress; \
    _DERIVE_EVENT(T, onpress) \
    using Widget::onrelease; \
    _DERIVE_EVENT(T, onrelease) \
    using Widget::onblur; \
    _DERIVE_EVENT(T, onblur) \
    using Widget::onclick; \
    _DERIVE_EVENT(T, onclick) \
    using Widget::onhold; \
    _DERIVE_EVENT_TIME(T, onhold)
 
namespace ui {
 
template <class T>
class CoreEventHandlers {
public:
    virtual void onpress(std::function<void(T &, const Event &)> callback) = 0;
 
    virtual void onrelease(std::function<void(T &, const Event &)> callback) = 0;
 
    virtual void onblur(std::function<void(T &, const Event &)> callback) = 0;
 
    virtual void onhold(std::function<void(T &, const Event &, time_t)> callback) = 0;
 
    inline void onclick(std::function<void(T &, const Event &)> callback) {
        onrelease(callback);
    }
};
 
template <class T>
class EventHandlers : public CoreEventHandlers<T> {
public:
    using CoreEventHandlers<T>::onpress;
    using CoreEventHandlers<T>::onrelease;
    using CoreEventHandlers<T>::onblur;
    using CoreEventHandlers<T>::onhold;
    using CoreEventHandlers<T>::onclick;
 
    inline void onpress(std::function<void(T &)> callback) {
        onpress([callback](T &widget, const Event &) { callback(widget); });
    }
 
    inline void onpress(std::function<void(const Event &)> callback) {
        onpress([callback](T &, const Event &event) { callback(event); });
    }
 
    inline void onpress(std::function<void()> callback) {
        onpress([callback](T &, const Event &) { callback(); });
    }
 
    inline void onrelease(std::function<void(T &)> callback) {
        onrelease([callback](T &widget, const Event &) { callback(widget); });
    }
 
    inline void onrelease(std::function<void(const Event &)> callback) {
        onrelease([callback](T &, const Event &event) { callback(event); });
    }
 
    inline void onrelease(std::function<void()> callback) {
        onrelease([callback](T &, const Event &) { callback(); });
    }
 
    inline void onblur(std::function<void(T &)> callback) {
        onblur([callback](T &widget, const Event &) { callback(widget); });
    }
 
    inline void onblur(std::function<void(const Event &)> callback) {
        onblur([callback](T &, const Event &event) { callback(event); });
    }
 
    inline void onblur(std::function<void()> callback) {
        onblur([callback](T &, const Event &) { callback(); });
    }
 
    inline void onhold(std::function<void(T &, time_t)> callback) {
        onhold([callback](T &widget, const Event &, time_t time) { callback(widget, time); });
    }
 
    inline void onhold(std::function<void(const Event &, time_t)> callback) {
        onhold([callback](T &, const Event &event, time_t time) { callback(event, time); });
    }
 
    inline void onhold(std::function<void(time_t)> callback) {
        onhold([callback](T &, const Event &, time_t time) { callback(time); });
    }
 
    inline void onhold(std::function<void(T &)> callback) {
        onhold([callback](T &widget, const Event &, time_t) { callback(widget); });
    }
 
    inline void onhold(std::function<void(const Event &)> callback) {
        onhold([callback](T &, const Event &event, time_t) { callback(event); });
    }
 
    inline void onhold(std::function<void()> callback) {
        onhold([callback](T &, const Event &, time_t) { callback(); });
    }
 
    inline void onclick(std::function<void(T &)> callback) {
        onclick([callback](T &widget, const Event &) { callback(widget); });
    }
 
    inline void onclick(std::function<void(const Event &)> callback) {
        onclick([callback](T &, const Event &event) { callback(event); });
    }
 
    inline void onclick(std::function<void()> callback) {
        onclick([callback](T &, const Event &) { callback(); });
    }
};
 
} // namespace ui