size_policy.hpp

#ifndef TERMOX_WIDGET_SIZE_POLICY_HPP
#define TERMOX_WIDGET_SIZE_POLICY_HPP
#include <limits>
#include <utility>
 
#include <signals_light/signal.hpp>
 
namespace ox {
 
class Size_policy {
   private:
    struct Data {
        int hint            = 0;
        int min             = 0;
        int max             = maximum_max;
        double stretch      = 1.;
        bool can_ignore_min = true;
    } data_;
 
   public:
    sl::Signal<void()> policy_updated;
 
    static auto constexpr maximum_max =
        std::numeric_limits<decltype(data_.max)>::max();
 
   public:
    explicit Size_policy(int hint            = 0,
                         int min             = 0,
                         int max             = maximum_max,
                         double stretch      = 1.,
                         bool can_ignore_min = true);
 
    Size_policy(Size_policy const& x);
 
    Size_policy(Size_policy&& x);
 
    auto operator=(Size_policy const& x) -> Size_policy&;
 
    auto operator=(Size_policy&& x) -> Size_policy&;
 
    friend auto operator==(Size_policy const& a, Size_policy const& b) -> bool;
    friend auto operator!=(Size_policy const& a, Size_policy const& b) -> bool;
 
   public:
    void hint(int value);
 
    [[nodiscard]] auto hint() const -> int;
 
    void min(int value);
 
    [[nodiscard]] auto min() const -> int;
 
    void max(int value);
 
    [[nodiscard]] auto max() const -> int;
 
 
    void stretch(double value);
 
    [[nodiscard]] auto stretch() const -> double;
 
    void can_ignore_min(bool enable);
 
    [[nodiscard]] auto can_ignore_min() const -> bool;
 
   public:
    /* _Helper Methods_ */
    [[nodiscard]] static auto fixed(int hint) -> Size_policy;
 
    [[nodiscard]] static auto minimum(int hint) -> Size_policy;
 
    [[nodiscard]] static auto maximum(int hint) -> Size_policy;
 
    [[nodiscard]] static auto preferred(int hint) -> Size_policy;
 
    [[nodiscard]] static auto expanding(int hint) -> Size_policy;
 
    [[nodiscard]] static auto minimum_expanding(int hint) -> Size_policy;
 
    [[nodiscard]] static auto ignored() -> Size_policy;
};
 
template <int Hint, typename Widget_t>
struct Fixed_height : Widget_t {
    template <typename... Args>
    explicit Fixed_height(Args&&... args)
        : Widget_t{std::forward<Args>(args)...}
    {
        this->height_policy = Size_policy::fixed(Hint);
    }
 
    explicit Fixed_height(typename Widget_t::Parameters parameters)
        : Widget_t{std::move(parameters)}
    {
        this->height_policy = Size_policy::fixed(Hint);
    }
};
 
template <int Hint, typename Widget_t>
struct Fixed_width : Widget_t {
    template <typename... Args>
    explicit Fixed_width(Args&&... args) : Widget_t{std::forward<Args>(args)...}
    {
        this->width_policy = Size_policy::fixed(Hint);
    }
 
    explicit Fixed_width(typename Widget_t::Parameters parameters)
        : Widget_t{std::move(parameters)}
    {
        this->width_policy = Size_policy::fixed(Hint);
    }
};
 
template <int Hint, typename Widget_t>
struct Minimum_height : Widget_t {
    template <typename... Args>
    explicit Minimum_height(Args&&... args)
        : Widget_t{std::forward<Args>(args)...}
    {
        this->height_policy = Size_policy::minimum(Hint);
    }
 
    explicit Minimum_height(typename Widget_t::Parameters parameters)
        : Widget_t{std::move(parameters)}
    {
        this->height_policy = Size_policy::minimum(Hint);
    }
};
 
template <int Hint, typename Widget_t>
struct Minimum_width : Widget_t {
    template <typename... Args>
    explicit Minimum_width(Args&&... args)
        : Widget_t{std::forward<Args>(args)...}
    {
        this->width_policy = Size_policy::minimum(Hint);
    }
 
    explicit Minimum_width(typename Widget_t::Parameters parameters)
        : Widget_t{std::move(parameters)}
    {
        this->width_policy = Size_policy::minimum(Hint);
    }
};
 
template <int Hint, typename Widget_t>
struct Maximum_height : Widget_t {
    template <typename... Args>
    explicit Maximum_height(Args&&... args)
        : Widget_t{std::forward<Args>(args)...}
    {
        this->height_policy = Size_policy::maximum(Hint);
    }
 
