Window full-screen events, and a full-screen fix for the title bar on Windows

WindowEnteredFullScreenEvent and WindowExitedFullScreenEvent report a window
entering and leaving full screen: on macOS from AppKit's did-enter/did-exit
notifications (the green button, the View menu and SetFullScreen() alike), on
Linux from the window manager's GDK_WINDOW_STATE_FULLSCREEN, and on Windows,
which has no full-screen window state, from SetFullScreen(). They are appended
after WindowClosedEvent, so the C event type values stay as they were.

Windows: SetTitleBarStyle() on a full-screen window no longer adds WS_CAPTION
to it, which put a title bar on the full-screen window; it records the caption
for leaving full screen instead, also for a window that had none before. A
maximized window with a hidden title bar now covers the taskbar in full screen:
the maximized clamp to the work area in WM_NCCALCSIZE skips full-screen windows.

Fixes #58

Author: lijy91

src/capi/window_c.cpp

@@ -1390,6 +1390,16 @@ bool to_c_window_event(const nativeapi::WindowEvent& event, native_window_event_
     (void)typed;
     return true;
   }
+  if (const auto* typed = dynamic_cast<const nativeapi::WindowEnteredFullScreenEvent*>(&event)) {
+    out->type = NATIVE_WINDOW_EVENT_TYPE_ENTERED_FULL_SCREEN;
+    (void)typed;
+    return true;
+  }
+  if (const auto* typed = dynamic_cast<const nativeapi::WindowExitedFullScreenEvent*>(&event)) {
+    out->type = NATIVE_WINDOW_EVENT_TYPE_EXITED_FULL_SCREEN;
+    (void)typed;
+    return true;
+  }
   return false;
 }
 

src/capi/window_c.h

@@ -84,6 +84,8 @@ typedef enum {
   NATIVE_WINDOW_EVENT_TYPE_RESIZED = 6,
   NATIVE_WINDOW_EVENT_TYPE_CREATED = 7,
   NATIVE_WINDOW_EVENT_TYPE_CLOSED = 8,
+  NATIVE_WINDOW_EVENT_TYPE_ENTERED_FULL_SCREEN = 9,
+  NATIVE_WINDOW_EVENT_TYPE_EXITED_FULL_SCREEN = 10,
 } native_window_event_type_t;
 
 /// One WindowEvent, tagged by its concrete type.

src/platform/linux/window_manager_linux.cpp

@@ -284,7 +284,7 @@ static void InstallGlobalSwizzling() {
 }
 
 // Show-state and geometry tracking for WindowMinimizedEvent, WindowMaximizedEvent,
-// WindowRestoredEvent, WindowMovedEvent and WindowResizedEvent. The windows are
+// WindowRestoredEvent, the full-screen pair, WindowMovedEvent and WindowResizedEvent. The windows are
 // usually created by someone else (Flutter's runner, the host application), so
 // the two toplevel signals are watched with emission hooks, like the focus pair.
 static gulong g_window_state_hook_id = 0;
@@ -375,6 +375,11 @@ static gboolean on_window_state_emission_hook(GSignalInvocationHint* ihint,
     g_window_signal_fn(g_window_signal_context, id,
                        (state & GDK_WINDOW_STATE_MAXIMIZED) ? "maximized" : "restored");
   }
+  if (changed & GDK_WINDOW_STATE_FULLSCREEN) {
+    g_window_signal_fn(g_window_signal_context, id,
+                       (state & GDK_WINDOW_STATE_FULLSCREEN) ? "entered_full_screen"
+                                                             : "exited_full_screen");
+  }
   return TRUE;  // Continue emission
 }
 
@@ -610,6 +615,12 @@ class WindowManager::Impl {
     } else if (event_type == "restored") {
       WindowRestoredEvent event(window_id);
       manager_->DispatchWindowEvent(event);
+    } else if (event_type == "entered_full_screen") {
+      WindowEnteredFullScreenEvent event(window_id);
+      manager_->DispatchWindowEvent(event);
+    } else if (event_type == "exited_full_screen") {
+      WindowExitedFullScreenEvent event(window_id);
+      manager_->DispatchWindowEvent(event);
     } else if (event_type == "moved" || event_type == "resized") {
       // Report what the getters return (the frame, decorations included), not
       // the content rectangle configure-event talks about.

src/platform/macos/window_manager_macos.mm

@@ -196,6 +196,20 @@ - (void)windowDidMove:(NSNotification*)notification {
   }
 }
 
