Restore wine access after program loses and regains focus.

tests/foreground_focus_test.cpp

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+#include "../foreground_focus.h"
+#include "../review_x11.h"
+#pragma push_macro("_WIN32")
+#undef _WIN32
+#include <xcb/xcb.h>
+#pragma pop_macro("_WIN32")
+#include <cstdio>
+#include <cstdlib>
+#include <string>
+#include <vector>
+
+namespace {
+void pump() {
+  const auto deadline = GetTickCount64() + 100;
+  do {
+    MSG message{};
+    while (PeekMessageW(&message, nullptr, 0, 0, PM_REMOVE)) {
+      TranslateMessage(&message);
+      DispatchMessageW(&message);
+    }
+    Sleep(5);
+  } while (GetTickCount64() < deadline);
+}
+bool check(bool passed, const char *message) {
+  if (!passed) std::fprintf(stderr, "FAIL: %s\n", message);
+  return passed;
+}
+}
+
+int main(int argc, char **argv) {
+  if (argc != 2) return 2;
+  const std::string command = "\"Z:" + std::string(argv[1]) + "\"";
+  const int units = MultiByteToWideChar(CP_UTF8, 0, command.c_str(), -1, nullptr, 0);
+  std::vector<WCHAR> wideCommand(units);
+  MultiByteToWideChar(CP_UTF8, 0, command.c_str(), -1, wideCommand.data(), units);
+  STARTUPINFOW startup{};
+  startup.cb = sizeof(startup);
+  PROCESS_INFORMATION process{};
+  if (!CreateProcessW(nullptr, wideCommand.data(), nullptr, nullptr, FALSE, 0,
+          nullptr, nullptr, &startup, &process)) return 2;
+  HWND launcher = nullptr;
+  const auto deadline = GetTickCount64() + 5000;
+  while (!(launcher = FindWindowW(L"WineAccessForegroundFixture", nullptr)) &&
+      GetTickCount64() < deadline) Sleep(10);
+  if (!launcher) return 2;
+  HWND button = GetDlgItem(launcher, 1);
+  auto *connection = xcb_connect(nullptr, nullptr);
+  if (xcb_connection_has_error(connection)) return 2;
+  auto *screen = xcb_setup_roots_iterator(xcb_get_setup(connection)).data;
+  const auto desktop = static_cast<xcb_window_t>(reinterpret_cast<uintptr_t>(
+      GetPropW(GetDesktopWindow(), L"__wine_x11_whole_window")));
+  if (!desktop) return 2;
+  constexpr char name[] = "_NET_ACTIVE_WINDOW";
+  auto *atomReply = xcb_intern_atom_reply(connection,
+      xcb_intern_atom(connection, 0, sizeof(name) - 1, name), nullptr);
+  if (!atomReply) return 2;
+  const auto activeAtom = atomReply->atom;
+  std::free(atomReply);
+  constexpr char stateName[] = "WM_STATE";
+  auto *stateReply = xcb_intern_atom_reply(connection,
+      xcb_intern_atom(connection, 0, sizeof(stateName) - 1, stateName), nullptr);
+  if (!stateReply) return 2;
+  const auto stateAtom = stateReply->atom;
+  std::free(stateReply);
+  auto acknowledge = [&](HWND window) {
+    const auto xid = static_cast<xcb_window_t>(reinterpret_cast<uintptr_t>(
+        GetPropW(window, L"__wine_x11_whole_window")));
+    const uint32_t state[] = {1, XCB_WINDOW_NONE}; // ICCCM NormalState.
+    xcb_change_property(connection, XCB_PROP_MODE_REPLACE, xid,
+        stateAtom, stateAtom, 32, 2, state);
+    xcb_flush(connection);
+    pump();
+  };
+  const auto linuxWindow = xcb_generate_id(connection);
+  xcb_create_window(connection, XCB_COPY_FROM_PARENT, linuxWindow, screen->root,
+      0, 0, 20, 20, 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, screen->root_visual, 0, nullptr);
+  xcb_map_window(connection, linuxWindow);
+  auto focus = [&](xcb_window_t target, xcb_window_t active) {
+    xcb_change_property(connection, XCB_PROP_MODE_REPLACE, screen->root,
+        activeAtom, XCB_ATOM_WINDOW, 32, 1, &active);
+    xcb_set_input_focus(connection, XCB_INPUT_FOCUS_POINTER_ROOT, target, XCB_CURRENT_TIME);
+    xcb_flush(connection);
+    pump();
+  };
+  WNDCLASSW cls{};
+  cls.hInstance = GetModuleHandleW(nullptr);
+  cls.lpfnWndProc = DefWindowProcW;
+  cls.lpszClassName = L"WineAccessOtherFixture";
+  RegisterClassW(&cls);
+  HWND other = CreateWindowW(cls.lpszClassName, L"Second fixture", WS_OVERLAPPEDWINDOW,
+      380, 50, 300, 200, nullptr, nullptr, cls.hInstance, nullptr);
+  pump();
+  bool ok = true;
+  // Returning a launcher without activation leaves Wine's desktop with no
+  // remembered foreground, as when an external game window has closed.
+  ShowWindow(launcher, SW_HIDE);
+  pump();
+  ShowWindow(launcher, SW_SHOWNOACTIVATE);
+  acknowledge(launcher);
+  focus(linuxWindow, linuxWindow);
+  ok &= check(!GetForegroundWindow(), "Linux focus clears Wine foreground");
+  ok &= check(!restore_virtual_desktop_focus() && !GetForegroundWindow(), "Linux focus is never taken");
+  focus(desktop, linuxWindow);
+  ok &= check(!restore_virtual_desktop_focus(), "window manager must also select desktop");
+  focus(linuxWindow, desktop);
+  ok &= check(!restore_virtual_desktop_focus(), "X11 focus must also select desktop");
+  focus(desktop, desktop);
+  ok &= check(wine_x11_desktop_focused() && !GetForegroundWindow(), "reproduce orphaned virtual desktop focus");
+  EnableWindow(launcher, FALSE);
+  ok &= check(!restore_virtual_desktop_focus(), "disabled application is not activated");
+  EnableWindow(launcher, TRUE);
+  ShowWindow(other, SW_SHOWNOACTIVATE);
+  acknowledge(other);
+  focus(linuxWindow, linuxWindow);
+  focus(desktop, desktop);
+  ok &= check(!restore_virtual_desktop_focus() && !GetForegroundWindow(), "ambiguous applications are not chosen");
+  ShowWindow(other, SW_HIDE);
+  ok &= check(restore_virtual_desktop_focus(), "single application recovers foreground");
+  pump();
+  GUITHREADINFO gui{};
+  gui.cbSize = sizeof(gui);
+  GetGUIThreadInfo(GetWindowThreadProcessId(launcher, nullptr), &gui);
+  ok &= check(GetForegroundWindow() == launcher && gui.hwndFocus == button, "launcher restores its control focus");
+  ok &= check(!restore_virtual_desktop_focus() && GetForegroundWindow() == launcher, "existing Wine focus stays unchanged");
+  ShowWindow(launcher, SW_HIDE);
+  pump();
+  ShowWindow(launcher, SW_SHOWNOACTIVATE);
+  acknowledge(launcher);
+  focus(linuxWindow, linuxWindow);
+  focus(desktop, desktop);
+  ok &= check(restore_virtual_desktop_focus(), "later workspace return recovers again");
+  DestroyWindow(other);
+  PostMessageW(launcher, WM_CLOSE, 0, 0);
+  WaitForSingleObject(process.hProcess, 5000);
+  CloseHandle(process.hProcess);
+  CloseHandle(process.hThread);
+  xcb_destroy_window(connection, linuxWindow);
+  xcb_disconnect(connection);
+  if (ok) std::puts("PASS: virtual desktop foreground recovery and focus guards");
+  return ok ? 0 : 1;
+}