InputManager.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef MACHINE_INPUT_MANAGER_H
#define MACHINE_INPUT_MANAGER_H

#include "pedigree/kernel/Spinlock.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/process/Semaphore.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/List.h"
#include "pedigree/kernel/utilities/new"

class Thread;

class EXPORTED_PUBLIC InputManager
{
  public:
    const static int Key = 1;
    const static int Mouse = 2;
    const static int Joystick = 4;
    const static int RawKey = 8;
    const static int MachineKey = 16;  // machine-specific key codes
    const static int Unknown = 255;

    typedef int CallbackType;

    struct InputNotification
    {
        CallbackType type;
        void *meta;

        union
        {
            struct
            {
                uint64_t key;
            } key;
            struct
            {
                ssize_t relx;
                ssize_t rely;
                ssize_t relz;

                bool buttons[64];
            } pointy;
            struct
            {
                uint8_t scancode;

                bool keyUp;
            } rawkey;
            struct
            {
                uint8_t scancode;

                bool keyUp;
            } machinekey;
        } data;
    };

    typedef void (*callback_t)(InputNotification &);

    InputManager();

    virtual ~InputManager();

    void initialise();

    void shutdown();

    static InputManager &instance()
    {
        return m_Instance;
    }

    void keyPressed(uint64_t key);

    void rawKeyUpdate(uint8_t scancode, bool bKeyUp);

    void machineKeyUpdate(uint8_t scancode, bool bKeyUp);

    void mouseUpdate(
        ssize_t relX, ssize_t relY, ssize_t relZ, uint32_t buttonBitmap);

    void joystickUpdate(
        ssize_t relX, ssize_t relY, ssize_t relZ, uint32_t buttonBitmap);

    void installCallback(
        CallbackType filter, callback_t callback, void *meta = 0,
        Thread *pThread = 0, uintptr_t param = 0);

    void
    removeCallback(callback_t callback, void *meta = 0, Thread *pThread = 0);

    bool removeCallbackByThread(Thread *pThread);

    static int trampoline(void *ptr);

    void mainThread();

    bool isActive() const
    {
        return m_bActive;
    }

  private:
    static InputManager m_Instance;

    void putNotification(InputNotification *note);

    struct CallbackItem
    {
        callback_t func;

#ifdef THREADS
        Thread *pThread;
#endif

        uintptr_t nParam;

        CallbackType filter;

        void *meta;
    };

    List<InputNotification *> m_InputQueue;

    Spinlock m_QueueLock;

    List<CallbackItem *> m_Callbacks;

#ifdef THREADS
    Semaphore m_InputQueueSize;

    Thread *m_pThread;
#endif

    bool m_bActive;
};

#endif