event.h

/* -*- mode: C; c-basic-offset: 4; intent-tabs-mode: nil -*-
 *
 * Sifteo SDK
 *
 * Copyright <c> 2012 Sifteo, Inc.
 *
 * 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 OR COPYRIGHT HOLDERS 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.
 */

#pragma once
#ifdef NOT_USERSPACE
#   error This is a userspace-only header, not allowed by the current build.
#endif

#include <sifteo/abi.h>

namespace Sifteo {


template <_SYSVectorID tID>
struct EventVector {
    EventVector() {}

    void unset() const {
        _SYS_setVector(tID, 0, 0);
    }

    template <typename tContext>
    void set(void (*handler)(tContext, unsigned), tContext context) const {
        _SYS_setVector(tID, (void*) handler, reinterpret_cast<void*>(context));
    }

    void set(void (*handler)(void*, unsigned)) const {
        _SYS_setVector(tID, (void*) handler, 0);
    }

    template <typename tClass>
    void set(void (tClass::*handler)(unsigned), tClass *cls) const {
        union {
            void *pVoid;
            void (tClass::*pMethod)(unsigned);
        } u;
        u.pMethod = handler;
        _SYS_setVector(tID, u.pVoid, (void*) cls);
    }

    void *handler() const {
        return _SYS_getVectorHandler(tID);
    }

    void *context() const {
        return _SYS_getVectorContext(tID);
    }
};


template <_SYSVectorID tID>
struct NullaryEventVector {
    NullaryEventVector() {}

    void unset() const {
        _SYS_setVector(tID, 0, 0);
    }

    template <typename tContext>
    void set(void (*handler)(tContext), tContext context) const {
        _SYS_setVector(tID, (void*) handler, reinterpret_cast<void*>(context));
    }

    void set(void (*handler)()) const {
        _SYS_setVector(tID, (void*) handler, 0);
    }

    template <typename tClass>
    void set(void (tClass::*handler)(), tClass *cls) const {
        union {
            void *pVoid;
            void (tClass::*pMethod)();
        } u;
        u.pMethod = handler;
        _SYS_setVector(tID, u.pVoid, (void*) cls);
    }

    void *handler() const {
        return _SYS_getVectorHandler(tID);
    }

    void *context() const {
        return _SYS_getVectorContext(tID);
    }
};


struct GameMenuEventVector {
    GameMenuEventVector() {}

    void unset() const {
        _SYS_setGameMenuLabel(0);
        _SYS_setVector(_SYS_BASE_GAME_MENU, 0, 0);
    }

    template <typename tContext>
    void set(void (*handler)(tContext), tContext context, const char *label=0) const {
        if (label)
            _SYS_setGameMenuLabel(label);
        _SYS_setVector(_SYS_BASE_GAME_MENU, (void*) handler, reinterpret_cast<void*>(context));
    }

    void set(void (*handler)(void*), const char *label=0) const {
        if (label)
            _SYS_setGameMenuLabel(label);
        _SYS_setVector(_SYS_BASE_GAME_MENU, (void*) handler, 0);
    }

    template <typename tClass>
    void set(void (tClass::*handler)(), tClass *cls, const char *label=0) const {
        union {
            void *pVoid;
            void (tClass::*pMethod)();
        } u;
        u.pMethod = handler;
        if (label)
            _SYS_setGameMenuLabel(label);
        _SYS_setVector(_SYS_BASE_GAME_MENU, u.pVoid, (void*) cls);
    }

    void *handler() const {
        return _SYS_getVectorHandler(_SYS_BASE_GAME_MENU);
    }

    void *context() const {
        return _SYS_getVectorContext(_SYS_BASE_GAME_MENU);
    }

    void setLabel(const char *label) const {
        ASSERT(label && label[0]);
        _SYS_setGameMenuLabel(label);
    }

    void setResumeEnabled(bool enabled) const {
        _SYS_setPauseMenuResumeEnabled(enabled);
    }
};


template <_SYSVectorID tID>
struct NeighborEventVector {
    NeighborEventVector() {}

    void unset() const {
        _SYS_setVector(tID, 0, 0);
    }

    template <typename tContext>
    void set(void (*handler)(tContext, unsigned, unsigned, unsigned, unsigned), tContext context) const {
        _SYS_setVector(tID, (void*) handler, reinterpret_cast<void*>(context));
    }

    void set(void (*handler)(void*, unsigned, unsigned, unsigned, unsigned)) const {
        _SYS_setVector(tID, (void*) handler, 0);
    }

    template <typename tClass>
    void set(void (tClass::*handler)(unsigned, unsigned, unsigned, unsigned), tClass *cls) const {
        union {
            void *pVoid;
            void (tClass::*pMethod)(unsigned, unsigned, unsigned, unsigned);
        } u;
        u.pMethod = handler;
        _SYS_setVector(tID, u.pVoid, (void*) cls);
    }

    void *handler() const {
        return _SYS_getVectorHandler(tID);
    }

    void *context() const {
        return _SYS_getVectorContext(tID);
    }
};


namespace Events {

    /*
     * Neighboring events
     */

    const NeighborEventVector<_SYS_NEIGHBOR_ADD>     neighborAdd;

    const NeighborEventVector<_SYS_NEIGHBOR_REMOVE>  neighborRemove;

    /*
     * Cube events
     */

    const EventVector<_SYS_CUBE_CONNECT>     cubeConnect;

    const EventVector<_SYS_CUBE_DISCONNECT>  cubeDisconnect;

    const EventVector<_SYS_CUBE_ASSETDONE>   cubeAssetDone;

    const EventVector<_SYS_CUBE_ACCELCHANGE> cubeAccelChange;

    const EventVector<_SYS_CUBE_TOUCH>       cubeTouch;

    const EventVector<_SYS_CUBE_BATTERY>     cubeBatteryLevelChange;

    const EventVector<_SYS_CUBE_REFRESH>     cubeRefresh;

    /*
     * Base events
     */

    const EventVector<_SYS_BASE_TRACKER>     baseTracker;

    const GameMenuEventVector                gameMenu;

    const EventVector<_SYS_BASE_VOLUME_DELETE>  volumeDelete;

    const EventVector<_SYS_BASE_VOLUME_COMMIT>  volumeCommit;

    /*
     * Bluetooth events
     */

    const NullaryEventVector<_SYS_BASE_BT_CONNECT>  bluetoothConnect;

    const NullaryEventVector<_SYS_BASE_BT_DISCONNECT>  bluetoothDisconnect;

    const NullaryEventVector<_SYS_BASE_BT_READ_AVAILABLE>  bluetoothReadAvailable;

    const NullaryEventVector<_SYS_BASE_BT_WRITE_AVAILABLE>  bluetoothWriteAvailable;
    
    /*
     * USB events
     */

    const NullaryEventVector<_SYS_BASE_USB_CONNECT>  usbConnect;

    const NullaryEventVector<_SYS_BASE_USB_DISCONNECT>  usbDisconnect;

    const NullaryEventVector<_SYS_BASE_USB_READ_AVAILABLE>  usbReadAvailable;

    const NullaryEventVector<_SYS_BASE_USB_WRITE_AVAILABLE>  usbWriteAvailable;

};  // namespace Events

};  // namespace Sifteo