spk_interface_window.hpp

#pragma once
 
#include <algorithm>
#include <iostream>
 
#include "structure/widget/spk_scalable_widget.hpp"
 
#include "structure/widget/spk_frame.hpp"
#include "structure/widget/spk_icon_button.hpp"
#include "structure/widget/spk_linear_layout.hpp"
#include "structure/widget/spk_text_label.hpp"
 
namespace spk
{
    template <typename TContentType>
    class InterfaceWindow : public spk::ScalableWidget
    {
    private:
        class TitleBar;
 
        class TitleBar : public spk::Widget
        {
            friend class InterfaceWindow;
 
        private:
            spk::HorizontalLayout _layout;
 
            spk::Frame _background;
            spk::TextLabel _titleLabel;
            spk::IconButton _minimizeButton;
            spk::IconButton _maximizeButton;
            spk::IconButton _closeButton;
 
            InterfaceWindow *_owner;
            bool _isDragging = false;
            bool _hasMouseFocus = false;
            spk::Vector2Int _dragStartMousePosition;
            spk::Extend2D _dragStartGeometry;
 
            void _onGeometryChange() override
            {
                _background.setGeometry(geometry().atOrigin());
                setHeight(geometry().size.y);
                _layout.setGeometry(geometry().atOrigin());
            }
 
        public:
            TitleBar(const std::wstring &p_name, spk::Widget *p_parent, InterfaceWindow *p_owner) :
                spk::Widget(p_name, p_parent),
                _background(p_name + L"/Background", this),
                _titleLabel(p_name + L"/TitleLabel", this),
                _minimizeButton(p_name + L"/MinimizeButton", this),
                _maximizeButton(p_name + L"/MaximizeButton", this),
                _closeButton(p_name + L"/CloseButton", this),
                _owner(p_owner)
            {
                _background.setLayer(0);
                _background.setCornerSize({4, 4});
                _background.activate();
 
                _titleLabel.setTexture(nullptr);
                _titleLabel.setLayer(1);
                _titleLabel.setCornerSize({0, 0});
                _titleLabel.setAlignment(spk::HorizontalAlignment::Centered, spk::VerticalAlignment::Centered);
                _titleLabel.activate();
 
                _minimizeButton.setLayer(1);
                _minimizeButton.setTexture(&spk::Widget::Style::defaultInterfaceWindowButtonReleased, spk::IconButton::State::Released);
                _minimizeButton.setTexture(&spk::Widget::Style::defaultInterfaceWindowButtonPressed, spk::IconButton::State::Pressed);
                _minimizeButton.setCornerSize({4, 4});
                _minimizeButton.setIconTexture(spk::Widget::Style::defaultIconset);
                _minimizeButton.setIconSpriteID({3, 0});
                _minimizeButton.setIconPadding({5, 5});
                _minimizeButton.activate();
 
                _maximizeButton.setLayer(1);
                _maximizeButton.setTexture(&spk::Widget::Style::defaultInterfaceWindowButtonReleased, spk::IconButton::State::Released);
                _maximizeButton.setTexture(&spk::Widget::Style::defaultInterfaceWindowButtonPressed, spk::IconButton::State::Pressed);
                _maximizeButton.setCornerSize({4, 4});
                _maximizeButton.setIconTexture(spk::Widget::Style::defaultIconset);
                _maximizeButton.setIconSpriteID({1, 0});
                _maximizeButton.setIconPadding({5, 5});
                _maximizeButton.activate();
 
                _closeButton.setLayer(1);
                _closeButton.setTexture(&spk::Widget::Style::defaultInterfaceWindowButtonReleased, spk::IconButton::State::Released);
                _closeButton.setTexture(&spk::Widget::Style::defaultInterfaceWindowButtonPressed, spk::IconButton::State::Pressed);
                _closeButton.setCornerSize({4, 4});
                _closeButton.setIconTexture(spk::Widget::Style::defaultIconset);
                _closeButton.setIconSpriteID({0, 0});
                _closeButton.setIconPadding({5, 5});
                _closeButton.activate();
 
                setHeight(16);
 
                _layout.setPadding(2);
                _layout.addElement(&_titleLabel, spk::Layout::SizePolicy::Extend);
                _layout.addElement(&_minimizeButton, spk::Layout::SizePolicy::Desired);
                _layout.addElement(&_maximizeButton, spk::Layout::SizePolicy::Desired);
                _layout.addElement(&_closeButton, spk::Layout::SizePolicy::Desired);
 
                sizeHint().configureMinimalGenerator([&]() {
                    return (_layout.sizeHint().minimal());
                });
            }
 
            void setTitle(const std::wstring &p_title)
            {
                _titleLabel.setText(p_title);
                sizeHint().release();
            }
 
            void setHeight(size_t p_height)
            {
                _minimizeButton.sizeHint().setDesired({static_cast<uint32_t>(p_height), static_cast<uint32_t>(p_height)});
                _maximizeButton.sizeHint().setDesired({static_cast<uint32_t>(p_height), static_cast<uint32_t>(p_height)});
                _closeButton.sizeHint().setDesired({static_cast<uint32_t>(p_height), static_cast<uint32_t>(p_height)});
                sizeHint().release();
                _layout.sizeHint().release();
            }
 
            void toggleMaximizedMode()
            {
                if (_maximizeButton.iconSpriteID() == spk::Vector2UInt{2, 0})
                {
                    _maximizeButton.setIconSpriteID({1, 0});
                }
                else
                {
                    _maximizeButton.setIconSpriteID({2, 0});
                }
                _maximizeButton.setVisualState(spk::IconButton::State::Released);
            }
 
