CUSlider.h

//
//  CUSlider.h
//  Cornell University Game Library (CUGL)
//
//  This module provides support for a slider, which allows the user to drag
//  a knob to select a value.  The slider can be spartan (a circle on a line),
//  or it can have custom images.
//
//  The slider can track its own state, relieving you of having to manually
//  check mouse presses. However, it can only do this when the slider 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 and Enze Zhou
//  Version: 1/8/18
//
#ifndef __CU_SLIDER_H__
#define __CU_SLIDER_H__
 
#include <cugl/2d/CUNode.h>
#include <cugl/2d/CUButton.h>
 
namespace cugl {
 
#define DEFAULT_MIN       0
 
#define DEFAULT_MAX     100
 
#define DEFAULT_RADIUS   20
 
#pragma mark -
#pragma mark Slider
 
class Slider : public Node {
public:
#pragma mark Listener
    
    typedef std::function<void(const std::string& name, float value)> Listener;
    
protected:
#pragma mark -
#pragma mark Values
 
    float _value;
    Vec2 _range;
 
    std::shared_ptr<Button> _knob;
    std::shared_ptr<Node> _path;
    Rect _bounds;
    Rect _adjust;
    
    float _tick;
    bool  _snap;
    
    bool _active;
    bool _mouse;
    Vec2 _dragpos;
    Uint32 _inputkey;
    Listener _listener;
 
public:
#pragma mark -
#pragma mark Constructors
 
    Slider();
 
    ~Slider() { dispose(); }
 
    virtual void dispose() override;
 
    virtual bool init() override {
        return init(Vec2(DEFAULT_MIN,DEFAULT_MAX),Rect(DEFAULT_MIN,DEFAULT_RADIUS,DEFAULT_MAX,0));
    }
 
    bool init(const Vec2& range, const Rect& bounds);
 
    bool initWithUI(const Vec2& range, const Rect& bounds,
                    const std::shared_ptr<Node>& path,
                    const std::shared_ptr<Button>& knob);
 
    bool initWithData(const SceneLoader* loader, const std::shared_ptr<JsonValue>& data) override;
 
    
#pragma mark -
#pragma mark Static Constructors
 
    static std::shared_ptr<Slider> alloc() {
        std::shared_ptr<Slider> node = std::make_shared<Slider>();
        return (node->init() ? node : nullptr);
    }
 
    static std::shared_ptr<Slider> alloc(const Vec2& range, const Rect& bounds) {
        std::shared_ptr<Slider> node = std::make_shared<Slider>();
        return (node->init(range,bounds) ? node : nullptr);
    }
    
    static std::shared_ptr<Slider> allocWithUI(const Vec2& range, const Rect& bounds,
                                               const std::shared_ptr<Node>& path,
                                               const std::shared_ptr<Button>& knob) {
        std::shared_ptr<Slider> node = std::make_shared<Slider>();
        return (node->initWithUI(range,bounds,path,knob) ? node : nullptr);
    }
    
    static std::shared_ptr<Slider> allocWithData(const SceneLoader* loader,
                                                 const std::shared_ptr<JsonValue>& data) {
        std::shared_ptr<Slider> node = std::make_shared<Slider>();
        return (node->initWithData(loader,data) ? node : nullptr);
    }
 
 
#pragma mark -
#pragma mark Slider State
 
    float getMinValue() const { return _range.x; }
 
    void setMinValue(float value) { _range.x = value; reposition(); }
 
    float getMaxValue() const { return _range.y; }
 
    void setMaxValue(float value) { _range.y = value; reposition(); }
 
    const Vec2& getRange() const { return _range; }
 
    void setRange(const Vec2& range) { _range = range; reposition(); }
 
    void setRange(float min, float max) { setRange(Vec2(min,max)); }
    
    float getValue() const { return _value; }
 
    void setValue(float value) { _value = validate(value); reposition(); }
 
    
#pragma mark -
#pragma mark Appearance
 
    const std::shared_ptr<Button>& getKnob() const { return _knob; }
 
    void setKnob(const std::shared_ptr<Button>& knob) { placeKnob(knob); reconfigure(); }
 
    const std::shared_ptr<Node>& getPath() const { return _path; }
    
    void setPath(const std::shared_ptr<Node>& path) { placePath(path); reconfigure(); }
 
    const Rect& getBounds() const { return _bounds; }
 
    void getBounds(const Rect& value) { _bounds = value; reconfigure(); }
    
#pragma mark -
#pragma mark Tick Support
 
    float getTick() const { return _tick; }
    
    void setTick(float value) { _tick = value; reposition(); }
    
    bool hasSnap() const { return _snap; }
    
    void snapTick(bool value) { _snap = value; reposition(); }
 
#pragma mark -
#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; }
    
    
protected:
#pragma mark -
#pragma mark Internal Helpers
 
    float validate(float value) const;
    
    void reconfigure();
 
    void reposition();
    
    void dragKnob(const Vec2& pos);
    
    void placeKnob(const std::shared_ptr<Button>& knob);
    
    void placePath(const std::shared_ptr<Node>& path);
 
};
 
}
 
#endif /* __CU_SLIDER_H__ */