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 "../text/font_book.hpp"
#include "../GUI/gui_window_size.hpp"
#include "../GUI/theme.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 = {};
 
    extent2 window_size = {};
 
    gui_window_size window_size_state = gui_window_size::normal;
 
    hi::font_book *font_book = nullptr;
 
    hi::theme const *theme = nullptr;
 
    aarectangle clipping_rectangle = {};
 
    extent2 sub_pixel_size = {1.0f, 1.0f};
 
    unicode_bidi_class writing_direction = unicode_bidi_class::L;
 
    utc_nanoseconds display_time_point = {};
 
    float baseline = 0.0f;
 
    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 theme == nullptr;
    }
 
    [[nodiscard]] constexpr explicit operator bool() const noexcept
    {
        return not empty();
    }
 
    [[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 rectangle_on_window() const noexcept
    {
        return bounding_rectangle(to_window * rectangle());
    }
 
    [[nodiscard]] constexpr aarectangle clipping_rectangle_on_window() const noexcept
    {
        return bounding_rectangle(to_window * clipping_rectangle);
    }
 
    [[nodiscard]] constexpr aarectangle clipping_rectangle_on_window(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();
    }
 
    [[nodiscard]] constexpr bool left_to_right() const noexcept
    {
        return writing_direction == unicode_bidi_class::L;
    }
 
    [[nodiscard]] constexpr bool right_to_left() const noexcept
    {
        return not left_to_right();
    }
 
    constexpr widget_layout(
        extent2 window_size,
        gui_window_size window_size_state,
        hi::font_book& font_book,
        hi::theme const& theme,
        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),
        window_size(window_size),
        window_size_state(window_size_state),
        font_book(&font_book),
        theme(&theme),
        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 = *this;
        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));
        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