CUTextField.h

//
//  CUTextField.h
//  Cornell University Game Library (CUGL)
//
//  This module provides support for a single line text field. It is useful
//  for providing input forms for your application, such as saved games or
//  player settings.  Because it is only a single line, it is a subclass of
//  label.  A multiline text input would be a TextArea, and that is not
//  currently supported.
//
//  To make use of a TextField, BOTH Keyboard and TextInput input devices
//  must be activated.  In particular, TextInput allows the support of
//  virtual keyboards on mobile devices.
//
//  This class uses our standard shared-pointer architecture.
//
//  1. The constructor does not perform any initialization; it just sets all
//     attributes to their defaults.
//
//  2. All initialization takes place via init methods, which can fail if an
//     object is initialized more than once.
//
//  3. All allocation takes place via static constructors which return a shared
//     pointer.
//
//  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 and Enze Zhou
//  Version: 1/8/18
//
#ifndef __CU_TEXT_FIELD_H__
#define __CU_TEXT_FIELD_H__

#include <cugl/2d/CULabel.h>
#include <cugl/input/CUTextInput.h>
#include <cugl/input/CUKeyboard.h>
#include <string>

namespace cugl {

#pragma mark -
#pragma mark TextFieldListener

typedef std::function<void (const std::string& name, const std::string& current)> TextFieldListener;

#pragma mark -
#pragma mark TextField

class TextField : public Label {
protected:
#pragma mark -
#pragma mark Values

    Rect _cursor;
    int _cursorBlink;
    int _cursorIndex;
    float _textLength;
    
    
    bool _active;
    bool _focused;
    bool _mouse;
    Uint32 _inputKey;
    
    TextFieldListener _typeListener;
    TextFieldListener _exitListener;

    bool _altDown;
    bool _metaDown;
    bool _backDown;
    Uint32 _backCount;


public:
#pragma mark -
#pragma mark Constructors

    TextField();

    ~TextField() { dispose(); }

    virtual void dispose() override;


#pragma mark -
#pragma mark Static Constructors

    static std::shared_ptr<TextField> alloc(const Size& size, const std::shared_ptr<Font>& font) {
        std::shared_ptr<TextField> result = std::make_shared<TextField>();
        return (result->Label::init(size,font) ? result : nullptr);
    }

    static std::shared_ptr<TextField> alloc(const std::string& text, const std::shared_ptr<Font>& font) {
        std::shared_ptr<TextField> result = std::make_shared<TextField>();
        return (result->initWithText(text,font) ? result : nullptr);
    }

    static std::shared_ptr<TextField> alloc(const char* text, const std::shared_ptr<Font>& font) {
        std::shared_ptr<TextField> result = std::make_shared<TextField>();
        return (result->initWithText(text,font) ? result : nullptr);
    }
    
    static std::shared_ptr<Node> allocWithData(const SceneLoader* loader,
                                               const std::shared_ptr<JsonValue> data) {
        std::shared_ptr<TextField> node = std::make_shared<TextField>();
        if (!node->initWithData(loader,data)) { node = nullptr; }
        return std::dynamic_pointer_cast<Node>(node);
    }


#pragma mark -
#pragma mark Listener

    bool hasTypeListener() const { return _typeListener != nullptr; }

    const TextFieldListener getTypeListener() const { return _typeListener; }

    void setTypeListener(TextFieldListener listener) { _typeListener = listener; }

    bool removeTypeListener();
    
    bool hasExitListener() const { return _exitListener != nullptr; }
    
    const TextFieldListener getExitListener() const { return _exitListener; }
    
    void setExitListener(TextFieldListener listener) { _exitListener = listener; }
    
    bool removeExitListener();

    
#pragma mark -
#pragma mark Editing

    virtual void setText(const std::string& text, bool resize=false) override;
    
    bool activate(Uint32 key);

    bool deactivate(bool dispose=false);

    bool isActive() const { return _active; }
    
    bool requestFocus();

    bool releaseFocus();

    bool hasFocus() const { return _focused; }
    
    
protected:
#pragma mark -
#pragma mark Rendering

    virtual void draw(const std::shared_ptr<SpriteBatch>& batch, const Mat4& transform, Color4 tint) override;

    
#pragma mark -
#pragma mark Internal Helpers

    bool validate(const std::string& value);
    
    void updateInput(const TextInputEvent& event, bool focus);

    void updateKey(const KeyEvent& Event, bool focus, bool down);

    void updatePress(Vec2 pos, bool focus);

    void updateCursor();

    int skipWord(bool forward);

    void deleteOne();
    
    bool deleteMany(Uint32 counter);

};

}

#endif /* __CU_TEXT_FIELD_H__ */