CULabel.h

//
//  CULabel.h
//  Cornell University Game Library (CUGL)
//
//  This module provides a scene graph node that displays a single line of text.
//  We have moved multiline text support to a separate class.
//
//  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
//  Version: 7/6/16
//
#ifndef __CU_LABEL_H__
#define __CU_LABEL_H__

#include <string>
#include <cugl/2d/CUNode.h>
#include <cugl/2d/CUFont.h>

namespace cugl {

class Label : public Node {
#pragma mark Values
public:
    enum class HAlign : int {
        LEFT = 0,
        CENTER = 1,
        RIGHT = 2,
        HARDLEFT = 3,
        TRUECENTER = 4,
        HARDRIGHT = 5
    };
    
    enum class VAlign {
        BOTTOM = 0,
        MIDDLE = 1,
        TOP = 2,
        HARDBOTTOM= 3,
        TRUEMIDDLE= 4,
        HARDTOP = 5,
    };
protected:
    std::shared_ptr<Font> _font;
    
    std::string  _text;
    Rect _textbounds;
    Rect _truebounds;
    
    Vec2 _padding;
    HAlign _halign;
    VAlign _valign;
    
    Color4 _foreground;
    Color4 _background;
    
    GLenum _blendEquation;
    GLenum _srcFactor;
    GLenum _dstFactor;

    bool _rendered;
    std::vector<Vertex2> _vertices;
    std::vector<unsigned short> _indices;
    std::shared_ptr<Texture> _texture;

public:
#pragma mark -
#pragma mark Constructors

    Label();
    
    ~Label() { 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, const std::shared_ptr<Font>& font);
    
    bool initWithText(const char* text, const std::shared_ptr<Font>& font) {
        return initWithText(std::string(text), font);
    }

    bool initWithText(const std::string& text, const std::shared_ptr<Font>& font);

    virtual bool initWithData(const SceneLoader* loader, const std::shared_ptr<JsonValue> data) override;

#pragma mark -
#pragma mark Static Constructors

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

    static std::shared_ptr<Label> alloc(const std::string& text, const std::shared_ptr<Font>& font) {
        std::shared_ptr<Label> result = std::make_shared<Label>();
        return (result->initWithText(text,font) ? result : nullptr);
    }
    
    static std::shared_ptr<Label> alloc(const char* text, const std::shared_ptr<Font>& font) {
        std::shared_ptr<Label> result = std::make_shared<Label>();
        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<Label> result = std::make_shared<Label>();
        if (!result->initWithData(loader,data)) { result = nullptr; }
        return std::dynamic_pointer_cast<Node>(result);
    }
    
#pragma mark -
#pragma mark Text Attributes

    const std::string& getText() const { return _text; }
    
    virtual void setText(const std::string& text, bool resize=false);
    
    const Vec2& getPadding() const { return _padding; }

    float getPaddingX() const { return _padding.x; }
    
    float getPaddingY() const { return _padding.y; }
    
    void setPadding(const Vec2& padding) {
        setPadding(padding.x,padding.y);
    }

    void setPadding(float padx, float pady);
    
    void setPaddingX(float padx) {
        setPadding(padx,_padding.y);
    }

    void setPaddingY(float pady) {
        setPadding(_padding.x,pady);
    }
    
    HAlign getHorizontalAlignment() const { return _halign; }

    void setHorizontalAlignment(HAlign halign);

    VAlign getVerticalAlignment() const { return _valign; }
    
    void setVerticalAlignment(VAlign valign);

    const Rect& getTextBounds() const { return _textbounds; }

    const Rect getTrueBounds() const  {
        return Rect(_textbounds.origin+_truebounds.origin,_truebounds.size);
    }
    
    float getBaseLine() const;

    virtual void setContentSize(const Size& size) override;
    
    virtual void setContentSize(float width, float height) override {
        setContentSize(Size(width, height));
    }
    
#pragma mark -
#pragma mark Other Attributes

    Color4 getForeground() const { return _foreground; }

    void setForeground(Color4 color) { _foreground = color; updateColor(); }

    Color4 getBackground() const { return _background; }
    
    void setBackground(Color4 color);
    
    std::shared_ptr<Font> getFont() const { return _font; }
    
    void setFont(const std::shared_ptr<Font>& font, bool resize=false);
    
#pragma mark -
#pragma mark Rendering

    void setBlendFunc(GLenum srcFactor, GLenum dstFactor) { _srcFactor = srcFactor; _dstFactor = dstFactor; }
    
    GLenum getSourceBlendFactor() const { return _srcFactor; }
    
    GLenum getDestinationBlendFactor() const { return _srcFactor; }
    
    void setBlendEquation(GLenum equation) { _blendEquation = equation; }
    
    GLenum getBlendEquation() const { return _blendEquation; }

    virtual void draw(const std::shared_ptr<SpriteBatch>& batch, const Mat4& transform, Color4 tint) override;
    
private:
#pragma mark -
#pragma mark Internal Helpers

    void computeSize();

    void generateRenderData();
    
    void clearRenderData();
    
    void updateColor();
};
    
}
#endif /* __CU_LABEL_H__ */