scroll_widget.hpp

// Copyright Take Vos 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 "widget.hpp"
#include "scroll_bar_widget.hpp"
#include "scroll_aperture_widget.hpp"
#include "scroll_delegate.hpp"
#include "../GUI/gui_window.hpp"
#include "../geometry/axis.hpp"
 
namespace hi::inline v1 {
 
template<axis Axis = axis::both, bool ControlsWindow = false>
class scroll_widget final : public widget {
public:
    using super = widget;
    using delegate_type = scroll_delegate<Axis, ControlsWindow>;
 
    static constexpr hi::axis axis = Axis;
    static constexpr bool controls_window = ControlsWindow;
 
    ~scroll_widget()
    {
        if (auto delegate = _delegate.lock()) {
            delegate->deinit(*this);
        }
    }
 
    scroll_widget(gui_window& window, widget *parent, std::weak_ptr<delegate_type> delegate = {}) noexcept :
        super(window, parent), _delegate(std::move(delegate))
    {
        hi_axiom(is_gui_thread());
        hi_axiom(parent);
 
        // The scroll-widget will not draw itself, only its selected content.
        semantic_layer = parent->semantic_layer;
 
        _aperture = std::make_unique<scroll_aperture_widget>(window, this);
        _horizontal_scroll_bar = std::make_unique<horizontal_scroll_bar_widget>(
            window, this, _aperture->content_width, _aperture->aperture_width, _aperture->offset_x);
        _vertical_scroll_bar = std::make_unique<vertical_scroll_bar_widget>(
            window, this, _aperture->content_height, _aperture->aperture_height, _aperture->offset_y);
 
        if (auto d = _delegate.lock()) {
            d->init(*this);
        }
    }
 
    template<typename Widget, typename... Args>
    Widget& make_widget(Args&&...args) noexcept
    {
        return _aperture->make_widget<Widget>(std::forward<Args>(args)...);
    }
 
    [[nodiscard]] generator<widget *> children() const noexcept override
    {
        co_yield _aperture.get();
        co_yield _vertical_scroll_bar.get();
        co_yield _horizontal_scroll_bar.get();
    }
 
    widget_constraints const& set_constraints() noexcept override
    {
        _layout = {};
        hilet aperture_constraints = _aperture->set_constraints();
        hilet horizontal_constraints = _horizontal_scroll_bar->set_constraints();
        hilet vertical_constraints = _vertical_scroll_bar->set_constraints();
 
        _constraints = aperture_constraints;
 
        // When there are scrollbars the widget minimum size becomes basically zero.
        // However we should at least have enough room to fit in the scroll-bars length-wise.
        if constexpr (any(axis & axis::horizontal)) {
            _constraints.minimum.width() = horizontal_constraints.minimum.width();
            inplace_max(_constraints.preferred.width(), horizontal_constraints.minimum.width());
            inplace_max(_constraints.maximum.width(), horizontal_constraints.minimum.width());
        }
        if constexpr (any(axis & axis::vertical)) {
            _constraints.minimum.height() = vertical_constraints.minimum.height();
            inplace_max(_constraints.preferred.height(), vertical_constraints.minimum.height());
            inplace_max(_constraints.maximum.height(), vertical_constraints.minimum.height());
        }
 
        // Make room for the thickness of the scroll-bars.
        if constexpr (any(axis & axis::horizontal)) {
            _constraints.minimum.height() += horizontal_constraints.preferred.height();
            _constraints.preferred.height() += horizontal_constraints.preferred.height();
            _constraints.maximum.height() += horizontal_constraints.preferred.height();
        }
        if constexpr (any(axis & axis::vertical)) {
            _constraints.minimum.width() += vertical_constraints.preferred.width();
            _constraints.preferred.width() += vertical_constraints.preferred.width();
            _constraints.maximum.width() += vertical_constraints.preferred.width();
        }
        return _constraints;
    }
 
