AWindowBase.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2024 Alex2772 and Contributors
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
//
// Created by alex2 on 6/9/2021.
//
 
#pragma once
 
#include <AUI/View/AViewContainer.h>
#include "AUI/Performance/APerformanceFrame.h"
#include "AUI/Performance/APerformanceSection.h"
#include "AWindowManager.h"
#include "AOverlappingSurface.h"
#include "ADragNDrop.h"
#include "AUI/Util/ATouchScroller.h"
#include "ATouchscreenKeyboardPolicy.h"
#include <chrono>
#include <optional>
 
namespace testing {
    class UITest;
}
 
class API_AUI_VIEWS AWindowBase: public AViewContainer {
    friend class SoftwareRenderer;
    friend class testing::UITest;
    friend struct IRenderingContext::Init;
 
public:
    using BeforeFrameQueue = AMessageQueue<AFakeMutex, IRenderer&>;
 
    AWindowBase();
 
    struct Profiling {
        _weak<AView> highlightView;
 
        bool highlightRedrawRequests = false;
 
        bool renderToTextureDecay = false;
 
        bool breakpointOnMarkMinContentSizeInvalid = false;
    };
 
 
    virtual void blockUserInput(bool blockUserInput = true);
 
    virtual ~AWindowBase();
 
 
    void preventClickOnPointerRelease();
 
    [[nodiscard]]
    bool isPreventingClickOnPointerRelease() const noexcept {
        return mPreventClickOnPointerRelease.valueOr(false);
    }
 
    template<aui::invocable<const _<AView>&> Callback>
    void iterateOverFocusChain(Callback&& callback) {
        for (auto view = mFocusedView.lock(); view;) {
            callback(view);
 
            auto container = _cast<AViewContainer>(view);
            if (!container) return;
            view = container->focusChainTarget();
        }
    }
 
    [[nodiscard]]
    virtual unsigned frameMillis() const noexcept = 0;
 
    static AWindowManager& getWindowManager() {
        return *getWindowManagerImpl();
    }
    template<typename WindowManager, typename... Args>
    static void setWindowManager(Args&&... args) {
        destroyWindowManager(); // destroys previous window manager so IEventLoop::Handle sets window manager to the
                                // previous one BEFORE the new window manager is set
        getWindowManagerImpl() = std::make_unique<WindowManager>(std::forward<Args>(args)...);
    }
    static void destroyWindowManager() {
        getWindowManagerImpl() = nullptr;
    }
 
    const _unique<IRenderingContext>& getRenderingContext() const {
        return mRenderingContext;
    }
 
    [[nodiscard]]
    BeforeFrameQueue& beforeFrameQueue() noexcept {
        return mBeforeFrameQueue;
    }
 
    void updateDpi();
 
    float getDpiRatio()
    {
        return mDpiRatio;
    }
 
    _<AView> getFocusedView() const
    {
        return mFocusedView.lock();
    }
 
    void setFocusedView(const _<AView>& view);
    void updateFocusChain();
    void onPointerPressed(const APointerPressedEvent& event) override;
 
    void onPointerMove(glm::vec2 pos, const APointerMoveEvent& event) override;
 
    void closeOverlappingSurfacesOnClick();
 
    bool isFocused() const {
        return mIsFocused;
    }
 
    [[nodiscard]]
    const glm::ivec2& getMousePos() const {
        return mMousePos;
    }
 
    void onKeyDown(AInput::Key key) override;
 
 
    virtual void focusNextView();
    virtual void flagRedraw();
 
    void makeCurrent() {
        currentWindowStorage() = this;
    }
 
    _<AOverlappingSurface> createOverlappingSurface(const glm::ivec2& position,
                                                    const glm::ivec2& size,
                                                    bool closeOnClick = true) {
        return createOverlappingSurface([&](unsigned attempt) -> AOptional<glm::ivec2> {
            switch (attempt) {
                case 0: return position;
                case 1: return glm::clamp(position, {0, 0}, {getSize() - size});
                default: return std::nullopt;
            }
        }, size, closeOnClick);
    }
 
    _<AOverlappingSurface> createOverlappingSurface(const std::function<AOptional<glm::ivec2>(unsigned)>& positionFactory,
                                                    const glm::ivec2& size,
                                                    bool closeOnClick = true) {
        glm::ivec2 position = {0, 0};
        auto maxPos = getSize() - size;
        for (unsigned index = 0; ; ++index) {
            auto optionalPosition = positionFactory(index);
            if (optionalPosition) {
                position = *optionalPosition;
 
                if (position.x >= 0 && position.y >= 0 && glm::all(glm::lessThan(position, maxPos))) {
                    break;
                }
            } else {
                break;
            }
        }
 
        auto tmp = createOverlappingSurfaceImpl(position, size);
        tmp->mParentWindow = this;
        tmp->mCloseOnClick = closeOnClick;
        mOverlappingSurfaces << tmp;
        return tmp;
    }
    void closeOverlappingSurface(AOverlappingSurface* surface) {
        if (mOverlappingSurfaces.erase(aui::ptr::fake(surface)) > 0) {
            closeOverlappingSurfaceImpl(surface);
        }
    }
 
