tab_widget.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 "widget.hpp"
#include "grid_widget.hpp"
#include "tab_delegate.hpp"
#include "../macros.hpp"
 
namespace hi { inline namespace v1 {
 
class tab_widget final : public widget {
public:
    using super = widget;
    using delegate_type = tab_delegate;
 
    std::shared_ptr<delegate_type> delegate;
 
    ~tab_widget()
    {
        hi_assert_not_null(delegate);
        delegate->deinit(*this);
    }
 
    tab_widget(widget *parent, std::shared_ptr<delegate_type> delegate) noexcept : super(parent), delegate(std::move(delegate))
    {
        hi_axiom(loop::main().on_thread());
        hi_assert_not_null(parent);
 
        // The tab-widget will not draw itself, only its selected child.
        semantic_layer = parent->semantic_layer;
 
        hi_assert_not_null(this->delegate);
        _delegate_cbt = this->delegate->subscribe([&] {
            ++global_counter<"tab_widget:delegate:constrain">;
            process_event({gui_event_type::window_reconstrain});
        });
 
        this->delegate->init(*this);
    }
 
    tab_widget(widget *parent, different_from<std::shared_ptr<delegate_type>> auto&& value) noexcept
        requires requires { make_default_tab_delegate(hi_forward(value)); }
        : tab_widget(parent, make_default_tab_delegate(hi_forward(value)))
    {
    }
 
    template<typename WidgetType, typename Key, typename... Args>
    WidgetType& make_widget(Key const& key, Args&&...args)
    {
        hi_axiom(loop::main().on_thread());
 
        auto tmp = std::make_unique<WidgetType>(this, std::forward<Args>(args)...);
        auto& ref = *tmp;
 
        hi_assert_not_null(delegate);
        delegate->add_tab(*this, static_cast<std::size_t>(key), size(_children));
        _children.push_back(std::move(tmp));
        ++global_counter<"tab_widget:make_widget:constrain">;
        process_event({gui_event_type::window_reconstrain});
        return ref;
    }
 
    [[nodiscard]] generator<widget_intf &> children(bool include_invisible) noexcept override
    {
        for (hilet& child : _children) {
            co_yield *child;
        }
    }
 
    [[nodiscard]] box_constraints update_constraints() noexcept override
    {
        _layout = {};
 
        auto& selected_child_ = selected_child();
 
        if (_previous_selected_child != &selected_child_) {
            _previous_selected_child = &selected_child_;
            hi_log_info("tab_widget::update_constraints() selected tab changed");
            process_event({gui_event_type::window_resize});
        }
 
        for (hilet& child : _children) {
            child->mode = child.get() == &selected_child_ ? widget_mode::enabled : widget_mode::invisible;
        }
 
        return selected_child_.update_constraints();
    }
    void set_layout(widget_layout const& context) noexcept override
    {
        _layout = context;
 
        for (hilet& child : _children) {
            if (*child->mode > widget_mode::invisible) {
                child->set_layout(context);
            }
        }
    }
    void draw(draw_context const& context) noexcept override
    {
        if (*mode > widget_mode::invisible) {
            for (hilet& child : _children) {
                child->draw(context);
            }
        }
    }
    [[nodiscard]] hitbox hitbox_test(point2 position) const noexcept override
    {
        hi_axiom(loop::main().on_thread());
 
        if (*mode >= widget_mode::partial) {
            auto r = hitbox{};
            for (hilet& child : _children) {
                r = child->hitbox_test_from_parent(position, r);
            }
            return r;
        } else {
            return {};
        }
    }
    [[nodiscard]] widget_id find_next_widget(
        widget_id current_widget,
        keyboard_focus_group group,
        keyboard_focus_direction direction) const noexcept override
    {
        hi_axiom(loop::main().on_thread());
        return selected_child().find_next_widget(current_widget, group, direction);
    }
private:
    widget const *_previous_selected_child = nullptr;
    std::vector<std::unique_ptr<widget>> _children;
    notifier<>::callback_token _delegate_cbt;
 
    using const_iterator = decltype(_children)::const_iterator;
 
    [[nodiscard]] const_iterator find_selected_child() const noexcept
    {
        hi_axiom(loop::main().on_thread());
        hi_assert_not_null(delegate);
 
        auto index = delegate->index(const_cast<tab_widget&>(*this));
        if (index >= 0 and index < ssize(_children)) {
            return _children.begin() + index;
        }
 
        return _children.end();
    }
    [[nodiscard]] widget& selected_child() const noexcept
    {
        hi_axiom(loop::main().on_thread());
        hi_assert(not _children.empty());
 
        auto i = find_selected_child();
        if (i != _children.cend()) {
            return **i;
        } else {
            return *_children.front();
        }
    }
};
 
}} // namespace hi::v1