widget.hpp

// Copyright Take Vos 2019-2021.
// 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/gui_window.hpp"
#include "../GUI/gui_device.hpp"
#include "../GUI/mouse_event.hpp"
#include "../GUI/hit_box.hpp"
#include "../GUI/keyboard_event.hpp"
#include "../GUI/theme.hpp"
#include "../GUI/draw_context.hpp"
#include "../GUI/keyboard_focus_direction.hpp"
#include "../GUI/keyboard_focus_group.hpp"
#include "../text/shaped_text.hpp"
#include "../alignment.hpp"
#include "../graphic_path.hpp"
#include "../color/sfloat_rgba16.hpp"
#include "../color/sfloat_rg32.hpp"
#include "../geometry/transform.hpp"
#include "../URL.hpp"
#include "../vspan.hpp"
#include "../utils.hpp"
#include "../cpu_utc_clock.hpp"
#include "../observable.hpp"
#include "../command.hpp"
#include "../unfair_recursive_mutex.hpp"
#include "../interval_extent2.hpp"
#include "../flow_layout.hpp"
#include "../ranged_numeric.hpp"
#include <limits>
#include <memory>
#include <vector>
#include <mutex>
#include <typeinfo>
 
namespace tt::pipeline_image {
struct Image;
struct vertex;
} // namespace tt::pipeline_image
namespace tt::pipeline_SDF {
struct vertex;
}
namespace tt::pipeline_flat {
struct vertex;
}
namespace tt::pipeline_box {
struct vertex;
}
 
namespace tt {
class abstract_container_widget;
 
class widget : public std::enable_shared_from_this<widget> {
public:
    gui_window &window;
 
    observable<bool> enabled = true;
 
    widget(gui_window &window, std::shared_ptr<abstract_container_widget> parent) noexcept;
 
    virtual ~widget();
    widget(const widget &) = delete;
    widget &operator=(const widget &) = delete;
    widget(widget &&) = delete;
    widget &operator=(widget &&) = delete;
 
    virtual void init() noexcept {}
 
    [[nodiscard]] float margin() const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        return _margin;
    }
 
