widget_layout.hpp

// 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 "gui_window_size.hpp"
#include "../layout/box_shape.hpp"
#include "../geometry/module.hpp"
#include "../unicode/module.hpp"
#include "../font/module.hpp"
#include "../GFX/module.hpp"
#include "../chrono.hpp"
#include "../utility/module.hpp"
 
namespace hi { inline namespace v1 {
 
class widget_layout {
public:
    static constexpr float redraw_overhang = 2;
 
    box_shape shape;
 
    translate2 to_parent = {};
 
    translate2 from_parent = {};
 
    translate2 to_window = {};
 
    translate2 from_window = {};
 
    extent2 window_size = {};
 
    float elevation = 0.0f;
 
    gui_window_size window_size_state = gui_window_size::normal;
 
    aarectangle clipping_rectangle = {};
 
    extent2 sub_pixel_size = {1.0f, 1.0f};
 
    utc_nanoseconds display_time_point = {};
 
    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&, widget_layout const&) noexcept = default;
 
    [[nodiscard]] constexpr bool empty() const noexcept
    {
        // Theme must always be set if layout is valid.
        return display_time_point == utc_nanoseconds{};
    }
 
    [[nodiscard]] constexpr explicit operator bool() const noexcept
    {
        return not empty();
    }
 
    [[nodiscard]] constexpr translate3 to_window3() const noexcept
    {
        return translate3{narrow_cast<translate2>(to_window), elevation};
    }
 
    [[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 shape.rectangle;
    }
 
    [[nodiscard]] constexpr aarectangle rectangle_on_window() const noexcept
    {
        return to_window * rectangle();
    }
 
    [[nodiscard]] constexpr aarectangle clipping_rectangle_on_window() const noexcept
    {
        return to_window * clipping_rectangle;
    }
 
    [[nodiscard]] constexpr aarectangle clipping_rectangle_on_window(aarectangle narrow_clipping_rectangle) const noexcept
    {
        return to_window * intersect(clipping_rectangle, narrow_clipping_rectangle);
    }
 
    [[nodiscard]] constexpr float width() const noexcept
    {
        return shape.width();
    }
 
    [[nodiscard]] constexpr float height() const noexcept
    {
        return shape.height();
    }
 
    [[nodiscard]] constexpr extent2 size() const noexcept
    {
        return shape.size();
    }
 
    constexpr widget_layout(
        extent2 window_size,
        gui_window_size window_size_state,
        hi::subpixel_orientation subpixel_orientation,
        utc_nanoseconds display_time_point) noexcept :
        to_parent(),
        from_parent(),
        to_window(),
        from_window(),
        shape(window_size),
        window_size(window_size),
        window_size_state(window_size_state),
        clipping_rectangle(window_size),
        sub_pixel_size(hi::sub_pixel_size(subpixel_orientation)),
        display_time_point(display_time_point)
    {
    }
 
    [[nodiscard]] constexpr widget_layout
    transform(box_shape const& child_shape, float child_elevation, aarectangle new_clipping_rectangle) const noexcept
    {
        widget_layout r = *this;
        r.shape.rectangle = aarectangle{child_shape.size()};
 
        if (child_shape.baseline) {
            r.shape.baseline = *child_shape.baseline - child_shape.y();
 
        } else if (r.shape.baseline) {
            // Use the baseline of the current layout and translate it.
            *r.shape.baseline -= child_shape.y();
        }
 
        if (child_shape.centerline) {
            r.shape.centerline = *child_shape.centerline - child_shape.x();
 
        } else if (r.shape.centerline) {
            // Use the baseline of the current layout and translate it.
            *r.shape.centerline -= child_shape.x();
        }
 
        r.to_parent = translate2{child_shape.x(), child_shape.y()};
        r.from_parent = ~r.to_parent;
        r.to_window = r.to_parent * this->to_window;
        r.from_window = r.from_parent * this->from_window;
        r.clipping_rectangle = r.from_parent * intersect(this->clipping_rectangle, new_clipping_rectangle);
        r.elevation += child_elevation;
        return r;
    }
 
    [[nodiscard]] constexpr widget_layout transform(box_shape const& child_shape, float child_elevation = 1.0f) const noexcept
    {
        return transform(child_shape, child_elevation, child_shape.rectangle + redraw_overhang);
    }
 
    [[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::v1