ofxListenerUtils

ofxListenerUtils.h

//
//  ofxListenerUtils.h
//
//  Created by ISHII 2bit on 2017/03/04.
//
//

#pragma once

#ifndef ofxListenerUtils_h
#define ofxListenerUtils_h

#include <type_traits>
#include "ofEvents.h"
#include "ofLog.h"

#define define_has_method(methodName, Arguments)\
namespace ofx {\
    namespace detail {\
        template <typename T>\
        struct has_ ## methodName ## _method {\
            template <typename U, void(U::*)(Arguments &)> struct checker;\
            template <typename U>\
            static std::true_type test(checker<U, &U::methodName> *);\
            template <typename U>\
            static std::false_type test(...);\
            static constexpr bool value = decltype(test<T>(nullptr))::value;\
        };\
        template <typename T>\
        struct has_plain_ ## methodName ## _method {\
            template <typename U, void(U::*)()> struct checker;\
            template <typename U>\
            static std::true_type test(checker<U, &U::methodName> *);\
            template <typename U>\
            static std::false_type test(...);\
            static constexpr bool value = decltype(test<T>(nullptr))::value;\
        };\
    };\
};

#define enabler(method, T) typename std::enable_if<ofx::detail::has_ ## method ## _method<T>::value>::type
#define disabler(method, T) typename std::enable_if<!ofx::detail::has_ ## method ## _method<T>::value>::type

