Widget.hpp

// Copyright 2019 Pokitec
// All rights reserved.
 
#pragma once
 
#include "TTauri/GUI/Window_forward.hpp"
#include "TTauri/GUI/GUIDevice_forward.hpp"
#include "TTauri/GUI/MouseEvent.hpp"
#include "TTauri/GUI/HitBox.hpp"
#include "TTauri/GUI/KeyboardEvent.hpp"
#include "TTauri/GUI/Theme.hpp"
#include "TTauri/Text/ShapedText.hpp"
#include "TTauri/Foundation/attributes.hpp"
#include "TTauri/Foundation/Path.hpp"
#include "TTauri/Foundation/R16G16B16A16SFloat.hpp"
#include "TTauri/Foundation/R32G32SFloat.hpp"
#include "TTauri/Foundation/URL.hpp"
#include "TTauri/Foundation/pickle.hpp"
#include "TTauri/Foundation/vspan.hpp"
#include "TTauri/Foundation/utils.hpp"
#include "TTauri/Foundation/Trigger.hpp"
#include "TTauri/Foundation/cpu_utc_clock.hpp"
#include "TTauri/Foundation/observable.hpp"
#include <rhea/constraint.hpp>
#include <limits>
#include <memory>
#include <vector>
#include <mutex>
#include <typeinfo>
 
namespace tt {
class DrawContext;
}
namespace tt::PipelineImage {
struct Image;
struct Vertex;
}
namespace tt::PipelineSDF {
struct Vertex;
}
namespace tt::PipelineFlat {
struct Vertex;
}
namespace tt::PipelineBox {
struct Vertex;
}
 
namespace tt {
 
 
class Widget {
protected:
    mutable std::recursive_mutex mutex;
 
    Window &window;
 
    Widget *parent;
 
    std::vector<std::unique_ptr<Widget>> children;
 
    Widget *content = nullptr;
 
    mat fromWindowTransform;
 
    mat toWindowTransform;
 
    vec minimumExtent;
 
    rhea::constraint minimumWidthConstraint;
    rhea::constraint minimumHeightConstraint;
 
    vec preferredExtent;
 
    rhea::constraint preferredWidthConstraint;
    rhea::constraint preferredHeightConstraint;
 
    vec fixedExtent;
 
    rhea::constraint fixedWidthConstraint;
    rhea::constraint fixedHeightConstraint;
 
    bool hover = false;
 
    bool focus = false;
 
public:
    rhea::variable const left;
    rhea::variable const bottom;
    rhea::variable const width;
    rhea::variable const height;
 
    rhea::linear_expression const right = left + width;
    rhea::linear_expression const centre = left + width * 0.5;
    rhea::linear_expression const top = bottom + height;
    rhea::linear_expression const middle = bottom + height * 0.5;
 
    float elevation;
 
    std::atomic<R32G32SFloat> _extent;
    std::atomic<R32G32SFloat> _offsetFromParent;
    std::atomic<R32G32SFloat> _offsetFromWindow;
 
    mutable std::atomic<bool> forceLayout = true;
    mutable std::atomic<bool> forceRedraw = true;
 
    observable<bool> enabled = true;
 
    Widget(Window &window, Widget *parent, vec defaultExtent) noexcept;
    virtual ~Widget();
 
    Widget(const Widget &) = delete;
    Widget &operator=(const Widget &) = delete;
    Widget(Widget &&) = delete;
    Widget &operator=(Widget &&) = delete;
 
    virtual Widget &addWidget(Alignment alignment, std::unique_ptr<Widget> childWidget) noexcept;
 
    template<typename T, typename... Args>
    T &makeWidgetDirectly(Args &&... args) {
        return static_cast<T &>(
            addWidget(Alignment::TopLeft, std::make_unique<T>(window, this, std::forward<Args>(args)...))
        );
    }
 
    template<typename T, typename... Args>
    T &makeWidget(Args &&... args) {
        if (content != nullptr) {
            return content->makeWidget<T>(std::forward<Args>(args)...);
        } else {
            return makeWidgetDirectly<T>(std::forward<Args>(args)...);
        }
    }
 
    template<typename T, typename... Args>
    T &makeAlignedWidgetDirectly(Alignment alignement, Args &&... args) {
        return static_cast<T &>(
            addWidget(alignement, std::make_unique<T>(window, this, std::forward<Args>(args)...))
        );
    }
 
    template<typename T, typename... Args>
    T &makeAlignedWidget(Alignment alignment, Args &&... args) {
        if (content != nullptr) {
            return content->makeAlignedWidget<T>(alignment, std::forward<Args>(args)...);
        } else {
            return makeAlignedWidgetDirectly<T>(alignment, std::forward<Args>(args)...);
        }
    }
 
    aarect makeWindowRectangle() const noexcept;
 
