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 "../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_vec2.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_vec2 preferred_size() const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        return _preferred_size;
    }
 
    [[nodiscard]] relative_base_line preferred_base_line() const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        return _preferred_base_line;
    }
 
    void set_layout_parameters(
        aarect const &window_rectangle,
        aarect const &window_clipping_rectangle,
        float window_base_line = std::numeric_limits<float>::infinity()) noexcept
    {
        if (std::isinf(window_base_line)) {
            window_base_line = _preferred_base_line.position(window_rectangle.bottom(), window_rectangle.top());
        }
 
        tt_axiom(gui_system_mutex.recurse_lock_count());
 
        if (_window_rectangle != window_rectangle) {
            // The previous position needs to be redrawn.
            window.request_redraw(_window_clipping_rectangle);
 
            _window_rectangle = window_rectangle;
            _request_relayout = true;
        }
 
        ttlet window_clipping_rectangle_clean =
            intersect(window_clipping_rectangle, expand(_window_rectangle, theme::global->borderWidth));
        if (_window_clipping_rectangle != window_clipping_rectangle_clean) {
            _window_clipping_rectangle = window_clipping_rectangle_clean;
            _request_relayout = true;
        }
 
        if (_window_base_line != window_base_line) {
            _window_base_line = window_base_line;
            _request_relayout = true;
        }
    }
 
    [[nodiscard]] aarect window_rectangle() const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        return _window_rectangle;
    }
 
    [[nodiscard]] virtual aarect window_clipping_rectangle() const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        return _window_clipping_rectangle;
    }
 
    [[nodiscard]] float window_base_line() const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        return _window_base_line;
    }
 
    [[nodiscard]] aarect rectangle() const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        return aarect{_window_rectangle.extent()};
    }
 
    [[nodiscard]] float base_line() const noexcept
    {
        tt_axiom(gui_system_mutex.recurse_lock_count());
        return _window_base_line - _window_rectangle.y();
    }
 
    [[nodiscard]] gui_device *device() const noexcept;
 
    [[nodiscard]] virtual hit_box hitbox_test(f32x4 window_position) const noexcept
    {
        ttlet lock = std::scoped_lock(gui_system_mutex);
 
        if (_window_clipping_rectangle.contains(window_position) && _window_rectangle.contains(window_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 draw_context make_draw_context(draw_context context) 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());
    }
 
    [[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 _from_window_transform;
 
    matrix3 _to_window_transform;
 
    bool _request_reconstrain = true;
 
    bool _request_relayout = true;
 
    aarect _window_rectangle;
 
    float _window_base_line;
 
    aarect _window_clipping_rectangle;
 
    interval_vec2 _preferred_size;
 
    relative_base_line _preferred_base_line = relative_base_line{};
 
    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