Make Window::SetHasShadow work on Windows and add SetVisibleInTaskbar

SetHasShadow was a no-op on Windows, so a frameless window kept the drop
shadow the compositor draws around its frame. Turn off non-client
rendering instead, which takes the shadow with it, and remember the flag
on the HWND so HasShadow() can answer.

SetVisibleInTaskbar is new: it adds and removes the window's taskbar
button through ITaskbarList, the only way to change it on a window that
is already on screen. The shell hands a window a fresh button every time
it is shown, so the flag is applied again after each show.

macOS has no per-window taskbar; it drops the window from the
application's Window menu instead. Linux sets the window manager's
skip-taskbar hint. The three mobile platforms record nothing.

Author: lijy91

src/capi/window_c.cpp

@@ -1006,6 +1006,33 @@ bool native_window_is_visible_on_all_workspaces(native_window_t window) {
   }
 }
 
+void native_window_set_visible_in_taskbar(native_window_t window, bool is_visible_in_taskbar) {
+  auto self = nativeapi::HandleTable::GetInstance().Resolve<nativeapi::Window>(window);
+  if (!self) {
+    return;
+  }
+  try {
+    self->SetVisibleInTaskbar(is_visible_in_taskbar);
+    return;
+  } catch (...) {
+    fprintf(stderr, "[nativeapi] %s: unexpected exception\n", "native_window_set_visible_in_taskbar");
+    return;
+  }
+}
+
+bool native_window_is_visible_in_taskbar(native_window_t window) {
+  auto self = nativeapi::HandleTable::GetInstance().Resolve<nativeapi::Window>(window);
+  if (!self) {
+    return false;
+  }
+  try {
+    return self->IsVisibleInTaskbar();
+  } catch (...) {
+    fprintf(stderr, "[nativeapi] %s: unexpected exception\n", "native_window_is_visible_in_taskbar");
+    return false;
+  }
+}
+
 void native_window_set_ignore_mouse_events(native_window_t window, bool is_ignore_mouse_events) {
   auto self = nativeapi::HandleTable::GetInstance().Resolve<nativeapi::Window>(window);
   if (!self) {

src/capi/window_c.h

@@ -308,6 +308,12 @@ void native_window_set_visible_on_all_workspaces(native_window_t window, bool is
 FFI_PLUGIN_EXPORT
 bool native_window_is_visible_on_all_workspaces(native_window_t window);
 
+FFI_PLUGIN_EXPORT
+void native_window_set_visible_in_taskbar(native_window_t window, bool is_visible_in_taskbar);
+
+FFI_PLUGIN_EXPORT
+bool native_window_is_visible_in_taskbar(native_window_t window);
+
 FFI_PLUGIN_EXPORT
 void native_window_set_ignore_mouse_events(native_window_t window, bool is_ignore_mouse_events);
 

src/platform/android/window_android.cpp

@@ -375,6 +375,14 @@ bool Window::IsVisibleOnAllWorkspaces() const {
   return false;
 }
 
+void Window::SetVisibleInTaskbar(bool is_visible_in_taskbar) {
+  ALOGW("SetVisibleInTaskbar not supported on Android");
+}
+
+bool Window::IsVisibleInTaskbar() const {
+  return false;
+}
+
 void Window::SetIgnoreMouseEvents(bool is_ignore_mouse_events) {
   ALOGW("SetIgnoreMouseEvents not supported on Android");
 }

src/platform/ios/window_ios.mm

@@ -418,6 +418,14 @@
   return false;
 }
 
+void Window::SetVisibleInTaskbar(bool is_visible_in_taskbar) {
+  // Not applicable to iOS
+}
+
+bool Window::IsVisibleInTaskbar() const {
+  return false;
+}
+
 void Window::SetIgnoreMouseEvents(bool is_ignore_mouse_events) {
   // Not applicable to iOS
 }

src/platform/linux/window_linux.cpp

@@ -695,6 +695,18 @@ bool Window::IsVisibleOnAllWorkspaces() const {
   return state & GDK_WINDOW_STATE_STICKY;
 }
 
+void Window::SetVisibleInTaskbar(bool is_visible_in_taskbar) {
+  if (pimpl_->widget_ && GTK_IS_WINDOW(pimpl_->widget_)) {
+    gtk_window_set_skip_taskbar_hint(GTK_WINDOW(pimpl_->widget_), !is_visible_in_taskbar);
+  }
+}
+
+bool Window::IsVisibleInTaskbar() const {
+  if (!pimpl_->widget_ || !GTK_IS_WINDOW(pimpl_->widget_))
+    return true;
+  return !gtk_window_get_skip_taskbar_hint(GTK_WINDOW(pimpl_->widget_));
+}
+
 void Window::SetIgnoreMouseEvents(bool is_ignore_mouse_events) {
   // This would involve setting input shapes or event masks
   // Provide stub implementation

src/platform/macos/window_macos.mm

@@ -686,6 +686,16 @@ static void NativeApiUpdateWindowClass(NSWindow* window, bool non_activating) {
   return [pimpl_->ns_window_ collectionBehavior] & NSWindowCollectionBehaviorCanJoinAllSpaces;
 }
 
+void Window::SetVisibleInTaskbar(bool is_visible_in_taskbar) {
+  // The Dock lists applications, not windows; the closest per-window list is the
+  // application's Window menu.
+  [pimpl_->ns_window_ setExcludedFromWindowsMenu:!is_visible_in_taskbar];
+}
+
+bool Window::IsVisibleInTaskbar() const {
+  return ![pimpl_->ns_window_ isExcludedFromWindowsMenu];
+}
+
 void Window::SetIgnoreMouseEvents(bool is_ignore_mouse_events) {
   [pimpl_->ns_window_ setIgnoresMouseEvents:is_ignore_mouse_events];
 }

src/platform/ohos/window_ohos.cpp

@@ -359,6 +359,14 @@ bool Window::IsVisibleOnAllWorkspaces() const {
   return false;
 }
 
+void Window::SetVisibleInTaskbar(bool is_visible_in_taskbar) {
+  // SetVisibleInTaskbar not supported on OpenHarmony
+}
+
+bool Window::IsVisibleInTaskbar() const {
+  return false;
+}
+
 void Window::SetIgnoreMouseEvents(bool is_ignore_mouse_events) {
   // SetIgnoreMouseEvents not supported on OpenHarmony
 }

src/platform/windows/window_windows.cpp

@@ -4,6 +4,7 @@
 #include <dwmapi.h>
 #include <windows.h>
 #include <commctrl.h>
+#include <shobjidl.h>
 #include <cmath>
 #include <iostream>
 #include <optional>
@@ -16,6 +17,7 @@
 #include "window_message_dispatcher.h"
 
 #pragma comment(lib, "dwmapi.lib")
+#pragma comment(lib, "ole32.lib")
 
 namespace nativeapi {
 
@@ -24,6 +26,33 @@ static const wchar_t* kWindowIdProperty = L"NativeAPIWindowId";
 // Set while the title bar is hidden. Kept on the HWND, like the style itself, so every
 // wrapper of the window agrees and the frame handling below outlives any one wrapper.
 static const wchar_t* kTitleBarHiddenProperty = L"NativeAPITitleBarHidden";
+// The other two window flags the system cannot be asked about afterwards, kept on the
+// HWND for the same reason.
+static const wchar_t* kNoShadowProperty = L"NativeAPINoShadow";
+static const wchar_t* kHiddenFromTaskbarProperty = L"NativeAPIHiddenFromTaskbar";
+
+// Adds or removes the window's taskbar button. The shell owns that button, so this is
+// the only way to change it on a window that is already on screen; the window style
+// alternative (WS_EX_TOOLWINDOW) only takes effect while the window is hidden and also
+// drops it from Alt+Tab.
+static void ApplyTaskbarVisibility(HWND hwnd, bool is_visible) {
+  const HRESULT com = CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
+  ITaskbarList* taskbar = nullptr;
+  if (SUCCEEDED(CoCreateInstance(CLSID_TaskbarList, nullptr, CLSCTX_INPROC_SERVER,
+                                 IID_PPV_ARGS(&taskbar)))) {
+    if (SUCCEEDED(taskbar->HrInit())) {
+      if (is_visible)
+        taskbar->AddTab(hwnd);
+      else
+        taskbar->DeleteTab(hwnd);
+    }
+    taskbar->Release();
+  }
+  // RPC_E_CHANGED_MODE says the thread already belongs to another apartment, which is
+  // then not ours to leave.
+  if (SUCCEEDED(com))
+    CoUninitialize();
+}
 
 #ifndef NATIVEAPI_ENABLE_WINUI3
 // A window with WS_THICKFRAME but no WS_CAPTION keeps its sizing frame on all sides.
@@ -117,10 +146,21 @@ static LRESULT CALLBACK WindowLifetimeProc(HWND hwnd, UINT message, WPARAM wp, L
     RemoveWindowSubclass(hwnd, WindowLifetimeProc, subclass_id);
     RemovePropW(hwnd, kWindowIdProperty);
     RemovePropW(hwnd, kTitleBarHiddenProperty);
+    RemovePropW(hwnd, kNoShadowProperty);
+    RemovePropW(hwnd, kHiddenFromTaskbarProperty);
     const auto result = DefSubclassProc(hwnd, message, wp, lp);
     WindowRegistry::GetInstance().Remove(static_cast<WindowId>(reference));
     return result;
   }
+  if (message == WM_WINDOWPOSCHANGED) {
+    const auto* pos = reinterpret_cast<const WINDOWPOS*>(lp);
+    const LRESULT result = DefSubclassProc(hwnd, message, wp, lp);
+    // The shell gives a window a fresh taskbar button every time it is shown, so a
+    // window that is meant to stay out of the taskbar has to leave it again.
+    if (pos && (pos->flags & SWP_SHOWWINDOW) && GetPropW(hwnd, kHiddenFromTaskbarProperty))
+      ApplyTaskbarVisibility(hwnd, false);
+    return result;
+  }
 #ifndef NATIVEAPI_ENABLE_WINUI3
   if (message == WM_NCCALCSIZE || message == WM_NCHITTEST || message == WM_PARENTNOTIFY) {
     if (auto handled = HandleHiddenTitleBarFrame(hwnd, message, wp, lp)) return *handled;
@@ -1086,12 +1126,25 @@ TitleBarStyle Window::GetTitleBarStyle() const {
 }
 
 void Window::SetHasShadow(bool has_shadow) {
-  // Windows shadow is typically handled automatically
-  // Custom shadow implementation would be complex
+  if (!pimpl_->hwnd_)
+    return;
+
+  // The shadow is part of the frame the desktop compositor draws around the window, so
+  // it goes away with the rest of that frame. On a window that still has a title bar
+  // the caption is drawn there too and the compositor keeps both.
+  DWMNCRENDERINGPOLICY policy = has_shadow ? DWMNCRP_USEWINDOWSTYLE : DWMNCRP_DISABLED;
+  if (FAILED(DwmSetWindowAttribute(pimpl_->hwnd_, DWMWA_NCRENDERING_POLICY, &policy,
+                                   sizeof(policy))))
+    return;
+
+  if (has_shadow)
+    RemovePropW(pimpl_->hwnd_, kNoShadowProperty);
+  else
+    SetPropW(pimpl_->hwnd_, kNoShadowProperty, reinterpret_cast<HANDLE>(1));
 }
 
 bool Window::HasShadow() const {
-  return true;  // Windows typically have shadows by default
+  return pimpl_->hwnd_ && !GetPropW(pimpl_->hwnd_, kNoShadowProperty);
 }
 
 void Window::SetOpacity(float opacity) {
@@ -1224,6 +1277,21 @@ bool Window::IsVisibleOnAllWorkspaces() const {
   return false;  // Not supported on Windows by default
 }
 
+void Window::SetVisibleInTaskbar(bool is_visible_in_taskbar) {
+  if (!pimpl_->hwnd_)
+    return;
+
+  if (is_visible_in_taskbar)
+    RemovePropW(pimpl_->hwnd_, kHiddenFromTaskbarProperty);
+  else
+    SetPropW(pimpl_->hwnd_, kHiddenFromTaskbarProperty, reinterpret_cast<HANDLE>(1));
+  ApplyTaskbarVisibility(pimpl_->hwnd_, is_visible_in_taskbar);
+}
+
+bool Window::IsVisibleInTaskbar() const {
+  return pimpl_->hwnd_ && !GetPropW(pimpl_->hwnd_, kHiddenFromTaskbarProperty);
+}
+
 void Window::SetIgnoreMouseEvents(bool is_ignore_mouse_events) {
   if (pimpl_->hwnd_) {
     LONG exStyle = GetWindowLong(pimpl_->hwnd_, GWL_EXSTYLE);

src/window.h

@@ -736,13 +736,25 @@ class Window : public NativeObjectProvider, public std::enable_shared_from_this<
    *
    * Controls the drop shadow effect around the window. On some platforms,
    * this may affect window compositing and visual effects.
+   *
+   * @note Platform availability:
+   * - macOS: ✅ Fully supported - Drops the shadow of any window
+   * - Windows: ⚠️ Frameless windows only - The desktop compositor always draws the
+   *   shadow of a window that has a title bar; with TitleBarStyle::Hidden the shadow
+   *   follows this flag
+   * - Linux: ⚠️ Recorded only - The window manager owns the shadow
+   * - Android: ❌ Not applicable - Always ignored
+   * - iOS: ❌ Not applicable - Always ignored
+   * - OpenHarmony: ❌ Not applicable - Always ignored
    */
   void SetHasShadow(bool has_shadow);
 
   /**
    * @brief Checks if the window currently displays a shadow.
    *
    * @return true if shadow is enabled, false otherwise
+   *
+   * @see SetHasShadow() for platform availability.
    */
   bool HasShadow() const;
 
@@ -819,6 +831,37 @@ class Window : public NativeObjectProvider, public std::enable_shared_from_this<
    */
   bool IsVisibleOnAllWorkspaces() const;
 
+  /**
+   * @brief Sets whether the window is listed in the taskbar.
+   *
+   * @param is_visible_in_taskbar true to list the window, false to hide it from the
+   *        taskbar
+   *
+   * A window hidden from the taskbar keeps its own appearance and behavior; only the
+   * shell's list of open windows drops it. Useful for overlays, tool palettes and
+   * windows an app shows from its tray icon. The window stays reachable through
+   * Alt+Tab on the platforms noted below.
+   *
+   * @note Platform availability:
+   * - macOS: ⚠️ Window menu only - The Dock lists applications, not windows, so the
+   *   window is only dropped from the application's Window menu
+   * - Windows: ✅ Fully supported - Adds or removes the window's taskbar button
+   * - Linux: ✅ Fully supported - Sets the window manager's skip-taskbar hint
+   * - Android: ❌ Not applicable - Always ignored
+   * - iOS: ❌ Not applicable - Always ignored
+   * - OpenHarmony: ❌ Not applicable - Always ignored
+   */
+  void SetVisibleInTaskbar(bool is_visible_in_taskbar);
+
+  /**
+   * @brief Checks if the window is listed in the taskbar.
+   *
+   * @return true if the window has a taskbar entry, false if it is hidden from it
+   *
+   * @see SetVisibleInTaskbar() for platform availability.
+   */
+  bool IsVisibleInTaskbar() const;
+
   /**
    * @brief Sets whether the window ignores mouse input events.
    *