grid_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 "../layout/layout.hpp"
#include "../macros.hpp"
#include <memory>
#include <coroutine>
 
hi_export_module(hikogui.widgets.grid_widget);
 
hi_export namespace hi { inline namespace v1 {
 
class grid_widget : public widget {
public:
    using super = widget;
 
    ~grid_widget() {}
 
    grid_widget(widget_intf const* parent) noexcept : widget(parent)
    {
    }
 
    /* Add a widget to the grid.
     */
    widget& insert(
        std::size_t first_column,
        std::size_t first_row,
        std::size_t last_column,
        std::size_t last_row,
        std::unique_ptr<widget> widget) noexcept
    {
        hi_axiom(loop::main().on_thread());
        hi_axiom(first_column < last_column);
        hi_axiom(first_row < last_row);
 
        if (_grid.cell_in_use(first_column, first_row, last_column, last_row)) {
            hi_log_fatal("cell ({},{}) of grid_widget is already in use", first_column, first_row);
        }
 
        auto& ref = *widget;
        _grid.add_cell(first_column, first_row, last_column, last_row, std::move(widget));
        hi_log_info("grid_widget::insert({}, {}, {}, {})", first_column, first_row, last_column, last_row);
 
        ++global_counter<"grid_widget:insert:constrain">;
        process_event({gui_event_type::window_reconstrain});
        return ref;
    }
 
    widget &push_front(std::unique_ptr<widget> widget) noexcept
    {
        for (auto &cell: _grid) {
            ++cell.first_column;
            ++cell.last_column;
        }
        return insert(0, 0, 1, 1, std::move(widget));
    }
 
    widget &push_back(std::unique_ptr<widget> widget) noexcept
    {
        auto it = std::max_element(_grid.begin(), _grid.end(), [](auto const &a, auto const &b) {
            return a.last_column < b.last_column;
        });
 
        if (it == _grid.end()) {
            return insert(0, 0, 1, 1, std::move(widget));
        } else {
            return insert(it->last_column, 0, it->last_column + 1, 1, std::move(widget));
        }
    }
 
    widget &push_top(std::unique_ptr<widget> widget) noexcept
    {
        for (auto &cell: _grid) {
            ++cell.first_row;
            ++cell.last_row;
        }
        return insert(0, 0, 1, 1, std::move(widget));
    }
 
    widget &push_bottom(std::unique_ptr<widget> widget) noexcept
    {
        auto it = std::max_element(_grid.begin(), _grid.end(), [](auto const &a, auto const &b) {
            return a.last_row < b.last_row;
        });
 
        if (it == _grid.end()) {
            return insert(0, 0, 1, 1, std::move(widget));
        } else {
            return insert(0, it->last_row, 1, it->last_row + 1, std::move(widget));
        }
    }
 
    template<typename Widget, typename... Args>
    Widget&
    emplace(std::size_t first_column, std::size_t first_row, std::size_t last_column, std::size_t last_row, Args&&...args)
    {
        hi_axiom(first_column < last_column);
        hi_axiom(first_row < last_row);
        auto tmp = std::make_unique<Widget>(this, std::forward<Args>(args)...);
        return static_cast<Widget&>(insert(first_column, first_row, last_column, last_row, std::move(tmp)));
    }
 
    template<typename Widget, typename... Args>
    Widget& emplace(std::size_t column, std::size_t row, Args&&...args)
    {
        return emplace<Widget>(column, row, column + 1, row + 1, std::forward<Args>(args)...);
    }
 
    template<typename Widget, typename... Args>
    Widget& emplace(std::string_view address, Args&&...args)
    {
        auto const[column_first, row_first, column_last, row_last] = parse_spreadsheet_range(address);
        return emplace<Widget>(column_first, row_first, column_last, row_last, std::forward<Args>(args)...);
    }
 
    template<typename Widget, typename... Args>
    Widget& emplace_front(Args&&...args)
    {
        return static_cast<Widget&>(push_front(std::make_unique<Widget>(this, std::forward<Args>(args)...)));
    }
 
    template<typename Widget, typename... Args>
    Widget& emplace_back(Args&&...args)
    {
        return static_cast<Widget&>(push_back(std::make_unique<Widget>(this, std::forward<Args>(args)...)));
    }
 
    template<typename Widget, typename... Args>
    Widget& emplace_top(Args&&...args)
    {
        return static_cast<Widget&>(push_top(std::make_unique<Widget>(this, std::forward<Args>(args)...)));
    }
 
    template<typename Widget, typename... Args>
    Widget& emplace_bottom(Args&&...args)
    {
        return static_cast<Widget&>(push_bottom(std::make_unique<Widget>(this, std::forward<Args>(args)...)));
    }
 
    void clear() noexcept
    {
        _grid.clear();
    }
 
    [[nodiscard]] generator<widget_intf &> children(bool include_invisible) noexcept override
    {
        for (auto const& cell : _grid) {
            co_yield *cell.value;
        }
    }
 
    [[nodiscard]] box_constraints update_constraints() noexcept override
    {
        _layout = {};
 
        for (auto& cell : _grid) {
            cell.set_constraints(cell.value->update_constraints());
        }
 
        return _grid.constraints(os_settings::left_to_right());
    }
 
    void set_layout(widget_layout const& context) noexcept override
    {
        if (compare_store(_layout, context)) {
            _grid.set_layout(context.shape, theme().baseline_adjustment());
        }
 
        for (auto const& cell : _grid) {
            cell.value->set_layout(context.transform(cell.shape, transform_command::level));
        }
    }
 
    void draw(draw_context const& context) noexcept override
    {
        if (mode() > widget_mode::invisible) {
            for (auto const& cell : _grid) {
                cell.value->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 (auto const& cell : _grid) {
                r = cell.value->hitbox_test_from_parent(position, r);
            }
            return r;
        } else {
            return {};
        }
    }
private:
    grid_layout<std::unique_ptr<widget>> _grid;
};
 
}} // namespace hi::v1