gui_anchor.hpp

#ifndef LXGUI_GUI_ANCHOR_HPP
#define LXGUI_GUI_ANCHOR_HPP
 
#include "lxgui/gui_vector2.hpp"
#include "lxgui/lxgui.hpp"
#include "lxgui/utils.hpp"
#include "lxgui/utils_observer.hpp"
 
#include <string>
 
namespace lxgui::gui {
 
class region;
 
enum class anchor_type { abs, rel };
 
enum class point {
    top_left = 0,
    top,
    top_right,
    right,
    bottom_right,
    bottom,
    bottom_left,
    left,
    center
};
 
enum class constraint { none, x, y };
 
struct anchor_data {
    anchor_data(point input_point) :
        object_point(input_point), parent_name("$default"), parent_point(input_point) {}
 
    anchor_data(point input_point, const std::string& input_parent) :
        object_point(input_point), parent_name(input_parent), parent_point(input_point) {}
 
    anchor_data(point input_point, const std::string& input_parent, point input_parent_point) :
        object_point(input_point), parent_name(input_parent), parent_point(input_parent_point) {}
 
    anchor_data(
        point              input_point,
        const std::string& input_parent,
        point              input_parent_point,
        const vector2f&    input_offset,
        anchor_type        input_type = anchor_type::abs) :
        object_point(input_point),
        parent_name(input_parent),
        parent_point(input_parent_point),
        offset(input_offset),
        type(input_type) {}
 
    anchor_data(
        point              input_point,
        const std::string& input_parent,
        const vector2f&    input_offset,
        anchor_type        input_type = anchor_type::abs) :
        object_point(input_point),
        parent_name(input_parent),
        parent_point(input_point),
        offset(input_offset),
        type(input_type) {}
 
    anchor_data(
        point           input_point,
        const vector2f& input_offset,
        anchor_type     input_type = anchor_type::abs) :
        object_point(input_point),
        parent_name("$default"),
        parent_point(input_point),
        offset(input_offset),
        type(input_type) {}
 
    anchor_data(
        point           input_point,
        point           input_parent_point,
        const vector2f& input_offset,
        anchor_type     input_type = anchor_type::abs) :
        object_point(input_point),
        parent_name("$default"),
        parent_point(input_parent_point),
        offset(input_offset),
        type(input_type) {}
 
    anchor_data(point input_point, point input_parent_point) :
        object_point(input_point), parent_name("$default"), parent_point(input_parent_point) {}
 
    point       object_point = point::top_left;
    std::string parent_name;
    point       parent_point = point::top_left;
    vector2f    offset;
    anchor_type type = anchor_type::abs;
};
 
class anchor : private anchor_data {
public:
    using anchor_data::object_point;
    using anchor_data::offset;
    using anchor_data::parent_point;
    using anchor_data::type;
 
    anchor(region& object, const anchor_data& data);
 
    // Non-copiable, non-movable
    anchor(const anchor&) = delete;
    anchor(anchor&&)      = delete;
    anchor& operator=(const anchor&) = delete;
    anchor& operator=(anchor&&) = delete;
 
    vector2f get_point(const region& object) const;
 
    const utils::observer_ptr<region>& get_parent() {
        return parent_;
    }
 
    utils::observer_ptr<const region> get_parent() const {
        return parent_;
    }
 
    std::string serialize(const std::string& tab) const;
 
    const anchor_data& get_data() const {
        return *this;
    }
 
private:
    void update_parent_(region& object);
 
    utils::observer_ptr<region> parent_ = nullptr;
};
 
} // namespace lxgui::gui
 
#endif