CUPanInput.h

//
//  CUPanInput.h
//  Cornell University Game Library (CUGL)
//
//  This class provides basic support for multifinger pan gestures.  SDL blurs
//  pinches, rotations, and pans all into a single input event.  Therefore, you
//  need to set the sensitivity threshold to distinguish them.
//
//  This class is a singleton and should never be allocated directly.  It
//  should only be accessed via the Input dispatcher.
//
//  CUGL MIT 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: 12/20/16
//
#ifndef __CU_PAN_INPUT_H__
#define __CU_PAN_INPUT_H__
#include <cugl/input/CUInput.h>
#include <cugl/math/CUVec2.h>

namespace cugl {

#pragma mark -
#pragma mark PanEvent

class PanEvent {
public:
    Timestamp timestamp;
    Vec2 position;
    Vec2 pan;
    Vec2 delta;
    int fingers;
    
    PanEvent() : fingers(0) {}
    
    PanEvent(const Vec2& point, const Vec2& offset, int down, const Timestamp& stamp) {
        position = point; fingers = down; pan = offset; delta = offset; timestamp = stamp;
    }
};


#pragma mark -
#pragma mark PanInput

class PanInput : public InputDevice {
public:
#pragma mark Listener

    typedef std::function<void(const PanEvent& event, bool focus)> Listener;
    
protected:
    bool  _screen;
    bool  _active;
    bool  _fingery;
    float _threshold;
    float _spread;
    PanEvent _event;
    
    std::unordered_map<Uint32, Listener> _beginListeners;
    std::unordered_map<Uint32, Listener> _finishListeners;
    std::unordered_map<Uint32, Listener> _motionListeners;
    
    
#pragma mark Constructor

    PanInput();
    
    virtual ~PanInput() {}
    
    virtual void dispose() override;
    
    
#pragma mark Device Attributes
public:
    bool isTouchScreen() const { return _screen; }
    
    void setTouchScreen(bool flag);
    
    float getThreshold() const { return sqrtf(_threshold); }
    
    void setThreshold(float threshold);
    
    bool isFingerSensitive() const { return _fingery; }

    void setFingerSensitive(bool flag) { _fingery = flag; }

    
#pragma mark Data Polling

    bool isActive() const { return _active; }
    
    const Vec2& getDelta() const { return _active ? _event.delta : Vec2::ZERO; }
    
    const Vec2& getPan() const  { return _active ? _event.pan : Vec2::ZERO; }
    
    const Vec2& getPosition() const { return _active ? _event.position : Vec2::ZERO; }
    
    int getFingers() const { return _active ? _event.fingers : 0; }

    
#pragma mark Listeners

    virtual bool requestFocus(Uint32 key) override;
    
    bool isListener(Uint32 key) const;
    
    const Listener getBeginListener(Uint32 key) const;
    
    const Listener getEndListener(Uint32 key) const;
    
    const Listener getMotionListener(Uint32 key) const;
    
    bool addBeginListener(Uint32 key, Listener listener);
    
    bool addEndListener(Uint32 key, Listener listener);
    
    bool addMotionListener(Uint32 key, Listener listener);
    
    bool removeBeginListener(Uint32 key);
    
    bool removeEndListener(Uint32 key);
    
    bool removeMotionListener(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;
    
    Vec2 getScaledPosition(float x, float y);
    
    // Apparently friends are not inherited
    friend class Input;
};

}
#endif /* __CU_PAN_INPUT_H__ */