CUProgressBar.h

//
//  CUProgressBar.h
//  Cornell University Game Library (CUGL)
//
//  This module provides support for a simple progress bar, which is useful
//  for displaying things such as asset loading.
//
//  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: 1/8/17
//
#ifndef __CU_PROGRESS_BAR_H__
#define __CU_PROGRESS_BAR_H__
#include <cugl/2d/CUNode.h>
#include <cugl/2d/CUPolygonNode.h>

namespace cugl {

class ProgressBar: public Node {
protected:
    float _progress;
    Size _foresize;

    std::shared_ptr<PolygonNode> _background;
    std::shared_ptr<PolygonNode> _foreground;
    std::shared_ptr<PolygonNode> _begincap;
    std::shared_ptr<PolygonNode> _finalcap;
 
public:
#pragma mark -
#pragma mark Constructors

    ProgressBar() : _progress(1.0f) {}
    
    ~ProgressBar() { dispose(); }
    
    virtual void dispose() override;
    
    virtual bool init() override {
        CUAssertLog(false,"This node does not support the empty initializer");
        return false;
    }

    bool init(const Size& size) {
        return initWithCaps(nullptr,nullptr,nullptr,nullptr,size);
    }

    bool init(const std::shared_ptr<Texture>& background) {
        return initWithCaps(background,nullptr,nullptr,nullptr);
    }
    
    bool init(const std::shared_ptr<Texture>& background, const Size& size) {
        return initWithCaps(background,nullptr,nullptr,nullptr,size);
    }

    bool init(const std::shared_ptr<Texture>& background,
              const std::shared_ptr<Texture>& foreground) {
        return initWithCaps(background,foreground,nullptr,nullptr);
    }
    
    bool init(const std::shared_ptr<Texture>& background,
              const std::shared_ptr<Texture>& foreground,
              const Size& size) {
        return initWithCaps(background,foreground,nullptr,nullptr,size);
    }

    bool initWithCaps(const std::shared_ptr<Texture>& background,
                      const std::shared_ptr<Texture>& foreground,
                      const std::shared_ptr<Texture>& beginCap,
                      const std::shared_ptr<Texture>& finalCap);

    bool initWithCaps(const std::shared_ptr<Texture>& background,
                      const std::shared_ptr<Texture>& foreground,
                      const std::shared_ptr<Texture>& beginCap,
                      const std::shared_ptr<Texture>& finalCap,
                      const Size& size);
    
    bool initWithData(const SceneLoader* loader, const std::shared_ptr<JsonValue>& data) override;

#pragma mark -
#pragma mark Static Constructors

    static std::shared_ptr<ProgressBar> alloc(const Size& size) {
        std::shared_ptr<ProgressBar> node = std::make_shared<ProgressBar>();
        return (node->init(size) ? node : nullptr);
    }

    static std::shared_ptr<ProgressBar> alloc(const std::shared_ptr<Texture>& background) {
        std::shared_ptr<ProgressBar> node = std::make_shared<ProgressBar>();
        return (node->init(background) ? node : nullptr);
    }

    static std::shared_ptr<ProgressBar> alloc(const std::shared_ptr<Texture>& background, const Size& size) {
        std::shared_ptr<ProgressBar> node = std::make_shared<ProgressBar>();
        return (node->init(background,size) ? node : nullptr);
    }

    static std::shared_ptr<ProgressBar> alloc(const std::shared_ptr<Texture>& background,
                                              const std::shared_ptr<Texture>& foreground) {
        std::shared_ptr<ProgressBar> node = std::make_shared<ProgressBar>();
        return (node->init(background,foreground) ? node : nullptr);
    }
    
    static std::shared_ptr<ProgressBar> alloc(const std::shared_ptr<Texture>& background,
                                              const std::shared_ptr<Texture>& foreground,
                                              const Size& size) {
        std::shared_ptr<ProgressBar> node = std::make_shared<ProgressBar>();
        return (node->init(background,foreground,size) ? node : nullptr);
    }

    static std::shared_ptr<ProgressBar> allocWithCaps(const std::shared_ptr<Texture>& background,
                                                      const std::shared_ptr<Texture>& foreground,
                                                      const std::shared_ptr<Texture>& beginCap,
                                                      const std::shared_ptr<Texture>& finalCap) {
        std::shared_ptr<ProgressBar> node = std::make_shared<ProgressBar>();
        return (node->initWithCaps(background,foreground,beginCap,finalCap) ? node : nullptr);
    }
    
    static std::shared_ptr<ProgressBar> allocWithCaps(const std::shared_ptr<Texture>& background,
                                                      const std::shared_ptr<Texture>& foreground,
                                                      const std::shared_ptr<Texture>& beginCap,
                                                      const std::shared_ptr<Texture>& finalCap,
                                                      const Size& size) {
        std::shared_ptr<ProgressBar> node = std::make_shared<ProgressBar>();
        return (node->initWithCaps(background,foreground,beginCap,finalCap,size) ? node : nullptr);
    }
    
    static std::shared_ptr<Node> allocWithData(const SceneLoader* loader,
                                               const std::shared_ptr<JsonValue>& data) {
        std::shared_ptr<ProgressBar> result = std::make_shared<ProgressBar>();
        if (!result->initWithData(loader,data)) { result = nullptr; }
        return std::dynamic_pointer_cast<Node>(result);
    }
    
#pragma mark -
#pragma mark Properties

    float getProgress() const { return _progress; }

    void setProgress(float progress);
    
    Color4 getBackgroundColor() const { return _background->getColor(); }
    
    void setBackgroundColor(Color4 color) { _background->setColor(color); }

    Color4 getForegroundColor() const { return _foreground->getColor(); }
    
    void setForegroundColor(Color4 color);
};

}

#endif /* __CU_PROGRESS_BAR_H__ */