        private:
            bool _isInsideTitleLabel(const spk::Vector2Int &p_position) const
            {
                return (_titleLabel.geometry().contains(p_position));
            }
 
            void _releaseMouseFocus()
            {
                if (_hasMouseFocus == true)
                {
                    releaseFocus(FocusType::Mouse);
                    _hasMouseFocus = false;
                }
            }
 
            void _onMousePressEvent(spk::MousePressEvent &p_event) override
            {
                if (p_event.button != spk::Mouse::Button::Left || _isInsideTitleLabel(p_event.mouse.position) == false ||
                    _owner->_isMaximized == true)
                {
                    return;
                }
 
                _isDragging = true;
                _dragStartMousePosition = p_event.mouse.position;
                _dragStartGeometry = _owner->geometry();
 
                if (hasFocus(FocusType::Mouse) == false)
                {
                    takeFocus(FocusType::Mouse);
                    _hasMouseFocus = true;
                }
 
                p_event.isConsumed = true;
            }
 
            void _onMouseMotionEvent(spk::MouseMotionEvent &p_event) override
            {
                if (_isDragging == false)
                {
                    return;
                }
 
                spk::Vector2Int delta = p_event.position - _dragStartMousePosition;
                spk::Extend2D targetGeometry = _dragStartGeometry;
                targetGeometry.anchor += delta;
 
                _owner->setGeometry(targetGeometry);
                p_event.isConsumed = true;
            }
 
            void _onMouseReleaseEvent(spk::MouseReleaseEvent &p_event) override
            {
                if (_isDragging == false || p_event.button != spk::Mouse::Button::Left)
                {
                    return;
                }
 
                _isDragging = false;
                _releaseMouseFocus();
 
                p_event.isConsumed = true;
            }
 
            void _onMouseDoubleClickEvent(spk::MouseDoubleClickEvent &p_event) override
            {
                if (p_event.button != spk::Mouse::Button::Left || _isInsideTitleLabel(p_event.mouse.position) == false)
                {
                    return;
                }
 
                _owner->_toggleMaximizedMode();
                p_event.isConsumed = true;
            }
        };
 
        spk::VerticalLayout _layout;
 
        TitleBar _titleBar;
        TContentType _content;
 
        spk::IconButton::Contract _minimizeContract;
        bool _isMaximized = false;
        spk::Extend2D _baseGeometry;
        spk::Extend2D _maximizedGeometry;
        spk::IconButton::Contract _maximizeContract;
        spk::IconButton::Contract _closeContract;
 
        void _toggleMaximizedMode()
        {
            _titleBar.toggleMaximizedMode();
            spk::ScalableWidget::setGeometry(_isMaximized == false ? _maximizedGeometry : _baseGeometry);
            _isMaximized = !_isMaximized;
        }
 
        void _onGeometryChange() override
        {
            _layout.setGeometry(geometry().atOrigin());
        }
 
    public:
        InterfaceWindow(const std::wstring &p_name, spk::Widget *p_parent) :
            spk::ScalableWidget(p_name, p_parent),
            _titleBar(p_name + L"/TitleBar", this, this),
            _content(p_name + L"/Content", this)
        {
            _layout.setPadding(2);
            _layout.addElement(&_titleBar, spk::Layout::SizePolicy::Standard);
            _layout.addElement(&_content, spk::Layout::SizePolicy::Extend);
 
            _minimizeContract = _titleBar._minimizeButton.subscribe([&]() {
                _content.toggle();
            });
            _maximizeContract = _titleBar._maximizeButton.subscribe([&]() {
                _toggleMaximizedMode();
            });
            _closeContract = _titleBar._closeButton.subscribe([&]() {
                deactivate();
            });
 
            _titleBar.activate();
            _content.activate();
 
            sizeHint().configureMinimalGenerator([&]() {
                spk::Vector2UInt titleBarMinimalSize = _titleBar.sizeHint().minimal();
                spk::Vector2UInt contentMinimalSize = _content.sizeHint().minimal();
 
                return (spk::Vector2UInt{
                    std::max(titleBarMinimalSize.x, contentMinimalSize.x),
                    titleBarMinimalSize.y + 2 + contentMinimalSize.y});
            });
        }

        void setGeometry(const spk::Extend2D &p_geometry) override
        {
            spk::ScalableWidget::setGeometry(p_geometry);
            _baseGeometry = p_geometry;
        }

        void setTitle(const std::wstring &p_title)
        {
            _titleBar.setTitle(p_title);
            sizeHint().release();
        }

        void setTitleBarHeight(size_t p_height)
        {
            _titleBar.setHeight(p_height);
            sizeHint().release();
        }

        void setMaximizedSize(const spk::Extend2D &p_maximizedGeometry)
        {
            _maximizedGeometry = p_maximizedGeometry;
        }

        void maximize()
        {
            if (_isMaximized == false)
            {
                _toggleMaximizedMode();
            }
        }

        void minimize()
        {
            _content.deactivate();
        }

        void restore()
        {
            if (_content.isActive() == false)
            {
                _content.activate();
            }
 
            if (_isMaximized == true)
            {
                _toggleMaximizedMode();
            }
        }

        TContentType &content()
        {
            return _content;
        }

        const TContentType &content() const
        {
            return _content;
        }
    };
}