    void set_layout(widget_layout const& layout) noexcept override
    {
        if (compare_store(_layout, layout)) {
            hilet horizontal_visible = _aperture->x_axis_scrolls() and any(axis & axis::horizontal);
            hilet vertical_visible = _aperture->y_axis_scrolls() and any(axis & axis::vertical);
            hilet both_visible = horizontal_visible and vertical_visible;
 
            _horizontal_scroll_bar->mode = horizontal_visible ? widget_mode::enabled : widget_mode::invisible;
            _vertical_scroll_bar->mode = vertical_visible ? widget_mode::enabled : widget_mode::invisible;
 
            hilet vertical_scroll_bar_width = _vertical_scroll_bar->constraints().preferred.width();
            hilet horizontal_scroll_bar_height = _horizontal_scroll_bar->constraints().preferred.height();
 
            // The aperture size grows to fill the size of the layout.
            hilet aperture_size = extent2{
                vertical_visible ? layout.width() - vertical_scroll_bar_width : layout.width(),
                horizontal_visible ? layout.height() - horizontal_scroll_bar_height : layout.height()};
            hilet aperture_offset = point2{0.0f, horizontal_visible ? horizontal_scroll_bar_height : 0.0f};
            _aperture_rectangle = aarectangle{aperture_offset, aperture_size};
 
            // The length of the scroll-bar is the full length of the widget, or just the length of the aperture depending
            // if the counter-part scroll-bar is visible.
            hilet horizontal_scroll_bar_size =
                extent2{both_visible ? aperture_size.width() : layout.width(), horizontal_scroll_bar_height};
            hilet vertical_scroll_bar_size =
                extent2{vertical_scroll_bar_width, both_visible ? aperture_size.height() : layout.height()};
 
            _vertical_scroll_bar_rectangle = aarectangle{
                point2{layout.width() - vertical_scroll_bar_size.width(), layout.height() - vertical_scroll_bar_size.height()},
                vertical_scroll_bar_size};
 
            _horizontal_scroll_bar_rectangle = aarectangle{point2{0.0f, 0.0f}, horizontal_scroll_bar_size};
 
            if constexpr (controls_window) {
                window.set_resize_border_priority(
                    true, not vertical_visible, not horizontal_visible, true);
            }
        }
 
        _aperture->set_layout(layout.transform(_aperture_rectangle));
        if (*_vertical_scroll_bar->mode > widget_mode::invisible) {
            _vertical_scroll_bar->set_layout(layout.transform(_vertical_scroll_bar_rectangle));
        }
        if (*_horizontal_scroll_bar->mode > widget_mode::invisible) {
            _horizontal_scroll_bar->set_layout(layout.transform(_horizontal_scroll_bar_rectangle));
        }
    }
 
    void draw(draw_context const& context) noexcept
    {
        if (*mode > widget_mode::invisible) {
            _vertical_scroll_bar->draw(context);
            _horizontal_scroll_bar->draw(context);
            _aperture->draw(context);
        }
    }
 
    [[nodiscard]] hitbox hitbox_test(point3 position) const noexcept override
    {
        hi_axiom(is_gui_thread());
 
        if (*mode >= widget_mode::partial) {
            auto r = _aperture->hitbox_test_from_parent(position);
            r = _horizontal_scroll_bar->hitbox_test_from_parent(position, r);
            r = _vertical_scroll_bar->hitbox_test_from_parent(position, r);
 
            if (layout().contains(position)) {
                r = std::max(r, hitbox{this, position});
            }
            return r;
 
        } else {
            return {};
        }
    }
    // @endprivatesection
private:
    std::weak_ptr<delegate_type> _delegate;
 
    aarectangle _aperture_rectangle;
    std::unique_ptr<scroll_aperture_widget> _aperture;
 
    aarectangle _horizontal_scroll_bar_rectangle;
    std::unique_ptr<horizontal_scroll_bar_widget> _horizontal_scroll_bar;
 
    aarectangle _vertical_scroll_bar_rectangle;
    std::unique_ptr<vertical_scroll_bar_widget> _vertical_scroll_bar;
};
 
template<bool ControlsWindow = false>
using vertical_scroll_widget = scroll_widget<axis::vertical, ControlsWindow>;
 
template<bool ControlsWindow = false>
using horizontal_scroll_widget = scroll_widget<axis::horizontal, ControlsWindow>;
 
} // namespace hi::inline v1