CUTextInput.h

//
//  CUTextInput.h
//  Cornell University Game Library (CUGL)
//
//  This class is an object-oriented interface to the SDL text input system.
//  We have tried to keep this class as minimal as possible to make it as
//  flexible as possible.
//
//  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/8/16

#ifndef __CU_TEXT_INPUT_H__
#define __CU_TEXT_INPUT_H__

#include "CUInput.h"
#include "../util/CUTimestamp.h"
#include <functional>

namespace cugl {
    
#pragma mark TextInputEvent
    
class TextInputEvent {
public:
    Timestamp timestamp;
    std::string buffer;
    std::string added;

    TextInputEvent() {}
    
    TextInputEvent(const std::string& text, const std::string& suffix, const Timestamp& stamp) {
        buffer = text; added = suffix; timestamp = stamp;
    }
};


#pragma mark -
#pragma mark TextInputListener

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

#pragma mark TextInputValidator

typedef std::function<bool(const std::string& value)> TextInputValidator;

#pragma mark -

class TextInput : public InputDevice {
#pragma mark Values
protected:
    std::string _buffer;

    bool _active;
    bool _updated;
    
    TextInputValidator _validator;
    std::unordered_map<Uint32, TextInputListener> _listeners;

#pragma mark -
#pragma mark Constructor

    TextInput();

    virtual ~TextInput() {}
    
    virtual void dispose() override;

public:
#pragma mark -
#pragma mark Activation

    void begin();
    
    void end();

    bool isActive() const { return _active; }
    
#pragma mark -
#pragma mark Data Access

    const std::string& getBuffer() const { return _buffer; }

    bool didUpdate() const { return _updated; }
    
#pragma mark -
#pragma mark Listeners

    virtual bool requestFocus(Uint32 key) override;

    void setValidator(TextInputValidator validator);

    const TextInputValidator getValidator() const { return _validator; }

    bool isListener(Uint32 key) const;
    
    const TextInputListener getListener(Uint32 key) const;
    
    bool addListener(Uint32 key, TextInputListener listener);

    bool removeListener(Uint32 key);

protected:
    void validate(const std::string& value, const Timestamp& stamp);


#pragma mark -
#pragma mark Input Device

    virtual void clearState() override { _updated = false; }
    
    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_TEXT_INPUT_H__ */