    void onFocusLost() override;
    void render(ARenderContext context) override;
    void applyGeometryToChildren() override;
    void onPointerReleased(const APointerReleasedEvent& event) override;
 
    virtual bool onDragEnter(const ADragNDrop::EnterEvent& event);
    virtual void onDragLeave();
    virtual void onDragDrop(const ADragNDrop::DropEvent& event);
 
    void requestShowTouchscreenKeyboard();
 
    void requestHideTouchscreenKeyboard();
 
    bool shouldDisplayHoverAnimations() const;
 
    void onScroll(const AScrollEvent& event) override;
 
    virtual void forceUpdateCursor();
 
    bool onGesture(const glm::ivec2& origin, const AGestureEvent& event) override;
 
    static constexpr std::chrono::milliseconds DOUBLECLICK_MAX_DURATION = std::chrono::milliseconds(500);
 
    size_t getFps() {
        return mLastCapturedFps;
    }
 
    void setTouchscreenKeyboardPolicy(ATouchscreenKeyboardPolicy policy) noexcept {
        mKeyboardPolicy = policy;
    }
 
    struct ScalingParams {
        float scalingFactor = 1.f;
        AOptional<glm::uvec2> minimalWindowSizeDp = std::nullopt;
    };
 
    void setScalingParams(ScalingParams params);
 
    Profiling& profiling() {
        return mProfiling;
    }
 
    void markMinContentSizeInvalid() override;
 
signals:
    emits<>            dpiChanged;
    emits<glm::ivec2>  mouseMove;
    emits<AInput::Key> keyDown;
    emits<>            redrawn;
 
    emits<> touchscreenKeyboardShown;
 
 
    emits<> touchscreenKeyboardHidden;
 
#if AUI_PROFILING
    emits<APerformanceSection::Datas> performanceFrameComplete;
#endif
 
protected:
    bool mIsFocused = true;
 
    AOptional<bool> mPreventClickOnPointerRelease;
 
    bool mForceUpdateCursorGuard = false;
 
    bool mPerformDoubleClickOnPointerRelease = false;
 
    std::chrono::milliseconds mLastButtonPressedTime = std::chrono::milliseconds::zero();
    AOptional<APointerIndex> mLastButtonPressed;
    glm::vec2 mLastPosition = {0, 0};
 
    _unique<IRenderingContext> mRenderingContext;
 
    static AWindowBase*& currentWindowStorage();
 
    virtual _<AOverlappingSurface> createOverlappingSurfaceImpl(const glm::ivec2& position, const glm::ivec2& size) = 0;
    virtual void closeOverlappingSurfaceImpl(AOverlappingSurface* surface) = 0;
 
    virtual void createDevtoolsWindow();
 
    static _unique<AWindowManager>& getWindowManagerImpl();
 
    virtual float fetchDpiFromSystem() const;
 
    virtual void showTouchscreenKeyboardImpl();
    virtual void hideTouchscreenKeyboardImpl();
 
    void markPixelDataInvalid(ARect<int> invalidArea) override;
 
private:
    void processTouchscreenKeyboardRequest();
 
    _weak<AView> mFocusedView;
    Profiling mProfiling{};
    float mDpiRatio = 1.f;
    ScalingParams mScalingParams;
 
    BeforeFrameQueue mBeforeFrameQueue;
 
    ATouchscreenKeyboardPolicy mKeyboardPolicy = ATouchscreenKeyboardPolicy::SHOWN_IF_NEEDED;
 
    enum class KeyboardRequest {
        NO_OP,
        SHOW,
        HIDE
    };
 
    KeyboardRequest mKeyboardRequestedState = KeyboardRequest::NO_OP;
 
    glm::ivec2 mMousePos = {0, 0};
    ASet<_<AOverlappingSurface>> mOverlappingSurfaces;
 
    struct Scroll {
        APointerIndex pointer;
        ATouchScroller scroller;
    };
 
    ASmallVector<Scroll, 10 /* typical max number of fingers */> mScrolls;
 
    std::chrono::time_point<std::chrono::high_resolution_clock> mLastTimeFpsCaptured = std::chrono::high_resolution_clock::now();
    size_t mFpsCounter = 0;
    size_t mLastCapturedFps = 0;
 
#if AUI_SHOW_TOUCHES
    struct ShowTouches {
        glm::vec2 press;
        AVector<glm::vec2> moves;
        AOptional<glm::vec2> release;
    };
    AMap<APointerIndex, ShowTouches> mShowTouches;
#endif
};
 
 
#define AUI_ASSERT_UI_THREAD_ONLY() { AUI_ASSERTX((AWindow::current() ? AThread::current() == AWindow::current()->getThread() : AThread::current() == getThread()), "this method should be used in ui thread only."); }
 
#define AUI_ASSERT_WORKER_THREAD_ONLY() { AUI_ASSERTX(AThread::current() != AWindow::current()->getThread(), "this method should be used in worker thread only."); }