alignment.hpp

Go to the documentation of this file.

// Copyright Take Vos 2019, 2021-2022.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "../utility/module.hpp"
#include <optional>
 
namespace hi::inline v1 {
 
enum class vertical_alignment : uint8_t {
    none = 0,
 
    top = 1,
 
    middle = 2,
 
    bottom = 3
};
 
[[nodiscard]] constexpr std::optional<float> make_guideline(
    vertical_alignment alignment,
    float bottom,
    float top,
    float guideline_width)
{
    hi_axiom(is_integral_value(bottom));
    hi_axiom(is_integral_value(top));
    hi_axiom(is_integral_value(guideline_width));
    hi_axiom(bottom <= top);
    hi_axiom(guideline_width >= 0.0f);
 
    hilet guideline_bottom = bottom;
    hilet guideline_top = top - guideline_width;
    // XXX use std::round when constexpr.
    hilet guideline_middle = static_cast<float>(static_cast<long long>((bottom + top - guideline_width) / 2.0f + 0.5f));
 
    switch (alignment) {
    case vertical_alignment::none:
        return {};
    case vertical_alignment::top:
        if (guideline_bottom <= top) {
            return guideline_top;
        } else {
            return {};
        }
    case vertical_alignment::bottom:
        if (guideline_top >= bottom) {
            return guideline_top;
        } else {
            return {};
        }
    case vertical_alignment::middle:
        if (guideline_bottom <= guideline_top) {
            return std::clamp(guideline_middle, guideline_bottom, guideline_top);
        } else {
            return {};
        }
    }
    hi_no_default();
}
 
enum class horizontal_alignment : uint8_t {
    none = 0,
 
    flush = 1,
 
    left = 2,
 
    center = 3,
 
    justified = 4,
 
    right = 5,
};
 
[[nodiscard]] constexpr std::optional<float> make_guideline(
    horizontal_alignment alignment,
    float left,
    float right,
    float guideline_width = 0.0f)
{
    hi_axiom(is_integral_value(left));
    hi_axiom(is_integral_value(right));
    hi_axiom(is_integral_value(guideline_width));
    hi_axiom(left <= right);
    hi_axiom(guideline_width >= 0.0f);
 
    hilet guideline_left = left;
    hilet guideline_right = right - guideline_width;
    // XXX use std::round when constexpr.
    hilet guideline_center = static_cast<float>(static_cast<long long>((left + right - guideline_width) / 2.0f + 0.5f));
 
    switch (alignment) {
    case horizontal_alignment::none:
        return {};
    case horizontal_alignment::left:
        if (guideline_left <= right) {
            return guideline_left;
        } else {
            return {};
        }
    case horizontal_alignment::right:
        if (guideline_right >= left) {
            return guideline_right;
        } else {
            return {};
        }
    case horizontal_alignment::center:
        if (guideline_left <= guideline_right) {
            return std::clamp(guideline_center, guideline_left, guideline_right);
        } else {
            return {};
        }
    }
    hi_no_default();
}
 
[[nodiscard]] constexpr horizontal_alignment mirror(horizontal_alignment const& rhs) noexcept
{
    if (rhs == horizontal_alignment::left) {
        return horizontal_alignment::right;
    } else if (rhs == horizontal_alignment::right) {
        return horizontal_alignment::left;
    } else {
        return rhs;
    }
}
 
[[nodiscard]] constexpr horizontal_alignment mirror(horizontal_alignment const& rhs, bool left_to_right) noexcept
{
    if (left_to_right) {
        return rhs;
    } else {
        return mirror(rhs);
    }
}
 
[[nodiscard]] constexpr horizontal_alignment resolve(horizontal_alignment const& rhs, bool left_to_right) noexcept
{
    if (rhs == horizontal_alignment::flush or rhs == horizontal_alignment::justified) {
        return left_to_right ? horizontal_alignment::left : horizontal_alignment::right;
    } else {
        return rhs;
    }
}
 
[[nodiscard]] constexpr horizontal_alignment resolve_mirror(horizontal_alignment const& rhs, bool left_to_right) noexcept
{
    return resolve(mirror(rhs, left_to_right), left_to_right);
}
 
class alignment {
public:
    constexpr alignment() noexcept : _value(0) {}
    constexpr alignment(alignment const&) noexcept = default;
    constexpr alignment(alignment&&) noexcept = default;
    constexpr alignment& operator=(alignment const&) noexcept = default;
    constexpr alignment& operator=(alignment&&) noexcept = default;
 
    constexpr explicit alignment(uint8_t value) noexcept : _value(value) {}
 
    constexpr alignment(horizontal_alignment t, vertical_alignment v = vertical_alignment::none) noexcept :
        _value((to_underlying(v) << 4) | to_underlying(t))
    {
        hi_axiom(to_underlying(v) <= 0xf);
        hi_axiom(to_underlying(t) <= 0xf);
    }
 
