CUFloatLayout.h

//
//  CUFloatLayout.h
//  Cornell University Game Library (CUGL)
//
//  This module provides an support for a float layout.  Children in a float
//  layout are arranged in order, according to the layout orientation (horizontal
//  or vertical).  If there is not enough space in the Node for the children
//  to all be in the same row or column (depending on orientation), then the
//  later children wrap around to a new row or column.  This is the same way
//  that float layouts work in Java.
//
//  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_FLOAT_LAYOUT_H__
#define __CU_FLOAT_LAYOUT_H__
#include <cugl/2d/layout/CULayout.h>
#include <vector>
#include <unordered_map>
 
namespace cugl {
    
class FloatLayout : public Layout {
public:
    enum class Alignment : int {
        BOTTOM_LEFT     = 0,
        MIDDLE_LEFT     = 1,
        TOP_LEFT        = 2,
        BOTTOM_CENTER   = 3,
        CENTER          = 4,
        TOP_CENTER      = 5,
        BOTTOM_RIGHT    = 6,
        MIDDLE_RIGHT    = 7,
        TOP_RIGHT       = 8
    };
    
protected:
    std::vector<std::string> _priority;
    std::unordered_map<std::string,size_t> _keyset;
    
    bool _horizontal;
    Alignment _alignment;
    
#pragma mark Internal Helpers
 
    void layoutHorizontal(Node* node);
    
    void layoutVertical(Node* node);
 
    
#pragma mark Constructors
public:
    FloatLayout();
    
    ~FloatLayout() { dispose(); }
    
    virtual bool initWithData(const std::shared_ptr<JsonValue>& data) override;
    
    virtual void dispose() override { _priority.clear(); _keyset.clear(); }
    
    static std::shared_ptr<FloatLayout> alloc() {
        std::shared_ptr<FloatLayout> result = std::make_shared<FloatLayout>();
        return (result->init() ? result : nullptr);
    }
    
    static std::shared_ptr<FloatLayout> allocWithData(const std::shared_ptr<JsonValue>& data) {
        std::shared_ptr<FloatLayout> result = std::make_shared<FloatLayout>();
        return (result->initWithData(data) ? result : nullptr);
    }
    
#pragma mark Layout
 
    bool isHorizontal() const { return _horizontal; }
 
    void setHorizontal(bool value) { _horizontal = value; }
    
    Alignment getAlignment() const { return _alignment; }
    
    void setAlignment(Alignment value) { _alignment = value; }
 
    virtual bool add(const std::string key, const std::shared_ptr<JsonValue>& data) override;
    
    bool addPriority(const std::string key, size_t priority);
    
    virtual bool remove(const std::string key) override;
    
    virtual void layout(Node* node) override;
    
};
 
}
 
 
#endif /* __CU_FLOAT_LAYOUT_H__ */