Window_base.hpp

// Copyright 2019 Pokitec
// All rights reserved.
 
#pragma once
 
#include "TTauri/GUI/globals.hpp"
#include "TTauri/GUI/WindowDelegate.hpp"
#include "TTauri/GUI/GUIDevice_forward.hpp"
#include "TTauri/GUI/Cursor.hpp"
#include "TTauri/GUI/HitBox.hpp"
#include "TTauri/GUI/MouseEvent.hpp"
#include "TTauri/GUI/KeyboardEvent.hpp"
#include "TTauri/GUI/SubpixelOrientation.hpp"
#include "TTauri/Cells/Label.hpp"
#include "TTauri/Text/gstring.hpp"
#include "TTauri/Foundation/logger.hpp"
#include "TTauri/Foundation/vec.hpp"
#include "TTauri/Foundation/aarect.hpp"
#include "TTauri/Foundation/ivec.hpp"
#include "TTauri/Foundation/iaarect.hpp"
#include "TTauri/Foundation/Trigger.hpp"
#include "TTauri/Foundation/cpu_utc_clock.hpp"
#include "TTauri/Foundation/fast_mutex.hpp"
#include <rhea/simplex_solver.hpp>
#include <unordered_set>
#include <memory>
#include <mutex>
 
namespace tt {
class Widget;
 
class Window_base {
public:
    enum class State {
        Initializing, 
        NoWindow, 
        NoDevice, 
        NoSurface, 
        NoSwapchain, 
        ReadyToRender, 
        SwapchainLost, 
        SurfaceLost, 
        DeviceLost, 
        WindowLost, 
    };
 
    enum class Size {
        Normal,
        Minimized,
        Maximized
    };
 
    State state = State::NoDevice;
 
    Cursor currentCursor = Cursor::None;
 
    std::atomic<bool> forceLayout = true;
 
    std::atomic<bool> forceRedraw = true;
 
    std::atomic<bool> resizing = false;
 
    std::atomic<bool> active = false;
 
    Size size = Size::Normal;
 
    fast_mutex widgetSolverMutex;
 
    ivec minimumWindowExtent;
 
    ivec maximumWindowExtent;
 
    ivec currentWindowExtent;
 
    std::shared_ptr<WindowDelegate> delegate;
 
    Label title;
 
    GUIDevice *device = nullptr;
 
    SubpixelOrientation subpixelOrientation = SubpixelOrientation::BlueRight;
 
    float dpi = 72.0;
 
    [[nodiscard]] float fontScale() const noexcept {
        return dpi / (windowScale() * 72.0f);
    }
 
    std::unique_ptr<Widget> widget;
 
    Widget *mouseTargetWidget = nullptr;
 
    Widget *keyboardTargetWidget = nullptr;
 
    Widget *firstKeyboardWidget = nullptr;
 
    Widget *lastKeyboardWidget = nullptr;
 
    Window_base(std::shared_ptr<WindowDelegate> const &delegate, Label &&title);
    virtual ~Window_base();
 
    Window_base(Window_base const &) = delete;
    Window_base &operator=(Window_base const &) = delete;
    Window_base(Window_base &&) = delete;
    Window_base &operator=(Window_base &&) = delete;
 
    virtual void initialize();
 
    void setDevice(GUIDevice *device);
 
    void unsetDevice() { setDevice({}); }
 
    void layout(hires_utc_clock::time_point displayTimePoint);
 
    int layoutChildren(hires_utc_clock::time_point displayTimePoint, bool force);
 
    virtual void render(hires_utc_clock::time_point displayTimePoint) = 0;
 
    bool isClosed();
 
    template<typename T, typename... Args>
    T &makeWidget(Args &&... args);
 
    rhea::constraint addConstraint(rhea::constraint const& constraint) noexcept;
 
    rhea::constraint addConstraint(
        rhea::linear_equation const& equation,
        rhea::strength const &strength = rhea::strength::required(),
        double weight = 1.0
    ) noexcept;
 
    rhea::constraint addConstraint(
        rhea::linear_inequality const& equation,
        rhea::strength const &strength = rhea::strength::required(),
        double weight = 1.0
    ) noexcept;
 
    void removeConstraint(rhea::constraint const& constraint) noexcept;
 
    rhea::constraint replaceConstraint(
        rhea::constraint const &oldConstraint,
        rhea::constraint const &newConstraint
    ) noexcept;
 
    rhea::constraint replaceConstraint(
        rhea::constraint const &oldConstraint,
        rhea::linear_equation const &newEquation,
        rhea::strength const &strength = rhea::strength::required(),
        double weight = 1.0
    ) noexcept;
 
    rhea::constraint replaceConstraint(
        rhea::constraint const &oldConstraint,
        rhea::linear_inequality const &newEquation,
        rhea::strength const &strength = rhea::strength::required(),
        double weight = 1.0
    ) noexcept;
 
    virtual void setCursor(Cursor cursor) = 0;
 
    virtual void closeWindow() = 0;
 
    virtual void minimizeWindow() = 0;
    virtual void maximizeWindow() = 0;
    virtual void normalizeWindow() = 0;
    virtual void setWindowSize(ivec extent) = 0;
 
    [[nodiscard]] virtual std::string getTextFromClipboard() const noexcept = 0;
    virtual void setTextOnClipboard(std::string str) noexcept = 0;
 
    void updateToNextKeyboardTarget(Widget *currentTargetWidget) noexcept;
 
    void updateToPrevKeyboardTarget(Widget *currentTargetWidget) noexcept;
 
protected:
 
    iaarect OSWindowRectangle;
 
    [[nodiscard]] float windowScale() const noexcept;
 
    virtual void windowChangedSize(ivec extent);
 
    virtual void openingWindow();
 
    virtual void closingWindow();
 
    virtual void teardown() = 0;
 
    virtual void build() = 0;
 
    void updateMouseTarget(Widget const *newTargetWidget, vec position=vec{0.0f, 0.0f}) noexcept;
 
    void updateKeyboardTarget(Widget const *newTargetWidget) noexcept;
 
    void handleMouseEvent(MouseEvent event) noexcept;
 
    void handleKeyboardEvent(KeyboardEvent const &event) noexcept;
 
    void handleKeyboardEvent(KeyboardState _state, KeyboardModifiers modifiers, KeyboardVirtualKey key) noexcept;
 
    void handleKeyboardEvent(Grapheme grapheme, bool full=true) noexcept;
 
    void handleKeyboardEvent(char32_t c, bool full=true) noexcept;
 
    HitBox hitBoxTest(vec position) const noexcept;
 
private:
    rhea::simplex_solver widgetSolver;
 
 
    bool constraintsUpdated = false;
 
    rhea::constraint currentWindowExtentWidthConstraint;
 
    rhea::constraint currentWindowExtentHeightConstraint;
 
    vec suggestWidgetExtent(vec extent) noexcept;
 
    [[nodiscard]] std::pair<vec,vec> getMinimumAndMaximumWidgetExtent() noexcept;
 
    void layoutWindow() noexcept;
 
 
};
 
}