CUButton.h

//
//  CUButton.h
//  Cornell University Game Library (CUGL)
//
//  This module provides support for a simple clickable button. The button may
//  either be represented by two images (one up and one down), or a single
//  image and two different color tints.
//
//  The button can track its own state, relieving you of having to manually
//  check mouse presses. However, it can only do this when the button is part
//  of a scene graph, as the scene graph maps mouse coordinates to screen
//  coordinates.
//
//  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 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: 10/28/18
//
#ifndef __CU_BUTTON_H__
#define __CU_BUTTON_H__
#include <cugl/assets/CUJsonValue.h>
#include <cugl/2d/CUNode.h>
#include <cugl/2d/CUPolygonNode.h>
#include <cugl/math/CUColor4.h>
#include <unordered_map>

namespace cugl {

#pragma mark -
#pragma mark Button

class Button : public Node {
public:
#pragma mark Listener

    typedef std::function<void(const std::string& name, bool down)> Listener;

protected:
    bool _down;
    bool _toggle;

    std::shared_ptr<Node> _upnode;
    std::shared_ptr<Node> _downnode;
    std::shared_ptr<JsonValue> _upform;
    std::shared_ptr<JsonValue> _downform;
    Color4 _upcolor;
    Color4 _downcolor;
    std::string _upchild;
    std::string _downchild;

    Poly2 _bounds;

    bool _active;
    bool _mouse;
    Uint32 _inputkey;
    Listener _listener;
    
public:
#pragma mark Constructors

    Button();
    
    ~Button() { dispose(); }
    
    virtual void dispose() override;
  
    virtual bool init() override {
        CUAssertLog(false,"This node does not support the empty initializer");
        return false;
    }
    
    bool init(const std::shared_ptr<Node>& up) {
        return init(up,up->getColor()*Color4::GRAY);
    }
    
    bool init(const std::shared_ptr<Node>& up, Color4 down);
    
    bool init(const std::shared_ptr<Node>& up, const std::shared_ptr<Node>& down);
    
    bool initWithData(const SceneLoader* loader, const std::shared_ptr<JsonValue>& data) override;

#pragma mark Static Constructors

    static std::shared_ptr<Button> alloc(const std::shared_ptr<Node>& up) {
        std::shared_ptr<Button> node = std::make_shared<Button>();
        return (node->init(up) ? node : nullptr);
    }

    static std::shared_ptr<Button> alloc(const std::shared_ptr<Node>& up, Color4 down) {
        std::shared_ptr<Button> node = std::make_shared<Button>();
        return (node->init(up,down) ? node : nullptr);
    }

    static std::shared_ptr<Button> alloc(const std::shared_ptr<Node>& up, const std::shared_ptr<Node>& down) {
        std::shared_ptr<Button> node = std::make_shared<Button>();
        return (node->init(up,down) ? node : nullptr);
    }

    static std::shared_ptr<Node> allocWithData(const SceneLoader* loader,
                                               const std::shared_ptr<JsonValue>& data) {
        std::shared_ptr<Button> result = std::make_shared<Button>();
        if (!result->initWithData(loader,data)) { result = nullptr; }
        return std::dynamic_pointer_cast<Node>(result);
    }
    
#pragma mark Button Attributes

    virtual void setColor(Color4 color) override;

    const Poly2& getPushable() const { return _bounds; }
    
    void setPushable(const Poly2& bounds);
    
    void setPushable(const std::vector<Vec2>& vertices);
    
    virtual void doLayout() override;
    
#pragma mark Button State

    bool containsScreen(const Vec2& point);
    
    bool containsScreen(float x, float y) {
        return containsScreen(Vec2(x,y));
    }

    bool isDown() const { return _down; }
    
    void setDown(bool down);

    bool isToggle() const { return _toggle; }

    void setToggle(bool value) { _toggle = value; }

#pragma mark Listeners

    bool hasListener() const { return _listener != nullptr; }
    
    const Listener getListener() const { return _listener; }
    
    void setListener(Listener listener) { _listener = listener; }
    
    bool removeListener();
    
    bool activate(Uint32 key);

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

}

#endif /* __CU_BUTTON_H__ */