    [[nodiscard]] float draw_layer() const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        return _draw_layer;
    }
 
    [[nodiscard]] int logical_layer() const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        return _logical_layer;
    }
 
    [[nodiscard]] int semantic_layer() const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        return _semantic_layer;
    }
 
    [[nodiscard]] ranged_int<3> width_resistance() const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        return _width_resistance;
    }
 
    [[nodiscard]] ranged_int<3> height_resistance() const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        return _height_resistance;
    }
 
    [[nodiscard]] interval_extent2 preferred_size() const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        return _preferred_size;
    }
 
    void
    set_layout_parameters(geo::transformer auto const &local_to_parent, extent2 size, aarectangle const &clipping_rectangle) noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
 
        _local_to_parent = local_to_parent;
        _parent_to_local = ~local_to_parent;
        if (auto parent = _parent.lock()) {
            auto parent_ = reinterpret_cast<widget *>(parent.get());
            _local_to_window = local_to_parent * parent_->local_to_window();
            _window_to_local = ~local_to_parent * parent_->window_to_local();
        } else {
            _local_to_window = local_to_parent;
            _window_to_local = ~local_to_parent;
        }
        _size = size;
        _clipping_rectangle = clipping_rectangle;
        _visible_rectangle = intersect(aarectangle{size}, clipping_rectangle);
    }
 
    void
    set_layout_parameters_from_parent(aarectangle child_rectangle, aarectangle parent_clipping_rectangle, float draw_layer_delta) noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        tt_axiom(child_rectangle.extent() >= _preferred_size.minimum());
 
        ttlet child_translate = translate2{child_rectangle};
        ttlet child_size = child_rectangle.extent();
        ttlet rectangle = aarectangle{child_size};
        ttlet child_clipping_rectangle = intersect(~child_translate * parent_clipping_rectangle, expand(rectangle, margin()));
 
        set_layout_parameters(translate_z(draw_layer_delta) * child_translate, child_size, child_clipping_rectangle);
    }
 
    void set_layout_parameters_from_parent(aarectangle child_rectangle) noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
 
        if (auto parent = _parent.lock()) {
            auto parent_ = reinterpret_cast<widget *>(parent.get());
            ttlet draw_layer_delta = _draw_layer - parent_->draw_layer();
            return set_layout_parameters_from_parent(child_rectangle, parent_->clipping_rectangle(), draw_layer_delta);
        } else {
            return set_layout_parameters_from_parent(child_rectangle, child_rectangle, 0.0f);
        }
    }
 
    [[nodiscard]] matrix3 parent_to_local() const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        return _parent_to_local;
    }
 
    [[nodiscard]] matrix3 local_to_parent() const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        return _local_to_parent;
    }
 
    [[nodiscard]] matrix3 window_to_local() const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        return _window_to_local;
    }
 
    [[nodiscard]] matrix3 local_to_window() const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        return _local_to_window;
    }
 
    [[nodiscard]] extent2 size() const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        return _size;
    }
 
    [[nodiscard]] float width() const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        return _size.width();
    }
 
    [[nodiscard]] float height() const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        return _size.height();
    }
 
    [[nodiscard]] aarectangle rectangle() const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        return aarectangle{_size};
    }
 
    [[nodiscard]] virtual float base_line() const noexcept
    {
        return rectangle().middle();
    }
 
    [[nodiscard]] aarectangle clipping_rectangle() const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        return _clipping_rectangle;
    }
 
    [[nodiscard]] gui_device *device() const noexcept;
 
    [[nodiscard]] virtual hit_box hitbox_test(point2 position) const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
 
        if (_visible_rectangle.contains(position)) {
            return hit_box{weak_from_this(), _draw_layer};
        } else {
            return {};
        }
    }
 
    [[nodiscard]] virtual bool accepts_keyboard_focus(keyboard_focus_group group) const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        return false;
    }
 
    [[nodiscard]] virtual bool update_constraints(hires_utc_clock::time_point display_time_point, bool need_reconstrain) noexcept;
 
    [[nodiscard]] virtual void update_layout(hires_utc_clock::time_point display_time_point, bool need_layout) noexcept;
 
    virtual [[nodiscard]] color background_color() const noexcept;
 
    virtual [[nodiscard]] color foreground_color() const noexcept;
 
    virtual [[nodiscard]] color focus_color() const noexcept;
 
    virtual [[nodiscard]] color accent_color() const noexcept;
 
    virtual [[nodiscard]] color label_color() const noexcept;
 
    virtual void draw(draw_context context, hires_utc_clock::time_point display_time_point) noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
    }
 
    virtual void request_redraw() const noexcept
    {
        window.request_redraw(aarectangle{_local_to_window * _clipping_rectangle});
    }
 
    [[nodiscard]] virtual bool handle_event(command command) noexcept;
 
    [[nodiscard]] virtual bool handle_event(std::vector<command> const &commands) noexcept
    {
        for (ttlet command : commands) {
            if (handle_event(command)) {
                return true;
            }
        }
        return false;
    }
 
    [[nodiscard]] virtual bool
    handle_command_recursive(command command, std::vector<std::shared_ptr<widget>> const &reject_list) noexcept;
 
    [[nodiscard]] virtual bool handle_event(mouse_event const &event) noexcept;
 
    [[nodiscard]] virtual bool handle_event(keyboard_event const &event) noexcept;
 
    [[nodiscard]] virtual std::shared_ptr<widget> find_next_widget(
        std::shared_ptr<widget> const &current_keyboard_widget,
        keyboard_focus_group group,
        keyboard_focus_direction direction) const noexcept;
 
    [[nodiscard]] std::shared_ptr<abstract_container_widget const> shared_parent() const noexcept;
 
    [[nodiscard]] std::shared_ptr<abstract_container_widget> shared_parent() noexcept;
 
    [[nodiscard]] abstract_container_widget const &parent() const noexcept;
 
    [[nodiscard]] abstract_container_widget &parent() noexcept;
 
    [[nodiscard]] bool is_first(keyboard_focus_group group) const noexcept;
 
    [[nodiscard]] bool is_last(keyboard_focus_group group) const noexcept;
 
    [[nodiscard]] static std::vector<std::shared_ptr<widget>>
    parent_chain(std::shared_ptr<tt::widget> const &child_widget) noexcept;
 
protected:
    std::weak_ptr<abstract_container_widget> _parent;
 
    bool _hover = false;
 
    bool _focus = false;
 
    matrix3 _window_to_local;
 
    matrix3 _local_to_window;
 
    matrix3 _parent_to_local;
 
    matrix3 _local_to_parent;
 
    extent2 _size;
 
    aarectangle _clipping_rectangle;
 
    aarectangle _visible_rectangle;
 
    bool _request_reconstrain = true;
 
    bool _request_relayout = true;
 
    interval_extent2 _preferred_size;
 
    ranged_int<3> _width_resistance = 1;
    ranged_int<3> _height_resistance = 1;
 
    float _margin = theme::global->margin;
 
    float _draw_layer;
 
    int _semantic_layer;
 
    int _logical_layer;
 
private:
    typename decltype(enabled)::callback_ptr_type _enabled_callback;
};
 
} // namespace tt