关键节点

editor/app/Platform/Win32/Chrome/HostRuntimeState.h

@@ -0,0 +1,226 @@
+#pragma once
+
+#include "BorderlessWindowFrame.h"
+
+#include <windows.h>
+
+namespace XCEngine::UI::Editor::Host {
+
+struct BorderlessWindowResizeState {
+    bool active = false;
+    BorderlessWindowResizeEdge edge = BorderlessWindowResizeEdge::None;
+    POINT initialScreenPoint = {};
+    RECT initialWindowRect = {};
+    BorderlessWindowResizeEdge hoveredEdge = BorderlessWindowResizeEdge::None;
+};
+
+struct PredictedClientPixelSize {
+    bool active = false;
+    UINT width = 0u;
+    UINT height = 0u;
+    bool presented = false;
+};
+
+struct BorderlessWindowPlacementState {
+    bool maximized = false;
+    bool hasRestoreRect = false;
+    RECT restoreRect = {};
+};
+
+struct BorderlessWindowDragRestoreState {
+    bool armed = false;
+    POINT initialScreenPoint = {};
+};
+
+class HostRuntimeState {
+public:
+    void Reset() {
+        m_windowDpi = 96u;
+        m_inInteractiveResize = false;
+        m_borderlessResizeState = {};
+        m_predictedClientPixelSize = {};
+        m_borderlessWindowPlacementState = {};
+        m_borderlessWindowDragRestoreState = {};
+        m_skipNextSteadyStateFrame = false;
+    }
+
+    void SetWindowDpi(UINT dpi) {
+        m_windowDpi = dpi == 0u ? 96u : dpi;
+    }
+
+    UINT GetWindowDpi() const {
+        return m_windowDpi;
+    }
+
+    float GetDpiScale(float baseDpiScale) const {
+        return baseDpiScale > 0.0f
+            ? static_cast<float>(m_windowDpi) / baseDpiScale
+            : 1.0f;
+    }
+
+    void BeginInteractiveResize() {
+        m_inInteractiveResize = true;
+    }
+
+    void EndInteractiveResize() {
+        m_inInteractiveResize = false;
+    }
+
+    bool IsInteractiveResize() const {
+        return m_inInteractiveResize;
+    }
+
+    void BeginBorderlessResize(
+        BorderlessWindowResizeEdge edge,
+        const POINT& initialScreenPoint,
+        const RECT& initialWindowRect) {
+        m_borderlessResizeState.active = edge != BorderlessWindowResizeEdge::None;
+        m_borderlessResizeState.edge = edge;
+        m_borderlessResizeState.initialScreenPoint = initialScreenPoint;
+        m_borderlessResizeState.initialWindowRect = initialWindowRect;
+        m_borderlessResizeState.hoveredEdge = edge;
+        m_inInteractiveResize = m_borderlessResizeState.active;
+    }
+
+    void EndBorderlessResize() {
+        m_borderlessResizeState.active = false;
+        m_borderlessResizeState.edge = BorderlessWindowResizeEdge::None;
+        m_inInteractiveResize = false;
+        m_predictedClientPixelSize = {};
+    }
+
+    bool IsBorderlessResizeActive() const {
+        return m_borderlessResizeState.active;
+    }
+
+    BorderlessWindowResizeEdge GetBorderlessResizeEdge() const {
+        return m_borderlessResizeState.edge;
+    }
+
+    const POINT& GetBorderlessResizeInitialScreenPoint() const {
+        return m_borderlessResizeState.initialScreenPoint;
+    }
+
+    const RECT& GetBorderlessResizeInitialWindowRect() const {
+        return m_borderlessResizeState.initialWindowRect;
+    }
+
+    void SetHoveredBorderlessResizeEdge(BorderlessWindowResizeEdge edge) {
+        m_borderlessResizeState.hoveredEdge = edge;
+    }
+
+    BorderlessWindowResizeEdge GetHoveredBorderlessResizeEdge() const {
+        return m_borderlessResizeState.hoveredEdge;
+    }
+
+    void SetPredictedClientPixelSize(UINT width, UINT height) {
+        if (width == 0u || height == 0u) {
+            m_predictedClientPixelSize = {};
+            return;
+        }
+
+        m_predictedClientPixelSize.active = true;
+        m_predictedClientPixelSize.width = width;
+        m_predictedClientPixelSize.height = height;
+        m_predictedClientPixelSize.presented = false;
+    }
+
+    void ClearPredictedClientPixelSize() {
+        m_predictedClientPixelSize = {};
+    }
+
+    bool TryGetPredictedClientPixelSize(UINT& outWidth, UINT& outHeight) const {
+        outWidth = 0u;
+        outHeight = 0u;
+        if (!m_predictedClientPixelSize.active ||
+            m_predictedClientPixelSize.width == 0u ||
+            m_predictedClientPixelSize.height == 0u) {
+            return false;
+        }
+
+        outWidth = m_predictedClientPixelSize.width;
+        outHeight = m_predictedClientPixelSize.height;
+        return true;
+    }
+
+    void MarkPredictedClientPixelSizePresented() {
+        if (!m_predictedClientPixelSize.active) {
+            return;
+        }
+
+        m_predictedClientPixelSize.presented = true;
+    }
+
+    bool ConsumePresentedPredictedClientPixelSizeMatch(UINT width, UINT height) {
+        if (!m_predictedClientPixelSize.active ||
+            !m_predictedClientPixelSize.presented ||
+            m_predictedClientPixelSize.width != width ||
+            m_predictedClientPixelSize.height != height) {
+            return false;
+        }
+
+        m_predictedClientPixelSize = {};
+        return true;
+    }
+
+    void RequestSkipNextSteadyStateFrame() {
+        m_skipNextSteadyStateFrame = true;
+    }
+
+    bool ConsumeSkipNextSteadyStateFrame() {
+        const bool skipFrame = m_skipNextSteadyStateFrame;
+        m_skipNextSteadyStateFrame = false;
+        return skipFrame;
+    }
+
+    void SetBorderlessWindowMaximized(bool maximized) {
+        m_borderlessWindowPlacementState.maximized = maximized;
+    }
+
+    bool IsBorderlessWindowMaximized() const {
+        return m_borderlessWindowPlacementState.maximized;
+    }
+
+    void SetBorderlessWindowRestoreRect(const RECT& rect) {
+        m_borderlessWindowPlacementState.restoreRect = rect;
+        m_borderlessWindowPlacementState.hasRestoreRect = true;
+    }
+
+    bool TryGetBorderlessWindowRestoreRect(RECT& outRect) const {
+        outRect = {};
+        if (!m_borderlessWindowPlacementState.hasRestoreRect) {
+            return false;
+        }
+
+        outRect = m_borderlessWindowPlacementState.restoreRect;
+        return true;
+    }
+
+    void BeginBorderlessWindowDragRestore(const POINT& initialScreenPoint) {
+        m_borderlessWindowDragRestoreState.armed = true;
+        m_borderlessWindowDragRestoreState.initialScreenPoint = initialScreenPoint;
+    }
+
+    void EndBorderlessWindowDragRestore() {
+        m_borderlessWindowDragRestoreState = {};
+    }
+
+    bool IsBorderlessWindowDragRestoreArmed() const {
+        return m_borderlessWindowDragRestoreState.armed;
+    }
+
+    const POINT& GetBorderlessWindowDragRestoreInitialScreenPoint() const {
+        return m_borderlessWindowDragRestoreState.initialScreenPoint;
+    }
+
+private:
+    UINT m_windowDpi = 96u;
+    bool m_inInteractiveResize = false;
+    BorderlessWindowResizeState m_borderlessResizeState = {};
+    PredictedClientPixelSize m_predictedClientPixelSize = {};
+    BorderlessWindowPlacementState m_borderlessWindowPlacementState = {};
+    BorderlessWindowDragRestoreState m_borderlessWindowDragRestoreState = {};
+    bool m_skipNextSteadyStateFrame = false;
+};
+
+} // namespace XCEngine::UI::Editor::Host