AWindowBase.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2025 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 {
       AProperty<_weak<AView>> highlightView;

       AProperty<bool> highlightRedrawRequests = false;

       AProperty<bool> renderToTextureDecay = false;

       AProperty<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);

   aui::lazy<Profiling>& profiling() {
       return mProfiling;
   }
 
   void markMinContentSizeInvalid() override;
 
signals:
   emits<>            dpiChanged;
   emits<glm::ivec2>  mouseMove;
   emits<AInput::Key> keyDown;
   emits<>            redrawn;
   emits<>            layoutUpdateComplete;

   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;
   aui::lazy<Profiling> mProfiling = [] { return Profiling{}; };
   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() == nullptr || AThread::current() == AWindow::current()->getThread(), "this method should be used in ui thread only."); }

#define AUI_ASSERT_WORKER_THREAD_ONLY() { AUI_ASSERTX(AWindow::current() == nullptr || AThread::current() != AWindow::current()->getThread(), "this method should be used in worker thread only."); }
 

© 2025 AUI Framework Contributors. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. All trademarks are property of their respective owners.