+- (void)windowDidEnterFullScreen:(NSNotification*)notification {
+  NSWindow* window = [notification object];
+  if (_impl && window && nativeapi::g_window_event_trampoline) {
+    nativeapi::g_window_event_trampoline(_impl, window, "entered_full_screen");
+  }
+}
+
+- (void)windowDidExitFullScreen:(NSNotification*)notification {
+  NSWindow* window = [notification object];
+  if (_impl && window && nativeapi::g_window_event_trampoline) {
+    nativeapi::g_window_event_trampoline(_impl, window, "exited_full_screen");
+  }
+}
+
 - (void)windowDidChangeOcclusionState:(NSNotification*)notification {
   // Posted when a window comes on screen, for which AppKit has no notification
   // of its own
@@ -279,6 +293,14 @@ static WindowId ResolveWindowId(NSWindow* ns_window) {
                selector:@selector(windowDidMove:)
                    name:NSWindowDidMoveNotification
                  object:nil];
+    [center addObserver:delegate_
+               selector:@selector(windowDidEnterFullScreen:)
+                   name:NSWindowDidEnterFullScreenNotification
+                 object:nil];
+    [center addObserver:delegate_
+               selector:@selector(windowDidExitFullScreen:)
+                   name:NSWindowDidExitFullScreenNotification
+                 object:nil];
     [center addObserver:delegate_
                selector:@selector(windowDidChangeOcclusionState:)
                    name:NSWindowDidChangeOcclusionStateNotification
@@ -377,6 +399,12 @@ static WindowId ResolveWindowId(NSWindow* ns_window) {
   } else if (event_type == "restored") {
     WindowRestoredEvent event(window_id);
     manager_->DispatchWindowEvent(event);
+  } else if (event_type == "entered_full_screen") {
+    WindowEnteredFullScreenEvent event(window_id);
+    manager_->DispatchWindowEvent(event);
+  } else if (event_type == "exited_full_screen") {
+    WindowExitedFullScreenEvent event(window_id);
+    manager_->DispatchWindowEvent(event);
   } else if (event_type == "resized") {
     // The frame size, which is what Window::GetSize() returns
     NSRect frame = [window frame];

src/platform/windows/window_manager_windows.cpp

@@ -132,6 +132,23 @@ using WindowChangedFn = void (*)(void* impl, DWORD event, HWND hwnd);
 static WindowChangedFn g_window_changed_fn = nullptr;
 static void* g_window_changed_context = nullptr;
 
+// Window::SetFullScreen() reports its changes here: Windows has no full-screen
+// window state of its own, so there is nothing to be notified about.
+using FullScreenChangedFn = void (*)(void* impl, HWND hwnd, bool is_full_screen);
+static FullScreenChangedFn g_full_screen_changed_fn = nullptr;
+static void* g_full_screen_changed_context = nullptr;
+
+}  // namespace
+
+// Declared in window_windows.cpp, hence outside the anonymous namespace.
+void NotifyWindowFullScreenChanged(HWND hwnd, bool is_full_screen) {
+  if (g_full_screen_changed_fn && g_full_screen_changed_context) {
+    g_full_screen_changed_fn(g_full_screen_changed_context, hwnd, is_full_screen);
+  }
+}
+
+namespace {
+
 // Top-level windows that a listener can make sense of: anything already known
 // to the library, otherwise what the user sees as a window. Tooltips, menus and
 // other helper windows move and resize as well and must not get an id for it.
@@ -481,6 +498,11 @@ class WindowManager::Impl {
     g_window_changed_fn = [](void* impl, DWORD event, HWND hwnd) {
       static_cast<Impl*>(impl)->OnWindowChanged(event, hwnd);
     };
+    g_full_screen_changed_context = this;
+    g_full_screen_changed_fn = [](void* impl, HWND hwnd, bool is_full_screen) {
+      static_cast<Impl*>(impl)->OnWindowEvent(
+          hwnd, is_full_screen ? "entered_full_screen" : "exited_full_screen");
+    };
 
     // Unlike the foreground hook this only concerns our own windows, so it is
     // scoped to this process and costs nothing while other applications work.
@@ -526,6 +548,8 @@ class WindowManager::Impl {
     g_foreground_changed_context = nullptr;
     g_window_changed_fn = nullptr;
     g_window_changed_context = nullptr;
+    g_full_screen_changed_fn = nullptr;
+    g_full_screen_changed_context = nullptr;
     for (const auto& [hwnd, snapshot] : g_window_snapshots) {
       UnwatchWindowGeometry(hwnd);
     }
@@ -648,6 +672,12 @@ class WindowManager::Impl {
     } else if (event_type == "maximized") {
       WindowMaximizedEvent event(window_id);
       manager_->DispatchWindowEvent(event);
+    } else if (event_type == "entered_full_screen") {
+      WindowEnteredFullScreenEvent event(window_id);
+      manager_->DispatchWindowEvent(event);
+    } else if (event_type == "exited_full_screen") {
+      WindowExitedFullScreenEvent event(window_id);
+      manager_->DispatchWindowEvent(event);
     } else if (event_type == "resized" || event_type == "moved") {
       // Report what the getters return (logical pixels), not the raw rectangle
       auto window = WindowRegistry::GetInstance().Get(window_id);

src/platform/windows/window_windows.cpp

@@ -207,6 +207,10 @@ struct FullScreenState {
 };
 static std::unordered_map<HWND, FullScreenState> g_full_screen_windows;
 
+// Emits the full-screen pair; defined with the rest of the window events in
+// window_manager_windows.cpp.
+void NotifyWindowFullScreenChanged(HWND hwnd, bool is_full_screen);
+
 // The frame bits taken away while a window is full screen, and put back afterwards.
 static constexpr LONG_PTR kFullScreenRemovedStyle = WS_CAPTION | WS_THICKFRAME;
 static constexpr LONG_PTR kFullScreenRemovedExStyle =
@@ -297,7 +301,9 @@ static std::optional<LRESULT> HandleHiddenTitleBarFrame(HWND hwnd, UINT message,
     auto* params = reinterpret_cast<NCCALCSIZE_PARAMS*>(lp);
     const LONG top = params->rgrc[0].top;
     const LRESULT result = DefSubclassProc(hwnd, message, wp, lp);
-    if (!IsZoomed(hwnd)) {
+    // A full screen window keeps WS_MAXIMIZE when it was maximized, but it has no
+    // frame to hang past the monitor and must cover the taskbar too.
+    if (!IsZoomed(hwnd) || g_full_screen_windows.count(hwnd)) {
       params->rgrc[0].top = top;
       return result;
     }
@@ -690,6 +696,7 @@ void Window::SetFullScreen(bool is_full_screen) {
                  monitor.rcMonitor.right - monitor.rcMonitor.left,
                  monitor.rcMonitor.bottom - monitor.rcMonitor.top,
                  SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
+    NotifyWindowFullScreenChanged(hwnd, true);
     return;
   }
 
@@ -709,6 +716,7 @@ void Window::SetFullScreen(bool is_full_screen) {
   SetWindowPlacement(hwnd, &state.placement);
   SetWindowPos(hwnd, nullptr, 0, 0, 0, 0,
                SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
+  NotifyWindowFullScreenChanged(hwnd, false);
 }
 
 bool Window::IsFullScreen() const {
@@ -1393,13 +1401,19 @@ void Window::SetTitleBarStyle(TitleBarStyle style) {
 #ifdef NATIVEAPI_ENABLE_WINUI3
   if (!SetWinUI3TitleBarStyle(pimpl_->hwnd_, style)) return;
 #else
-  LONG_PTR flags = GetWindowLongPtrW(pimpl_->hwnd_, GWL_STYLE);
   // Keep the native caption style even when its non-client area is hidden by
   // HandleHiddenTitleBarFrame. Removing it makes Windows maximize the outer
   // window over the entire monitor, which also hides the taskbar. Clamping only
   // the client area in WM_NCCALCSIZE cannot fix the shell's fullscreen detection.
-  flags |= WS_CAPTION;
-  SetWindowLongPtrW(pimpl_->hwnd_, GWL_STYLE, flags);
+  const auto full_screen = g_full_screen_windows.find(pimpl_->hwnd_);
+  if (full_screen != g_full_screen_windows.end()) {
+    // A full screen window shows no caption; leaving full screen puts it back,
+    // also on a window that had none when it went full screen.
+    full_screen->second.style |= WS_CAPTION;
+  } else {
+    SetWindowLongPtrW(pimpl_->hwnd_, GWL_STYLE,
+                      GetWindowLongPtrW(pimpl_->hwnd_, GWL_STYLE) | WS_CAPTION);
+  }
 #endif
   // Read by WM_NCCALCSIZE during the frame change below.
   if (style == TitleBarStyle::Hidden) {

src/window.h

@@ -342,7 +342,10 @@ class Window : public NativeObjectProvider, public std::enable_shared_from_this<
    * @param is_full_screen true to enter fullscreen mode, false to exit
    *
    * In fullscreen mode, the window occupies the entire screen with no
-   * window decorations (title bar, borders) visible.
+   * window decorations (title bar, borders) visible. The change is reported by
+   * WindowEnteredFullScreenEvent and WindowExitedFullScreenEvent; on macOS and
+   * Linux it completes asynchronously, so IsFullScreen() may still return the old
+   * state right after this call.
    */
   void SetFullScreen(bool is_full_screen);
 
@@ -1596,4 +1599,50 @@ class WindowClosedEvent : public WindowEvent {
   std::string GetTypeName() const override { return "WindowClosedEvent"; }
 };
 
+/**
+ * Event class for a window entering full screen
+ *
+ * This event is emitted once a window is full screen, whoever made it so: SetFullScreen(),
+ * or the user through the system's own controls where there are any. IsFullScreen()
+ * already returns true. The new size is reported by WindowResizedEvent.
+ *
+ * @note Platform availability:
+ * - macOS: ✅ Fully supported - The green button, the View menu and SetFullScreen() alike;
+ *   emitted once the full-screen animation has finished.
+ * - Windows: ⚠️ SetFullScreen() only - Windows has no full-screen window state, so a window
+ *   another component makes borderless and monitor-sized is not reported.
+ * - Linux: ✅ Fully supported - Whatever the window manager reports, SetFullScreen() and
+ *   its own shortcuts (F11 in many) alike; emitted when the window manager confirms it.
+ * - Android: ❌ Not applicable - Never emitted
+ * - iOS: ❌ Not applicable - Never emitted
+ * - OpenHarmony: ❌ Not applicable - Never emitted
+ */
+class WindowEnteredFullScreenEvent : public WindowEvent {
+ public:
+  explicit WindowEnteredFullScreenEvent(WindowId window_id) : WindowEvent(window_id) {}
+
+  std::string GetTypeName() const override { return "WindowEnteredFullScreenEvent"; }
+};
+
+/**
+ * Event class for a window leaving full screen
+ *
+ * This event is emitted once a window is no longer full screen, whoever ended it.
+ * IsFullScreen() already returns false.
+ *
+ * @note Platform availability:
+ * - macOS: ✅ Fully supported - Emitted once the animation back has finished.
+ * - Windows: ⚠️ SetFullScreen() only - See WindowEnteredFullScreenEvent.
+ * - Linux: ✅ Fully supported - Emitted when the window manager confirms it.
+ * - Android: ❌ Not applicable - Never emitted
+ * - iOS: ❌ Not applicable - Never emitted
+ * - OpenHarmony: ❌ Not applicable - Never emitted
+ */
+class WindowExitedFullScreenEvent : public WindowEvent {
+ public:
+  explicit WindowExitedFullScreenEvent(WindowId window_id) : WindowEvent(window_id) {}
+
+  std::string GetTypeName() const override { return "WindowExitedFullScreenEvent"; }
+};
+
 }  // namespace nativeapi