    constexpr alignment(vertical_alignment v, horizontal_alignment h = horizontal_alignment::none) noexcept :
        _value((to_underlying(v) << 4) | to_underlying(h))
    {
        hi_axiom(to_underlying(v) <= 0xf);
        hi_axiom(to_underlying(h) <= 0xf);
    }
 
    [[nodiscard]] static constexpr alignment top_flush() noexcept
    {
        return {horizontal_alignment::flush, vertical_alignment::top};
    }
 
    [[nodiscard]] static constexpr alignment top_left() noexcept
    {
        return {horizontal_alignment::left, vertical_alignment::top};
    }
 
    [[nodiscard]] static constexpr alignment top_center() noexcept
    {
        return {horizontal_alignment::center, vertical_alignment::top};
    }
 
    [[nodiscard]] static constexpr alignment top_justified() noexcept
    {
        return {horizontal_alignment::justified, vertical_alignment::top};
    }
 
    [[nodiscard]] static constexpr alignment top_right() noexcept
    {
        return {horizontal_alignment::right, vertical_alignment::top};
    }
 
    [[nodiscard]] static constexpr alignment middle_flush() noexcept
    {
        return {horizontal_alignment::flush, vertical_alignment::middle};
    }
 
    [[nodiscard]] static constexpr alignment middle_left() noexcept
    {
        return {horizontal_alignment::left, vertical_alignment::middle};
    }
 
    [[nodiscard]] static constexpr alignment middle_center() noexcept
    {
        return {horizontal_alignment::center, vertical_alignment::middle};
    }
 
    [[nodiscard]] static constexpr alignment middle_justified() noexcept
    {
        return {horizontal_alignment::justified, vertical_alignment::middle};
    }
 
    [[nodiscard]] static constexpr alignment middle_right() noexcept
    {
        return {horizontal_alignment::right, vertical_alignment::middle};
    }
 
    [[nodiscard]] static constexpr alignment bottom_left() noexcept
    {
        return {horizontal_alignment::left, vertical_alignment::bottom};
    }
 
    [[nodiscard]] static constexpr alignment bottom_center() noexcept
    {
        return {horizontal_alignment::center, vertical_alignment::bottom};
    }
 
    [[nodiscard]] static constexpr alignment bottom_right() noexcept
    {
        return {horizontal_alignment::right, vertical_alignment::bottom};
    }
 
    [[nodiscard]] constexpr horizontal_alignment horizontal() const noexcept
    {
        return static_cast<horizontal_alignment>(_value & 0xf);
    }
 
    [[nodiscard]] constexpr vertical_alignment vertical() const noexcept
    {
        return static_cast<vertical_alignment>(_value >> 4);
    }
 
    [[nodiscard]] constexpr friend bool operator==(alignment const& lhs, alignment const& rhs) noexcept = default;
 
    [[nodiscard]] constexpr friend bool operator==(alignment const& lhs, horizontal_alignment const& rhs) noexcept
    {
        return lhs.horizontal() == rhs;
    }
 
    [[nodiscard]] constexpr friend bool operator==(horizontal_alignment const& lhs, alignment const& rhs) noexcept
    {
        return lhs == rhs.horizontal();
    }
 
    [[nodiscard]] constexpr friend bool operator==(alignment const& lhs, vertical_alignment const& rhs) noexcept
    {
        return lhs.vertical() == rhs;
    }
 
    [[nodiscard]] constexpr friend bool operator==(vertical_alignment const& lhs, alignment const& rhs) noexcept
    {
        return lhs == rhs.vertical();
    }
 
    [[nodiscard]] constexpr friend alignment mirror(alignment const& rhs) noexcept
    {
        return alignment{mirror(rhs.horizontal()), rhs.vertical()};
    }
 
    [[nodiscard]] constexpr friend alignment mirror(alignment const& rhs, bool left_to_right) noexcept
    {
        return alignment{mirror(rhs.horizontal(), left_to_right), rhs.vertical()};
    }
 
    [[nodiscard]] constexpr friend alignment resolve(alignment const& rhs, bool left_to_right) noexcept
    {
        return alignment{resolve(rhs.horizontal(), left_to_right), rhs.vertical()};
    }
 
    [[nodiscard]] constexpr friend alignment resolve_mirror(alignment const& rhs, bool left_to_right) noexcept
    {
        return alignment{resolve_mirror(rhs.horizontal(), left_to_right), rhs.vertical()};
    }
 
private:
    uint8_t _value;
};
 
constexpr alignment operator|(horizontal_alignment lhs, vertical_alignment rhs) noexcept
{
    return alignment{lhs, rhs};
}
 
constexpr alignment operator|(vertical_alignment lhs, horizontal_alignment rhs) noexcept
{
    return alignment{lhs, rhs};
}
 
} // namespace hi::inline v1