#define define_ofxAddListeners(method, Method, Arguments)\
define_has_method(method, Arguments);\
template <typename T>\
auto ofxAdd ## Method ## Listener(T &t, ofEventOrder order = OF_EVENT_ORDER_AFTER_APP)\
-> enabler(method, T) {\
    ofAddListener(ofEvents().method, &t, &T::method, order);\
}\
template <typename T>\
auto ofxAdd ## Method ## Listener(T *t, ofEventOrder order = OF_EVENT_ORDER_AFTER_APP)\
-> enabler(method, T) {\
    ofAddListener(ofEvents().method, t, &T::method, order);\
}\
template <typename T>\
auto ofxAdd ## Method ## Listener(T t, ofEventOrder order = OF_EVENT_ORDER_AFTER_APP)\
-> disabler(method, typename std::remove_pointer<T>::type) {\
    ofLogNotice("ofxListenerUtils") << (#method " is not defined.");\
}\
template <typename T>\
auto ofxRemove ## Method ## Listener(T &t, ofEventOrder order = OF_EVENT_ORDER_AFTER_APP)\
-> enabler(method, T) {\
    ofRemoveListener(ofEvents().method, &t, &T::method, order);\
}\
template <typename T>\
auto ofxRemove ## Method ## Listener(T *t, ofEventOrder order = OF_EVENT_ORDER_AFTER_APP)\
-> enabler(method, T) {\
    ofRemoveListener(ofEvents().method, t, &T::method, order);\
}\
template <typename T>\
auto ofxRemove ## Method ## Listener(T t, ofEventOrder order = OF_EVENT_ORDER_AFTER_APP)\
-> disabler(method, typename std::remove_pointer<T>::type) {\
    ofLogNotice("ofxListenerUtils") << (#method " is not defined.");\
}

define_ofxAddListeners(setup, Setup, ofEventArgs);
define_ofxAddListeners(update, Update, ofEventArgs);
define_ofxAddListeners(draw, Draw, ofEventArgs);
define_ofxAddListeners(exit, Exit, ofEventArgs);

define_ofxAddListeners(windowResized, WindowResized, ofResizeEventArgs);

define_ofxAddListeners(keyPressed, KeyPressed, ofKeyEventArgs);
define_ofxAddListeners(keyReleased, KeyReleased, ofKeyEventArgs);

define_ofxAddListeners(mouseMoved, MouseMoved, ofMouseEventArgs);
define_ofxAddListeners(mouseDragged, MouseDragged, ofMouseEventArgs);
define_ofxAddListeners(mousePressed, MousePressed, ofMouseEventArgs);
define_ofxAddListeners(mouseReleased, MouseReleased, ofMouseEventArgs);
define_ofxAddListeners(mouseScrolled, MouseScrolled, ofMouseEventArgs);
define_ofxAddListeners(mouseEntered, MouseEntered, ofMouseEventArgs);
define_ofxAddListeners(mouseExited, MouseExited, ofMouseEventArgs);

define_ofxAddListeners(touchDown, TouchDown, ofTouchEventArgs);
define_ofxAddListeners(touchUp, TouchUp, ofTouchEventArgs);
define_ofxAddListeners(touchMoved, TouchMoved, ofTouchEventArgs);
define_ofxAddListeners(touchDoubleTap, TouchDoubleTap, ofTouchEventArgs);
define_ofxAddListeners(touchCancelled, TouchCancelled, ofTouchEventArgs);

define_ofxAddListeners(messageEvent, MessageEvent, ofMessage);
define_ofxAddListeners(fileDragEvent, FileDragEvent, ofDragInfo);

#undef enabler
#undef disabler
#undef define_addListener
#undef define_has_method

// Add

template <typename T>
void ofxAddLoopEventListeners(T &t, ofEventOrder order = OF_EVENT_ORDER_AFTER_APP) {
    ofxAddSetupListener(t, order);
    ofxAddUpdateListener(t, order);
    ofxAddDrawListener(t, order);
    ofxAddExitListener(t, order);
}

template <typename T>
void ofxAddKeyEventListeners(T &t, ofEventOrder order = OF_EVENT_ORDER_AFTER_APP) {
    ofxAddKeyPressedListener(t, order);
    ofxAddKeyReleasedListener(t, order);
}

template <typename T>
void ofxAddMouseEventListeners(T &t, ofEventOrder order = OF_EVENT_ORDER_AFTER_APP) {
    ofxAddMouseMovedListener(t, order);
    ofxAddMouseDraggedListener(t, order);
    ofxAddMousePressedListener(t, order);
    ofxAddMouseReleasedListener(t, order);
    ofxAddMouseScrolledListener(t, order);
    ofxAddMouseEnteredListener(t, order);
    ofxAddMouseExitedListener(t, order);
}

template <typename T>
void ofxAddTouchEventListeners(T &t, ofEventOrder order = OF_EVENT_ORDER_AFTER_APP) {
    ofxAddTouchDownListener(t, order);
    ofxAddTouchUpListener(t, order);
    ofxAddTouchMovedListener(t, order);
    ofxAddTouchDoubleTapListener(t, order);
    ofxAddTouchCancelledListener(t, order);
}

template <typename T>
void ofxAddCoreEventListeners(T &t, ofEventOrder order = OF_EVENT_ORDER_AFTER_APP) {
    ofxAddLoopEventListeners(t, order);
    ofxAddKeyEventListeners(t, order);
    ofxAddMouseMovedListener(t, order);
    ofxAddTouchEventListeners(t, order);
    
    ofxAddWindowResizedListener(t, order);
    ofxAddMessageEventListener(t, order);
    ofxAddFileDragEventListener(t, order);
}

// Register (alias of Add)

template <typename T>
void ofxRegisterLoopEvents(T &t, ofEventOrder order = OF_EVENT_ORDER_AFTER_APP) {
    ofxAddLoopEventListeners(t, order);
}

template <typename T>
void ofxRegisterKeyEvents(T &t, ofEventOrder order = OF_EVENT_ORDER_AFTER_APP) {
    ofxAddKeyEventListeners(t, order);
}

template <typename T>
void ofxRegisterMouseEvents(T &t, ofEventOrder order = OF_EVENT_ORDER_AFTER_APP) {
    ofxAddMouseEventListener(t, order);
}

template <typename T>
void ofxRegisterTouchEvents(T &t, ofEventOrder order = OF_EVENT_ORDER_AFTER_APP) {
    ofxAddTouchEventListeners(t, order);
}

// Remove

template <typename T>
void ofxRemoveLoopEventListeners(T &t, ofEventOrder order = OF_EVENT_ORDER_AFTER_APP) {
    ofxRemoveSetupListener(t, order);
    ofxRemoveUpdateListener(t, order);
    ofxRemoveDrawListener(t, order);
    ofxRemoveExitListener(t, order);
}

template <typename T>
void ofxRemoveKeyEventListeners(T &t, ofEventOrder order = OF_EVENT_ORDER_AFTER_APP) {
    ofxRemoveKeyPressedListener(t, order);
    ofxRemoveKeyReleasedListener(t, order);
}

template <typename T>
void ofxRemoveMouseEventListeners(T &t, ofEventOrder order = OF_EVENT_ORDER_AFTER_APP) {
    ofxRemoveMouseMovedListener(t, order);
    ofxRemoveMouseDraggedListener(t, order);
    ofxRemoveMousePressedListener(t, order);
    ofxRemoveMouseReleasedListener(t, order);
    ofxRemoveMouseScrolledListener(t, order);
    ofxRemoveMouseEnteredListener(t, order);
    ofxRemoveMouseExitedListener(t, order);
}

template <typename T>
void ofxRemoveTouchEventListeners(T &t, ofEventOrder order = OF_EVENT_ORDER_AFTER_APP) {
    ofxRemoveTouchDownListener(t, order);
    ofxRemoveTouchUpListener(t, order);
    ofxRemoveTouchMovedListener(t, order);
    ofxRemoveTouchDoubleTapListener(t, order);
    ofxRemoveTouchCancelledListener(t, order);
}

template <typename T>
void ofxRemoveCoreEventListeners(T &t, ofEventOrder order = OF_EVENT_ORDER_AFTER_APP) {
    ofxRemoveLoopEventListeners(t, order);
    ofxRemoveKeyEventListeners(t, order);
    ofxRemoveMouseMovedListener(t, order);
    ofxRemoveTouchEventListeners(t, order);
    
    ofxRemoveWindowResizedListener(t, order);
    ofxRemoveMessageEventListener(t, order);
    ofxRemoveFileDragEventListener(t, order);
}

// Unregister (alias of Remove)

template <typename T>
void ofxUnregisterLoopEvents(T &t, ofEventOrder order = OF_EVENT_ORDER_AFTER_APP) {
    ofxRemoveLoopEventListeners(t, order);
}

template <typename T>
void ofxUnregisterKeyEvents(T &t, ofEventOrder order = OF_EVENT_ORDER_AFTER_APP) {
    ofxRemoveKeyEventListeners(t, order);
}

template <typename T>
void ofxUnregisterMouseEvents(T &t, ofEventOrder order = OF_EVENT_ORDER_AFTER_APP) {
    ofxRemoveMouseEventListener(t, order);
}

template <typename T>
void ofxUnregisterTouchEvents(T &t, ofEventOrder order = OF_EVENT_ORDER_AFTER_APP) {
    ofxRemoveTouchEventListeners(t, order);
}


#endif /* ofxListenerUtils_h */