CUMouse.h

//
//  CUMouse.h
//  Cornell University Game Library (CUGL)
//
//  This class provides basic mouse support. While SDL combines mouse and touch
//  support into the same interface, we do not.  All touches are handled by
//  the Touchscreen class.
//
//  This class is a singleton and should never be allocated directly.  It
//  should only be accessed via the Input dispatcher.
//
//  CUGL zlib License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Walker White
//  Version: 7/9/16

#ifndef __CU_MOUSE_H__
#define __CU_MOUSE_H__

#include "CUInput.h"
#include "../math/CURect.h"
#include "../math/CUVec2.h"

#define SDL_BUTTON_ALLMASK ((1 << 6) - 1)

namespace cugl {
    
#pragma mark -

class ButtonState {
private:
    Uint32 _state;

public:
#pragma mark Constructors

    ButtonState() : _state(0) { }

    ButtonState(Uint32 state) { _state = state; }

#pragma mark Buttons

    bool hasLeft() const    { return (_state & SDL_BUTTON_LMASK) != 0;  }

    bool hasMiddle() const  { return (_state & SDL_BUTTON_MMASK) != 0;  }

    bool hasRight() const   { return (_state & SDL_BUTTON_RMASK) != 0;  }

    bool hasX1() const      { return (_state & SDL_BUTTON_X1MASK) != 0; }
    
    bool hasX2() const      { return (_state & SDL_BUTTON_X2MASK) != 0; }
    
    void setLeft(bool value)    { toggle(SDL_BUTTON_LMASK,value);   }

    void setMiddle(bool value)  { toggle(SDL_BUTTON_MMASK,value);   }

    void setRight(bool value)   { toggle(SDL_BUTTON_RMASK,value);   }
    
    void setX1(bool value)      { toggle(SDL_BUTTON_X1MASK,value);  }

    void setX2(bool value)      { toggle(SDL_BUTTON_X2MASK,value);  }

    
#pragma mark Bitwise Operations

    ButtonState& operator&=(ButtonState mouse) {
        _state &= mouse._state;
        return *this;
    }

    ButtonState& operator|=(ButtonState mouse) {
        _state |= mouse._state;
        return *this;
    }

    ButtonState& operator^=(ButtonState mouse) {
        _state ^= mouse._state;
        return *this;
    }
    
    ButtonState& operator-=(ButtonState mouse) {
        _state &= ~mouse._state;
        return *this;
    }

    const ButtonState operator&(ButtonState mouse) const {
        return ButtonState(_state & mouse._state);
    }

    const ButtonState operator|(ButtonState mouse) const {
        return ButtonState(_state | mouse._state);
    }

    const ButtonState operator^(ButtonState mouse) const {
        return ButtonState(_state ^ mouse._state);
    }

    const ButtonState operator-(ButtonState mouse) const {
        return ButtonState(_state & ~mouse._state);
    }

    const ButtonState operator~() const {
        return ButtonState(~_state & SDL_BUTTON_ALLMASK);
    }

private:
    void toggle(Uint32 bmask, bool value) {
        _state = (value ? _state | bmask : _state & ~bmask);
    }
    
    // Allow MouseEvent direct access
    friend class MouseEvent;
};
    
#pragma mark -
    
class MouseEvent {
public:
    Timestamp timestamp;
    ButtonState buttons;
    Vec2 position;
    
    MouseEvent() {}
    
    MouseEvent(Uint32 state, const Vec2& point, const Timestamp& stamp) {
        buttons._state = state; timestamp = stamp; position = point;
    }
};

#pragma mark -

class MouseWheelEvent {
public:
    Timestamp timestamp;
    Vec2 direction;
    bool flipped;
    
    MouseWheelEvent() : flipped(false) {}
    
    MouseWheelEvent(const Vec2& offset, const Timestamp& stamp, bool flip=false) {
        direction = offset; timestamp = stamp; flipped = flip;
    }

};

#pragma mark -
#pragma mark MouseButtonListener

typedef std::function<void(const MouseEvent& event, Uint8 clicks, bool focus)>
        MouseButtonListener;

#pragma mark -
#pragma mark MouseMotionListener

typedef std::function<void(const MouseEvent& event, const Vec2& previous, bool focus)>
        MouseMotionListener;

#pragma mark -
#pragma mark MouseWheelListener

typedef std::function<void(const MouseWheelEvent& event, bool focus)>
        MouseWheelListener;

#pragma mark -

class Mouse : public InputDevice {
public:
    enum class PointerAwareness {
        BUTTON,
        DRAG,
        ALWAYS
    };
    
protected:
    PointerAwareness _awareness;

    ButtonState _lastState;
    ButtonState _currState;
    
    Vec2 _lastPoint;
    Vec2 _currPoint;

    Vec2 _wheelOffset;
    
    std::unordered_map<Uint32, MouseButtonListener> _pressListeners;
    std::unordered_map<Uint32, MouseButtonListener> _releaseListeners;
    std::unordered_map<Uint32, MouseMotionListener> _moveListeners;
    std::unordered_map<Uint32, MouseMotionListener> _dragListeners;
    std::unordered_map<Uint32, MouseWheelListener> _wheelListeners;

#pragma mark Constructor

    Mouse() : InputDevice(), _awareness(PointerAwareness::BUTTON) {}
    
    virtual ~Mouse() { }

    virtual void dispose() override;

public:
    PointerAwareness getPointerAwareness() const { return _awareness; }
    
    void setPointerAwareness(PointerAwareness awareness) { _awareness = awareness; }
    

#pragma mark Data Polling

    ButtonState buttonDown() const { return _currState; }
    
    ButtonState buttonUp() const { return ~_currState; }

    ButtonState buttonPressed() const { return _currState-_lastState; }

    ButtonState buttonReleased() const { return _lastState-_currState; }

    Vec2 pointerPosition() const { return _currPoint; }

    Vec2 pointerOffset() const { return _currPoint-_lastPoint; }

    Vec2 wheelDirection() const { return _wheelOffset; }
    
#pragma mark Listeners

    virtual bool requestFocus(Uint32 key) override;
    
    bool isListener(Uint32 key) const;
    
    const MouseButtonListener getPressListener(Uint32 key) const;
    
    const MouseButtonListener getReleaseListener(Uint32 key) const;

    const MouseMotionListener getDragListener(Uint32 key) const;

    const MouseMotionListener getMotionListener(Uint32 key) const;

    const MouseWheelListener getWheelListener(Uint32 key) const;

    bool addPressListener(Uint32 key, MouseButtonListener listener);

    bool addReleaseListener(Uint32 key, MouseButtonListener listener);

    bool addDragListener(Uint32 key, MouseMotionListener listener);

    bool addMotionListener(Uint32 key, MouseMotionListener listener);

    bool addWheelListener(Uint32 key, MouseWheelListener listener);

    bool removePressListener(Uint32 key);

    bool removeReleaseListener(Uint32 key);

    bool removeDragListener(Uint32 key);

    bool removeMotionListener(Uint32 key);

    bool removeWheelListener(Uint32 key);

protected:
#pragma mark Input Device

    virtual void clearState() override;
    
    virtual bool updateState(const SDL_Event& event, const Timestamp& stamp) override;
    
    virtual void queryEvents(std::vector<Uint32>& eventset) override;
    
    // Apparently friends are not inherited
    friend class Input;
};

}

#endif /* __CU_MOUSE_H__ */