    void setMinimumExtent(vec newMinimumExtent) noexcept;
    void setMinimumExtent(float width, float height) noexcept;
 
    void setPreferredExtent(vec newPreferredExtent) noexcept;
 
    void setFixedExtent(vec newFixedExtent) noexcept;
    void setFixedHeight(float height) noexcept;
    void setFixedWidth(float width) noexcept;
 
    rhea::constraint placeBelow(Widget const &rhs, float margin=theme->margin) const noexcept;
    rhea::constraint placeAbove(Widget const &rhs, float margin=theme->margin) const noexcept;
 
    rhea::constraint placeLeftOf(Widget const &rhs, float margin=theme->margin) const noexcept;
 
    rhea::constraint placeRightOf(Widget const &rhs, float margin=theme->margin) const noexcept;
 
    rhea::constraint placeAtTop(float margin=theme->margin) const noexcept;
 
    rhea::constraint placeAtBottom(float margin=theme->margin) const noexcept;
 
    rhea::constraint placeLeft(float margin=theme->margin) const noexcept;
 
    rhea::constraint placeRight(float margin=theme->margin) const noexcept;
 
 
    [[nodiscard]] vec extent() const noexcept {
        return static_cast<vec>(_extent.load(std::memory_order::memory_order_relaxed));
    }
 
    void setExtent(vec rhs) noexcept {
        _extent.store(R32G32SFloat{rhs}, std::memory_order::memory_order_relaxed);
    }
 
    [[nodiscard]] vec offsetFromParent() const noexcept {
        return static_cast<vec>(_offsetFromParent.load(std::memory_order::memory_order_relaxed));
    }
 
    void setOffsetFromParent(vec rhs) noexcept {
        _offsetFromParent.store(R32G32SFloat{rhs}, std::memory_order::memory_order_relaxed);
    }
 
    [[nodiscard]] vec offsetFromWindow() const noexcept {
        return static_cast<vec>(_offsetFromWindow.load(std::memory_order::memory_order_relaxed));
    }
 
    void setOffsetFromWindow(vec rhs) noexcept {
        _offsetFromWindow.store(R32G32SFloat{rhs}, std::memory_order::memory_order_relaxed);
    }
 
    [[nodiscard]] aarect rectangle() const noexcept {
        return aarect{extent()};      
    }
 
    [[nodiscard]] aarect windowRectangle() const noexcept {
        return {
            vec::origin() + offsetFromWindow(),
            vec{extent()}
        };
    }
 
    [[nodiscard]] aarect clippingRectangle() const noexcept {
        return expand(windowRectangle(), Theme::margin);
    }
 
    [[nodiscard]] GUIDevice *device() const noexcept;
 
    [[nodiscard]] virtual HitBox hitBoxTest(vec position) const noexcept;
 
    [[nodiscard]] virtual bool acceptsFocus() const noexcept {
        return false;
    }
 
    [[nodiscard]] ssize_t nestingLevel() noexcept {
        return numeric_cast<ssize_t>(elevation);
    }
 
    [[nodiscard]] float z() noexcept {
        return elevation * 0.01f;
    }
 
    [[nodiscard]] virtual int needs(hires_utc_clock::time_point displayTimePoint) noexcept;
 
    virtual void layout(hires_utc_clock::time_point displayTimePoint) noexcept;
 
    [[nodiscard]] int layoutChildren(hires_utc_clock::time_point displayTimePoint, bool force) noexcept;
 
    virtual void draw(DrawContext const &drawContext, hires_utc_clock::time_point displayTimePoint) noexcept;
 
    virtual void handleCommand(string_ltag command) noexcept;
 
    virtual void handleMouseEvent(MouseEvent const &event) noexcept {
        auto lock = std::scoped_lock(mutex);
 
        if (event.type == MouseEvent::Type::Entered) {
            hover = true;
            forceRedraw = true;
        } else if (event.type == MouseEvent::Type::Exited) {
            hover = false;
            forceRedraw = true;
        }
    }
 
    [[nodiscard]] std::vector<Widget *> childPointers(bool reverse) const noexcept;
 
    [[nodiscard]] virtual Widget *nextKeyboardWidget(Widget const *currentKeyboardWidget, bool reverse) const noexcept;
 
    virtual void handleKeyboardEvent(KeyboardEvent const &event) noexcept {
        auto lock = std::scoped_lock(mutex);
 
        switch (event.type) {
        case KeyboardEvent::Type::Entered:
            focus = true;
            forceRedraw = true;
            break;
 
        case KeyboardEvent::Type::Exited:
            focus = false;
            forceRedraw = true;
            break;
 
        case KeyboardEvent::Type::Key:
            for (ttlet command : event.getCommands()) {
                handleCommand(command);
            }
            break;
 
        default:;
        }
    }
};
 
inline Widget * const foundWidgetPtr = reinterpret_cast<Widget *>(1);
 
}