    explicit Maximum_height(typename Widget_t::Parameters parameters)
        : Widget_t{std::move(parameters)}
    {
        this->height_policy = Size_policy::maximum(Hint);
    }
};
 
template <int Hint, typename Widget_t>
struct Maximum_width : Widget_t {
    template <typename... Args>
    explicit Maximum_width(Args&&... args)
        : Widget_t{std::forward<Args>(args)...}
    {
        this->width_policy = Size_policy::maximum(Hint);
    }
 
    explicit Maximum_width(typename Widget_t::Parameters parameters)
        : Widget_t{std::move(parameters)}
    {
        this->width_policy = Size_policy::maximum(Hint);
    }
};
 
template <int Hint, typename Widget_t>
struct Preferred_height : Widget_t {
    template <typename... Args>
    explicit Preferred_height(Args&&... args)
        : Widget_t{std::forward<Args>(args)...}
    {
        this->height_policy = Size_policy::preferred(Hint);
    }
 
    explicit Preferred_height(typename Widget_t::Parameters parameters)
        : Widget_t{std::move(parameters)}
    {
        this->height_policy = Size_policy::preferred(Hint);
    }
};
 
template <int Hint, typename Widget_t>
struct Preferred_width : Widget_t {
    template <typename... Args>
    explicit Preferred_width(Args&&... args)
        : Widget_t{std::forward<Args>(args)...}
    {
        this->width_policy = Size_policy::preferred(Hint);
    }
 
    explicit Preferred_width(typename Widget_t::Parameters parameters)
        : Widget_t{std::move(parameters)}
    {
        this->width_policy = Size_policy::preferred(Hint);
    }
};
 
template <int Hint, typename Widget_t>
struct Expanding_height : Widget_t {
    template <typename... Args>
    explicit Expanding_height(Args&&... args)
        : Widget_t{std::forward<Args>(args)...}
    {
        this->height_policy = Size_policy::expanding(Hint);
    }
 
    explicit Expanding_height(typename Widget_t::Parameters parameters)
        : Widget_t{std::move(parameters)}
    {
        this->height_policy = Size_policy::expanding(Hint);
    }
};
 
template <int Hint, typename Widget_t>
struct Expanding_width : Widget_t {
    template <typename... Args>
    explicit Expanding_width(Args&&... args)
        : Widget_t{std::forward<Args>(args)...}
    {
        this->width_policy = Size_policy::expanding(Hint);
    }
 
    explicit Expanding_width(typename Widget_t::Parameters parameters)
        : Widget_t{std::move(parameters)}
    {
        this->width_policy = Size_policy::expanding(Hint);
    }
};
 
template <int Hint, typename Widget_t>
struct Minimum_expanding_height : Widget_t {
    template <typename... Args>
    explicit Minimum_expanding_height(Args&&... args)
        : Widget_t{std::forward<Args>(args)...}
    {
        this->height_policy = Size_policy::minimum_expanding(Hint);
    }
 
    explicit Minimum_expanding_height(typename Widget_t::Parameters parameters)
        : Widget_t{std::move(parameters)}
    {
        this->height_policy = Size_policy::minimum_expanding(Hint);
    }
};
 
template <int Hint, typename Widget_t>
struct Minimum_expanding_width : Widget_t {
    template <typename... Args>
    explicit Minimum_expanding_width(Args&&... args)
        : Widget_t{std::forward<Args>(args)...}
    {
        this->width_policy = Size_policy::minimum_expanding(Hint);
    }
 
    explicit Minimum_expanding_width(typename Widget_t::Parameters parameters)
        : Widget_t{std::move(parameters)}
    {
        this->width_policy = Size_policy::minimum_expanding(Hint);
    }
};
 
template <typename Widget_t>
struct Ignored_height : Widget_t {
    template <typename... Args>
    explicit Ignored_height(Args&&... args)
        : Widget_t{std::forward<Args>(args)...}
    {
        this->height_policy = Size_policy::ignored();
    }
 
    explicit Ignored_height(typename Widget_t::Parameters parameters)
        : Widget_t{std::move(parameters)}
    {
        this->height_policy = Size_policy::ignored();
    }
};
 
template <typename Widget_t>
struct Ignored_width : Widget_t {
    template <typename... Args>
    explicit Ignored_width(Args&&... args)
        : Widget_t{std::forward<Args>(args)...}
    {
        this->width_policy = Size_policy::ignored();
    }
 
    explicit Ignored_width(typename Widget_t::Parameters parameters)
        : Widget_t{std::move(parameters)}
    {
        this->width_policy = Size_policy::ignored();
    }
};
 
[[nodiscard]] auto is_valid(Size_policy const& p) -> bool;
 
}  // namespace ox
#endif  // TERMOX_WIDGET_SIZE_POLICY_HPP