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 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_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 SliderListener

typedef std::function<void(const std::string& name, float value)> SliderListener;

    
#pragma mark -
#pragma mark Slider

class Slider : public Node {
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;
    SliderListener _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 SliderListener getListener() const { return _listener; }

    void setListener(SliderListener 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__ */