widget_layout.hpp

Go to the documentation of this file.

// Copyright Take Vos 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 "../geometry/matrix.hpp"
#include "../geometry/axis_aligned_rectangle.hpp"
#include "../geometry/transform.hpp"
#include "../geometry/translate.hpp"
#include "../unicode/unicode_bidi_class.hpp"
#include "../GFX/subpixel_orientation.hpp"
#include "../chrono.hpp"
#include "widget_baseline.hpp"
 
namespace hi { inline namespace v1 {
 
class widget_layout {
public:
    static constexpr float redraw_overhang = 2.0f;
 
    matrix3 to_parent;
 
    matrix3 from_parent;
 
    matrix3 to_window;
 
    matrix3 from_window;
 
    extent2 size;
 
    aarectangle clipping_rectangle;
 
    extent2 sub_pixel_size;
 
    unicode_bidi_class writing_direction;
 
    utc_nanoseconds display_time_point;
 
    float baseline;
 
    constexpr widget_layout(widget_layout const&) noexcept = default;
    constexpr widget_layout(widget_layout&&) noexcept = default;
    constexpr widget_layout& operator=(widget_layout const&) noexcept = default;
    constexpr widget_layout& operator=(widget_layout&&) noexcept = default;
    constexpr widget_layout() noexcept = default;
 
    [[nodiscard]] constexpr friend bool operator==(widget_layout const& lhs, widget_layout const& rhs) noexcept
    {
        hi_axiom((lhs.to_parent == rhs.to_parent) == (lhs.from_parent == rhs.from_parent));
        hi_axiom((lhs.to_window == rhs.to_window) == (lhs.from_window == rhs.from_window));
 
        // clang-format on
        return lhs.size == rhs.size and lhs.to_parent == rhs.to_parent and lhs.to_window == rhs.to_window and
            lhs.clipping_rectangle == rhs.clipping_rectangle and lhs.sub_pixel_size == rhs.sub_pixel_size and
            lhs.writing_direction == rhs.writing_direction and lhs.baseline == rhs.baseline;
        // clang-format off
    }
 
    [[nodiscard]] constexpr bool contains(point3 mouse_position) const noexcept
    {
        return rectangle().contains(mouse_position) and clipping_rectangle.contains(mouse_position);
    }
 
    [[nodiscard]] constexpr aarectangle rectangle() const noexcept
    {
        return aarectangle{size};
    }
 
    [[nodiscard]] constexpr aarectangle window_clipping_rectangle() const noexcept
    {
        return bounding_rectangle(to_window * clipping_rectangle);
    }
 
    [[nodiscard]] constexpr aarectangle window_clipping_rectangle(aarectangle narrow_clipping_rectangle) const noexcept
    {
        return bounding_rectangle(to_window * intersect(clipping_rectangle, narrow_clipping_rectangle));
    }
 
    [[nodiscard]] constexpr float width() const noexcept
    {
        return size.width();
    }
 
    [[nodiscard]] constexpr float height() const noexcept
    {
        return size.height();
    }
 
    constexpr widget_layout(
        extent2 window_size,
        hi::subpixel_orientation subpixel_orientation,
        unicode_bidi_class writing_direction,
        utc_nanoseconds display_time_point) noexcept :
        to_parent(),
        from_parent(),
        to_window(),
        from_window(),
        size(window_size),
        clipping_rectangle(window_size),
        sub_pixel_size(hi::sub_pixel_size(subpixel_orientation)),
        writing_direction(writing_direction),
        display_time_point(display_time_point),
        baseline()
    {
    }
 
    [[nodiscard]] constexpr widget_layout
    transform(aarectangle const &child_rectangle, float elevation, aarectangle new_clipping_rectangle, widget_baseline new_baseline = widget_baseline{}) const noexcept
    {
        auto to_parent3 = translate3{child_rectangle, elevation};
        auto from_parent3 = ~to_parent3;
 
        widget_layout r;
        r.to_parent = to_parent3;
        r.from_parent = from_parent3;
        r.to_window = to_parent3 * this->to_window;
        r.from_window = from_parent3 * this->from_window;
        r.size = child_rectangle.size();
        r.clipping_rectangle = bounding_rectangle(from_parent3 * intersect(this->clipping_rectangle, new_clipping_rectangle));
        r.sub_pixel_size = this->sub_pixel_size;
        r.writing_direction = this->writing_direction;
        r.display_time_point = this->display_time_point;
        if (new_baseline.empty()) {
            r.baseline = this->baseline - child_rectangle.bottom();
        } else {
            r.baseline = new_baseline.absolute(child_rectangle.height());
        }
        return r;
    }
 
    [[nodiscard]] constexpr widget_layout transform(aarectangle const &child_rectangle, float elevation = 1.0f, widget_baseline new_baseline = widget_baseline{}) const noexcept
    {
        return transform(child_rectangle, elevation, child_rectangle + redraw_overhang, new_baseline);
    }
 
    [[nodiscard]] constexpr widget_layout transform(aarectangle const &child_rectangle, widget_baseline new_baseline) const noexcept
    {
        return transform(child_rectangle, 1.0f, child_rectangle + redraw_overhang, new_baseline);
    }
 
    [[nodiscard]] constexpr widget_layout override_clip(aarectangle new_clipping_rectangle) const noexcept
    {
        auto r = *this;
        r.clipping_rectangle = new_clipping_rectangle;
        return r;
    }
};
 
}} // namespace hi::inline v1