[release] prepare v1.5.2 release notes

.github/workflows/build.yml

@@ -698,6 +698,13 @@ jobs:
 
           Copy-Item (Join-Path $buildDir "*.dll") $portableDir -Force
 
+          # Bundled Amyuni usbmmidd_v2 virtual display driver (headless hosts)
+          $driverDir = Join-Path $buildDir "usbmmidd_v2"
+          if (!(Test-Path (Join-Path $driverDir "deviceinstaller64.exe"))) {
+            throw "Missing bundled usbmmidd_v2 driver package: $driverDir"
+          }
+          Copy-Item $driverDir (Join-Path $portableDir "usbmmidd_v2") -Recurse -Force
+
           foreach ($file in $portableFiles) {
             $packagedFile = Join-Path $portableDir $file[1]
             if (!(Test-Path $packagedFile)) {

README.md

@@ -205,6 +205,8 @@ sudo apt install "./crossdesk-linux-amd64-<version>.deb"
 
 CrossDesk 使用 [GPL-3.0](LICENSE) 许可。隐私说明见 [隐私政策](PRIVACY.md#中文)。
 
+Windows 安装包内置 [Amyuni Technologies](https://www.amyuni.com/) 的 USB Mobile Monitor 虚拟显示器驱动（usbmmidd_v2），用于无显示器主机；驱动未作任何修改，其许可见安装目录 `usbmmidd_v2\License.txt`。
+
 ### Code signing policy
 
 CrossDesk 使用 SignPath.io 为本仓库构建的官方 Windows 发布包提供代码签名。

README_EN.md

@@ -205,6 +205,8 @@ Thanks to [HelloGitHub](https://hellogithub.com/), [Ruanyf Weekly](https://githu
 
 CrossDesk is licensed under [GPL-3.0](LICENSE). See the [Privacy Policy](PRIVACY.md#english).
 
+The Windows packages bundle the unmodified USB Mobile Monitor virtual display driver (usbmmidd_v2) by [Amyuni Technologies](https://www.amyuni.com/) for hosts without a monitor; its license is in `usbmmidd_v2\License.txt` in the install directory.
+
 ### Code signing policy
 
 CrossDesk uses SignPath.io to sign official Windows releases built from this repository.

apps/desktop/resources/windows/usbmmidd_v2/License.txt

@@ -0,0 +1,12 @@
+Copyright 2014-2021 Amyuni Technologies Inc.
+https://www.amyuni.com
+
+This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
+By using this software, you accept to be prompted with an advertisement page which is not always under the control of the author. A fully commercial version is available for users who do not wisth to see those advertisements.
+
+Permission is granted to anyone to use this software for any purpose subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software.
+   If you use this software in a product, an acknowledgment in the product documentation would be required.
+2. Altered versions must be plainly marked as such, and must not be misrepresented as being the original software.
+3. This notice may not be removed or altered from any distribution.

apps/desktop/resources/windows/usbmmidd_v2/idd_instructions.txt

@@ -0,0 +1,50 @@
+Procedure to add a virtual monitor to your system (Windows 10 Only!)
+
+- Download our virtual display driver from https://www.amyuni.com/downloads/usbmmidd_v2.zip
+- Unpack the zip file to an empty folder, e.g. c:\temp\usbmmidd
+- Make sure you read the License.txt file as with any other software product
+- Open a command prompt window as Administrator (you cannot add a device to your system unless you "Run As Administrator")
+- Run the following commands:
+	- cd c:\temp\usbmmid (or whatever destination folder you chose)
+	- deviceinstaller64 install usbmmidd.inf usbmmidd (If you are on a 32-bit system, replace "deviceinstaller64" by "deviceinstaller")
+	- Make sure you see the message that the drivers are signed by Amyuni Technologies Inc. This is a confirmation that the drivers went through Microsoft driver signing procedure and are virus free
+	
+- Starting with version 2, the virtual monitor supports the following display resolutions by default:
+
+1024 x 768 pixels
+1360 x 768 pixels
+1440 x 900 pixels
+1600 x 900 pixels
+1600 x 1200 pixels
+1920 x 1080 pixels [Default Resolution]
+1920 x 1200 pixels
+2560 x 1440 pixels
+3840 x 2160 pixels
+
+After the first step above is executed, you can modify the list of supported resolutions by changing the following registry key:
+HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\WUDF\Services\usbmmIdd\Parameters\Monitors
+
+Up to 10 resolutions can be defined through this registry key. The keys should be named from "0" to "9". The (Default) registry value defines the default monitor resolution.
+
+Note that the list of resolutions can also be found in the usbmmidd.inf file that accompanies the printer driver. The inf file should not be modified in any way, otherwise the virtual display driver digital signature is invalidated.
+
+Once you are satisfied with the list of resolutions, you can activate the virtual monitor by running: 
+- deviceinstaller64 enableidd 1
+
+With version 2, rou can run this command multiple times to add up to 4 virtual monitors to your system.
+
+The included batch file usbmmidd.bat runs these commands automatically and selects between the 32- or 64-bit version of deviceinstaller.
+If you are not comfortable opening a command prompt and entering these commands, right-click on usbmmidd.bat and "Run As Administrator."
+
+That's it. You now have a high definition monitor in your Display Settings. You can change the display resolution, position the monitor, extend the desktop or do whatever you do with a real monitor.
+
+To deactivate the virtual monitor, run the command:
+deviceinstaller64 enableidd 0
+If ou have added more than one monitor, you should run this command multiple times to remove all monitors.
+
+to reactivate a virtual monitor:
+deviceinstaller64 enableidd 1
+
+To completely remove the drivers from your system, you can either go through the Device Manager and uninstall "USB Mobile Monitor Virtual Display", or run the commands:
+deviceinstaller64 stop usbmmidd
+deviceinstaller64 remove usbmmid

apps/desktop/resources/windows/usbmmidd_v2/usbmmidd.bat

@@ -0,0 +1,16 @@
+@cd /d "%~dp0"
+
+@goto %PROCESSOR_ARCHITECTURE%
+@exit
+
+:AMD64
+@cmd /c deviceinstaller64.exe install usbmmidd.inf usbmmidd
+@cmd /c deviceinstaller64.exe enableidd 1
+@goto end
+
+:x86
+@cmd /c deviceinstaller.exe install usbmmidd.inf usbmmidd
+@cmd /c deviceinstaller.exe enableidd 1
+
+:end
+@pause

apps/desktop/scripts/windows/nsis_script.nsi

@@ -92,6 +92,10 @@ installApp:
     File "..\..\..\..\build\windows\x64\release\crossdesk_privacy_window.dll"
     ; Bundle runtime DLLs from the release output directory
     File /x crossdesk_privacy_window.dll "..\..\..\..\build\windows\x64\release\*.dll"
+    ; Amyuni usbmmidd_v2 virtual display driver for headless hosts. xmake
+    ; copies apps\desktop\resources\windows\usbmmidd_v2 into the release
+    ; output directory after building crossdesk; its License.txt ships with it.
+    File /r "..\..\..\..\build\windows\x64\release\usbmmidd_v2"
 
     Call RegisterInstalledService
 
@@ -142,6 +146,7 @@ cancelUninstall:
 
 uninstallApp:
     Call un.UnregisterInstalledService
+    Call un.RemoveUsbmmiddDriver
 
     ; Delete main executable and uninstaller
     Delete "$INSTDIR\CrossDesk.exe"
@@ -151,6 +156,9 @@ uninstallApp:
     Delete "$INSTDIR\crossdesk_privacy_window.dll"
     Delete "$INSTDIR\uninstall.exe"
 
+    ; Leave the install directory before removing it
+    SetOutPath "$TEMP"
+
     ; Recursively delete installation directory
     RMDir /r "$INSTDIR"
 
@@ -248,3 +256,50 @@ unregister_with_sc:
         Abort
     ${EndIf}
 FunctionEnd
+
+; The session helper (or an elevated CrossDesk) installs the bundled usbmmidd
+; driver on first headless use and records HKLM\SOFTWARE\CrossDesk\
+; UsbmmiddDriverInstalled in the 64-bit registry view. Only a driver CrossDesk
+; installed is removed here; one set up by the user for other software stays.
+; deviceinstaller64.exe resolves usbmmIdd.dll relative to the working
+; directory, so run it from the driver folder. Failures are logged, not fatal:
+; the driver can still be removed from Device Manager.
+Function un.RemoveUsbmmiddDriver
+    IfFileExists "$INSTDIR\usbmmidd_v2\deviceinstaller64.exe" 0 done
+
+    SetRegView 64
+    ClearErrors
+    ReadRegDWORD $0 HKLM "Software\${PRODUCT_NAME}" "UsbmmiddDriverInstalled"
+    ${If} ${Errors}
+    ${OrIf} $0 != 1
+        SetRegView lastused
+        Return
+    ${EndIf}
+
+    DetailPrint "Removing the usbmmidd virtual display driver installed by CrossDesk"
+    SetOutPath "$INSTDIR\usbmmidd_v2"
+    ; Unplug every virtual monitor first (the driver allows up to four).
+    StrCpy $1 0
+unplug_loop:
+    nsExec::ExecToLog '"$INSTDIR\usbmmidd_v2\deviceinstaller64.exe" enableidd 0'
+    Pop $2
+    IntOp $1 $1 + 1
+    ${If} $2 = 0
+    ${AndIf} $1 < 4
+        Goto unplug_loop
+    ${EndIf}
+    nsExec::ExecToLog '"$INSTDIR\usbmmidd_v2\deviceinstaller64.exe" stop usbmmidd'
+    Pop $2
+    nsExec::ExecToLog '"$INSTDIR\usbmmidd_v2\deviceinstaller64.exe" remove usbmmidd'
+    Pop $2
+    ${If} $2 != 0
+        DetailPrint "usbmmidd driver removal returned $2; remove 'USB Mobile Monitor Virtual Display' from Device Manager if it remains"
+    ${EndIf}
+    SetOutPath "$TEMP"
+
+    DeleteRegValue HKLM "Software\${PRODUCT_NAME}" "UsbmmiddDriverInstalled"
+    DeleteRegKey /ifempty HKLM "Software\${PRODUCT_NAME}"
+    SetRegView lastused
+
+done:
+FunctionEnd

apps/desktop/src/common/rounded_corner_button.cpp

@@ -1,63 +0,0 @@
-#include "rounded_corner_button.h"
-
-namespace crossdesk {
-bool RoundedCornerButton(const char* label, const ImVec2& size, float rounding,
-                         ImDrawFlags round_flags, bool enabled,
-                         ImU32 normal_col, ImU32 hover_col, ImU32 active_col,
-                         ImU32 border_col) {
-  ImGuiWindow* current_window = ImGui::GetCurrentWindow();
-  if (current_window->SkipItems) return false;
-
-  const ImGuiStyle& style = ImGui::GetStyle();
-
-  ImGuiID button_id = current_window->GetID(label);
-  ImVec2 cursor_pos = current_window->DC.CursorPos;
-  ImVec2 button_size = ImGui::CalcItemSize(size, 0.0f, 0.0f);
-  ImRect button_rect(cursor_pos, ImVec2(cursor_pos.x + button_size.x,
-                                        cursor_pos.y + button_size.y));
-  ImGui::ItemSize(button_rect);
-  if (!ImGui::ItemAdd(button_rect, button_id)) return false;
-
-  bool is_hovered = false, is_held = false;
-  bool is_pressed = false;
-  if (enabled) {
-    is_pressed =
-        ImGui::ButtonBehavior(button_rect, button_id, &is_hovered, &is_held);
-  }
-
-  if (normal_col == 0) normal_col = ImGui::GetColorU32(ImGuiCol_Button);
-  if (hover_col == 0) hover_col = ImGui::GetColorU32(ImGuiCol_ButtonHovered);
-  if (active_col == 0) active_col = ImGui::GetColorU32(ImGuiCol_ButtonActive);
-  if (border_col == 0) border_col = ImGui::GetColorU32(ImGuiCol_Border);
-
-  ImU32 fill_color = normal_col;
-  if (is_held && is_hovered)
-    fill_color = active_col;
-  else if (is_hovered)
-    fill_color = hover_col;
-
-  if (!enabled) fill_color = IM_COL32(120, 120, 120, 180);
-
-  ImDrawList* window_draw_list = ImGui::GetWindowDrawList();
-
-  window_draw_list->AddRectFilled(button_rect.Min, button_rect.Max, fill_color,
-                                  rounding, round_flags);
-
-  if (style.FrameBorderSize > 0.0f) {
-    window_draw_list->AddRect(button_rect.Min, button_rect.Max, border_col,
-                              rounding, round_flags, style.FrameBorderSize);
-  }
-
-  ImU32 text_color =
-      ImGui::GetColorU32(enabled ? ImGuiCol_Text : ImGuiCol_TextDisabled);
-
-  const char* label_end = ImGui::FindRenderedTextEnd(label);
-  ImGui::PushStyleColor(ImGuiCol_Text,
-                        ImGui::ColorConvertU32ToFloat4(text_color));
-  ImGui::RenderTextClipped(button_rect.Min, button_rect.Max, label, label_end,
-                           nullptr, ImVec2(0.5f, 0.5f), &button_rect);
-  ImGui::PopStyleColor();
-
-  return is_pressed;
-}
-}  // namespace crossdesk

apps/desktop/src/common/rounded_corner_button.h

@@ -1,20 +0,0 @@
-/*
- * @Author: DI JUNKUN
- * @Date: 2026-02-26
- * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
- */
-
-#ifndef _ROUNDED_CORNER_BUTTON_H_
-#define _ROUNDED_CORNER_BUTTON_H_
-
-#include "imgui.h"
-#include "imgui_internal.h"
-
-namespace crossdesk {
-bool RoundedCornerButton(const char* label, const ImVec2& size, float rounding,
-                         ImDrawFlags round_flags, bool enabled = true,
-                         ImU32 normal_col = 0, ImU32 hover_col = 0,
-                         ImU32 active_col = 0, ImU32 border_col = 0);
-}  // namespace crossdesk
-
-#endif

apps/desktop/src/config_center/config_center.cpp

@@ -296,14 +296,16 @@ int ConfigCenter::SetTurnMode(TURN_MODE turn_mode) {
   return 0;
 }
 
-int ConfigCenter::SetTurn(bool enable_turn) {
+int ConfigCenter::SetTurn(bool enable_turn, bool force_relay) {
   if (!enable_turn) {
     return SetTurnMode(TURN_MODE::DISABLED);
   }
-  if (turn_mode_ == TURN_MODE::DISABLED) {
+  if (!force_relay) {
     return SetTurnMode(TURN_MODE::AUTO_UDP_TCP);
   }
-  return SetTurnMode(turn_mode_);
+  // Use TURN/UDP by default, preserving an explicitly configured TCP relay.
+  return SetTurnMode(turn_mode_ == TURN_MODE::FORCE_TCP ? TURN_MODE::FORCE_TCP
+                                                     : TURN_MODE::FORCE_UDP);
 }
 
 int ConfigCenter::SetServerHost(const std::string& signal_server_host) {
@@ -467,6 +469,10 @@ bool ConfigCenter::IsEnableTurn() const {
   return turn_mode_ != TURN_MODE::DISABLED;
 }
 
+bool ConfigCenter::IsForceRelay() const {
+  return turn_mode_ == TURN_MODE::FORCE_UDP || turn_mode_ == TURN_MODE::FORCE_TCP;
+}
+
 bool ConfigCenter::IsEnableSrtp() const { return true; }
 
 std::string ConfigCenter::GetSignalServerHost() const {

apps/desktop/src/config_center/config_center.h

@@ -46,7 +46,7 @@ class ConfigCenter {
   int SetVideoEncodeFormat(VIDEO_ENCODE_FORMAT video_encode_format);
   int SetHardwareVideoCodec(bool hardware_video_codec);
   int SetTurnMode(TURN_MODE turn_mode);
-  int SetTurn(bool enable_turn);
+  int SetTurn(bool enable_turn, bool force_relay);
   int SetServerHost(const std::string& signal_server_host);
   int SetServerPort(int signal_server_port);
   int SetSelfHosted(bool enable_self_hosted);
@@ -69,6 +69,7 @@ class ConfigCenter {
   bool IsHardwareVideoCodec() const;
   TURN_MODE GetTurnMode() const;
   bool IsEnableTurn() const;
+  bool IsForceRelay() const;
   bool IsEnableSrtp() const;
   std::string GetSignalServerHost() const;
   int GetSignalServerPort() const;

apps/desktop/src/gui/application/application_state.h

@@ -10,56 +10,16 @@
 #include <atomic>
 #include <chrono>
 #include <cstdint>
-#include <memory>
 #include <nlohmann/json.hpp>
 #include <string>
 
 namespace crossdesk::gui_detail {
 
 struct MainWindowState {
-  float title_bar_width_ = 640;
-  float title_bar_height_ = 30;
-  float title_bar_button_width_ = 30;
-  float title_bar_button_height_ = 30;
-
   bool exit_ = false;
-  const int sdl_refresh_ms_ = 16;
-
-  bool main_window_minimized_ = false;
-  int main_window_width_real_ = 720;
-  int main_window_height_real_ = 540;
-  float main_window_dpi_scaling_w_ = 1.0f;
-  float main_window_dpi_scaling_h_ = 1.0f;
-  float dpi_scale_ = 1.0f;
-  float main_window_width_default_ = 640;
-  float main_window_height_default_ = 480;
-  float main_window_width_ = 640;
-  float main_window_height_ = 480;
-  float main_window_width_last_ = 640;
-  float main_window_height_last_ = 480;
-  float local_window_width_ = 320;
-  float local_window_height_ = 235;
-  float remote_window_width_ = 320;
-  float remote_window_height_ = 235;
-  float local_child_window_width_ = 266;
-  float local_child_window_height_ = 180;
-  float remote_child_window_width_ = 266;
-  float remote_child_window_height_ = 180;
-  float main_window_text_y_padding_ = 10;
-  float main_child_window_x_padding_ = 27;
-  float main_child_window_y_padding_ = 45;
-  float status_bar_height_ = 22;
-  float connection_status_window_width_ = 200;
-  float connection_status_window_height_ = 150;
-  float notification_window_width_ = 200;
-  float notification_window_height_ = 80;
-  float about_window_width_ = 300;
-  float about_window_height_ = 170;
-  float update_notification_window_width_ = 400;
-  float update_notification_window_height_ = 320;
 };
 
-// Application-global interaction flags that coordinate SDL events with media
+// Application-global interaction flags that coordinate UI events with media
 // and remote-control devices.
 struct InteractionState {
   bool start_mouse_controller_ = false;
@@ -69,17 +29,11 @@ struct InteractionState {
   bool start_keyboard_capturer_ = false;
   bool keyboard_capturer_is_started_ = false;
   bool keyboard_capturer_uses_window_events_ = false;
-  bool foucs_on_main_window_ = false;
   bool focus_on_stream_window_ = false;
   bool audio_capture_ = false;
   int screen_width_ = 1280;
   int screen_height_ = 720;
   int selected_display_ = 0;
-  std::string connect_button_label_ = "Connect";
-  char input_password_tmp_[7] = "";
-  char input_password_[7] = "";
-  std::string random_password_;
-  char new_password_[7] = "";
   char remote_id_display_[12] = "";
   unsigned char audio_buffer_[720]{};
   int audio_len_ = 0;
@@ -87,7 +41,6 @@ struct InteractionState {
   bool need_to_rejoin_ = false;
   std::chrono::steady_clock::time_point last_rejoin_check_time_ =
       std::chrono::steady_clock::now();
-  bool just_created_ = false;
   std::string controlled_remote_id_;
   std::string focused_remote_id_;
   std::string remote_client_id_;
@@ -100,26 +53,13 @@ struct UpdateState {
   std::string release_name_;
   std::string release_notes_;
   std::string release_date_;
-  bool show_new_version_icon_ = false;
-  bool show_new_version_icon_in_menu_ = true;
-  double new_version_icon_last_trigger_time_ = 0.0;
-  double new_version_icon_render_start_time_ = 0.0;
 };
 
 struct StreamWindowState {
   bool need_to_create_stream_window_ = false;
   bool stream_window_created_ = false;
   bool stream_window_inited_ = false;
-  bool window_maximized_ = false;
   bool control_mouse_ = false;
-  int stream_window_width_default_ = 1280;
-  int stream_window_height_default_ = 720;
-  float stream_window_width_ = 1280;
-  float stream_window_height_ = 720;
-  int stream_window_width_real_ = 1280;
-  int stream_window_height_real_ = 720;
-  float stream_window_dpi_scaling_w_ = 1.0f;
-  float stream_window_dpi_scaling_h_ = 1.0f;
 };
 
 struct ServerWindowState {
@@ -130,60 +70,22 @@ struct ServerWindowState {
   std::atomic<bool> need_to_destroy_server_window_{false};
   bool server_window_created_ = false;
   bool server_window_inited_ = false;
-  int server_window_width_default_ = 250;
-  int server_window_height_default_ = 150;
-  float server_window_width_ = 250;
-  float server_window_height_ = 150;
-  float server_window_title_bar_height_ = 30.0f;
-  int server_window_normal_width_ = 250;
-  int server_window_normal_height_ = 150;
-  float server_window_dpi_scaling_w_ = 1.0f;
-  float server_window_dpi_scaling_h_ = 1.0f;
-  float window_rounding_ = 6.0f;
-  float window_rounding_default_ = 6.0f;
   bool server_window_collapsed_ = false;
-  bool server_window_collapsed_dragging_ = false;
-  float server_window_collapsed_drag_start_mouse_x_ = 0.0f;
-  float server_window_collapsed_drag_start_mouse_y_ = 0.0f;
-  int server_window_collapsed_drag_start_win_x_ = 0;
-  int server_window_collapsed_drag_start_win_y_ = 0;
-  bool server_window_dragging_ = false;
-  float server_window_drag_start_mouse_x_ = 0.0f;
-  float server_window_drag_start_mouse_y_ = 0.0f;
-  int server_window_drag_start_win_x_ = 0;
-  int server_window_drag_start_win_y_ = 0;
 };
 
 struct UiState {
-  bool label_inited_ = false;
-  bool connect_button_pressed_ = false;
   bool password_validating_ = false;
   uint32_t password_validating_time_ = 0;
-  bool show_settings_window_ = false;
-  bool show_self_hosted_server_config_window_ = false;
   bool rejoin_ = false;
-  bool local_id_copied_ = false;
   bool show_password_ = true;
-  bool show_about_window_ = false;
   bool show_connection_status_window_ = false;
-  bool show_reset_password_window_ = false;
-  bool show_update_notification_window_ = false;
   bool fullscreen_button_pressed_ = false;
-  bool focus_on_input_widget_ = true;
   bool is_client_mode_ = false;
   bool is_server_mode_ = false;
   bool reload_recent_connections_ = true;
-  bool show_confirm_delete_connection_ = false;
-  bool show_edit_connection_alias_window_ = false;
   bool show_offline_warning_window_ = false;
-  bool delete_connection_ = false;
-  bool is_tab_bar_hovered_ = false;
-  std::string delete_connection_name_;
-  std::string edit_connection_alias_remote_id_;
-  char edit_connection_alias_[128] = "";
   std::string offline_warning_text_;
   bool re_enter_remote_id_ = false;
-  double copy_start_time_ = 0;
 };
 
 struct ApplicationState : MainWindowState,

apps/desktop/src/gui/application/gui_application.cpp

@@ -3,6 +3,7 @@
 #include <remote_action.h>
 
 #include <SDL3/SDL.h>
+#include <openssl/rand.h>
 #include <slint.h>
 #include <tinyfiledialogs.h>
 
@@ -34,6 +35,7 @@
 #include "platform.h"
 #include "platform/video_renderer.h"
 #include "rendering/slint_video_presenter.h"
+#include "rendering/video_geometry.h"
 #include "runtime/privacy_control_state.h"
 #if _WIN32
 #include <windows.h>
@@ -64,6 +66,28 @@ namespace {
 
 using namespace std::chrono_literals;
 
+std::optional<std::string> GenerateRandomPassword(std::string_view current) {
+  constexpr std::string_view alphabet =
+      "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+  constexpr auto unbiased_limit = 256 - 256 % alphabet.size();
+  std::string password;
+  do {
+    password.clear();
+    while (password.size() < 6) {
+      unsigned char value;
+      if (RAND_bytes(&value, sizeof(value)) != 1) {
+        return std::nullopt;
+      }
+      // Reject the incomplete bucket so every character is equally likely.
+      if (value < unbiased_limit) {
+        password.push_back(alphabet[value % alphabet.size()]);
+      }
+    }
+  } while (password == current ||
+           password.find_first_not_of("0123456789") == std::string::npos);
+  return password;
+}
+
 std::string CreatePasswordChangeRequestId(uint64_t sequence) {
   const auto timestamp = std::chrono::system_clock::now()
                              .time_since_epoch()
@@ -1237,6 +1261,7 @@ void GuiApplication::ResetSettingsUi() {
   ui_->main->set_hardware_codec_enabled(hardware_codec_available &&
                                        enable_hardware_video_codec_);
   ui_->main->set_turn_enabled(enable_turn_);
+  ui_->main->set_force_relay_enabled(config_center_->IsForceRelay());
   ui_->main->set_self_hosted_enabled(enable_self_hosted_);
   ui_->main->set_autostart_enabled(enable_autostart_);
   ui_->main->set_daemon_enabled(enable_daemon_);
@@ -1293,78 +1318,17 @@ void GuiApplication::BindMainCallbacks() {
     ui_->main->set_password_visible(show_password_);
   });
   main->on_reset_password([this](slint::SharedString value) {
-    const std::string password(value);
-    if (password.size() != 6) {
-      return false;
-    }
-
-    if (!peer_ || !signal_connected_) {
-      offline_warning_text_ =
-          localization::signal_disconnected[localization_language_index_];
-      show_offline_warning_window_ = true;
-      return true;
-    }
-
-    std::string request_id;
-    {
-      std::lock_guard<std::mutex> lock(password_change_mutex_);
-      if (password_change_pending_) {
-        return true;
-      }
-      request_id =
-          CreatePasswordChangeRequestId(++next_password_change_request_id_);
-      password_change_pending_ = true;
-      password_change_result_ready_ = false;
-      password_change_succeeded_ = false;
-      password_change_result_uncertain_ = false;
-      password_change_requested_at_ = std::chrono::steady_clock::now();
-      pending_password_change_request_id_ = request_id;
-      pending_local_password_ = password;
-      password_change_error_.clear();
-    }
-
-    const bool self_hosted = config_center_->IsSelfHosted();
-    const std::string server_host =
-        self_hosted ? config_center_->GetSignalServerHost()
-                    : config_center_->GetDefaultServerHost();
-    const int server_port =
-        self_hosted ? config_center_->GetSignalServerPort()
-                    : config_center_->GetDefaultSignalServerPort();
-    const std::string pending_identity =
-        std::string(client_id_) + "@" + password;
-    if (!settings_.StagePendingPasswordChange(
-            pending_identity, self_hosted, server_host, server_port,
-            request_id)) {
-      std::lock_guard<std::mutex> lock(password_change_mutex_);
-      password_change_pending_ = false;
-      pending_password_change_request_id_.clear();
-      pending_local_password_.clear();
-      password_change_error_.clear();
+    return RequestPasswordChange(std::string(value));
+  });
+  main->on_refresh_password([this] {
+    const auto password = GenerateRandomPassword(password_saved_);
+    if (!password) {
+      LOG_ERROR("Could not generate a random password");
       offline_warning_text_ = localization::failed[localization_language_index_];
       show_offline_warning_window_ = true;
-      LOG_ERROR("Could not durably stage password change");
-      return true;
+      return;
     }
-
-    const nlohmann::json request = {{"type", "change_password"},
-                                    {"request_id", request_id},
-                                    {"new_password", password}};
-    const std::string message = request.dump();
-    if (SendSignalMessage(peer_, message.data(), message.size()) != 0) {
-      {
-        std::lock_guard<std::mutex> lock(password_change_mutex_);
-        password_change_pending_ = false;
-        pending_password_change_request_id_.clear();
-        pending_local_password_.clear();
-        offline_warning_text_ =
-            localization::signal_disconnected[localization_language_index_];
-        show_offline_warning_window_ = true;
-      }
-      if (!settings_.ClearPendingPasswordChange()) {
-        LOG_WARN("Could not clear unsent pending password change");
-      }
-    }
-    return true;
+    RequestPasswordChange(*password);
   });
   main->on_connect_requested(
       [this](slint::SharedString id) { ConnectFromUi(std::string(id)); });
@@ -1845,7 +1809,6 @@ void GuiApplication::Tick() {
     }
   }
 
-  UpdateLabels();
   const bool was_reloading_recent_connections = reload_recent_connections_;
   HandleRecentConnections();
   if (was_reloading_recent_connections && !reload_recent_connections_) {
@@ -2039,6 +2002,78 @@ void GuiApplication::ShareLocalCursorState() {
   }
 }
 
+bool GuiApplication::RequestPasswordChange(const std::string &password) {
+  if (password.size() != 6) {
+    return false;
+  }
+
+  if (!peer_ || !signal_connected_) {
+    offline_warning_text_ =
+        localization::signal_disconnected[localization_language_index_];
+    show_offline_warning_window_ = true;
+    return true;
+  }
+
+  std::string request_id;
+  {
+    std::lock_guard<std::mutex> lock(password_change_mutex_);
+    if (password_change_pending_) {
+      return true;
+    }
+    request_id =
+        CreatePasswordChangeRequestId(++next_password_change_request_id_);
+    password_change_pending_ = true;
+    password_change_result_ready_ = false;
+    password_change_succeeded_ = false;
+    password_change_result_uncertain_ = false;
+    password_change_requested_at_ = std::chrono::steady_clock::now();
+    pending_password_change_request_id_ = request_id;
+    pending_local_password_ = password;
+    password_change_error_.clear();
+  }
+
+  const bool self_hosted = config_center_->IsSelfHosted();
+  const std::string server_host =
+      self_hosted ? config_center_->GetSignalServerHost()
+                  : config_center_->GetDefaultServerHost();
+  const int server_port =
+      self_hosted ? config_center_->GetSignalServerPort()
+                  : config_center_->GetDefaultSignalServerPort();
+  const std::string pending_identity = std::string(client_id_) + "@" + password;
+  if (!settings_.StagePendingPasswordChange(
+          pending_identity, self_hosted, server_host, server_port, request_id)) {
+    std::lock_guard<std::mutex> lock(password_change_mutex_);
+    password_change_pending_ = false;
+    pending_password_change_request_id_.clear();
+    pending_local_password_.clear();
+    password_change_error_.clear();
+    offline_warning_text_ = localization::failed[localization_language_index_];
+    show_offline_warning_window_ = true;
+    LOG_ERROR("Could not durably stage password change");
+    return true;
+  }
+
+  const nlohmann::json request = {{"type", "change_password"},
+                                {"request_id", request_id},
+                                {"new_password", password}};
+  const std::string message = request.dump();
+  if (SendSignalMessage(peer_, message.data(), message.size()) != 0) {
+    {
+      std::lock_guard<std::mutex> lock(password_change_mutex_);
+      password_change_pending_ = false;
+      pending_password_change_request_id_.clear();
+      pending_local_password_.clear();
+      offline_warning_text_ =
+          localization::signal_disconnected[localization_language_index_];
+      show_offline_warning_window_ = true;
+    }
+    if (!settings_.ClearPendingPasswordChange()) {
+      LOG_WARN("Could not clear unsent pending password change");
+    }
+  }
+  return true;
+}
+
 void GuiApplication::HandlePasswordChangeResult() {
   bool succeeded = false;
   bool uncertain = false;
@@ -2188,6 +2223,10 @@ void GuiApplication::SyncMainWindow() {
   ui_->main->set_local_id(UiText(FormatPeerId(client_id_)));
   ui_->main->set_local_password(password_saved_);
   ui_->main->set_password_visible(show_password_);
+  {
+    std::lock_guard<std::mutex> lock(password_change_mutex_);
+    ui_->main->set_password_change_pending(password_change_pending_);
+  }
   ui_->main->set_signal_connected(signal_connected_);
   ui_->main->set_signal_tls_error(signal_status_ ==
                                   SignalStatus::SignalTlsCertError);
@@ -2800,9 +2839,6 @@ void GuiApplication::ConfigureStreamVideoRenderer() {
         SlintVideoPresenter::SurfaceState state;
         state.selected_stream = focused_remote_id_;
         state.fullscreen = fullscreen_button_pressed_;
-        if (ui_) {
-          state.tab_count = ui_->tab_ids.size();
-        }
         return state;
       },
       [this] { video_frame_dirty_.store(true, std::memory_order_release); });
@@ -3057,7 +3093,8 @@ void GuiApplication::SaveSettingsFromUi() {
       static_cast<ConfigCenter::VIDEO_ENCODE_FORMAT>(
           video_encode_format_button_value_));
   config_center_->SetHardwareVideoCodec(enable_hardware_video_codec_);
-  config_center_->SetTurn(enable_turn_);
+  config_center_->SetTurn(enable_turn_, main->get_force_relay_enabled());
+  main->set_force_relay_enabled(config_center_->IsForceRelay());
   config_center_->SetSelfHosted(enable_self_hosted_);
   config_center_->SetAutostart(enable_autostart_);
   config_center_->SetDaemon(enable_daemon_);
@@ -3251,43 +3288,21 @@ void GuiApplication::SendPointerInput(int button, int kind, float x, float y) {
     return;
   }
 
-  const auto size = (*ui_->stream)->window().size();
-  const float scale = (*ui_->stream)->window().scale_factor();
-  const float available_width = size.width / scale;
-  const float titlebar_height =
-      !fullscreen_button_pressed_ && (*ui_->stream)->get_custom_titlebar()
-          ? kWaylandTitlebarLogicalHeight
-          : 0.0f;
-  const float available_height =
-      size.height / scale - titlebar_height -
-      (fullscreen_button_pressed_ ? 0.0f
-                                  : (ui_->tab_ids.size() > 1 ? 30.0f : 0.0f));
-  float render_width = available_width;
-  float render_height = available_height;
-  float offset_x = 0;
-  float offset_y = 0;
-  if (props->video_width_ > 0 && props->video_height_ > 0 &&
-      available_width > 0 && available_height > 0) {
-    const float video_aspect =
-        static_cast<float>(props->video_width_) / props->video_height_;
-    const float area_aspect = available_width / available_height;
-    if (video_aspect > area_aspect) {
-      render_height = available_width / video_aspect;
-      offset_y = (available_height - render_height) * 0.5f;
-    } else {
-      render_width = available_height * video_aspect;
-      offset_x = (available_width - render_width) * 0.5f;
-    }
+  std::optional<VideoPoint> point;
+  {
+    std::lock_guard lock(props->video_frame_mutex_);
+    point = MapVideoPoint(x, y, (*ui_->stream)->get_video_area_width(),
+                          (*ui_->stream)->get_video_area_height(),
+                          props->video_width_, props->video_height_);
   }
-  if (x < offset_x || x > offset_x + render_width || y < offset_y ||
-      y > offset_y + render_height) {
+  if (!point) {
     return;
   }
 
   RemoteAction action{};
   action.type = ControlType::mouse;
-  action.m.x = std::clamp((x - offset_x) / render_width, 0.0f, 1.0f);
-  action.m.y = std::clamp((y - offset_y) / render_height, 0.0f, 1.0f);
+  action.m.x = point->x;
+  action.m.y = point->y;
   // Slint enum order: Cancel=0, Down=1, Up=2, Move=3 and
   // Other=0, Left=1, Right=2, Middle=3.
   if (kind == 3) {
@@ -3330,24 +3345,20 @@ void GuiApplication::SendScrollInput(float delta_x, float delta_y, float x,
   if (!props || !props->peer_ || !props->control_mouse_ || !ui_->stream) {
     return;
   }
-  const auto size = (*ui_->stream)->window().size();
-  const float scale = (*ui_->stream)->window().scale_factor();
-  const float width = size.width / scale;
-  const float titlebar_height =
-      !fullscreen_button_pressed_ && (*ui_->stream)->get_custom_titlebar()
-          ? kWaylandTitlebarLogicalHeight
-          : 0.0f;
-  const float height =
-      size.height / scale - titlebar_height -
-      (fullscreen_button_pressed_ ? 0.0f
-                                  : (ui_->tab_ids.size() > 1 ? 30.0f : 0.0f));
-  if (width <= 0 || height <= 0) {
+  std::optional<VideoPoint> point;
+  {
+    std::lock_guard lock(props->video_frame_mutex_);
+    point = MapVideoPoint(x, y, (*ui_->stream)->get_video_area_width(),
+                          (*ui_->stream)->get_video_area_height(),
+                          props->video_width_, props->video_height_);
+  }
+  if (!point) {
     return;
   }
   RemoteAction action{};
   action.type = ControlType::mouse;
-  action.m.x = std::clamp(x / width, 0.0f, 1.0f);
-  action.m.y = std::clamp(y / height, 0.0f, 1.0f);
+  action.m.x = point->x;
+  action.m.y = point->y;
   if (std::abs(delta_y) >= std::abs(delta_x)) {
     action.m.flag = MouseFlag::wheel_vertical;
     action.m.s = delta_y > 0 ? 1 : delta_y < 0 ? -1 : 0;

apps/desktop/src/gui/application/gui_application.h

@@ -49,6 +49,7 @@ private:
   void BindServerCallbacks();
   void Tick();
   void ShareLocalCursorState();
+  bool RequestPasswordChange(const std::string &password);
   void HandlePasswordChangeResult();
   void HandleCredentialRecovery();
   void SyncMainWindow();
@@ -100,4 +101,4 @@ private:
 
 } // namespace crossdesk
 
-#endif
+#endif

apps/desktop/src/gui/application/sdl_event_dispatch.cpp

@@ -1,323 +0,0 @@
-#include "application/gui_application.h"
-
-#include <cstring>
-#include <memory>
-#include <mutex>
-#include <string>
-#include <vector>
-
-#include "rd_log.h"
-
-namespace crossdesk {
-
-void GuiApplication::ProcessSdlEvent(const SDL_Event &event) {
-  if (main_ctx_) {
-    ImGui::SetCurrentContext(main_ctx_);
-    ImGui_ImplSDL3_ProcessEvent(&event);
-  } else {
-    LOG_ERROR("Main context is null");
-    return;
-  }
-
-  if (stream_window_inited_) {
-    if (stream_ctx_) {
-      ImGui::SetCurrentContext(stream_ctx_);
-      ImGui_ImplSDL3_ProcessEvent(&event);
-    } else {
-      LOG_ERROR("Stream context is null");
-      return;
-    }
-  }
-
-  if (server_window_inited_) {
-    if (server_ctx_) {
-      ImGui::SetCurrentContext(server_ctx_);
-      ImGui_ImplSDL3_ProcessEvent(&event);
-    } else {
-      LOG_ERROR("Server context is null");
-      return;
-    }
-  }
-
-  if (APP_EXIT_EVENT != 0 && event.type == APP_EXIT_EVENT) {
-    LOG_INFO("Quit program from system tray");
-    if (stream_window_) {
-      SDL_SetWindowMouseGrab(stream_window_, false);
-    }
-#if defined(__linux__) && !defined(__APPLE__)
-    if (tray_) {
-      tray_->RemoveTrayIcon();
-    }
-#endif
-    exit_ = true;
-    return;
-  }
-
-  if (clipboard_.event_type() != 0 && event.type == clipboard_.event_type()) {
-    clipboard_.ApplyPendingRemoteText();
-    return;
-  }
-
-  switch (event.type) {
-  case SDL_EVENT_QUIT:
-    if (stream_window_inited_) {
-      LOG_INFO("Destroy stream window");
-      SDL_SetWindowMouseGrab(stream_window_, false);
-      DestroyStreamWindow();
-      DestroyStreamWindowContext();
-
-      {
-        // std::shared_lock lock(remote_sessions_mutex_);
-        for (auto &[host_name, props] : remote_sessions_) {
-          std::shared_ptr<std::vector<unsigned char>> frame_snapshot;
-          int video_width = 0;
-          int video_height = 0;
-          {
-            std::lock_guard<std::mutex> lock(props->video_frame_mutex_);
-            frame_snapshot = props->front_frame_;
-            video_width = props->video_width_;
-            video_height = props->video_height_;
-          }
-          if (frame_snapshot && !frame_snapshot->empty() && video_width > 0 &&
-              video_height > 0) {
-            thumbnail_->SaveToThumbnail(
-                (char *)frame_snapshot->data(), video_width, video_height,
-                host_name, props->remote_host_name_,
-                props->remember_password_ ? props->remote_password_ : "");
-          }
-
-          if (props->peer_) {
-            std::string client_id = (host_name == client_id_)
-                                        ? "C-" + std::string(client_id_)
-                                        : client_id_;
-            LOG_INFO("[{}] Leave connection [{}]", client_id, host_name);
-            LeaveConnection(props->peer_, host_name.c_str());
-            LOG_INFO("Destroy peer [{}]", client_id);
-            DestroyPeer(&props->peer_);
-          }
-
-          props->streaming_ = false;
-          props->remember_password_ = false;
-          props->connection_established_ = false;
-          props->audio_capture_button_pressed_ = false;
-
-          memset(&props->net_traffic_stats_, 0,
-                 sizeof(props->net_traffic_stats_));
-          SDL_SetWindowFullscreen(main_window_, false);
-          SDL_FlushEvents(STREAM_REFRESH_EVENT, STREAM_REFRESH_EVENT);
-          memset(audio_buffer_, 0, 720);
-        }
-      }
-
-      {
-        // std::unique_lock lock(remote_sessions_mutex_);
-        remote_sessions_.clear();
-      }
-
-      rejoin_ = false;
-      is_client_mode_ = false;
-      reload_recent_connections_ = true;
-      fullscreen_button_pressed_ = false;
-      start_keyboard_capturer_ = false;
-      just_created_ = false;
-      recent_connection_image_save_time_ = SDL_GetTicks();
-    } else {
-      LOG_INFO("Quit program");
-      exit_ = true;
-    }
-    break;
-
-  case SDL_EVENT_WINDOW_CLOSE_REQUESTED:
-    if (stream_window_ &&
-        event.window.windowID == SDL_GetWindowID(stream_window_)) {
-      break;
-    }
-
-    if (main_window_ &&
-        event.window.windowID == SDL_GetWindowID(main_window_)) {
-      if (!MinimizeMainWindowToTray()) {
-        SDL_HideWindow(main_window_);
-      }
-      break;
-    }
-
-    exit_ = true;
-    break;
-
-  case SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED:
-    if (stream_window_created_ &&
-        event.window.windowID == SDL_GetWindowID(stream_window_)) {
-      UpdateRenderRect();
-    }
-    break;
-
-  case SDL_EVENT_WINDOW_FOCUS_GAINED:
-    if (stream_window_ &&
-        SDL_GetWindowID(stream_window_) == event.window.windowID) {
-      focus_on_stream_window_ = true;
-    } else if (main_window_ &&
-               SDL_GetWindowID(main_window_) == event.window.windowID) {
-      foucs_on_main_window_ = true;
-    }
-    break;
-
-  case SDL_EVENT_WINDOW_FOCUS_LOST:
-    if (stream_window_ &&
-        SDL_GetWindowID(stream_window_) == event.window.windowID) {
-      keyboard_.ForceReleasePressedKeys();
-      focus_on_stream_window_ = false;
-    } else if (main_window_ &&
-               SDL_GetWindowID(main_window_) == event.window.windowID) {
-      foucs_on_main_window_ = false;
-    }
-    break;
-  case SDL_EVENT_DROP_FILE:
-    transfers_.HandleDropEvent(event);
-    break;
-
-  case SDL_EVENT_CLIPBOARD_UPDATE:
-    clipboard_.HandleLocalUpdate();
-    break;
-
-  case SDL_EVENT_MOUSE_MOTION:
-  case SDL_EVENT_MOUSE_BUTTON_DOWN:
-  case SDL_EVENT_MOUSE_BUTTON_UP:
-  case SDL_EVENT_MOUSE_WHEEL: {
-    Uint32 mouse_window_id = 0;
-    if (event.type == SDL_EVENT_MOUSE_MOTION) {
-      mouse_window_id = event.motion.windowID;
-    } else if (event.type == SDL_EVENT_MOUSE_BUTTON_DOWN ||
-               event.type == SDL_EVENT_MOUSE_BUTTON_UP) {
-      mouse_window_id = event.button.windowID;
-    } else if (event.type == SDL_EVENT_MOUSE_WHEEL) {
-      mouse_window_id = event.wheel.windowID;
-    }
-
-    if (focus_on_stream_window_ && stream_window_ &&
-        SDL_GetWindowID(stream_window_) == mouse_window_id) {
-      ProcessMouseEvent(event);
-    }
-    break;
-  }
-
-  case SDL_EVENT_KEY_DOWN:
-  case SDL_EVENT_KEY_UP:
-    if (keyboard_capturer_is_started_ &&
-        keyboard_capturer_uses_window_events_ &&
-        focus_on_stream_window_ && stream_window_ &&
-        SDL_GetWindowID(stream_window_) == event.key.windowID) {
-      ProcessKeyboardEvent(event);
-    }
-    break;
-
-  default:
-    if (event.type == STREAM_REFRESH_EVENT) {
-      auto *props = static_cast<RemoteSession *>(event.user.data1);
-      if (!props) {
-        break;
-      }
-      std::shared_ptr<std::vector<unsigned char>> frame_snapshot;
-      int video_width = 0;
-      int video_height = 0;
-      bool render_rect_dirty = false;
-      bool cleanup_pending = false;
-      {
-        std::lock_guard<std::mutex> lock(props->video_frame_mutex_);
-        cleanup_pending = props->stream_cleanup_pending_;
-        if (!cleanup_pending) {
-          frame_snapshot = props->front_frame_;
-          video_width = props->video_width_;
-          video_height = props->video_height_;
-        }
-        render_rect_dirty = props->render_rect_dirty_;
-      }
-
-      if (cleanup_pending) {
-        if (props->stream_texture_) {
-          SDL_DestroyTexture(props->stream_texture_);
-          props->stream_texture_ = nullptr;
-        }
-        {
-          std::lock_guard<std::mutex> lock(props->video_frame_mutex_);
-          props->stream_cleanup_pending_ = false;
-        }
-
-        if (render_rect_dirty) {
-          UpdateRenderRect();
-          std::lock_guard<std::mutex> lock(props->video_frame_mutex_);
-          props->render_rect_dirty_ = false;
-        }
-        break;
-      }
-
-      if (video_width <= 0 || video_height <= 0) {
-        break;
-      }
-      if (!frame_snapshot || frame_snapshot->empty()) {
-        break;
-      }
-
-      if (props->stream_texture_) {
-        if (video_width != props->texture_width_ ||
-            video_height != props->texture_height_) {
-          props->texture_width_ = video_width;
-          props->texture_height_ = video_height;
-
-          SDL_DestroyTexture(props->stream_texture_);
-          // props->stream_texture_ = SDL_CreateTexture(
-          //     stream_renderer_, stream_pixformat_,
-          //     SDL_TEXTUREACCESS_STREAMING, props->texture_width_,
-          //     props->texture_height_);
-
-          SDL_PropertiesID nvProps = SDL_CreateProperties();
-          SDL_SetNumberProperty(nvProps, SDL_PROP_TEXTURE_CREATE_WIDTH_NUMBER,
-                                props->texture_width_);
-          SDL_SetNumberProperty(nvProps, SDL_PROP_TEXTURE_CREATE_HEIGHT_NUMBER,
-                                props->texture_height_);
-          SDL_SetNumberProperty(nvProps, SDL_PROP_TEXTURE_CREATE_FORMAT_NUMBER,
-                                SDL_PIXELFORMAT_NV12);
-          SDL_SetNumberProperty(nvProps,
-                                SDL_PROP_TEXTURE_CREATE_COLORSPACE_NUMBER,
-                                SDL_COLORSPACE_BT601_LIMITED);
-          props->stream_texture_ =
-              SDL_CreateTextureWithProperties(stream_renderer_, nvProps);
-          SDL_DestroyProperties(nvProps);
-        }
-      } else {
-        props->texture_width_ = video_width;
-        props->texture_height_ = video_height;
-        // props->stream_texture_ = SDL_CreateTexture(
-        //     stream_renderer_, stream_pixformat_,
-        //     SDL_TEXTUREACCESS_STREAMING, props->texture_width_,
-        //     props->texture_height_);
-
-        SDL_PropertiesID nvProps = SDL_CreateProperties();
-        SDL_SetNumberProperty(nvProps, SDL_PROP_TEXTURE_CREATE_WIDTH_NUMBER,
-                              props->texture_width_);
-        SDL_SetNumberProperty(nvProps, SDL_PROP_TEXTURE_CREATE_HEIGHT_NUMBER,
-                              props->texture_height_);
-        SDL_SetNumberProperty(nvProps, SDL_PROP_TEXTURE_CREATE_FORMAT_NUMBER,
-                              SDL_PIXELFORMAT_NV12);
-        SDL_SetNumberProperty(nvProps,
-                              SDL_PROP_TEXTURE_CREATE_COLORSPACE_NUMBER,
-                              SDL_COLORSPACE_BT601_LIMITED);
-        props->stream_texture_ =
-            SDL_CreateTextureWithProperties(stream_renderer_, nvProps);
-        SDL_DestroyProperties(nvProps);
-      }
-
-      SDL_UpdateTexture(props->stream_texture_, NULL, frame_snapshot->data(),
-                        props->texture_width_);
-
-      if (render_rect_dirty) {
-        UpdateRenderRect();
-        std::lock_guard<std::mutex> lock(props->video_frame_mutex_);
-        props->render_rect_dirty_ = false;
-      }
-    }
-    break;
-  }
-}
-
-
-} // namespace crossdesk

apps/desktop/src/gui/application/sdl_events.cpp

@@ -1,424 +0,0 @@
-#include "application/gui_application.h"
-
-#include <remote_action.h>
-
-#include <algorithm>
-#include <cmath>
-#include <string>
-
-#include "device_controller.h"
-#include "rd_log.h"
-
-namespace crossdesk {
-namespace {
-int TranslateSdlKeypadScancodeToVk(const SDL_KeyboardEvent &event) {
-  const bool numlock_enabled = (event.mod & SDL_KMOD_NUM) != 0;
-
-  switch (event.scancode) {
-  case SDL_SCANCODE_NUMLOCKCLEAR:
-    return 0x90;
-  case SDL_SCANCODE_KP_ENTER:
-    return 0x0D;
-  case SDL_SCANCODE_KP_0:
-    if (!numlock_enabled) {
-      return 0x2D;
-    }
-    return 0x60;
-  case SDL_SCANCODE_KP_1:
-    if (!numlock_enabled) {
-      return 0x23;
-    }
-    return 0x61;
-  case SDL_SCANCODE_KP_2:
-    if (!numlock_enabled) {
-      return 0x28;
-    }
-    return 0x62;
-  case SDL_SCANCODE_KP_3:
-    if (!numlock_enabled) {
-      return 0x22;
-    }
-    return 0x63;
-  case SDL_SCANCODE_KP_4:
-    if (!numlock_enabled) {
-      return 0x25;
-    }
-    return 0x64;
-  case SDL_SCANCODE_KP_5:
-    return 0x65;
-  case SDL_SCANCODE_KP_6:
-    if (!numlock_enabled) {
-      return 0x27;
-    }
-    return 0x66;
-  case SDL_SCANCODE_KP_7:
-    if (!numlock_enabled) {
-      return 0x24;
-    }
-    return 0x67;
-  case SDL_SCANCODE_KP_8:
-    if (!numlock_enabled) {
-      return 0x26;
-    }
-    return 0x68;
-  case SDL_SCANCODE_KP_9:
-    if (!numlock_enabled) {
-      return 0x21;
-    }
-    return 0x69;
-  case SDL_SCANCODE_KP_PERIOD:
-  case SDL_SCANCODE_KP_COMMA:
-    if (!numlock_enabled) {
-      return 0x2E;
-    }
-    return 0x6E;
-  case SDL_SCANCODE_KP_DIVIDE:
-    return 0x6F;
-  case SDL_SCANCODE_KP_MULTIPLY:
-    return 0x6A;
-  case SDL_SCANCODE_KP_MINUS:
-    return 0x6D;
-  case SDL_SCANCODE_KP_PLUS:
-    return 0x6B;
-  case SDL_SCANCODE_KP_EQUALS:
-    return 0xBB;
-  default:
-    return -1;
-  }
-}
-
-int TranslateSdlKeyboardEventToVk(const SDL_KeyboardEvent &event) {
-  const int keypad_key_code = TranslateSdlKeypadScancodeToVk(event);
-  if (keypad_key_code >= 0) {
-    return keypad_key_code;
-  }
-
-  const int key = static_cast<int>(event.key);
-  if (key >= 'a' && key <= 'z') {
-    return key - 'a' + 0x41;
-  }
-  if (key >= 'A' && key <= 'Z') {
-    return key;
-  }
-  if (key >= '0' && key <= '9') {
-    return key;
-  }
-
-  switch (key) {
-  case ';':
-    return 0xBA;
-  case '\'':
-    return 0xDE;
-  case '`':
-    return 0xC0;
-  case ',':
-    return 0xBC;
-  case '.':
-    return 0xBE;
-  case '/':
-    return 0xBF;
-  case '\\':
-    return 0xDC;
-  case '[':
-    return 0xDB;
-  case ']':
-    return 0xDD;
-  case '-':
-    return 0xBD;
-  case '=':
-    return 0xBB;
-  default:
-    break;
-  }
-
-  switch (event.scancode) {
-  case SDL_SCANCODE_ESCAPE:
-    return 0x1B;
-  case SDL_SCANCODE_RETURN:
-    return 0x0D;
-  case SDL_SCANCODE_SPACE:
-    return 0x20;
-  case SDL_SCANCODE_BACKSPACE:
-    return 0x08;
-  case SDL_SCANCODE_TAB:
-    return 0x09;
-  case SDL_SCANCODE_PRINTSCREEN:
-    return 0x2C;
-  case SDL_SCANCODE_SCROLLLOCK:
-    return 0x91;
-  case SDL_SCANCODE_PAUSE:
-    return 0x13;
-  case SDL_SCANCODE_INSERT:
-    return 0x2D;
-  case SDL_SCANCODE_DELETE:
-    return 0x2E;
-  case SDL_SCANCODE_HOME:
-    return 0x24;
-  case SDL_SCANCODE_END:
-    return 0x23;
-  case SDL_SCANCODE_PAGEUP:
-    return 0x21;
-  case SDL_SCANCODE_PAGEDOWN:
-    return 0x22;
-  case SDL_SCANCODE_LEFT:
-    return 0x25;
-  case SDL_SCANCODE_RIGHT:
-    return 0x27;
-  case SDL_SCANCODE_UP:
-    return 0x26;
-  case SDL_SCANCODE_DOWN:
-    return 0x28;
-  case SDL_SCANCODE_F1:
-    return 0x70;
-  case SDL_SCANCODE_F2:
-    return 0x71;
-  case SDL_SCANCODE_F3:
-    return 0x72;
-  case SDL_SCANCODE_F4:
-    return 0x73;
-  case SDL_SCANCODE_F5:
-    return 0x74;
-  case SDL_SCANCODE_F6:
-    return 0x75;
-  case SDL_SCANCODE_F7:
-    return 0x76;
-  case SDL_SCANCODE_F8:
-    return 0x77;
-  case SDL_SCANCODE_F9:
-    return 0x78;
-  case SDL_SCANCODE_F10:
-    return 0x79;
-  case SDL_SCANCODE_F11:
-    return 0x7A;
-  case SDL_SCANCODE_F12:
-    return 0x7B;
-  case SDL_SCANCODE_CAPSLOCK:
-    return 0x14;
-  case SDL_SCANCODE_LSHIFT:
-    return 0xA0;
-  case SDL_SCANCODE_RSHIFT:
-    return 0xA1;
-  case SDL_SCANCODE_LCTRL:
-    return 0xA2;
-  case SDL_SCANCODE_RCTRL:
-    return 0xA3;
-  case SDL_SCANCODE_LALT:
-    return 0xA4;
-  case SDL_SCANCODE_RALT:
-    return 0xA5;
-  case SDL_SCANCODE_LGUI:
-    return 0x5B;
-  case SDL_SCANCODE_RGUI:
-    return 0x5C;
-  default:
-    return -1;
-  }
-}
-
-} // namespace
-
-int GuiApplication::ProcessKeyboardEvent(const SDL_Event &event) {
-  if (event.type != SDL_EVENT_KEY_DOWN && event.type != SDL_EVENT_KEY_UP) {
-    return -1;
-  }
-
-  // SDL represents key auto-repeat as additional key-down events. Forward
-  // them so the fallback path has the same long-press behavior as native hooks.
-  const int key_code = TranslateSdlKeyboardEventToVk(event.key);
-  if (key_code < 0) {
-    return 0;
-  }
-
-  return keyboard_.SendKeyCommand(key_code, event.type == SDL_EVENT_KEY_DOWN);
-}
-
-int GuiApplication::ProcessMouseEvent(const SDL_Event &event) {
-  controlled_remote_id_ = "";
-  RemoteAction remote_action{};
-
-  if ((event.type == SDL_EVENT_MOUSE_BUTTON_DOWN ||
-       event.type == SDL_EVENT_MOUSE_BUTTON_UP) &&
-      event.button.button != SDL_BUTTON_LEFT &&
-      event.button.button != SDL_BUTTON_RIGHT &&
-      event.button.button != SDL_BUTTON_MIDDLE) {
-    return 0;
-  }
-
-  float cursor_x = last_mouse_event.motion.x;
-  float cursor_y = last_mouse_event.motion.y;
-
-  auto normalize_cursor_to_window_space = [&](float *x, float *y) {
-    if (!x || !y || !stream_window_) {
-      return;
-    }
-
-    int window_width = 0;
-    int window_height = 0;
-    int pixel_width = 0;
-    int pixel_height = 0;
-    SDL_GetWindowSize(stream_window_, &window_width, &window_height);
-    SDL_GetWindowSizeInPixels(stream_window_, &pixel_width, &pixel_height);
-
-    if (window_width <= 0 || window_height <= 0 || pixel_width <= 0 ||
-        pixel_height <= 0) {
-      return;
-    }
-
-    if ((window_width != pixel_width || window_height != pixel_height) &&
-        (*x > static_cast<float>(window_width) + 1.0f ||
-         *y > static_cast<float>(window_height) + 1.0f)) {
-      const float scale_x =
-          static_cast<float>(window_width) / static_cast<float>(pixel_width);
-      const float scale_y =
-          static_cast<float>(window_height) / static_cast<float>(pixel_height);
-      *x *= scale_x;
-      *y *= scale_y;
-
-      static bool logged_pixel_to_window_conversion = false;
-      if (!logged_pixel_to_window_conversion) {
-        LOG_INFO(
-            "Mouse coordinate space converted from pixels to window units: "
-            "window={}x{}, pixels={}x{}, scale=({:.4f},{:.4f})",
-            window_width, window_height, pixel_width, pixel_height, scale_x,
-            scale_y);
-        logged_pixel_to_window_conversion = true;
-      }
-    }
-  };
-
-  if (event.type == SDL_EVENT_MOUSE_MOTION) {
-    cursor_x = event.motion.x;
-    cursor_y = event.motion.y;
-    normalize_cursor_to_window_space(&cursor_x, &cursor_y);
-  } else if (event.type == SDL_EVENT_MOUSE_BUTTON_DOWN ||
-             event.type == SDL_EVENT_MOUSE_BUTTON_UP) {
-    cursor_x = event.button.x;
-    cursor_y = event.button.y;
-    normalize_cursor_to_window_space(&cursor_x, &cursor_y);
-  } else if (event.type == SDL_EVENT_MOUSE_WHEEL) {
-    cursor_x = last_mouse_event.motion.x;
-    cursor_y = last_mouse_event.motion.y;
-  }
-
-  const bool is_pointer_position_event =
-      (event.type == SDL_EVENT_MOUSE_MOTION ||
-       event.type == SDL_EVENT_MOUSE_BUTTON_DOWN ||
-       event.type == SDL_EVENT_MOUSE_BUTTON_UP);
-
-  // std::shared_lock lock(remote_sessions_mutex_);
-  for (auto &it : remote_sessions_) {
-    auto props = it.second;
-    if (!props->control_mouse_) {
-      continue;
-    }
-
-    const bool file_transfer_window_hovered =
-        props->file_transfer_.file_transfer_window_hovered_;
-    const bool overlay_hovered =
-        props->control_bar_hovered_ || props->display_selectable_hovered_ ||
-        props->shortcut_selectable_hovered_ || file_transfer_window_hovered;
-
-    const SDL_FRect render_rect = props->stream_render_rect_f_;
-    if (render_rect.w <= 1.0f || render_rect.h <= 1.0f) {
-      continue;
-    }
-
-    if (is_pointer_position_event && cursor_x >= render_rect.x &&
-        cursor_x <= render_rect.x + render_rect.w &&
-        cursor_y >= render_rect.y &&
-        cursor_y <= render_rect.y + render_rect.h) {
-      controlled_remote_id_ = it.first;
-      last_mouse_event.motion.x = cursor_x;
-      last_mouse_event.motion.y = cursor_y;
-      last_mouse_event.button.x = cursor_x;
-      last_mouse_event.button.y = cursor_y;
-
-      remote_action.m.x = (cursor_x - render_rect.x) / render_rect.w;
-      remote_action.m.y = (cursor_y - render_rect.y) / render_rect.h;
-      remote_action.m.x = std::clamp(remote_action.m.x, 0.0f, 1.0f);
-      remote_action.m.y = std::clamp(remote_action.m.y, 0.0f, 1.0f);
-
-      if (SDL_EVENT_MOUSE_BUTTON_DOWN == event.type) {
-        remote_action.type = ControlType::mouse;
-        if (SDL_BUTTON_LEFT == event.button.button) {
-          remote_action.m.flag = MouseFlag::left_down;
-        } else if (SDL_BUTTON_RIGHT == event.button.button) {
-          remote_action.m.flag = MouseFlag::right_down;
-        } else if (SDL_BUTTON_MIDDLE == event.button.button) {
-          remote_action.m.flag = MouseFlag::middle_down;
-        }
-      } else if (SDL_EVENT_MOUSE_BUTTON_UP == event.type) {
-        remote_action.type = ControlType::mouse;
-        if (SDL_BUTTON_LEFT == event.button.button) {
-          remote_action.m.flag = MouseFlag::left_up;
-        } else if (SDL_BUTTON_RIGHT == event.button.button) {
-          remote_action.m.flag = MouseFlag::right_up;
-        } else if (SDL_BUTTON_MIDDLE == event.button.button) {
-          remote_action.m.flag = MouseFlag::middle_up;
-        }
-      } else if (SDL_EVENT_MOUSE_MOTION == event.type) {
-        remote_action.type = ControlType::mouse;
-        remote_action.m.flag = MouseFlag::move;
-      }
-
-      if (overlay_hovered) {
-        break;
-      }
-      if (props->peer_) {
-        std::string msg = remote_action.to_json();
-        SendReliableDataFrame(props->peer_, msg.c_str(), msg.size(),
-                              props->mouse_label_.c_str());
-      }
-    } else if (SDL_EVENT_MOUSE_WHEEL == event.type &&
-               last_mouse_event.button.x >= render_rect.x &&
-               last_mouse_event.button.x <= render_rect.x + render_rect.w &&
-               last_mouse_event.button.y >= render_rect.y &&
-               last_mouse_event.button.y <= render_rect.y + render_rect.h) {
-      float scroll_x = event.wheel.x;
-      float scroll_y = event.wheel.y;
-      if (event.wheel.direction == SDL_MOUSEWHEEL_FLIPPED) {
-        scroll_x = -scroll_x;
-        scroll_y = -scroll_y;
-      }
-
-      remote_action.type = ControlType::mouse;
-
-      auto roundUp = [](float value) -> int {
-        if (value > 0) {
-          return static_cast<int>(std::ceil(value));
-        } else if (value < 0) {
-          return static_cast<int>(std::floor(value));
-        }
-        return 0;
-      };
-
-      if (std::abs(scroll_y) >= std::abs(scroll_x)) {
-        remote_action.m.flag = MouseFlag::wheel_vertical;
-        remote_action.m.s = roundUp(scroll_y);
-      } else {
-        remote_action.m.flag = MouseFlag::wheel_horizontal;
-        remote_action.m.s = roundUp(scroll_x);
-      }
-
-      remote_action.m.x = (last_mouse_event.button.x - render_rect.x) /
-                          (std::max)(render_rect.w, 1.0f);
-      remote_action.m.y = (last_mouse_event.button.y - render_rect.y) /
-                          (std::max)(render_rect.h, 1.0f);
-      remote_action.m.x = std::clamp(remote_action.m.x, 0.0f, 1.0f);
-      remote_action.m.y = std::clamp(remote_action.m.y, 0.0f, 1.0f);
-
-      if (overlay_hovered) {
-        continue;
-      }
-      if (props->peer_) {
-        std::string msg = remote_action.to_json();
-        SendReliableDataFrame(props->peer_, msg.c_str(), msg.size(),
-                              props->mouse_label_.c_str());
-      }
-    }
-  }
-
-  return 0;
-}
-
-} // namespace crossdesk

apps/desktop/src/gui/application/window_lifecycle.cpp

@@ -1,687 +0,0 @@
-#include "application/gui_application.h"
-
-#include <libyuv.h>
-
-#if defined(__linux__) && !defined(__APPLE__)
-#include <X11/Xatom.h>
-#include <X11/Xlib.h>
-#endif
-
-#include <cmath>
-#include <cstdlib>
-#include <cstring>
-#include <fstream>
-#include <iostream>
-#include <memory>
-#include <mutex>
-#include <shared_mutex>
-#include <string>
-#include <thread>
-
-#include "fa_regular_400.h"
-#include "fa_solid_900.h"
-#include "layout_relative.h"
-#include "localization.h"
-#include "rd_log.h"
-#include "version_checker.h"
-
-#if defined(__APPLE__)
-#include "window_util_mac.h"
-#endif
-
-namespace crossdesk {
-
-namespace {
-const ImWchar *GetMultilingualGlyphRanges() {
-  static std::vector<ImWchar> glyph_ranges;
-  if (glyph_ranges.empty()) {
-    ImGuiIO &io = ImGui::GetIO();
-    ImFontGlyphRangesBuilder builder;
-    builder.AddRanges(io.Fonts->GetGlyphRangesDefault());
-    builder.AddRanges(io.Fonts->GetGlyphRangesChineseFull());
-    builder.AddRanges(io.Fonts->GetGlyphRangesCyrillic());
-
-    ImVector<ImWchar> built_ranges;
-    builder.BuildRanges(&built_ranges);
-    glyph_ranges.assign(built_ranges.Data,
-                        built_ranges.Data + built_ranges.Size);
-  }
-  return glyph_ranges.empty() ? nullptr : glyph_ranges.data();
-}
-
-bool CanReadFontFile(const char *font_path) {
-  if (!font_path) {
-    return false;
-  }
-
-  std::ifstream font_file(font_path, std::ios::binary);
-  return font_file.good();
-}
-
-#if _WIN32
-HICON LoadTrayIcon() {
-  HMODULE module = GetModuleHandleW(nullptr);
-  HICON icon = reinterpret_cast<HICON>(
-      LoadImageW(module, L"IDI_ICON1", IMAGE_ICON, 0, 0, LR_DEFAULTSIZE));
-  if (icon) {
-    return icon;
-  }
-
-  return LoadIconW(nullptr, IDI_APPLICATION);
-}
-
-#endif
-
-#if defined(__linux__) && !defined(__APPLE__)
-inline bool X11GetDisplayAndWindow(SDL_Window *window, Display **display_out,
-                                   ::Window *x11_window_out) {
-  if (!window || !display_out || !x11_window_out) {
-    return false;
-  }
-
-#if !defined(SDL_PROP_WINDOW_X11_DISPLAY_POINTER) ||                           \
-    !defined(SDL_PROP_WINDOW_X11_WINDOW_NUMBER)
-  // SDL build does not expose X11 window properties.
-  return false;
-#else
-  SDL_PropertiesID props = SDL_GetWindowProperties(window);
-  Display *display = (Display *)SDL_GetPointerProperty(
-      props, SDL_PROP_WINDOW_X11_DISPLAY_POINTER, NULL);
-  const Sint64 x11_window_num =
-      SDL_GetNumberProperty(props, SDL_PROP_WINDOW_X11_WINDOW_NUMBER, 0);
-  const ::Window x11_window = (::Window)x11_window_num;
-
-  if (!display || !x11_window) {
-    return false;
-  }
-
-  *display_out = display;
-  *x11_window_out = x11_window;
-  return true;
-#endif
-}
-
-inline void X11SendNetWmState(Display *display, ::Window x11_window,
-                              long action, Atom state1, Atom state2 = 0) {
-  if (!display || !x11_window) {
-    return;
-  }
-
-  const Atom wm_state = XInternAtom(display, "_NET_WM_STATE", False);
-
-  XEvent event;
-  memset(&event, 0, sizeof(event));
-  event.xclient.type = ClientMessage;
-  event.xclient.serial = 0;
-  event.xclient.send_event = True;
-  event.xclient.message_type = wm_state;
-  event.xclient.window = x11_window;
-  event.xclient.format = 32;
-  event.xclient.data.l[0] = action;
-  event.xclient.data.l[1] = (long)state1;
-  event.xclient.data.l[2] = (long)state2;
-  event.xclient.data.l[3] = 1; // normal source indication
-  event.xclient.data.l[4] = 0;
-
-  XSendEvent(display, DefaultRootWindow(display), False,
-             SubstructureRedirectMask | SubstructureNotifyMask, &event);
-}
-
-inline void X11SetWindowTypeUtility(Display *display, ::Window x11_window) {
-  if (!display || !x11_window) {
-    return;
-  }
-
-  const Atom wm_window_type =
-      XInternAtom(display, "_NET_WM_WINDOW_TYPE", False);
-  const Atom wm_window_type_utility =
-      XInternAtom(display, "_NET_WM_WINDOW_TYPE_UTILITY", False);
-
-  XChangeProperty(display, x11_window, wm_window_type, XA_ATOM, 32,
-                  PropModeReplace, (unsigned char *)&wm_window_type_utility, 1);
-}
-
-inline void X11SetWindowAlwaysOnTop(SDL_Window *window) {
-  Display *display = nullptr;
-  ::Window x11_window = 0;
-  if (!X11GetDisplayAndWindow(window, &display, &x11_window)) {
-    return;
-  }
-
-  const Atom state_above = XInternAtom(display, "_NET_WM_STATE_ABOVE", False);
-  const Atom state_stays_on_top =
-      XInternAtom(display, "_NET_WM_STATE_STAYS_ON_TOP", False);
-
-  // Request _NET_WM_STATE_ADD for ABOVE + STAYS_ON_TOP.
-  X11SendNetWmState(display, x11_window, 1, state_above, state_stays_on_top);
-  XFlush(display);
-}
-
-inline void X11SetWindowSkipTaskbar(SDL_Window *window) {
-  Display *display = nullptr;
-  ::Window x11_window = 0;
-  if (!X11GetDisplayAndWindow(window, &display, &x11_window)) {
-    return;
-  }
-
-  const Atom skip_taskbar =
-      XInternAtom(display, "_NET_WM_STATE_SKIP_TASKBAR", False);
-  const Atom skip_pager =
-      XInternAtom(display, "_NET_WM_STATE_SKIP_PAGER", False);
-
-  // Request _NET_WM_STATE_ADD for SKIP_TASKBAR + SKIP_PAGER.
-  X11SendNetWmState(display, x11_window, 1, skip_taskbar, skip_pager);
-
-  // Hint the WM that this is an auxiliary/utility window.
-  X11SetWindowTypeUtility(display, x11_window);
-
-  XFlush(display);
-}
-#endif
-} // namespace
-
-SDL_HitTestResult GuiApplication::HitTestCallback(SDL_Window *window,
-                                                  const SDL_Point *area,
-                                                  void *data) {
-  GuiApplication *application = (GuiApplication *)data;
-  if (!application) {
-    return SDL_HITTEST_NORMAL;
-  }
-
-  if (application->fullscreen_button_pressed_) {
-    return SDL_HITTEST_NORMAL;
-  }
-
-  // Server window: OS-level dragging for the title bar, but keep the left-side
-  // collapse/expand button clickable.
-  if (application->server_window_ && window == application->server_window_) {
-    const float title_h = application->server_window_title_bar_height_;
-    const float button_w = title_h;
-    if (area->y >= 0 && area->y < title_h) {
-      if (area->x >= 0 && area->x < button_w) {
-        return SDL_HITTEST_NORMAL;
-      }
-      return SDL_HITTEST_DRAGGABLE;
-    }
-    return SDL_HITTEST_NORMAL;
-  }
-
-  int window_width, window_height;
-  SDL_GetWindowSize(window, &window_width, &window_height);
-
-  // check if curosor is in tab bar
-  if (application->stream_window_inited_ && application->stream_window_created_ &&
-      !application->fullscreen_button_pressed_ && application->stream_ctx_) {
-    ImGuiContext *prev_ctx = ImGui::GetCurrentContext();
-    ImGui::SetCurrentContext(application->stream_ctx_);
-
-    ImGuiWindow *tab_bar_window = ImGui::FindWindowByName("TabBar");
-    if (tab_bar_window && tab_bar_window->Active) {
-      ImGuiIO &io = ImGui::GetIO();
-      float scale_x = io.DisplayFramebufferScale.x;
-      float scale_y = io.DisplayFramebufferScale.y;
-
-      float tab_bar_x = tab_bar_window->Pos.x * scale_x;
-      float tab_bar_y = tab_bar_window->Pos.y * scale_y;
-      float tab_bar_width = tab_bar_window->Size.x * scale_x;
-      float tab_bar_height = tab_bar_window->Size.y * scale_y;
-
-      ImGui::SetCurrentContext(prev_ctx);
-
-      if (area->x >= tab_bar_x && area->x <= tab_bar_x + tab_bar_width &&
-          area->y >= tab_bar_y && area->y <= tab_bar_y + tab_bar_height) {
-        return SDL_HITTEST_NORMAL;
-      }
-    } else {
-      ImGui::SetCurrentContext(prev_ctx);
-    }
-  }
-
-  float mouse_grab_padding = application->title_bar_button_width_ * 0.16f;
-  if (area->y < application->title_bar_button_width_ &&
-      area->y > mouse_grab_padding &&
-      area->x < window_width - application->title_bar_button_width_ * 3.0f &&
-      area->x > mouse_grab_padding) {
-    return SDL_HITTEST_DRAGGABLE;
-  }
-
-  // if (!application->streaming_) {
-  //   return SDL_HITTEST_NORMAL;
-  // }
-
-  if (area->y < mouse_grab_padding) {
-    if (area->x < mouse_grab_padding) {
-      return SDL_HITTEST_RESIZE_TOPLEFT;
-    } else if (area->x > window_width - mouse_grab_padding) {
-      return SDL_HITTEST_RESIZE_TOPRIGHT;
-    } else {
-      return SDL_HITTEST_RESIZE_TOP;
-    }
-  } else if (area->y > window_height - mouse_grab_padding) {
-    if (area->x < mouse_grab_padding) {
-      return SDL_HITTEST_RESIZE_BOTTOMLEFT;
-    } else if (area->x > window_width - mouse_grab_padding) {
-      return SDL_HITTEST_RESIZE_BOTTOMRIGHT;
-    } else {
-      return SDL_HITTEST_RESIZE_BOTTOM;
-    }
-  } else if (area->x < mouse_grab_padding) {
-    return SDL_HITTEST_RESIZE_LEFT;
-  } else if (area->x > window_width - mouse_grab_padding) {
-    return SDL_HITTEST_RESIZE_RIGHT;
-  }
-
-  return SDL_HITTEST_NORMAL;
-}
-
-int GuiApplication::CreateMainWindow() {
-  main_ctx_ = ImGui::CreateContext();
-  if (!main_ctx_) {
-    LOG_ERROR("Main context is null");
-    return -1;
-  }
-
-  ImGui::SetCurrentContext(main_ctx_);
-
-  if (!SDL_CreateWindowAndRenderer(
-          "CrossDesk Main Window", (int)main_window_width_,
-          (int)main_window_height_,
-          SDL_WINDOW_HIGH_PIXEL_DENSITY | SDL_WINDOW_BORDERLESS |
-              SDL_WINDOW_HIDDEN | SDL_WINDOW_TRANSPARENT,
-          &main_window_, &main_renderer_)) {
-    LOG_ERROR("Error creating MainWindow and MainRenderer: {}", SDL_GetError());
-    return -1;
-  }
-
-  float dpi_scale = SDL_GetDisplayContentScale(SDL_GetPrimaryDisplay());
-  if (std::abs(dpi_scale_ - dpi_scale) > 0.01f) {
-    dpi_scale_ = dpi_scale;
-
-    main_window_width_ = (int)(main_window_width_default_ * dpi_scale_);
-    main_window_height_ = (int)(main_window_height_default_ * dpi_scale_);
-    stream_window_width_ = (int)(stream_window_width_default_ * dpi_scale_);
-    stream_window_height_ = (int)(stream_window_height_default_ * dpi_scale_);
-    server_window_width_ = (int)(server_window_width_default_ * dpi_scale_);
-    server_window_height_ = (int)(server_window_height_default_ * dpi_scale_);
-    server_window_normal_width_ =
-        (int)(server_window_width_default_ * dpi_scale_);
-    server_window_normal_height_ =
-        (int)(server_window_height_default_ * dpi_scale_);
-    window_rounding_ = window_rounding_default_ * dpi_scale_;
-
-    SDL_SetWindowSize(main_window_, (int)main_window_width_,
-                      (int)main_window_height_);
-  }
-
-  SDL_SetWindowResizable(main_window_, false);
-
-  // for window region action
-  SDL_SetWindowHitTest(main_window_, HitTestCallback, this);
-
-  SDL_SetRenderDrawBlendMode(main_renderer_, SDL_BLENDMODE_BLEND);
-
-  SetupFontAndStyle(&main_windows_system_chinese_font_);
-
-  ImGuiStyle &style = ImGui::GetStyle();
-  style.ScaleAllSizes(dpi_scale_);
-  style.FontScaleDpi = dpi_scale_;
-
-#if _WIN32
-  SDL_PropertiesID props = SDL_GetWindowProperties(main_window_);
-  HWND main_hwnd = (HWND)SDL_GetPointerProperty(
-      props, SDL_PROP_WINDOW_WIN32_HWND_POINTER, NULL);
-
-  HICON tray_icon = LoadTrayIcon();
-  tray_ = std::make_unique<WinTray>(main_hwnd, tray_icon, L"CrossDesk",
-                                    localization_language_index_);
-#elif defined(__APPLE__)
-  tray_ = std::make_unique<MacTray>(main_window_, "CrossDesk",
-                                    localization_language_index_);
-#elif defined(__linux__) && !defined(__APPLE__)
-  tray_ = std::make_unique<LinuxTray>(
-      main_window_, "CrossDesk", localization_language_index_, APP_EXIT_EVENT);
-#endif
-
-  ImGui_ImplSDL3_InitForSDLRenderer(main_window_, main_renderer_);
-  ImGui_ImplSDLRenderer3_Init(main_renderer_);
-
-  return 0;
-}
-
-int GuiApplication::DestroyMainWindow() {
-  if (main_ctx_) {
-    ImGui::SetCurrentContext(main_ctx_);
-  }
-
-  if (main_renderer_) {
-    SDL_DestroyRenderer(main_renderer_);
-  }
-
-  if (main_window_) {
-    SDL_DestroyWindow(main_window_);
-  }
-
-  return 0;
-}
-
-int GuiApplication::CreateStreamWindow() {
-  if (stream_window_created_) {
-    return 0;
-  }
-
-  stream_window_width_ = (int)(stream_window_width_default_ * dpi_scale_);
-  stream_window_height_ = (int)(stream_window_height_default_ * dpi_scale_);
-
-  stream_ctx_ = ImGui::CreateContext();
-  if (!stream_ctx_) {
-    LOG_ERROR("Stream context is null");
-    return -1;
-  }
-
-  ImGui::SetCurrentContext(stream_ctx_);
-
-  if (!SDL_CreateWindowAndRenderer(
-          "CrossDesk Stream Window", (int)stream_window_width_,
-          (int)stream_window_height_,
-          SDL_WINDOW_HIGH_PIXEL_DENSITY | SDL_WINDOW_BORDERLESS |
-              SDL_WINDOW_TRANSPARENT,
-          &stream_window_, &stream_renderer_)) {
-    LOG_ERROR("Error creating stream_window_ and stream_renderer_: {}",
-              SDL_GetError());
-    return -1;
-  }
-
-  stream_pixformat_ = SDL_PIXELFORMAT_NV12;
-
-  SDL_SetWindowResizable(stream_window_, true);
-
-  // for window region action
-  SDL_SetWindowHitTest(stream_window_, HitTestCallback, this);
-
-  SDL_SetRenderDrawBlendMode(stream_renderer_, SDL_BLENDMODE_BLEND);
-
-  SetupFontAndStyle(&stream_windows_system_chinese_font_);
-
-  ImGuiStyle &style = ImGui::GetStyle();
-  style.ScaleAllSizes(dpi_scale_);
-  style.FontScaleDpi = dpi_scale_;
-
-  ImGui_ImplSDL3_InitForSDLRenderer(stream_window_, stream_renderer_);
-  ImGui_ImplSDLRenderer3_Init(stream_renderer_);
-
-  // change props->stream_render_rect_
-  SDL_Event event;
-  event.type = SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED;
-  event.window.windowID = SDL_GetWindowID(stream_window_);
-  SDL_PushEvent(&event);
-
-  stream_window_created_ = true;
-  just_created_ = true;
-
-  stream_window_inited_ = true;
-  LOG_INFO("Stream window inited");
-
-  return 0;
-}
-
-int GuiApplication::DestroyStreamWindow() {
-  stream_window_width_ = (float)stream_window_width_default_;
-  stream_window_height_ = (float)stream_window_height_default_;
-
-  if (stream_ctx_) {
-    ImGui::SetCurrentContext(stream_ctx_);
-  }
-
-  if (stream_renderer_) {
-    SDL_DestroyRenderer(stream_renderer_);
-    stream_renderer_ = nullptr;
-  }
-
-  if (stream_window_) {
-    SDL_DestroyWindow(stream_window_);
-    stream_window_ = nullptr;
-  }
-
-  stream_window_created_ = false;
-  focus_on_stream_window_ = false;
-  stream_window_grabbed_ = false;
-  control_mouse_ = false;
-
-  return 0;
-}
-
-int GuiApplication::CreateServerWindow() {
-  if (server_window_created_) {
-    return 0;
-  }
-  server_ctx_ = ImGui::CreateContext();
-  if (!server_ctx_) {
-    LOG_ERROR("Server context is null");
-    return -1;
-  }
-  ImGui::SetCurrentContext(server_ctx_);
-  if (!SDL_CreateWindowAndRenderer(
-          "CrossDesk Server Window", (int)server_window_width_,
-          (int)server_window_height_,
-          SDL_WINDOW_HIGH_PIXEL_DENSITY | SDL_WINDOW_BORDERLESS |
-              SDL_WINDOW_TRANSPARENT,
-          &server_window_, &server_renderer_)) {
-    LOG_ERROR("Error creating server_window_ and server_renderer_: {}",
-              SDL_GetError());
-    return -1;
-  }
-
-#if _WIN32
-  // Hide server window from the taskbar by making it a tool window.
-  {
-    SDL_PropertiesID server_props = SDL_GetWindowProperties(server_window_);
-    HWND server_hwnd = (HWND)SDL_GetPointerProperty(
-        server_props, SDL_PROP_WINDOW_WIN32_HWND_POINTER, NULL);
-
-    if (server_hwnd) {
-      LONG_PTR ex_style = GetWindowLongPtr(server_hwnd, GWL_EXSTYLE);
-      ex_style |= WS_EX_TOOLWINDOW;
-      ex_style &= ~WS_EX_APPWINDOW;
-      SetWindowLongPtr(server_hwnd, GWL_EXSTYLE, ex_style);
-
-      // Keep the server window above normal windows.
-      SetWindowPos(server_hwnd, HWND_TOPMOST, 0, 0, 0, 0,
-                   SWP_NOMOVE | SWP_NOSIZE | SWP_FRAMECHANGED | SWP_NOACTIVATE);
-    }
-  }
-#endif
-
-#if defined(__linux__) && !defined(__APPLE__)
-  // Best-effort keep above other windows on X11.
-  X11SetWindowAlwaysOnTop(server_window_);
-  // Best-effort hide from taskbar on X11.
-  X11SetWindowSkipTaskbar(server_window_);
-#endif
-
-#if defined(__APPLE__)
-  // Best-effort keep above other windows on macOS.
-  MacSetWindowAlwaysOnTop(server_window_, true);
-  // Best-effort exclude from Window menu / window cycling.
-  MacSetWindowExcludedFromWindowMenu(server_window_, true);
-#endif
-
-  // Set window position to bottom-right corner
-  SDL_Rect display_bounds;
-  if (SDL_GetDisplayUsableBounds(SDL_GetDisplayForWindow(server_window_),
-                                 &display_bounds)) {
-    int window_x =
-        display_bounds.x + display_bounds.w - (int)server_window_width_;
-    int window_y =
-        display_bounds.y + display_bounds.h - (int)server_window_height_;
-    SDL_SetWindowPosition(server_window_, window_x, window_y);
-  }
-
-  SDL_SetWindowResizable(server_window_, false);
-
-  SDL_SetRenderDrawBlendMode(server_renderer_, SDL_BLENDMODE_BLEND);
-
-  // for window region action
-  SDL_SetWindowHitTest(server_window_, HitTestCallback, this);
-
-  SetupFontAndStyle(&server_windows_system_chinese_font_);
-
-  ImGuiStyle &style = ImGui::GetStyle();
-  style.ScaleAllSizes(dpi_scale_);
-  style.FontScaleDpi = dpi_scale_;
-
-  ImGui_ImplSDL3_InitForSDLRenderer(server_window_, server_renderer_);
-  ImGui_ImplSDLRenderer3_Init(server_renderer_);
-
-  server_window_created_ = true;
-  server_window_inited_ = true;
-
-  LOG_INFO("Server window inited");
-
-  return 0;
-}
-
-int GuiApplication::DestroyServerWindow() {
-  if (server_ctx_) {
-    ImGui::SetCurrentContext(server_ctx_);
-  }
-
-  if (server_renderer_) {
-    SDL_DestroyRenderer(server_renderer_);
-    server_renderer_ = nullptr;
-  }
-
-  if (server_window_) {
-    SDL_DestroyWindow(server_window_);
-    server_window_ = nullptr;
-  }
-
-  server_window_created_ = false;
-  server_window_inited_ = false;
-
-  return 0;
-}
-
-int GuiApplication::SetupFontAndStyle(ImFont **system_chinese_font_out) {
-  float font_size = 32.0f;
-
-  // Setup Dear ImGui style
-  ImGuiIO &io = ImGui::GetIO();
-
-  io.IniFilename = NULL; // disable imgui.ini
-
-  // Build one merged atlas: UI font + icon font + multilingual fallback fonts.
-  ImFontConfig config;
-  config.FontDataOwnedByAtlas = false;
-  config.MergeMode = false;
-
-  if (system_chinese_font_out) {
-    *system_chinese_font_out = nullptr;
-  }
-
-  ImFont *ui_font = nullptr;
-  const ImWchar *multilingual_ranges = GetMultilingualGlyphRanges();
-
-#if defined(_WIN32)
-  const char *base_font_paths[] = {
-      "C:/Windows/Fonts/msyh.ttc",    "C:/Windows/Fonts/msyhbd.ttc",
-      "C:/Windows/Fonts/segoeui.ttf", "C:/Windows/Fonts/arial.ttf",
-      "C:/Windows/Fonts/simsun.ttc",  nullptr};
-#elif defined(__APPLE__)
-  const char *base_font_paths[] = {
-      "/System/Library/Fonts/PingFang.ttc",
-      "/System/Library/Fonts/Supplemental/Arial Unicode.ttf",
-      "/System/Library/Fonts/Supplemental/Arial.ttf",
-      "/System/Library/Fonts/SFNS.ttf", nullptr};
-#else
-  const char *base_font_paths[] = {
-      "/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc",
-      "/usr/share/fonts/opentype/noto/NotoSans-Regular.ttf",
-      "/usr/share/fonts/truetype/wqy/wqy-microhei.ttc",
-      "/usr/share/fonts/truetype/wqy/wqy-zenhei.ttc",
-      "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
-      nullptr};
-#endif
-
-  for (int i = 0; base_font_paths[i] != nullptr && ui_font == nullptr; ++i) {
-    if (!CanReadFontFile(base_font_paths[i])) {
-      continue;
-    }
-    ui_font = io.Fonts->AddFontFromFileTTF(base_font_paths[i], font_size,
-                                           &config, multilingual_ranges);
-    if (ui_font != nullptr) {
-      LOG_INFO("Loaded base UI font: {}", base_font_paths[i]);
-    }
-  }
-  if (!ui_font) {
-    ui_font = io.Fonts->AddFontDefault(&config);
-  }
-
-  if (!ui_font) {
-    LOG_WARN("Failed to initialize base UI font");
-    ImGui::StyleColorsLight();
-    return 0;
-  }
-
-  ImFontConfig icon_config = config;
-  icon_config.MergeMode = true;
-  static const ImWchar icon_ranges[] = {ICON_MIN_FA, ICON_MAX_FA, 0};
-  io.Fonts->AddFontFromMemoryTTF(fa_solid_900_ttf, fa_solid_900_ttf_len,
-                                 font_size, &icon_config, icon_ranges);
-
-  io.FontDefault = ui_font;
-  if (system_chinese_font_out) {
-    *system_chinese_font_out = ui_font;
-  }
-
-  ImGui::StyleColorsLight();
-
-  return 0;
-}
-
-int GuiApplication::DestroyMainWindowContext() {
-  if (!main_ctx_) {
-    return 0;
-  }
-
-  ImGui::SetCurrentContext(main_ctx_);
-  ImGui_ImplSDLRenderer3_Shutdown();
-  ImGui_ImplSDL3_Shutdown();
-  ImGui::DestroyContext(main_ctx_);
-  main_ctx_ = nullptr;
-
-  return 0;
-}
-
-int GuiApplication::DestroyStreamWindowContext() {
-  if (!stream_ctx_) {
-    stream_window_inited_ = false;
-    return 0;
-  }
-
-  stream_window_inited_ = false;
-  ImGui::SetCurrentContext(stream_ctx_);
-  ImGui_ImplSDLRenderer3_Shutdown();
-  ImGui_ImplSDL3_Shutdown();
-  ImGui::DestroyContext(stream_ctx_);
-  stream_ctx_ = nullptr;
-
-  return 0;
-}
-
-int GuiApplication::DestroyServerWindowContext() {
-  if (!server_ctx_) {
-    server_window_inited_ = false;
-    return 0;
-  }
-
-  server_window_inited_ = false;
-  ImGui::SetCurrentContext(server_ctx_);
-  ImGui_ImplSDLRenderer3_Shutdown();
-  ImGui_ImplSDL3_Shutdown();
-  ImGui::DestroyContext(server_ctx_);
-  server_ctx_ = nullptr;
-
-  return 0;
-}
-
-} // namespace crossdesk

apps/desktop/src/gui/application/window_rendering.cpp

@@ -1,236 +0,0 @@
-#include "application/gui_application.h"
-
-#include <cmath>
-
-#include "rd_log.h"
-
-namespace crossdesk {
-
-int GuiApplication::DrawMainWindow() {
-  if (!main_ctx_) {
-    LOG_ERROR("Main context is null");
-    return -1;
-  }
-
-  ImGui::SetCurrentContext(main_ctx_);
-  ImGui_ImplSDLRenderer3_NewFrame();
-  ImGui_ImplSDL3_NewFrame();
-  ImGui::NewFrame();
-
-  ImGuiIO &io = ImGui::GetIO();
-  ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, window_rounding_);
-
-  ImGui::SetNextWindowPos(ImVec2(0, 0), ImGuiCond_Always);
-  ImGui::SetNextWindowSize(ImVec2(io.DisplaySize.x, io.DisplaySize.y),
-                           ImGuiCond_Always);
-  ImGui::Begin("MainRender", nullptr,
-               ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoDecoration |
-                   ImGuiWindowFlags_NoBringToFrontOnFocus |
-                   ImGuiWindowFlags_NoDocking);
-  ImGui::PopStyleColor();
-  ImGui::PopStyleVar();
-
-  TitleBar(true);
-
-  MainWindow();
-
-  UpdateNotificationWindow();
-
-#if _WIN32 && CROSSDESK_PORTABLE
-  PortableServiceInstallWindow();
-#endif
-
-#ifdef __APPLE__
-  if (show_request_permission_window_) {
-    RequestPermissionWindow();
-  }
-#endif
-
-  ImGui::End();
-
-  // Rendering
-  (void)io;
-  ImGui::Render();
-  SDL_SetRenderScale(main_renderer_, io.DisplayFramebufferScale.x,
-                     io.DisplayFramebufferScale.y);
-  SDL_SetRenderDrawColor(main_renderer_, 0, 0, 0, 0);
-  SDL_RenderClear(main_renderer_);
-  ImGui_ImplSDLRenderer3_RenderDrawData(ImGui::GetDrawData(), main_renderer_);
-  SDL_RenderPresent(main_renderer_);
-
-  return 0;
-}
-
-int GuiApplication::DrawStreamWindow() {
-  if (!stream_ctx_) {
-    LOG_ERROR("Stream context is null");
-    return -1;
-  }
-
-  ImGui::SetCurrentContext(stream_ctx_);
-  ImGui_ImplSDLRenderer3_NewFrame();
-  ImGui_ImplSDL3_NewFrame();
-  ImGui::NewFrame();
-
-  StreamWindow();
-
-  ImGuiIO &io = ImGui::GetIO();
-  float stream_title_window_height =
-      fullscreen_button_pressed_ ? 0 : title_bar_height_;
-
-  ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
-  // Set minimum window size to 0 to allow exact height control
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowMinSize, ImVec2(0, 0));
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0));
-  ImGui::SetNextWindowPos(ImVec2(0, 0), ImGuiCond_Always);
-  ImGui::SetNextWindowSize(ImVec2(io.DisplaySize.x, stream_title_window_height),
-                           ImGuiCond_Always);
-  ImGui::Begin("StreamTitleWindow", nullptr,
-               ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoDecoration |
-                   ImGuiWindowFlags_NoBringToFrontOnFocus |
-                   ImGuiWindowFlags_NoDocking);
-  ImGui::PopStyleVar(2);
-  ImGui::PopStyleColor();
-
-  if (!fullscreen_button_pressed_) {
-    TitleBar(false);
-  }
-
-  ImGui::End();
-
-  // Rendering
-  (void)io;
-  ImGui::Render();
-  SDL_SetRenderScale(stream_renderer_, io.DisplayFramebufferScale.x,
-                     io.DisplayFramebufferScale.y);
-  SDL_SetRenderDrawColor(stream_renderer_, 0, 0, 0, 255);
-  SDL_RenderClear(stream_renderer_);
-
-  // std::shared_lock lock(remote_sessions_mutex_);
-  for (auto &it : remote_sessions_) {
-    auto props = it.second;
-    if (props->tab_selected_) {
-      SDL_FRect render_rect_f = {
-          props->stream_render_rect_f_.x, props->stream_render_rect_f_.y,
-          props->stream_render_rect_f_.w, props->stream_render_rect_f_.h};
-      SDL_RenderTexture(stream_renderer_, props->stream_texture_, NULL,
-                        &render_rect_f);
-    }
-  }
-  ImGui_ImplSDLRenderer3_RenderDrawData(ImGui::GetDrawData(), stream_renderer_);
-  SDL_RenderPresent(stream_renderer_);
-
-  return 0;
-}
-
-int GuiApplication::DrawServerWindow() {
-  if (!server_ctx_) {
-    LOG_ERROR("Server context is null");
-    return -1;
-  }
-  ImGui::SetCurrentContext(server_ctx_);
-  ImGui_ImplSDLRenderer3_NewFrame();
-  ImGui_ImplSDL3_NewFrame();
-  ImGui::NewFrame();
-
-  ImGuiIO &io = ImGui::GetIO();
-  server_window_width_ = io.DisplaySize.x;
-  server_window_height_ = io.DisplaySize.y;
-
-  ServerWindow();
-  ImGui::Render();
-  SDL_SetRenderScale(server_renderer_, io.DisplayFramebufferScale.x,
-                     io.DisplayFramebufferScale.y);
-  SDL_SetRenderDrawColor(server_renderer_, 0, 0, 0, 0);
-  SDL_RenderClear(server_renderer_);
-  ImGui_ImplSDLRenderer3_RenderDrawData(ImGui::GetDrawData(), server_renderer_);
-  SDL_RenderPresent(server_renderer_);
-  return 0;
-}
-
-bool GuiApplication::MinimizeMainWindowToTray() {
-  if (!main_window_) {
-    return false;
-  }
-
-#if defined(_WIN32) || defined(__APPLE__)
-  if (!tray_) {
-    return false;
-  }
-
-  tray_->MinimizeToTray();
-  return true;
-#elif defined(__linux__) && !defined(__APPLE__)
-  if (!tray_) {
-    return false;
-  }
-
-  return tray_->MinimizeToTray();
-#else
-  return false;
-#endif
-}
-
-void GuiApplication::UpdateRenderRect() {
-  // std::shared_lock lock(remote_sessions_mutex_);
-  for (auto &[_, props] : remote_sessions_) {
-    if (!props->reset_control_bar_pos_) {
-      props->mouse_diff_control_bar_pos_x_ = 0;
-      props->mouse_diff_control_bar_pos_y_ = 0;
-    }
-
-    if (!just_created_) {
-      props->reset_control_bar_pos_ = true;
-    }
-
-    int stream_window_width, stream_window_height;
-    SDL_GetWindowSize(stream_window_, &stream_window_width,
-                      &stream_window_height);
-    stream_window_width_ = (float)stream_window_width;
-    stream_window_height_ = (float)stream_window_height;
-
-    float video_ratio =
-        (float)props->video_width_ / (float)props->video_height_;
-    float video_ratio_reverse =
-        (float)props->video_height_ / (float)props->video_width_;
-
-    float render_area_width = props->render_window_width_;
-    float render_area_height = props->render_window_height_;
-
-    props->stream_render_rect_last_ = props->stream_render_rect_;
-
-    SDL_FRect rect_f{props->render_window_x_, props->render_window_y_,
-                     render_area_width, render_area_height};
-    if (render_area_width < render_area_height * video_ratio) {
-      rect_f.x = props->render_window_x_;
-      rect_f.y = std::abs(render_area_height -
-                          render_area_width * video_ratio_reverse) /
-                     2.0f +
-                 props->render_window_y_;
-      rect_f.w = render_area_width;
-      rect_f.h = render_area_width * video_ratio_reverse;
-    } else if (render_area_width > render_area_height * video_ratio) {
-      rect_f.x =
-          std::abs(render_area_width - render_area_height * video_ratio) /
-              2.0f +
-          props->render_window_x_;
-      rect_f.y = props->render_window_y_;
-      rect_f.w = render_area_height * video_ratio;
-      rect_f.h = render_area_height;
-    } else {
-      rect_f.x = props->render_window_x_;
-      rect_f.y = props->render_window_y_;
-      rect_f.w = render_area_width;
-      rect_f.h = render_area_height;
-    }
-
-    props->stream_render_rect_f_ = rect_f;
-    props->stream_render_rect_ = {static_cast<int>(std::lround(rect_f.x)),
-                                  static_cast<int>(std::lround(rect_f.y)),
-                                  static_cast<int>(std::lround(rect_f.w)),
-                                  static_cast<int>(std::lround(rect_f.h))};
-  }
-}
-
-} // namespace crossdesk

apps/desktop/src/gui/assets/layouts/layout.h

@@ -1,83 +0,0 @@
-/*
- * @Author: DI JUNKUN
- * @Date: 2024-06-14
- * Copyright (c) 2024 by DI JUNKUN, All Rights Reserved.
- */
-
-#ifndef _LAYOUT_STYLE_H_
-#define _LAYOUT_STYLE_H_
-
-#define MENU_WINDOW_WIDTH_CN 300 * dpi_scale_
-#define MENU_WINDOW_HEIGHT_CN 280 * dpi_scale_
-#define LOCAL_WINDOW_WIDTH_CN 300 * dpi_scale_
-#define LOCAL_WINDOW_HEIGHT_CN 280 * dpi_scale_
-#define REMOTE_WINDOW_WIDTH_CN 300 * dpi_scale_
-#define REMOTE_WINDOW_HEIGHT_CN 280 * dpi_scale_
-#define MENU_WINDOW_WIDTH_EN 190 * dpi_scale_
-#define MENU_WINDOW_HEIGHT_EN 245 * dpi_scale_
-#define IPUT_WINDOW_WIDTH 160 * dpi_scale_
-#define INPUT_WINDOW_PADDING_CN 66 * dpi_scale_
-#define INPUT_WINDOW_PADDING_EN 96 * dpi_scale_
-#define SETTINGS_WINDOW_WIDTH_CN 202 * dpi_scale_
-#define SETTINGS_WINDOW_WIDTH_EN 248 * dpi_scale_
-#if USE_CUDA
-#if _WIN32
-#define SETTINGS_WINDOW_HEIGHT_CN 405 * dpi_scale_
-#define SETTINGS_WINDOW_HEIGHT_EN 405 * dpi_scale_
-#else
-#define SETTINGS_WINDOW_HEIGHT_CN 375 * dpi_scale_
-#define SETTINGS_WINDOW_HEIGHT_EN 375 * dpi_scale_
-#endif
-#else
-#if _WIN32
-#define SETTINGS_WINDOW_HEIGHT_CN 375 * dpi_scale_
-#define SETTINGS_WINDOW_HEIGHT_EN 375 * dpi_scale_
-#else
-#define SETTINGS_WINDOW_HEIGHT_CN 345 * dpi_scale_
-#define SETTINGS_WINDOW_HEIGHT_EN 345 * dpi_scale_
-#endif
-#endif
-#define SELF_HOSTED_SERVER_CONFIG_WINDOW_WIDTH_CN 228 * dpi_scale_
-#define SELF_HOSTED_SERVER_CONFIG_WINDOW_WIDTH_EN 275 * dpi_scale_
-#define SELF_HOSTED_SERVER_CONFIG_WINDOW_HEIGHT_CN 195 * dpi_scale_
-#define SELF_HOSTED_SERVER_CONFIG_WINDOW_HEIGHT_EN 195 * dpi_scale_
-#define LANGUAGE_SELECT_WINDOW_PADDING_CN 120 * dpi_scale_
-#define LANGUAGE_SELECT_WINDOW_PADDING_EN 167 * dpi_scale_
-#define VIDEO_QUALITY_SELECT_WINDOW_PADDING_CN 120 * dpi_scale_
-#define VIDEO_QUALITY_SELECT_WINDOW_PADDING_EN 167 * dpi_scale_
-#define VIDEO_FRAME_RATE_SELECT_WINDOW_PADDING_CN 120 * dpi_scale_
-#define VIDEO_FRAME_RATE_SELECT_WINDOW_PADDING_EN 167 * dpi_scale_
-#define VIDEO_ENCODE_FORMAT_SELECT_WINDOW_PADDING_CN 120 * dpi_scale_
-#define VIDEO_ENCODE_FORMAT_SELECT_WINDOW_PADDING_EN 167 * dpi_scale_
-#define ENABLE_HARDWARE_VIDEO_CODEC_CHECKBOX_PADDING_CN 171 * dpi_scale_
-#define ENABLE_HARDWARE_VIDEO_CODEC_CHECKBOX_PADDING_EN 218 * dpi_scale_
-#define ENABLE_TURN_CHECKBOX_PADDING_CN 171 * dpi_scale_
-#define ENABLE_TURN_CHECKBOX_PADDING_EN 218 * dpi_scale_
-#define ENABLE_SELF_HOSTED_SERVER_CHECKBOX_PADDING_CN 171 * dpi_scale_
-#define ENABLE_SELF_HOSTED_SERVER_CHECKBOX_PADDING_EN 218 * dpi_scale_
-#define ENABLE_AUTOSTART_PADDING_CN 171 * dpi_scale_
-#define ENABLE_AUTOSTART_PADDING_EN 218 * dpi_scale_
-#define ENABLE_DAEMON_PADDING_CN 171 * dpi_scale_
-#define ENABLE_DAEMON_PADDING_EN 218 * dpi_scale_
-#define ENABLE_MINIZE_TO_TRAY_PADDING_CN 171 * dpi_scale_
-#define ENABLE_MINIZE_TO_TRAY_PADDING_EN 218 * dpi_scale_
-#define SELF_HOSTED_SERVER_HOST_INPUT_BOX_PADDING_CN 90 * dpi_scale_
-#define SELF_HOSTED_SERVER_HOST_INPUT_BOX_PADDING_EN 137 * dpi_scale_
-#define SELF_HOSTED_SERVER_PORT_INPUT_BOX_PADDING_CN 90 * dpi_scale_
-#define SELF_HOSTED_SERVER_PORT_INPUT_BOX_PADDING_EN 137 * dpi_scale_
-#define SETTINGS_SELECT_WINDOW_WIDTH 73 * dpi_scale_
-#define SELF_HOSTED_SERVER_INPUT_WINDOW_WIDTH 130 * dpi_scale_
-#define SETTINGS_OK_BUTTON_PADDING_CN 65 * dpi_scale_
-#define SETTINGS_OK_BUTTON_PADDING_EN 83 * dpi_scale_
-#define SELF_HOSTED_SERVER_CONFIG_OK_BUTTON_PADDING_CN 78 * dpi_scale_
-#define SELF_HOSTED_SERVER_CONFIG_OK_BUTTON_PADDING_EN 91 * dpi_scale_
-#define UPDATE_NOTIFICATION_OK_BUTTON_PADDING_CN 162 * dpi_scale_
-#define UPDATE_NOTIFICATION_OK_BUTTON_PADDING_EN 146 * dpi_scale_
-#define UPDATE_NOTIFICATION_RESERVED_HEIGHT 120 * dpi_scale_
-#define REQUEST_PERMISSION_WINDOW_WIDTH_CN 130 * dpi_scale_
-#define REQUEST_PERMISSION_WINDOW_HEIGHT_CN 125 * dpi_scale_
-#define REQUEST_PERMISSION_WINDOW_WIDTH_EN 260 * dpi_scale_
-#define REQUEST_PERMISSION_WINDOW_HEIGHT_EN 125 * dpi_scale_
-#define REQUEST_PERMISSION_WINDOW_CHECKBOX_PADDING_CN 90 * dpi_scale_
-#define REQUEST_PERMISSION_WINDOW_CHECKBOX_PADDING_EN 210 * dpi_scale_
-#endif

apps/desktop/src/gui/assets/layouts/layout_relative.h

@@ -1,87 +0,0 @@
-/*
- * @Author: DI JUNKUN
- * @Date: 2024-06-14
- * Copyright (c) 2024 by DI JUNKUN, All Rights Reserved.
- */
-
-#ifndef _LAYOUT_STYLE_H_
-#define _LAYOUT_STYLE_H_
-
-#define TITLE_BAR_HEIGHT 0.0625f
-#define TITLE_BAR_BUTTON_WIDTH 0.0625f
-#define TITLE_BAR_BUTTON_HEIGHT 0.0625f
-#define STATUS_BAR_HEIGHT 0.05f
-#define MENU_WINDOW_WIDTH_CN 300
-#define MENU_WINDOW_HEIGHT_CN 280
-#define LOCAL_WINDOW_WIDTH_CN 300
-#define LOCAL_WINDOW_HEIGHT_CN 280
-#define REMOTE_WINDOW_WIDTH_CN 300
-#define REMOTE_WINDOW_HEIGHT_CN 280
-#define MENU_WINDOW_WIDTH_EN 190
-#define MENU_WINDOW_HEIGHT_EN 245
-#define IPUT_WINDOW_WIDTH 160
-#define INPUT_WINDOW_PADDING_CN 66
-#define INPUT_WINDOW_PADDING_EN 96
-#define SETTINGS_WINDOW_WIDTH_CN 202
-#define SETTINGS_WINDOW_WIDTH_EN 248
-#if USE_CUDA
-#if _WIN32
-#define SETTINGS_WINDOW_HEIGHT_CN 405
-#define SETTINGS_WINDOW_HEIGHT_EN 405
-#else
-#define SETTINGS_WINDOW_HEIGHT_CN 375
-#define SETTINGS_WINDOW_HEIGHT_EN 375
-#endif
-#else
-#if _WIN32
-#define SETTINGS_WINDOW_HEIGHT_CN 375
-#define SETTINGS_WINDOW_HEIGHT_EN 375
-#else
-#define SETTINGS_WINDOW_HEIGHT_CN 345
-#define SETTINGS_WINDOW_HEIGHT_EN 345
-#endif
-#endif
-#define SELF_HOSTED_SERVER_CONFIG_WINDOW_WIDTH_CN 228
-#define SELF_HOSTED_SERVER_CONFIG_WINDOW_WIDTH_EN 275
-#define SELF_HOSTED_SERVER_CONFIG_WINDOW_HEIGHT_CN 195
-#define SELF_HOSTED_SERVER_CONFIG_WINDOW_HEIGHT_EN 195
-#define LANGUAGE_SELECT_WINDOW_PADDING_CN 120
-#define LANGUAGE_SELECT_WINDOW_PADDING_EN 167
-#define VIDEO_QUALITY_SELECT_WINDOW_PADDING_CN 120
-#define VIDEO_QUALITY_SELECT_WINDOW_PADDING_EN 167
-#define VIDEO_FRAME_RATE_SELECT_WINDOW_PADDING_CN 120
-#define VIDEO_FRAME_RATE_SELECT_WINDOW_PADDING_EN 167
-#define VIDEO_ENCODE_FORMAT_SELECT_WINDOW_PADDING_CN 120
-#define VIDEO_ENCODE_FORMAT_SELECT_WINDOW_PADDING_EN 167
-#define ENABLE_HARDWARE_VIDEO_CODEC_CHECKBOX_PADDING_CN 171
-#define ENABLE_HARDWARE_VIDEO_CODEC_CHECKBOX_PADDING_EN 218
-#define ENABLE_TURN_CHECKBOX_PADDING_CN 171
-#define ENABLE_TURN_CHECKBOX_PADDING_EN 218
-#define ENABLE_SELF_HOSTED_SERVER_CHECKBOX_PADDING_CN 171
-#define ENABLE_SELF_HOSTED_SERVER_CHECKBOX_PADDING_EN 218
-#define ENABLE_AUTOSTART_PADDING_CN 171
-#define ENABLE_AUTOSTART_PADDING_EN 218
-#define ENABLE_DAEMON_PADDING_CN 171
-#define ENABLE_DAEMON_PADDING_EN 218
-#define ENABLE_MINIZE_TO_TRAY_PADDING_CN 171
-#define ENABLE_MINIZE_TO_TRAY_PADDING_EN 218
-#define SELF_HOSTED_SERVER_HOST_INPUT_BOX_PADDING_CN 90
-#define SELF_HOSTED_SERVER_HOST_INPUT_BOX_PADDING_EN 137
-#define SELF_HOSTED_SERVER_PORT_INPUT_BOX_PADDING_CN 90
-#define SELF_HOSTED_SERVER_PORT_INPUT_BOX_PADDING_EN 137
-#define SETTINGS_SELECT_WINDOW_WIDTH 73
-#define SELF_HOSTED_SERVER_INPUT_WINDOW_WIDTH 130
-#define SETTINGS_OK_BUTTON_PADDING_CN 65
-#define SETTINGS_OK_BUTTON_PADDING_EN 83
-#define SELF_HOSTED_SERVER_CONFIG_OK_BUTTON_PADDING_CN 78
-#define SELF_HOSTED_SERVER_CONFIG_OK_BUTTON_PADDING_EN 91
-#define UPDATE_NOTIFICATION_OK_BUTTON_PADDING_CN 162
-#define UPDATE_NOTIFICATION_OK_BUTTON_PADDING_EN 146
-#define UPDATE_NOTIFICATION_RESERVED_HEIGHT 120
-#define REQUEST_PERMISSION_WINDOW_WIDTH_CN 130
-#define REQUEST_PERMISSION_WINDOW_HEIGHT_CN 125
-#define REQUEST_PERMISSION_WINDOW_WIDTH_EN 260
-#define REQUEST_PERMISSION_WINDOW_HEIGHT_EN 125
-#define REQUEST_PERMISSION_WINDOW_CHECKBOX_PADDING_CN 90
-#define REQUEST_PERMISSION_WINDOW_CHECKBOX_PADDING_EN 210
-#endif

apps/desktop/src/gui/assets/localization/localization_data.h

@@ -31,6 +31,8 @@ struct TranslationRow {
   X(local_id_copied_to_clipboard, u8"已复制到剪贴板", "Copied to clipboard",   \
     u8"Скопировано в буфер обмена")                                            \
   X(password, u8"密码", "Password", u8"Пароль")                                \
+  X(refresh_password, u8"刷新随机密码", "Refresh random password",            \
+    u8"Обновить случайный пароль")                                           \
   X(max_password_len, u8"最大6个字符", "Max 6 chars", u8"Макс. 6 символов")    \
   X(remote_desktop, u8"远程桌面", "Remote Desktop",                            \
     u8"Удаленный рабочий стол")                                                \
@@ -149,6 +151,7 @@ struct TranslationRow {
     "Enable Hardware Video Codec:", u8"Использовать аппаратный кодек:")        \
   X(enable_turn, u8"启用中继服务:",                                            \
     "Enable TURN Service:", u8"Включить TURN-сервис:")                         \
+  X(force_relay, u8"强制中继连接:", "Force Relay:", u8"Только через реле:")   \
   X(self_hosted_server_config, u8"自托管配置", "Self-Hosted Config",           \
     u8"Конфигурация self-hosted")                                              \
   X(self_hosted_server_settings, u8"自托管设置", "Self-Hosted Settings",       \

apps/desktop/src/gui/features/devices/session_device_manager.cpp

@@ -6,6 +6,7 @@
 #include <algorithm>
 #include <chrono>
 #include <cstdlib>
+#include <utility>
 
 #include "platform.h"
 #include "rd_log.h"
@@ -146,7 +147,7 @@ int SessionDeviceManager::InitializeScreenCapturer() {
                       ? 30
                       : 60;
   LOG_INFO("Init screen capturer with {} fps", fps);
-  display_info_list_.clear();
+  SetDisplayInfoList({});
   registered_display_stream_count_ = 0;
   last_video_frame_stream_id_.clear();
   invalid_video_stream_id_logged_ = false;
@@ -256,11 +257,11 @@ int SessionDeviceManager::InitializeScreenCapturer() {
 
   if (init_ret == 0) {
     LOG_INFO("Init screen capturer success");
-    const auto latest_display_info = screen_capturer_->GetDisplayInfoList();
+    auto latest_display_info = screen_capturer_->GetDisplayInfoList();
+    registered_display_stream_count_ = latest_display_info.size();
     if (!latest_display_info.empty()) {
-      display_info_list_ = latest_display_info;
+      SetDisplayInfoList(std::move(latest_display_info));
     }
-    registered_display_stream_count_ = display_info_list_.size();
     return 0;
   }
 
@@ -329,6 +330,33 @@ void SessionDeviceManager::StopSpeakerCapturer() {
   speaker_capture_.SetEnabled(false);
 }
 
+bool SessionDeviceManager::SyncDisplayInfo() {
+  if (!screen_capturer_) return false;
+  auto displays = screen_capturer_->GetDisplayInfoList();
+  if (displays.empty()) return false;
+  // Called every UI tick; replace the shared list only when geometry actually
+  // changed so readers on other threads rarely contend for the lock.
+  bool changed = false;
+  {
+    std::lock_guard<std::mutex> lock(display_info_mutex_);
+    changed = !std::equal(
+        displays.begin(), displays.end(), display_info_list_.begin(),
+        display_info_list_.end(), [](const auto &a, const auto &b) {
+          return a.handle == b.handle && a.name == b.name &&
+                 a.is_primary == b.is_primary && a.left == b.left &&
+                 a.top == b.top && a.width == b.width && a.height == b.height;
+        });
+    if (changed) display_info_list_ = displays;
+  }
+  if (changed && mouse_controller_) mouse_controller_->UpdateDisplayInfoList(displays);
+  return true;
+}
+
+void SessionDeviceManager::SetDisplayInfoList(std::vector<DisplayInfo> displays) {
+  std::lock_guard<std::mutex> lock(display_info_mutex_);
+  display_info_list_ = std::move(displays);
+}
+
 int SessionDeviceManager::StartMouseController() {
 #ifdef __APPLE__
   if (!owner_.EnsureMacAccessibilityPermission()) {
@@ -353,14 +381,9 @@ int SessionDeviceManager::StartMouseController() {
     }
   }
 
-  if (screen_capturer_) {
-    const auto latest_display_info = screen_capturer_->GetDisplayInfoList();
-    if (!latest_display_info.empty()) {
-      display_info_list_ = latest_display_info;
-    }
-  }
 #endif
 
+  SyncDisplayInfo();
   mouse_controller_ =
       static_cast<MouseController *>(device_controller_factory_->Create(
           DeviceControllerFactory::Device::Mouse));
@@ -369,7 +392,7 @@ int SessionDeviceManager::StartMouseController() {
     return -1;
   }
 
-  const int init_ret = mouse_controller_->Init(display_info_list_);
+  const int init_ret = mouse_controller_->Init(display_info_list());
   if (init_ret != 0) {
     LOG_INFO("Destroy mouse controller");
     mouse_controller_->Destroy();
@@ -558,16 +581,19 @@ void SessionDeviceManager::UpdateInteractions() {
     owner_.mouse_controller_is_started_ = false;
   }
 
-#if defined(__linux__) || defined(__APPLE__)
-  if (owner_.screen_capturer_is_started_ && screen_capturer_ &&
-      mouse_controller_) {
-    const auto latest_display_info = screen_capturer_->GetDisplayInfoList();
-    if (!latest_display_info.empty()) {
-      display_info_list_ = latest_display_info;
-      mouse_controller_->UpdateDisplayInfoList(display_info_list_);
+  if (owner_.screen_capturer_is_started_ && mouse_controller_ && SyncDisplayInfo()) {
+#ifdef _WIN32
+    const int active_display = screen_capturer_->GetCurrentMonitorIndex();
+    const auto displays = display_info_list();
+    if (active_display >= 0 &&
+        active_display < static_cast<int>(displays.size())) {
+      owner_.selected_display_ = active_display;
+      if (displays[active_display].width <= 0 ||
+          displays[active_display].height <= 0)
+        ReleaseRemoteMouseButtons();
     }
-  }
 #endif
+  }
 
   if (owner_.start_keyboard_capturer_ && owner_.focus_on_stream_window_) {
     if (!owner_.keyboard_capturer_is_started_ && StartKeyboardCapturer() == 0) {
@@ -640,20 +666,43 @@ void SessionDeviceManager::SendMouseCommand(const RemoteAction &action,
 }
 
 int SessionDeviceManager::SwitchDisplay(int display_id) {
-  return screen_capturer_ ? screen_capturer_->SwitchTo(display_id) : -1;
+  if (!screen_capturer_) return -1;
+  const int ret = screen_capturer_->SwitchTo(display_id);
+  if (ret == 0) SyncDisplayInfo();
+  return ret;
 }
 
 void SessionDeviceManager::ResetToInitialDisplay() {
-  if (screen_capturer_) {
-    screen_capturer_->ResetToInitialMonitor();
+  if (!screen_capturer_) {
+    return;
   }
+  const int ret = screen_capturer_->ResetToInitialMonitor();
+  if (ret != 0) {
+    LOG_WARN("Reset to initial display failed, ret={}", ret);
+    return;
+  }
+  // Capture backends start at display 0. Reset the input mapping as well so
+  // the next connection cannot show that display while controlling another.
+  owner_.selected_display_ = 0;
+  SyncDisplayInfo();
 }
 
-const std::vector<DisplayInfo> &
-SessionDeviceManager::display_info_list() const {
+std::vector<DisplayInfo> SessionDeviceManager::display_info_list() const {
+  std::lock_guard<std::mutex> lock(display_info_mutex_);
   return display_info_list_;
 }
 
+std::vector<HostDisplay> SessionDeviceManager::host_display_list() const {
+  std::lock_guard<std::mutex> lock(display_info_mutex_);
+  std::vector<HostDisplay> displays;
+  displays.reserve(display_info_list_.size());
+  for (const auto &display : display_info_list_) {
+    displays.push_back({display.name, display.left, display.top, display.right,
+                        display.bottom});
+  }
+  return displays;
+}
+
 void SessionDeviceManager::DestroyDevices() {
   speaker_capture_.Shutdown();
   if (mouse_controller_) {

apps/desktop/src/gui/features/devices/session_device_manager.h

@@ -74,7 +74,12 @@ public:
   int SwitchDisplay(int display_id);
   void ResetToInitialDisplay();
 
-  const std::vector<DisplayInfo> &display_info_list() const;
+  // Snapshot of the capture displays. The UI thread refreshes the list every
+  // tick while transport threads build host information and map mouse input
+  // from it, so callers get a copy taken under the lock.
+  std::vector<DisplayInfo> display_info_list() const;
+  // The same snapshot in the wire's host information form.
+  std::vector<HostDisplay> host_display_list() const;
 
 private:
   struct CapturedKeyboardInput {
@@ -91,6 +96,8 @@ private:
   bool ShouldSendCapturedFrame(std::chrono::steady_clock::time_point now,
                                int fps);
   bool ShouldCaptureCursor() const;
+  bool SyncDisplayInfo();
+  void SetDisplayInfoList(std::vector<DisplayInfo> displays);
   void RecordCaptureCadence(std::chrono::steady_clock::time_point now, int fps,
                             bool from_secure_desktop);
 
@@ -103,6 +110,8 @@ private:
   DeviceControllerFactory *device_controller_factory_ = nullptr;
   MouseController *mouse_controller_ = nullptr;
   KeyboardCapturer *keyboard_capturer_ = nullptr;
+  // Guards display_info_list_ (UI thread writes, transport threads read).
+  mutable std::mutex display_info_mutex_;
   std::vector<DisplayInfo> display_info_list_;
   size_t registered_display_stream_count_ = 0;
   std::deque<CapturedKeyboardInput> captured_keyboard_inputs_;

apps/desktop/src/gui/features/input/keyboard_controller.cpp

@@ -52,6 +52,9 @@ void PopulateWindowsKeyMetadataFromVk(int key_code, uint32_t* scan_code_out,
   if (!scan_code_out || !extended_out) {
     return;
   }
+  if (LookupWindowsKeyMetadataFromVk(key_code, scan_code_out, extended_out)) {
+    return;
+  }
 #if _WIN32
   const UINT scan_code =
       MapVirtualKeyW(static_cast<UINT>(key_code), MAPVK_VK_TO_VSC_EX);
@@ -61,7 +64,6 @@ void PopulateWindowsKeyMetadataFromVk(int key_code, uint32_t* scan_code_out,
     return;
   }
 #endif
-  LookupWindowsKeyMetadataFromVk(key_code, scan_code_out, extended_out);
 }
 
 #if _WIN32

apps/desktop/src/gui/features/settings/settings_manager.cpp

@@ -596,22 +596,6 @@ std::string SettingsManager::RecentConnectionDisplayName(
   return connection.remote_id;
 }
 
-void SettingsManager::BeginEditRecentConnectionAlias(
-    const Thumbnail::RecentConnection &connection) {
-  owner_.edit_connection_alias_remote_id_ = connection.remote_id;
-  std::memset(owner_.edit_connection_alias_, 0,
-              sizeof(owner_.edit_connection_alias_));
-
-  const auto alias_it = recent_connection_aliases_.find(connection.remote_id);
-  const std::string alias = alias_it != recent_connection_aliases_.end()
-                                ? alias_it->second
-                                : RecentConnectionDisplayName(connection);
-  CopyString(owner_.edit_connection_alias_, alias.c_str());
-
-  owner_.focus_on_input_widget_ = true;
-  owner_.show_edit_connection_alias_window_ = true;
-}
-
 void SettingsManager::SetRecentConnectionAlias(const std::string &remote_id,
                                                const std::string &alias) {
   if (!remote_id.empty()) {

apps/desktop/src/gui/features/settings/settings_manager.h

@@ -25,8 +25,6 @@ public:
   int SaveRecentConnectionAliases() const;
   std::string RecentConnectionDisplayName(
       const Thumbnail::RecentConnection &connection) const;
-  void
-  BeginEditRecentConnectionAlias(const Thumbnail::RecentConnection &connection);
   void SetRecentConnectionAlias(const std::string &remote_id,
                                 const std::string &alias);
   void EraseRecentConnectionAlias(const std::string &remote_id);

apps/desktop/src/gui/render.h

@@ -13,7 +13,7 @@ namespace crossdesk {
 
 class GuiApplication;
 
-// Stable application-facing facade. The SDL application and feature
+// Stable application-facing facade. The Slint application and feature
 // controllers remain private implementation details.
 class Render {
 public:
@@ -31,4 +31,4 @@ private:
 
 } // namespace crossdesk
 
-#endif
+#endif

apps/desktop/src/gui/rendering/slint_video_presenter.cpp

@@ -154,10 +154,8 @@ struct SlintVideoPresenter::Impl {
             const auto window_size = (*stream)->window().size();
             const float scale_factor =
                 std::max(1.0f, (*stream)->window().scale_factor());
-            const int top_inset =
-                !surface.fullscreen && surface.tab_count > 1
-                    ? static_cast<int>(std::lround(30.0f * scale_factor))
-                    : 0;
+            const int top_inset = static_cast<int>(std::lround(
+                (*stream)->get_video_area_top() * scale_factor));
             const bool rounded_window = (*stream)->get_custom_titlebar() &&
                                         !surface.fullscreen &&
                                         !(*stream)->window().is_maximized();
@@ -335,8 +333,7 @@ SlintVideoPresenter::PresentResult SlintVideoPresenter::Present(
       dynamic_cast<MacMetalVideoRenderer*>(&impl_->renderer);
   if (metal_renderer && metal_renderer->IsActive()) {
     const SurfaceState surface = impl_->CurrentState();
-    const double top_inset =
-        !surface.fullscreen && surface.tab_count > 1 ? 30.0 : 0.0;
+    const double top_inset = (*impl_->stream)->get_video_area_top();
     const auto outcome = metal_renderer->RenderLatest(
         frame.remote_id, top_inset, !surface.fullscreen);
     if (outcome.result == VideoRenderer::RenderResult::rendered) {

apps/desktop/src/gui/rendering/slint_video_presenter.h

@@ -28,7 +28,6 @@ public:
   struct SurfaceState {
     std::string selected_stream;
     bool fullscreen = false;
-    size_t tab_count = 0;
   };
 
   struct Frame {
@@ -78,4 +77,4 @@ private:
 
 }  // namespace crossdesk
 
-#endif
+#endif

apps/desktop/src/gui/rendering/video_geometry.h

@@ -0,0 +1,51 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-22
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _VIDEO_GEOMETRY_H_
+#define _VIDEO_GEOMETRY_H_
+
+#include <algorithm>
+#include <cmath>
+#include <optional>
+
+namespace crossdesk {
+
+struct VideoPoint {
+  float x;
+  float y;
+};
+
+// Area dimensions and pointer positions must use the same coordinate space.
+// Slint supplies both in logical pixels; remote input is resolution
+// independent.
+inline std::optional<VideoPoint> MapVideoPoint(float x, float y,
+                                               float area_width,
+                                               float area_height,
+                                               int video_width,
+                                               int video_height) {
+  if (!std::isfinite(x) || !std::isfinite(y) || !std::isfinite(area_width) ||
+      !std::isfinite(area_height) || area_width <= 0 || area_height <= 0 ||
+      video_width <= 0 || video_height <= 0) {
+    return std::nullopt;
+  }
+
+  const double scale =
+      std::min(static_cast<double>(area_width) / video_width,
+               static_cast<double>(area_height) / video_height);
+  const double width = video_width * scale;
+  const double height = video_height * scale;
+  const double left = (area_width - width) * 0.5;
+  const double top = (area_height - height) * 0.5;
+  if (x < left || x > left + width || y < top || y > top + height) {
+    return std::nullopt;
+  }
+  return VideoPoint{static_cast<float>((x - left) / width),
+                    static_cast<float>((y - top) / height)};
+}
+
+}  // namespace crossdesk
+
+#endif

apps/desktop/src/gui/runtime/connection_runtime.cpp

@@ -477,7 +477,42 @@ int GuiRuntime::ConnectTo(const std::string& remote_id, const char* password,
   LOG_INFO("Connect to [{}]", remote_id);
   focused_remote_id_ = remote_id;
 
-  bool exists = FindRemoteSession(remote_id) != nullptr;
+  auto stale = FindRemoteSession(remote_id);
+  bool exists = stale != nullptr;
+  if (stale) {
+    // A failed CreatePeer or a completed close can leave a session record
+    // without a reusable peer. Recreate it instead of leaving the UI in
+    // Connecting forever while JoinConnection has nothing to call.
+    if (stale->peer_ == nullptr) {
+      std::unique_lock lock(remote_sessions_mutex_);
+      auto it = remote_sessions_.find(remote_id);
+      if (it != remote_sessions_.end() && it->second == stale) {
+        remote_sessions_.erase(it);
+        exists = false;
+        LOG_INFO("[{}] Recreating stale remote session before connect",
+                 remote_id);
+      }
+    }
+    if (exists && !stale->closing_.load() &&
+        !stale->connection_established_) {
+      const auto status = stale->connection_status_.load();
+      if (status == ConnectionStatus::Disconnected ||
+          status == ConnectionStatus::Failed ||
+          status == ConnectionStatus::Closed) {
+        // The recreated session starts with an empty password; callers that
+        // pass none expect the one stored by the previous attempt to be reused.
+        const bool keep_stored_password = !password || !*password;
+        pending_reconnects_[remote_id] = {
+            keep_stored_password ? std::string(stale->remote_password_)
+                                 : std::string(password),
+            remember_password};
+        CloseRemoteSession(stale);
+        LOG_INFO("[{}] Reconnecting after terminal peer status {}", remote_id,
+                 static_cast<int>(status));
+        return 0;
+      }
+    }
+  }
 
   if (!exists) {
     PeerPtr* peer_to_init = nullptr;
@@ -496,13 +531,6 @@ int GuiRuntime::ConnectTo(const std::string& remote_id, const char* password,
         props->params_.user_data = props->peer_events_.get();
         props->peer_ = CreatePeer(&props->params_);
 
-        props->control_window_width_ = title_bar_height_ * 10.0f;
-        props->control_window_height_ = title_bar_height_ * 1.3f;
-        props->control_window_min_width_ = title_bar_height_ * 0.65f;
-        props->control_window_min_height_ = title_bar_height_ * 1.3f;
-        props->control_window_max_width_ = title_bar_height_ * 10.0f;
-        props->control_window_max_height_ = title_bar_height_ * 7.0f;
-
         props->connection_status_.store(ConnectionStatus::Connecting);
         show_connection_status_window_ = true;
 

apps/desktop/src/gui/runtime/gui_runtime.cpp

@@ -211,19 +211,6 @@ int GuiRuntime::CreateConnectionPeer() {
   }
 }
 
-void GuiRuntime::UpdateLabels() {
-  if (!label_inited_ ||
-      localization_language_index_last_ != localization_language_index_) {
-    connect_button_label_ =
-        connect_button_pressed_
-            ? localization::disconnect[localization_language_index_]
-            : localization::connect[localization_language_index_];
-    label_inited_ = true;
-    localization_language_index_last_ = localization_language_index_;
-  }
-}
-
-
 void GuiRuntime::HandleRecentConnections() {
   if (session_cleanup_tasks_.empty() && reload_recent_connections_ && thumbnail_) {
     uint32_t now_time = SDL_GetTicks();

apps/desktop/src/gui/runtime/gui_runtime.h

@@ -27,7 +27,7 @@ namespace crossdesk {
 class VideoRenderer;
 
 // Shared GUI runtime. It owns subsystem controllers and cross-cutting session
-// state, but no window lifecycle, ImGui view, or transport callback methods.
+// state, but no window lifecycle, UI view, or transport callback methods.
 class GuiRuntime : protected gui_detail::GuiState {
  protected:
   using FileTransferState = gui_detail::FileTransferState;
@@ -53,7 +53,6 @@ class GuiRuntime : protected gui_detail::GuiState {
   int RequestSingleDevicePresence(const std::string& remote_id,
                                   const char* password, bool remember_password);
 
-  void UpdateLabels();
   void HandleRecentConnections();
   void HandleConnectionStatusChange();
   void HandlePendingPresenceProbe();
@@ -65,6 +64,9 @@ class GuiRuntime : protected gui_detail::GuiState {
   void HandlePrivacy();
   bool IsAuthorizedController(const std::string& remote_id);
   void SetControllerPrivacySupport(const std::string& remote_id, bool supported);
+  // Caller holds connection_status_mutex_ exclusively. Turns privacy off when
+  // any connected controller lacks support, or on for the first automatic one.
+  void ApplyPrivacyAdmission(bool automatic_enable);
   void QueuePrivacyCommand(const std::string& remote_id, const PrivacyCommand& command);
 
   void CloseRemoteSession(std::shared_ptr<RemoteSession> props);

apps/desktop/src/gui/runtime/peer_data_callbacks.cpp

@@ -20,7 +20,6 @@
 #include "platform.h"
 #include "rd_log.h"
 #include "runtime/gui_runtime.h"
-#include "runtime/remote_action_codec.h"
 
 #if _WIN32
 #include "interactive_state.h"
@@ -288,7 +287,7 @@ void PeerEventHandler::OnReceiveDataBuffer(
                           remote_action.i.right[i], remote_action.i.bottom[i]));
         }
       }
-      remote_action_codec::Free(remote_action);
+      FreeRemoteAction(remote_action);
     } else {
       // server mode
       std::string host_name(remote_action.i.host_name,
@@ -302,7 +301,7 @@ void PeerEventHandler::OnReceiveDataBuffer(
         runtime->SetControllerPrivacySupport(
             remote_id, remote_action.i.supports_privacy_screen);
       }
-      remote_action_codec::Free(remote_action);
+      FreeRemoteAction(remote_action);
     }
   } else {
     // remote

apps/desktop/src/gui/runtime/peer_event_handler.cpp

@@ -21,7 +21,6 @@
 #include "platform/video_renderer.h"
 #include "rd_log.h"
 #include "runtime/gui_runtime.h"
-#include "runtime/remote_action_codec.h"
 
 #if _WIN32
 #include "interactive_state.h"
@@ -265,52 +264,22 @@ void PeerEventHandler::OnConnectionStatus(ConnectionStatus status,
           props->cursor_presentation_ = {};
         }
         {
-          RemoteAction remote_action{};
-          remote_action.i.supports_privacy_screen = true;
-          remote_action.i.display_num =
-              runtime->devices_.display_info_list().size();
-          remote_action.i.display_list =
-              (char**)malloc(remote_action.i.display_num * sizeof(char*));
-          remote_action.i.left =
-              (int*)malloc(remote_action.i.display_num * sizeof(int));
-          remote_action.i.top =
-              (int*)malloc(remote_action.i.display_num * sizeof(int));
-          remote_action.i.right =
-              (int*)malloc(remote_action.i.display_num * sizeof(int));
-          remote_action.i.bottom =
-              (int*)malloc(remote_action.i.display_num * sizeof(int));
-          for (int i = 0; i < remote_action.i.display_num; i++) {
+          RemoteAction remote_action = MakeHostInformation(
+              GetHostName(), runtime->devices_.host_display_list(),
+              /*supports_privacy_screen=*/true);
+          for (std::size_t i = 0; i < remote_action.i.display_num; i++) {
             LOG_INFO("Local display [{}:{}]", i + 1,
-                     runtime->devices_.display_info_list()[i].name);
-            remote_action.i.display_list[i] = (char*)malloc(
-                runtime->devices_.display_info_list()[i].name.length() + 1);
-            strncpy(remote_action.i.display_list[i],
-                    runtime->devices_.display_info_list()[i].name.c_str(),
-                    runtime->devices_.display_info_list()[i].name.length());
-            remote_action.i
-                .display_list[i][runtime->devices_.display_info_list()[i]
-                                     .name.length()] = '\0';
-            remote_action.i.left[i] =
-                runtime->devices_.display_info_list()[i].left;
-            remote_action.i.top[i] =
-                runtime->devices_.display_info_list()[i].top;
-            remote_action.i.right[i] =
-                runtime->devices_.display_info_list()[i].right;
-            remote_action.i.bottom[i] =
-                runtime->devices_.display_info_list()[i].bottom;
+                     remote_action.i.display_list[i]);
           }
-
-          std::string host_name = GetHostName();
-          remote_action.type = ControlType::host_infomation;
-          memcpy(&remote_action.i.host_name, host_name.data(),
-                 host_name.size());
-          remote_action.i.host_name[host_name.size()] = '\0';
-          remote_action.i.host_name_size = host_name.size();
-
           std::string msg = remote_action.to_json();
-          int ret = SendReliableDataFrame(props->peer_, msg.data(), msg.size(),
-                                          runtime->control_data_label_.c_str());
-          remote_action_codec::Free(remote_action);
+          const int ret =
+              SendReliableDataFrame(props->peer_, msg.data(), msg.size(),
+                                    runtime->control_data_label_.c_str());
+          if (ret != 0) {
+            LOG_WARN("[{}] host information send failed, ret={}", remote_id,
+                     ret);
+          }
+          FreeRemoteAction(remote_action);
         }
 
         if (!runtime->need_to_create_stream_window_) {
@@ -383,21 +352,6 @@ void PeerEventHandler::OnConnectionStatus(ConnectionStatus status,
       case ConnectionStatus::IncorrectPassword: {
         runtime->password_validating_ = false;
         runtime->password_validating_time_++;
-        if (runtime->connect_button_pressed_) {
-          runtime->connect_button_pressed_ = false;
-          props->connection_established_ = false;
-          runtime->connect_button_label_ =
-              localization::connect[runtime->localization_language_index_];
-        }
-        break;
-      }
-      case ConnectionStatus::NoSuchTransmissionId:
-      case ConnectionStatus::RemoteUnavailable: {
-        if (runtime->connect_button_pressed_) {
-          props->connection_established_ = false;
-          runtime->connect_button_label_ =
-              localization::connect[runtime->localization_language_index_];
-        }
         break;
       }
       default:
@@ -409,14 +363,11 @@ void PeerEventHandler::OnConnectionStatus(ConnectionStatus status,
     {
       std::unique_lock lock(runtime->connection_status_mutex_);
       if (status == ConnectionStatus::Connected) {
-        // Wait for explicit desktop capability before enabling privacy or
-        // sending privacy messages. Legacy and web controllers never opt in.
-        runtime->privacy_sessions_.Connected(
+        // Local privacy requires explicit desktop capability. Host info may
+        // arrive before Connected; consume that saved capability here.
+        const bool automatic_enable = runtime->privacy_sessions_.Connected(
             remote_id, runtime->config_center_->IsEnablePrivacyScreen());
-        if (!runtime->privacy_sessions_.CanEnable() &&
-            runtime->privacy_.Engaged()) {
-          runtime->privacy_.Disable();
-        }
+        runtime->ApplyPrivacyAdmission(automatic_enable);
       }
       runtime->connection_status_[remote_id] = status;
       runtime->devices_.OnControllerConnectionsChanged();
@@ -428,53 +379,22 @@ void PeerEventHandler::OnConnectionStatus(ConnectionStatus status,
         runtime->last_windows_service_status_tick_ = 0;
 #endif
         {
-          RemoteAction remote_action{};
-          remote_action.i.supports_privacy_screen = true;
-          remote_action.i.display_num =
-              runtime->devices_.display_info_list().size();
-          remote_action.i.display_list =
-              (char**)malloc(remote_action.i.display_num * sizeof(char*));
-          remote_action.i.left =
-              (int*)malloc(remote_action.i.display_num * sizeof(int));
-          remote_action.i.top =
-              (int*)malloc(remote_action.i.display_num * sizeof(int));
-          remote_action.i.right =
-              (int*)malloc(remote_action.i.display_num * sizeof(int));
-          remote_action.i.bottom =
-              (int*)malloc(remote_action.i.display_num * sizeof(int));
-          for (int i = 0; i < remote_action.i.display_num; i++) {
+          RemoteAction remote_action = MakeHostInformation(
+              GetHostName(), runtime->devices_.host_display_list(),
+              /*supports_privacy_screen=*/true);
+          for (std::size_t i = 0; i < remote_action.i.display_num; i++) {
             LOG_INFO("Local display [{}:{}]", i + 1,
-                     runtime->devices_.display_info_list()[i].name);
-            remote_action.i.display_list[i] = (char*)malloc(
-                runtime->devices_.display_info_list()[i].name.length() + 1);
-            strncpy(remote_action.i.display_list[i],
-                    runtime->devices_.display_info_list()[i].name.c_str(),
-                    runtime->devices_.display_info_list()[i].name.length());
-            remote_action.i
-                .display_list[i][runtime->devices_.display_info_list()[i]
-                                     .name.length()] = '\0';
-            remote_action.i.left[i] =
-                runtime->devices_.display_info_list()[i].left;
-            remote_action.i.top[i] =
-                runtime->devices_.display_info_list()[i].top;
-            remote_action.i.right[i] =
-                runtime->devices_.display_info_list()[i].right;
-            remote_action.i.bottom[i] =
-                runtime->devices_.display_info_list()[i].bottom;
+                     remote_action.i.display_list[i]);
           }
-
-          std::string host_name = GetHostName();
-          remote_action.type = ControlType::host_infomation;
-          memcpy(&remote_action.i.host_name, host_name.data(),
-                 host_name.size());
-          remote_action.i.host_name[host_name.size()] = '\0';
-          remote_action.i.host_name_size = host_name.size();
-
           std::string msg = remote_action.to_json();
-          int ret =
+          const int ret =
               SendReliableDataFrame(runtime->peer_, msg.data(), msg.size(),
                                     runtime->control_data_label_.c_str());
-          remote_action_codec::Free(remote_action);
+          if (ret != 0) {
+            LOG_WARN("[{}] host information send failed, ret={}", remote_id,
+                     ret);
+          }
+          FreeRemoteAction(remote_action);
         }
 
         runtime->need_to_destroy_server_window_.store(

apps/desktop/src/gui/runtime/peer_media_callbacks.cpp

@@ -50,9 +50,28 @@ void PeerEventHandler::OnReceiveVideoBuffer(
     if (native_renderer && native_renderer->IsActive()) {
       VideoRenderer::SubmitResult submit_result =
           VideoRenderer::SubmitResult::failed;
-      if (GetNativeVideoFrame(video_frame)) {
-        submit_result = native_renderer->SubmitNativeFrame(
-            remote_id, *video_frame->native_frame);
+      if (const auto* native = GetNativeVideoFrame(video_frame)) {
+        submit_result = native_renderer->SubmitNativeFrame(remote_id, *native);
+        // A CPU NV12 native frame is valid MiniRTC input, but the macOS Metal
+        // fast path only accepts CVPixelBuffer. Materialize it when that path
+        // rejects a software decoder's descriptor. This also supports peers
+        // using CPU decoding when their platform hardware decoder is unavailable.
+        if (submit_result == VideoRenderer::SubmitResult::failed &&
+            native->type == MiniRtcNativeVideoFrameCpuNv12) {
+          const size_t frame_size =
+              static_cast<size_t>(native->width) * native->height * 3U / 2U;
+          // One decode callback thread per session; keep the buffer across
+          // frames instead of a full-frame allocation per rejected frame.
+          auto& fallback = props->native_cpu_fallback_;
+          if (fallback.size() != frame_size) fallback.resize(frame_size);
+          if (native->copy_to_nv12(native->owner, fallback.data(),
+                                   fallback.size()) == 0) {
+            submit_result = native_renderer->SubmitNv12(
+                remote_id, fallback.data(), fallback.size(),
+                static_cast<int>(native->width),
+                static_cast<int>(native->height));
+          }
+        }
       } else
       {
         submit_result = native_renderer->SubmitNv12(

apps/desktop/src/gui/runtime/privacy_runtime.cpp

@@ -25,14 +25,27 @@ void GuiRuntime::SetControllerPrivacySupport(const std::string& remote_id,
                                            bool supported) {
   std::unique_lock lock(connection_status_mutex_);
   const auto found = connection_status_.find(remote_id);
-  if (found == connection_status_.end() ||
-      found->second != ConnectionStatus::Connected) return;
+  if (found == connection_status_.end()) return;
+  if (found->second != ConnectionStatus::Connected) {
+    if (found->second == ConnectionStatus::Connecting ||
+        found->second == ConnectionStatus::Gathering) {
+      privacy_sessions_.RememberSupport(remote_id, supported);
+      LOG_INFO("Privacy: retained early controller capability, peer={}, supported={}",
+               remote_id, supported);
+    }
+    return;
+  }
 
   const bool automatic_enable =
       privacy_sessions_.SetSupported(remote_id, supported);
+  ApplyPrivacyAdmission(automatic_enable &&
+                        config_center_->IsEnablePrivacyScreen());
+}
+
+void GuiRuntime::ApplyPrivacyAdmission(bool automatic_enable) {
   if (!privacy_sessions_.CanEnable()) {
     if (privacy_.Engaged()) privacy_.Disable();
-  } else if (automatic_enable && config_center_->IsEnablePrivacyScreen()) {
+  } else if (automatic_enable) {
     privacy_.EnableOnConnection();
   }
 }
@@ -45,8 +58,10 @@ void GuiRuntime::QueuePrivacyCommand(const std::string& remote_id,
       found->second != ConnectionStatus::Connected ||
       !privacy_sessions_.Supports(remote_id)) return;
   std::lock_guard lock(privacy_commands_mutex_);
-  if (privacy_commands_.size() < 32)
-    privacy_commands_.emplace_back(remote_id, command);
+  if (privacy_commands_.size() >= 32) return;
+  LOG_INFO("Privacy: queued controller command, peer={}, flag={}", remote_id,
+           static_cast<int>(command.flag));
+  privacy_commands_.emplace_back(remote_id, command);
 }
 
 void GuiRuntime::HandlePrivacy() {
@@ -71,17 +86,15 @@ void GuiRuntime::HandlePrivacy() {
     }
     last_privacy_status_tick_ = 0;
   }
-  auto status = privacy_.Snapshot();
+  PrivacyStatus status{};
   const uint64_t now = SDL_GetTicks();
-  if (!peer_ || (last_privacy_status_tick_ != 0 &&
-                 status.revision == last_privacy_revision_ &&
-                 now - last_privacy_status_tick_ < 1000))
-    return;
   std::vector<std::string> controllers;
   {
     std::shared_lock lock(connection_status_mutex_);
+    status = privacy_.Snapshot();
     for (const auto& [id, state] : connection_status_)
-      if (state == ConnectionStatus::Connected && privacy_sessions_.Supports(id))
+      if (state == ConnectionStatus::Connected &&
+          privacy_sessions_.Supports(id))
         controllers.push_back(id);
     if (!privacy_sessions_.CanEnable()) {
       status.state = PrivacyState::unsupported;
@@ -91,6 +104,10 @@ void GuiRuntime::HandlePrivacy() {
                   "A connected controller does not support privacy screen");
     }
   }
+  if (!peer_ || (last_privacy_status_tick_ != 0 &&
+                 status.revision == last_privacy_revision_ &&
+                 now - last_privacy_status_tick_ < 1000))
+    return;
   RemoteAction action{};
   action.type = ControlType::privacy_status;
   action.ps = status;

apps/desktop/src/gui/runtime/privacy_session_policy.h

@@ -13,19 +13,37 @@
 
 namespace crossdesk {
 
-// Guarded by GuiRuntime's connection_status_mutex_. Privacy covers the shared
-// desktop, so every connected controller must explicitly support it.
+// Guarded by GuiRuntime's connection_status_mutex_. Privacy covers the local
+// displays, so every connected controller must explicitly support its controls.
 class PrivacySessionPolicy {
  public:
-  void Connected(const std::string& remote_id, bool automatic_privacy) {
+  // Web controllers render through the browser and expose no privacy UI.
+  static bool IsWebController(const std::string& remote_id) {
+    return remote_id.find("web") != std::string::npos;
+  }
+
+  bool Connected(const std::string& remote_id, bool automatic_privacy) {
     const auto [entry, inserted] = controllers_.try_emplace(remote_id, false);
-    if (inserted && controllers_.size() == 1 && automatic_privacy) {
+    if (inserted && controllers_.size() == 1 && automatic_privacy &&
+        !IsWebController(remote_id)) {
       automatic_controller_ = remote_id;
     }
+    const auto early = early_support_.find(remote_id);
+    if (early == early_support_.end()) return false;
+    const bool supported = early->second;
+    early_support_.erase(early);
+    return SetSupported(remote_id, supported);
+  }
+
+  // Only transport-authenticated metadata from a connecting session is cached
+  // by the caller. It grants no control until Connected admits that session.
+  void RememberSupport(const std::string& remote_id, bool supported) {
+    early_support_[remote_id] = supported;
   }
 
   void Disconnected(const std::string& remote_id) {
     controllers_.erase(remote_id);
+    early_support_.erase(remote_id);
     if (automatic_controller_ == remote_id) automatic_controller_.clear();
   }
 
@@ -34,7 +52,7 @@ class PrivacySessionPolicy {
   bool SetSupported(const std::string& remote_id, bool supported) {
     const auto entry = controllers_.find(remote_id);
     if (entry == controllers_.end()) return false;
-    entry->second = supported && remote_id.find("web") == std::string::npos;
+    entry->second = supported && !IsWebController(remote_id);
     if (automatic_controller_ != remote_id) return false;
     automatic_controller_.clear();
     return CanEnable();
@@ -53,9 +71,10 @@ class PrivacySessionPolicy {
 
  private:
   std::unordered_map<std::string, bool> controllers_;
+  std::unordered_map<std::string, bool> early_support_;
   std::string automatic_controller_;
 };
 
 }  // namespace crossdesk
 
-#endif
+#endif

apps/desktop/src/gui/runtime/remote_action_codec.cpp

@@ -1,120 +0,0 @@
-#include "runtime/remote_action_codec.h"
-
-#include <remote_action.h>
-
-#include <cstdlib>
-#include <cstring>
-
-namespace crossdesk::remote_action_codec {
-
-std::vector<char> Serialize(const RemoteAction &action) {
-  std::vector<char> buffer;
-  buffer.push_back(static_cast<char>(action.type));
-
-  auto insert_bytes = [&](const void *ptr, size_t len) {
-    buffer.insert(buffer.end(), static_cast<const char *>(ptr),
-                  static_cast<const char *>(ptr) + len);
-  };
-
-  if (action.type == ControlType::host_infomation) {
-    insert_bytes(&action.i.host_name_size, sizeof(size_t));
-    insert_bytes(action.i.host_name, action.i.host_name_size);
-
-    size_t num = action.i.display_num;
-    insert_bytes(&num, sizeof(size_t));
-
-    for (size_t i = 0; i < num; ++i) {
-      const size_t len = std::strlen(action.i.display_list[i]);
-      insert_bytes(&len, sizeof(size_t));
-      insert_bytes(action.i.display_list[i], len);
-    }
-
-    insert_bytes(action.i.left, sizeof(int) * num);
-    insert_bytes(action.i.top, sizeof(int) * num);
-    insert_bytes(action.i.right, sizeof(int) * num);
-    insert_bytes(action.i.bottom, sizeof(int) * num);
-  }
-
-  return buffer;
-}
-
-bool Deserialize(const char *data, size_t size, RemoteAction &out) {
-  size_t offset = 0;
-  auto read = [&](void *dst, size_t len) -> bool {
-    if (offset + len > size) {
-      return false;
-    }
-    std::memcpy(dst, data + offset, len);
-    offset += len;
-    return true;
-  };
-
-  if (size < 1) {
-    return false;
-  }
-  out.type = static_cast<ControlType>(data[offset++]);
-
-  if (out.type == ControlType::host_infomation) {
-    out.i.supports_privacy_screen = false;
-    size_t name_len;
-    if (!read(&name_len, sizeof(size_t)) ||
-        name_len >= sizeof(out.i.host_name)) {
-      return false;
-    }
-    if (!read(out.i.host_name, name_len)) {
-      return false;
-    }
-    out.i.host_name[name_len] = '\0';
-    out.i.host_name_size = name_len;
-
-    size_t num;
-    if (!read(&num, sizeof(size_t))) {
-      return false;
-    }
-    out.i.display_num = num;
-
-    out.i.display_list =
-        static_cast<char **>(std::malloc(num * sizeof(char *)));
-    for (size_t i = 0; i < num; ++i) {
-      size_t len;
-      if (!read(&len, sizeof(size_t)) || offset + len > size) {
-        return false;
-      }
-      out.i.display_list[i] = static_cast<char *>(std::malloc(len + 1));
-      std::memcpy(out.i.display_list[i], data + offset, len);
-      out.i.display_list[i][len] = '\0';
-      offset += len;
-    }
-
-    auto alloc_int_array = [&](int *&array) {
-      array = static_cast<int *>(std::malloc(num * sizeof(int)));
-      return read(array, num * sizeof(int));
-    };
-
-    return alloc_int_array(out.i.left) && alloc_int_array(out.i.top) &&
-           alloc_int_array(out.i.right) && alloc_int_array(out.i.bottom);
-  }
-
-  return true;
-}
-
-void Free(RemoteAction &action) {
-  if (action.type != ControlType::host_infomation) {
-    return;
-  }
-
-  for (size_t i = 0; i < action.i.display_num; ++i) {
-    std::free(action.i.display_list[i]);
-  }
-  std::free(action.i.display_list);
-  std::free(action.i.left);
-  std::free(action.i.top);
-  std::free(action.i.right);
-  std::free(action.i.bottom);
-
-  action.i.display_list = nullptr;
-  action.i.left = action.i.top = action.i.right = action.i.bottom = nullptr;
-  action.i.display_num = 0;
-}
-
-} // namespace crossdesk::remote_action_codec

apps/desktop/src/gui/runtime/remote_action_codec.h

@@ -1,23 +0,0 @@
-/*
- * @Author: DI JUNKUN
- * @Date: 2026-09-04
- * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
- */
-
-#ifndef _REMOTE_ACTION_CODEC_H_
-#define _REMOTE_ACTION_CODEC_H_
-
-#include <cstddef>
-#include <vector>
-
-#include <remote_action.h>
-
-namespace crossdesk::remote_action_codec {
-
-std::vector<char> Serialize(const RemoteAction &action);
-bool Deserialize(const char *data, size_t size, RemoteAction &out);
-void Free(RemoteAction &action);
-
-} // namespace crossdesk::remote_action_codec
-
-#endif

apps/desktop/src/gui/runtime/remote_session.h

@@ -14,7 +14,6 @@
 #include <filesystem>
 #include <memory>
 #include <mutex>
-#include <optional>
 #include <queue>
 #include <string>
 #include <vector>
@@ -39,7 +38,6 @@ struct FileTransferState {
   std::chrono::steady_clock::time_point file_send_last_update_time_;
   uint64_t file_send_last_bytes_ = 0;
   bool file_transfer_window_visible_ = false;
-  bool file_transfer_window_hovered_ = false;
   std::atomic<uint32_t> current_file_id_{0};
 
   struct QueuedFile {
@@ -93,31 +91,12 @@ struct RemoteSession {
   bool audio_capture_button_pressed_ = true;
   bool control_mouse_ = true;
   bool streaming_ = false;
-  bool is_control_bar_in_left_ = true;
-  bool control_bar_hovered_ = false;
-  bool display_selectable_hovered_ = false;
-  bool shortcut_selectable_hovered_ = false;
-  bool control_bar_expand_ = true;
-  bool reset_control_bar_pos_ = false;
-  bool control_window_width_is_changing_ = false;
-  bool control_window_height_is_changing_ = false;
   bool p2p_mode_ = true;
   bool remember_password_ = false;
   char remote_password_[7] = "";
-  float sub_stream_window_width_ = 1280;
-  float sub_stream_window_height_ = 720;
-  float control_window_min_width_ = 20;
-  float control_window_max_width_ = 300;
-  float control_window_min_height_ = 38;
-  float control_window_max_height_ = 180;
-  float control_window_width_ = 300;
-  float control_window_height_ = 38;
-  float control_bar_pos_x_ = 0;
-  float control_bar_pos_y_ = 30;
-  float mouse_diff_control_bar_pos_x_ = 0;
-  float mouse_diff_control_bar_pos_y_ = 0;
-  double control_bar_button_pressed_time_ = 0;
-  double net_traffic_stats_button_pressed_time_ = 0;
+  // Reused across frames by the decode callback thread when a CPU NV12
+  // native frame has to be materialized for a renderer that rejects it.
+  std::vector<unsigned char> native_cpu_fallback_;
 
   // Written by the decode callback thread and consumed by the UI thread.
   std::mutex video_frame_mutex_;
@@ -131,31 +110,13 @@ struct RemoteSession {
   std::chrono::steady_clock::time_point background_snapshot_time_;
   bool render_rect_dirty_ = false;
   bool stream_cleanup_pending_ = false;
-  float mouse_pos_x_ = 0;
-  float mouse_pos_y_ = 0;
-  float mouse_pos_x_last_ = 0;
-  float mouse_pos_y_last_ = 0;
-  int texture_width_ = 1280;
-  int texture_height_ = 720;
   int video_width_ = 0;
   int video_height_ = 0;
-  int video_width_last_ = 0;
-  int video_height_last_ = 0;
   int selected_display_ = 0;
   size_t video_size_ = 0;
   uint64_t video_frame_sequence_ = 0;
   bool tab_selected_ = false;
   bool tab_opened_ = true;
-  std::optional<float> pos_x_before_docked_;
-  std::optional<float> pos_y_before_docked_;
-  float render_window_x_ = 0;
-  float render_window_y_ = 0;
-  float render_window_width_ = 0;
-  float render_window_height_ = 0;
-  std::string fullscreen_button_label_ = "Fullscreen";
-  std::string net_traffic_stats_button_label_ = "Show Net Traffic Stats";
-  std::string mouse_control_button_label_ = "Mouse Control";
-  std::string audio_capture_button_label_ = "Audio Capture";
   std::string remote_host_name_;
   bool remote_service_status_received_ = false;
   std::mutex privacy_status_mutex_;

apps/desktop/src/gui/runtime/runtime_state.h

@@ -40,7 +40,6 @@ struct InfrastructureState {
   std::string dll_log_path_;
   std::string cache_path_;
   int localization_language_index_ = -1;
-  int localization_language_index_last_ = -1;
   bool modules_inited_ = false;
   unsigned char aes128_key_[16]{};
   unsigned char aes128_iv_[16]{};
@@ -123,7 +122,6 @@ struct PlatformIntegrationState {
 
 struct UserSettingsState {
   char client_id_[10] = "";
-  char client_id_display_[12] = "";
   char client_id_with_password_[17] = "";
   char password_saved_[7] = "";
   char self_hosted_id_[17] = "";
@@ -155,8 +153,6 @@ struct UserSettingsState {
   std::string file_transfer_save_path_last_;
   char signal_server_ip_self_[256] = "";
   char signal_server_port_self_[6] = "";
-  bool settings_window_pos_reset_ = true;
-  bool self_hosted_server_config_window_pos_reset_ = true;
   std::string selected_current_file_path_;
   bool show_file_browser_ = true;
 };
@@ -204,7 +200,6 @@ struct ConnectionState {
   std::unordered_map<std::string, std::chrono::steady_clock::time_point>
       last_remote_pointer_input_time_;
   std::string selected_server_remote_id_;
-  std::string selected_server_remote_hostname_;
   std::mutex pending_presence_probe_mutex_;
   bool pending_presence_probe_ = false;
   bool pending_presence_result_ready_ = false;

apps/desktop/src/gui/ui/common.slint

@@ -41,6 +41,7 @@ export global FontAwesomeIcons {
     out property <string> keyboard: "\u{f11c}";
     out property <string> minus: "\u{f068}";
     out property <string> pen: "\u{f304}";
+    out property <string> rotate: "\u{f2f1}";
     out property <string> signal: "\u{f012}";
     out property <string> shield-halved: "\u{f3ed}";
     out property <string> square-full: "\u{f45c}";
@@ -54,6 +55,7 @@ export global FontAwesomeIcons {
 export component IconButton inherits Rectangle {
     in property <string> icon;
     in property <string> tooltip;
+    in property <bool> enabled: true;
     in property <bool> danger: false;
     in property <length> icon-size: 16px;
     in property <color> icon-color: #24272d;
@@ -69,6 +71,7 @@ export component IconButton inherits Rectangle {
                               : touch.has-hover ? (danger ? #f04438 : root.hover-background)
                                                 : root.normal-background;
     border-radius: 4px;
+    opacity: root.enabled ? 1 : 0.4;
 
     Text {
         text: root.icon;
@@ -90,6 +93,7 @@ export component IconButton inherits Rectangle {
     }
 
     touch := TouchArea {
+        enabled: root.enabled;
         clicked => { root.clicked(); }
     }
 

apps/desktop/src/gui/ui/main_window.slint

@@ -24,6 +24,7 @@ export global UiStrings {
     in-out property <string> online: "Online";
     in-out property <string> offline: "Offline";
     in-out property <string> password: "Password";
+    in-out property <string> refresh-password: "Refresh random password";
     in-out property <string> copied: "Local ID copied to clipboard";
     in-out property <string> connect: "Connect";
     in-out property <string> settings: "Settings";
@@ -48,6 +49,7 @@ export global UiStrings {
     in-out property <string> codec: "Video codec";
     in-out property <string> hardware-codec: "Hardware video codec";
     in-out property <string> turn-relay: "TURN relay";
+    in-out property <string> force-relay: "Force relay";
     in-out property <string> self-hosted: "Self-hosted server";
     in-out property <string> autostart: "Start with system";
     in-out property <string> daemon: "Run in background";
@@ -185,6 +187,57 @@ component ConnectionDialogButton inherits Rectangle {
     button-touch := TouchArea { clicked => { root.clicked(); } }
 }
 
+// Use the same compact, plain-text field for connection and password changes.
+component PasswordInput inherits Rectangle {
+    in-out property <string> text;
+    in property <int> max-length: 0;
+    private property <string> previous-text;
+    callback accepted;
+
+    width: 70px;
+    height: 23px;
+    background: white;
+    border-width: 1px;
+    border-color: ImGuiLineStyle.border;
+    border-radius: 3px;
+    forward-focus: editor;
+
+    init => { root.previous-text = root.text; }
+
+    editor := TextInput {
+        x: 5px; y: 1px; width: parent.width - 10px; height: parent.height - 2px;
+        text <=> root.text;
+        input-type: InputType.text;
+        single-line: true;
+        color: #202124;
+        font-size: ImGuiFontStyle.base;
+        vertical-alignment: center;
+        selection-foreground-color: white;
+        selection-background-color: #2463c7;
+        edited => {
+            // Validate the resulting text so typing, paste, and replacement
+            // all obey the limit while deletion and selection still work.
+            if (root.max-length > 0 && self.text.character-count > root.max-length) {
+                self.text = root.previous-text;
+            } else {
+                root.previous-text = self.text;
+            }
+        }
+        accepted => { root.accepted(); }
+    }
+    Timer {
+        interval: 1ms;
+        running: true;
+        triggered => {
+            self.running = false;
+            editor.focus();
+            // Place the caret after any restored password, including UTF-8.
+            editor.select-all();
+            editor.clear-selection();
+        }
+    }
+}
+
 export component MainWindow inherits Window {
     title: "CrossDesk";
     icon: @image-url("../../../resources/linux/crossdesk_256x256.png");
@@ -208,6 +261,7 @@ export component MainWindow inherits Window {
     in property <string> local-password: "";
     in-out property <string> remote-id-input: "";
     in property <bool> password-visible: true;
+    in property <bool> password-change-pending: false;
     in property <bool> signal-connected: false;
     in property <bool> signal-tls-error: false;
     in property <[RecentConnection]> recent-connections;
@@ -246,6 +300,10 @@ export component MainWindow inherits Window {
     in-out property <int> codec-index: 0;
     in-out property <bool> hardware-codec-enabled: true;
     in-out property <bool> turn-enabled: true;
+    in-out property <bool> force-relay-enabled: false;
+    changed turn-enabled => {
+        if !root.turn-enabled { root.force-relay-enabled = false; }
+    }
     in-out property <bool> self-hosted-enabled: false;
     in-out property <bool> autostart-enabled: false;
     in-out property <bool> daemon-enabled: false;
@@ -262,6 +320,7 @@ export component MainWindow inherits Window {
 
     callback copy-local-id;
     callback toggle-password-visibility;
+    callback refresh-password;
     callback reset-password(string) -> bool;
     callback format-remote-id(string) -> string;
     callback connect-requested(string);
@@ -676,19 +735,31 @@ export component MainWindow inherits Window {
                     IconButton {
                                 x: 174px;
                                 y: 133px;
-                                width: 29px;
+                                width: 24px;
                                 height: 30px;
                                 icon: root.password-visible ? FontAwesomeIcons.eye : FontAwesomeIcons.eye-slash;
                                 icon-size: 17px;
                                 clicked => { root.toggle-password-visibility(); }
                     }
                     IconButton {
-                                x: 214px;
+                                x: 198px;
                                 y: 133px;
-                                width: 29px;
+                                width: 24px;
+                                height: 30px;
+                                icon: FontAwesomeIcons.rotate;
+                                icon-size: 15px;
+                                tooltip: UiStrings.refresh-password;
+                                enabled: !root.password-change-pending;
+                                clicked => { root.refresh-password(); }
+                    }
+                    IconButton {
+                                x: 222px;
+                                y: 133px;
+                                width: 24px;
                                 height: 30px;
                                 icon: FontAwesomeIcons.pen;
                                 icon-size: 15px;
+                                enabled: !root.password-change-pending;
                                 clicked => { root.reset-password-open = true; }
                     }
             }
@@ -1144,25 +1215,11 @@ export component MainWindow inherits Window {
                 padding: 20px;
                 spacing: 12px;
                 DialogPromptText { prompt: UiStrings.new-password; }
-                Rectangle {
-                    height: 28px;
-                    background: white;
-                    border-width: 1px;
-                    border-color: ImGuiLineStyle.border;
-                    border-radius: 4px;
-
-                    LineEdit {
-                        x: 1px;
-                        y: 1.5px;
-                        width: parent.width - 2px;
-                        height: parent.height - 2px;
+                HorizontalLayout {
+                    alignment: center;
+                    PasswordInput {
                         text <=> root.new-password-input;
-                        input-type: InputType.password;
-                    }
-                    LineEditFocusUnderlineMask {
-                        x: 5px;
-                        y: parent.height - 3px;
-                        width: parent.width - 10px;
+                        max-length: 6;
                     }
                 }
                 Text { height: root.reset-password-invalid ? 18px : 0px; visible: root.reset-password-invalid; text: UiStrings.invalid-password; color: #d92d20; font-size: ImGuiFontStyle.small; horizontal-alignment: center; }
@@ -1288,30 +1345,10 @@ export component MainWindow inherits Window {
                     vertical-alignment: center;
                 }
 
-                if !root.connection-validating: Rectangle {
-                    x: 71px; y: 63px; width: 70px; height: 23px;
-                    background: white;
-                    border-width: 1px;
-                    border-color: ImGuiLineStyle.border;
-                    border-radius: 3px;
-                    connection-password-editor := TextInput {
-                        x: 5px; y: 1px; width: parent.width - 10px; height: parent.height - 2px;
-                        text <=> root.connection-password;
-                        // The legacy ImGui field uses CharsNoBlank without the
-                        // Password flag, so entered text remains visible.
-                        input-type: InputType.text;
-                        color: #202124;
-                        font-size: ImGuiFontStyle.base;
-                        vertical-alignment: center;
-                        selection-foreground-color: white;
-                        selection-background-color: #2463c7;
-                        accepted => { root.connection-submit-password(root.connection-password, root.connection-remember-password); }
-                    }
-                    Timer {
-                        interval: 1ms;
-                        running: true;
-                        triggered => { connection-password-editor.focus(); }
-                    }
+                if !root.connection-validating: PasswordInput {
+                    x: 71px; y: 63px;
+                    text <=> root.connection-password;
+                    accepted => { root.connection-submit-password(root.connection-password, root.connection-remember-password); }
                 }
 
                 if !root.connection-validating: Rectangle {
@@ -1486,6 +1523,11 @@ export component MainWindow inherits Window {
                         Text { x: 8px; y: 3px; width: root.compact-language ? 145px : 212px; height: 24px; text: UiStrings.turn-relay; font-size: ImGuiFontStyle.body; overflow: elide; vertical-alignment: center; }
                         ImGuiCheckBox { x: root.compact-language ? 157px : 224px; y: 3px; checked <=> root.turn-enabled; enabled: !root.settings-session-active; }
                     }
+                    Rectangle {
+                        height: 30px;
+                        Text { x: 8px; y: 3px; width: root.compact-language ? 145px : 212px; height: 24px; text: UiStrings.force-relay; color: root.turn-enabled ? #202124 : #8b8f95; font-size: ImGuiFontStyle.body; overflow: elide; vertical-alignment: center; }
+                        ImGuiCheckBox { x: root.compact-language ? 157px : 224px; y: 3px; checked <=> root.force-relay-enabled; enabled: root.turn-enabled && !root.settings-session-active; }
+                    }
                     Rectangle {
                         height: 30px;
                         Text { x: 8px; y: 3px; width: root.compact-language ? 145px : 212px; height: 24px; text: UiStrings.privacy-on-connect; color: root.privacy-setting-available ? #202124 : #8b8f95; font-size: ImGuiFontStyle.body; overflow: elide; vertical-alignment: center; }

apps/desktop/src/gui/ui/stream_window.slint

@@ -142,6 +142,11 @@ export component StreamWindow inherits Window {
 
     in property <bool> custom-titlebar: false;
     in property <bool> native-video-enabled: false;
+    // Export the actual input surface in logical pixels. Native rendering and
+    // input mapping must follow the same layout, including title and tab bars.
+    out property <length> video-area-top: content-layer.y + video.y;
+    out property <length> video-area-width: video.width;
+    out property <length> video-area-height: video.height;
     in property <bool> window-active: true;
     in property <bool> window-maximized: false;
     in property <[StreamTab]> tabs;
@@ -286,7 +291,7 @@ export component StreamWindow inherits Window {
             && pointer-y >= control.y
             && pointer-y <= control.y + control.height;
         let display-menu-x = control.x + (root.control-docked-left ? 9px : 42px);
-        let display-menu-y = control.y + control.height - 1px;
+        let display-menu-y = control.y + root.control-toolbar-height - 1px;
         let display-menu-height = min(180px, root.displays.length * 30px + 8px);
         let over-display-menu = root.display-menu-open
             && pointer-x >= display-menu-x
@@ -1012,9 +1017,9 @@ export component StreamWindow inherits Window {
                         && floor((display-touch.mouse-y - 4px) / 30px) < root.displays.length
                     ? floor((display-touch.mouse-y - 4px) / 30px) : -1;
                 x: control.x + (root.control-docked-left ? 9px : 42px);
-                // Overlap the control border by one pixel so the menu reads as
-                // an attached panel growing downward from the display button.
-                y: control.y + control.height - 1px;
+                // Anchor to the button row, independent of the expanded stats.
+                // Overlap its bottom edge by one pixel to keep the menu attached.
+                y: control.y + root.control-toolbar-height - 1px;
                 width: 180px;
                 height: self.expanded-height * root.display-menu-progress;
                 opacity: root.display-menu-progress;

apps/desktop/src/gui/ui/ui_localization.h

@@ -36,6 +36,7 @@ inline int ApplyMainWindowStrings(
   strings.set_online(Text(localization::online[language]));
   strings.set_offline(Text(localization::offline[language]));
   strings.set_password(Text(localization::password[language]));
+  strings.set_refresh_password(Text(localization::refresh_password[language]));
   strings.set_copied(
       Text(localization::local_id_copied_to_clipboard[language]));
   strings.set_connect(Text(localization::connect[language]));
@@ -69,6 +70,7 @@ inline int ApplyMainWindowStrings(
   strings.set_hardware_codec(
       Text(localization::enable_hardware_video_codec[language]));
   strings.set_turn_relay(Text(localization::enable_turn[language]));
+  strings.set_force_relay(Text(localization::force_relay[language]));
   strings.set_self_hosted(
       Text(localization::self_hosted_server_config[language]));
   strings.set_autostart(Text(localization::enable_autostart[language]));

apps/desktop/src/gui/views/panels/local_peer_panel.cpp

@@ -1,303 +0,0 @@
-#include <random>
-
-#include "application/gui_application.h"
-#include "layout_relative.h"
-#include "localization.h"
-#include "rd_log.h"
-
-namespace crossdesk {
-
-int GuiApplication::LocalWindow() {
-  ImGuiIO &io = ImGui::GetIO();
-  float local_window_width = io.DisplaySize.x * 0.5f;
-  float local_window_height =
-      io.DisplaySize.y * (1 - TITLE_BAR_HEIGHT - STATUS_BAR_HEIGHT);
-  float local_window_button_width = io.DisplaySize.x * 0.046f;
-  float local_window_button_height = io.DisplaySize.y * 0.075f;
-
-  ImGui::SetNextWindowPos(ImVec2(0.0f, io.DisplaySize.y * TITLE_BAR_HEIGHT),
-                          ImGuiCond_Always);
-  ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, window_rounding_ * 0.5f);
-
-  ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4(0, 0, 0, 0));
-  ImGui::BeginChild("LocalDesktopWindow",
-                    ImVec2(local_window_width, local_window_height),
-                    ImGuiChildFlags_None,
-                    ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
-                        ImGuiWindowFlags_NoBringToFrontOnFocus);
-  ImGui::PopStyleColor();
-
-  ImGui::SetCursorPos(
-      ImVec2(io.DisplaySize.x * 0.045f, io.DisplaySize.y * 0.02f));
-
-  ImGui::SetWindowFontScale(0.9f);
-  ImGui::TextColored(
-      ImVec4(0.0f, 0.0f, 0.0f, 0.5f), "%s",
-      localization::local_desktop[localization_language_index_].c_str());
-
-  ImGui::Spacing();
-  {
-    ImGui::SetNextWindowPos(
-        ImVec2(io.DisplaySize.x * 0.045f, io.DisplaySize.y * 0.15f),
-        ImGuiCond_Always);
-    ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4(239.0f / 255, 240.0f / 255,
-                                                   242.0f / 255, 1.0f));
-    ImGui::PushStyleVar(ImGuiStyleVar_ChildRounding, window_rounding_ * 1.5f);
-    ImGui::BeginChild(
-        "LocalDesktopPanel",
-        ImVec2(local_window_width * 0.8f, local_window_height * 0.43f),
-        ImGuiChildFlags_Borders,
-        ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
-            ImGuiWindowFlags_NoBringToFrontOnFocus);
-    ImGui::PopStyleVar();
-    ImGui::PopStyleColor();
-    {
-      ImGui::SetWindowFontScale(0.8f);
-      ImGui::Text("%s",
-                  localization::local_id[localization_language_index_].c_str());
-
-      ImGui::Spacing();
-
-      ImGui::SetNextItemWidth(io.DisplaySize.x * 0.25f);
-      ImGui::SetWindowFontScale(1.0f);
-      ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f);
-
-      if (strcmp(client_id_display_, client_id_)) {
-        for (int i = 0, j = 0; i < sizeof(client_id_); i++, j++) {
-          client_id_display_[j] = client_id_[i];
-          if (i == 2 || i == 5) {
-            client_id_display_[++j] = ' ';
-          }
-        }
-      }
-
-      ImGui::InputText(
-          "##local_id", client_id_display_, IM_ARRAYSIZE(client_id_display_),
-          ImGuiInputTextFlags_CharsUppercase | ImGuiInputTextFlags_ReadOnly);
-      ImGui::PopStyleVar();
-
-      ImGui::SameLine();
-
-      ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0, 0, 0, 0));
-      ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0, 0, 0, 0));
-      ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(0, 0, 0, 0));
-      ImGui::SetWindowFontScale(0.5f);
-      if (ImGui::Button(ICON_FA_COPY, ImVec2(local_window_button_width,
-                                             local_window_button_height))) {
-        local_id_copied_ = true;
-        ImGui::SetClipboardText(client_id_);
-        copy_start_time_ = ImGui::GetTime();
-      }
-      ImGui::SetWindowFontScale(1.0f);
-      ImGui::PopStyleColor(3);
-
-      double time_duration = ImGui::GetTime() - copy_start_time_;
-      if (local_id_copied_ && time_duration < 1.0f) {
-        ImGui::SetNextWindowPos(
-            ImVec2(io.DisplaySize.x * 0.33f, io.DisplaySize.y * 0.33f));
-        ImGui::SetNextWindowSize(
-            ImVec2(io.DisplaySize.x * 0.33f, io.DisplaySize.y * 0.33f));
-        ImGui::PushStyleColor(
-            ImGuiCol_WindowBg,
-            ImVec4(1.0f, 1.0f, 1.0f, 1.0f - (float)time_duration));
-        ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
-        ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, window_rounding_);
-        ImGui::Begin("ConnectionStatusWindow", nullptr,
-                     ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
-                         ImGuiWindowFlags_NoSavedSettings);
-        ImGui::PopStyleVar(2);
-        ImGui::PopStyleColor();
-
-        auto window_width = ImGui::GetWindowSize().x;
-        auto window_height = ImGui::GetWindowSize().y;
-        ImGui::SetWindowFontScale(0.8f);
-        std::string text = localization::local_id_copied_to_clipboard
-            [localization_language_index_];
-        auto text_width = ImGui::CalcTextSize(text.c_str()).x;
-        ImGui::SetCursorPosX((window_width - text_width) * 0.5f);
-        ImGui::SetCursorPosY(window_height * 0.4f);
-        ImGui::PushStyleColor(ImGuiCol_Text,
-                              ImVec4(0, 0, 0, 1.0f - (float)time_duration));
-        ImGui::Text("%s", text.c_str());
-        ImGui::PopStyleColor();
-        ImGui::SetWindowFontScale(1.0f);
-
-        ImGui::End();
-      }
-
-      ImGui::Spacing();
-      ImGui::Separator();
-      ImGui::Spacing();
-
-      ImGui::SetWindowFontScale(0.8f);
-      ImGui::Text("%s",
-                  localization::password[localization_language_index_].c_str());
-      ImGui::SetWindowFontScale(1.0f);
-
-      ImGui::SetNextItemWidth(io.DisplaySize.x * 0.25f);
-      ImGui::Spacing();
-
-      ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f);
-      ImGui::InputTextWithHint(
-          "##server_pwd",
-          localization::max_password_len[localization_language_index_].c_str(),
-          password_saved_, IM_ARRAYSIZE(password_saved_),
-          show_password_
-              ? ImGuiInputTextFlags_CharsNoBlank | ImGuiInputTextFlags_ReadOnly
-              : ImGuiInputTextFlags_CharsNoBlank |
-                    ImGuiInputTextFlags_Password |
-                    ImGuiInputTextFlags_ReadOnly);
-      ImGui::PopStyleVar();
-
-      ImGui::SameLine();
-      ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0, 0, 0, 0));
-      ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0, 0, 0, 0));
-      ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(0, 0, 0, 0));
-      ImGui::SetWindowFontScale(0.5f);
-      auto l_x = ImGui::GetCursorScreenPos().x;
-      auto l_y = ImGui::GetCursorScreenPos().y;
-      if (ImGui::Button(
-              show_password_ ? ICON_FA_EYE : ICON_FA_EYE_SLASH,
-              ImVec2(local_window_button_width, local_window_button_height))) {
-        show_password_ = !show_password_;
-      }
-
-      ImGui::SameLine();
-
-      if (ImGui::Button(ICON_FA_PEN, ImVec2(local_window_button_width,
-                                            local_window_button_height))) {
-        show_reset_password_window_ = true;
-      }
-      ImGui::SetWindowFontScale(1.0f);
-      ImGui::PopStyleColor(3);
-
-      if (show_reset_password_window_) {
-        ImGui::SetNextWindowPos(
-            ImVec2(io.DisplaySize.x * 0.33f, io.DisplaySize.y * 0.33f));
-        ImGui::SetNextWindowSize(
-            ImVec2(io.DisplaySize.x * 0.33f, io.DisplaySize.y * 0.33f));
-
-        ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding,
-                            window_rounding_ * 0.5f);
-        ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(1.0, 1.0, 1.0, 1.0));
-        ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 1.0f);
-        ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, window_rounding_);
-
-        ImGui::Begin("ResetPasswordWindow", nullptr,
-                     ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
-                         ImGuiWindowFlags_NoSavedSettings);
-        ImGui::PopStyleVar(2);
-        ImGui::PopStyleColor();
-
-        auto window_width = ImGui::GetWindowSize().x;
-        auto window_height = ImGui::GetWindowSize().y;
-        std::string text =
-            localization::new_password[localization_language_index_];
-        ImGui::SetWindowFontScale(0.5f);
-        auto text_width = ImGui::CalcTextSize(text.c_str()).x;
-        ImGui::SetCursorPosX((window_width - text_width) * 0.5f);
-        ImGui::SetCursorPosY(window_height * 0.2f);
-        ImGui::Text("%s", text.c_str());
-
-        ImGui::SetCursorPosX(window_width * 0.33f);
-        ImGui::SetCursorPosY(window_height * 0.4f);
-        ImGui::SetNextItemWidth(window_width * 0.33f);
-
-        ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f);
-
-        if (focus_on_input_widget_) {
-          ImGui::SetKeyboardFocusHere();
-          focus_on_input_widget_ = false;
-        }
-
-        bool enter_pressed = ImGui::InputText(
-            "##new_password", new_password_, IM_ARRAYSIZE(new_password_),
-            ImGuiInputTextFlags_CharsNoBlank |
-                ImGuiInputTextFlags_EnterReturnsTrue);
-
-        ImGui::PopStyleVar();
-
-        ImGui::SetCursorPosX(window_width * 0.315f);
-        ImGui::SetCursorPosY(window_height * 0.75f);
-
-        // OK
-        if (ImGui::Button(
-                localization::ok[localization_language_index_].c_str()) ||
-            enter_pressed) {
-          if (6 != strlen(new_password_)) {
-            LOG_ERROR("Invalid password length");
-            show_reset_password_window_ = true;
-            focus_on_input_widget_ = true;
-          } else {
-            show_reset_password_window_ = false;
-            memset(&password_saved_, 0, sizeof(password_saved_));
-            strncpy(password_saved_, new_password_,
-                    sizeof(password_saved_) - 1);
-            password_saved_[sizeof(password_saved_) - 1] = '\0';
-
-            // if self hosted
-            if (config_center_->IsSelfHosted()) {
-              std::string self_hosted_id_str;
-              if (strlen(self_hosted_id_) > 0) {
-                const char *at_pos = strchr(self_hosted_id_, '@');
-                if (at_pos != nullptr) {
-                  self_hosted_id_str =
-                      std::string(self_hosted_id_, at_pos - self_hosted_id_);
-                } else {
-                  self_hosted_id_str = self_hosted_id_;
-                }
-              } else {
-                self_hosted_id_str = client_id_;
-              }
-
-              std::string new_self_hosted_id =
-                  self_hosted_id_str + "@" + password_saved_;
-              memset(&self_hosted_id_, 0, sizeof(self_hosted_id_));
-              strncpy(self_hosted_id_, new_self_hosted_id.c_str(),
-                      sizeof(self_hosted_id_) - 1);
-              self_hosted_id_[sizeof(self_hosted_id_) - 1] = '\0';
-
-            } else {
-              std::string client_id_with_password =
-                  std::string(client_id_) + "@" + password_saved_;
-              strncpy(client_id_with_password_, client_id_with_password.c_str(),
-                      sizeof(client_id_with_password_) - 1);
-              client_id_with_password_[sizeof(client_id_with_password_) - 1] =
-                  '\0';
-            }
-
-            settings_.Save();
-
-            memset(new_password_, 0, sizeof(new_password_));
-
-            LeaveConnection(peer_, client_id_);
-            DestroyPeer(&peer_);
-            focus_on_input_widget_ = true;
-          }
-        }
-
-        ImGui::SameLine();
-
-        if (ImGui::Button(
-                localization::cancel[localization_language_index_].c_str())) {
-          show_reset_password_window_ = false;
-          focus_on_input_widget_ = true;
-          memset(new_password_, 0, sizeof(new_password_));
-        }
-
-        ImGui::SetWindowFontScale(1.0f);
-
-        ImGui::End();
-        ImGui::PopStyleVar();
-      }
-    }
-
-    ImGui::EndChild();
-  }
-
-  ImGui::EndChild();
-  ImGui::PopStyleVar();
-
-  return 0;
-}
-} // namespace crossdesk

apps/desktop/src/gui/views/panels/recent_connections_panel.cpp

@@ -1,656 +0,0 @@
-#include <algorithm>
-#include <cctype>
-
-#include "application/gui_application.h"
-#include "layout_relative.h"
-#include "localization.h"
-#include "rd_log.h"
-
-namespace crossdesk {
-namespace {
-
-std::string TrimConnectionAlias(const char *value) {
-  std::string alias = value ? value : "";
-
-  auto not_space = [](unsigned char ch) { return !std::isspace(ch); };
-  alias.erase(alias.begin(),
-              std::find_if(alias.begin(), alias.end(), not_space));
-  alias.erase(std::find_if(alias.rbegin(), alias.rend(), not_space).base(),
-              alias.end());
-
-  return alias;
-}
-
-void SetDarkTextTooltip(const char *text) {
-  ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.05f, 0.05f, 0.05f, 1.0f));
-  ImGui::BeginTooltip();
-  ImGui::SetWindowFontScale(0.5f);
-  ImGui::Text("%s", text);
-  ImGui::SetWindowFontScale(1.0f);
-  ImGui::EndTooltip();
-  ImGui::PopStyleColor();
-}
-
-} // namespace
-
-int GuiApplication::RecentConnectionsWindow() {
-  ImGuiIO &io = ImGui::GetIO();
-  float recent_connection_window_width = io.DisplaySize.x;
-  float recent_connection_window_height =
-      io.DisplaySize.y * (0.455f - STATUS_BAR_HEIGHT);
-  ImGui::SetNextWindowPos(ImVec2(0, io.DisplaySize.y * 0.55f),
-                          ImGuiCond_Always);
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
-  ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
-  ImGui::BeginChild(
-      "RecentConnectionsWindow",
-      ImVec2(recent_connection_window_width, recent_connection_window_height),
-      ImGuiChildFlags_Borders,
-      ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
-          ImGuiWindowFlags_NoBringToFrontOnFocus);
-  ImGui::PopStyleVar();
-  ImGui::PopStyleColor();
-
-  ImGui::SetCursorPos(
-      ImVec2(io.DisplaySize.x * 0.045f, io.DisplaySize.y * 0.02f));
-
-  ImGui::SetWindowFontScale(0.9f);
-  ImGui::TextColored(
-      ImVec4(0.0f, 0.0f, 0.0f, 0.5f), "%s",
-      localization::recent_connections[localization_language_index_].c_str());
-
-  ShowRecentConnections();
-
-  ImGui::EndChild();
-
-  return 0;
-}
-
-int GuiApplication::ShowRecentConnections() {
-  ImGuiIO &io = ImGui::GetIO();
-  float recent_connection_panel_width = io.DisplaySize.x * 0.912f;
-  float recent_connection_panel_height = io.DisplaySize.y * 0.29f;
-  float recent_connection_image_height = recent_connection_panel_height * 0.6f;
-  float recent_connection_image_width = recent_connection_image_height * 16 / 9;
-  float recent_connection_sub_container_width =
-      recent_connection_image_width * 1.2f;
-  float recent_connection_sub_container_height =
-      recent_connection_image_height * 1.4f;
-  float recent_connection_button_width = recent_connection_image_width * 0.15f;
-  float recent_connection_button_height =
-      recent_connection_image_height * 0.25f;
-  float recent_connection_footer_height =
-      recent_connection_button_height * 1.18f;
-  float recent_connection_name_width = recent_connection_image_width;
-  const float recent_connection_spacing = recent_connection_image_width * 0.16f;
-  const float recent_connections_content_width =
-      recent_connections_.empty()
-          ? 0.0f
-          : recent_connections_.size() * recent_connection_sub_container_width +
-                (recent_connections_.size() - 1) * recent_connection_spacing;
-  const float recent_connections_available_width =
-      recent_connection_panel_width - 2.0f * ImGui::GetStyle().WindowPadding.x;
-  const bool has_horizontal_overflow =
-      recent_connections_content_width > recent_connections_available_width;
-
-  ImGui::SetCursorPos(
-      ImVec2(io.DisplaySize.x * 0.045f, io.DisplaySize.y * 0.1f));
-
-  std::map<std::string, ImVec2> sub_containers_pos;
-  ImGui::PushStyleColor(ImGuiCol_ChildBg,
-                        ImVec4(239.0f / 255, 240.0f / 255, 242.0f / 255, 1.0f));
-  ImGui::PushStyleVar(ImGuiStyleVar_ChildRounding, 10.0f);
-  const ImGuiWindowFlags container_flags =
-      ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
-      ImGuiWindowFlags_NoBringToFrontOnFocus |
-      ImGuiWindowFlags_NoScrollWithMouse |
-      (has_horizontal_overflow ? ImGuiWindowFlags_AlwaysHorizontalScrollbar
-                               : ImGuiWindowFlags_None);
-  ImGui::BeginChild(
-      "RecentConnectionsContainer",
-      ImVec2(recent_connection_panel_width, recent_connection_panel_height),
-      ImGuiChildFlags_Borders, container_flags);
-  ImGui::PopStyleVar();
-  ImGui::PopStyleColor();
-  size_t recent_connections_count = recent_connections_.size();
-  int count = 0;
-  for (auto &it : recent_connections_) {
-    sub_containers_pos[it.first] = ImGui::GetCursorPos();
-    std::string recent_connection_sub_window_name =
-        "RecentConnectionsSubContainer" + it.first;
-    // recent connections sub container
-    ImGui::BeginChild(recent_connection_sub_window_name.c_str(),
-                      ImVec2(recent_connection_sub_container_width,
-                             recent_connection_sub_container_height),
-                      ImGuiChildFlags_None,
-                      ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
-                          ImGuiWindowFlags_NoBringToFrontOnFocus);
-    std::string connection_info = it.first;
-
-    // remote id length is 9
-    // password length is 6
-    // connection_info -> remote_id + 'Y' + host_name + '@' + password
-    //                 -> remote_id + 'N' + host_name
-    bool invalid_connection_info = false;
-    if (connection_info.size() > 9 && 'Y' == connection_info[9] &&
-        connection_info.size() >= 16) {
-      size_t pos_y = connection_info.find('Y');
-      size_t pos_at = connection_info.find('@');
-
-      if (pos_y == std::string::npos || pos_at == std::string::npos ||
-          pos_y >= pos_at) {
-        LOG_ERROR("Invalid filename");
-        invalid_connection_info = true;
-      } else {
-        it.second.remote_id = connection_info.substr(0, pos_y);
-        it.second.remote_host_name =
-            connection_info.substr(pos_y + 1, pos_at - pos_y - 1);
-        it.second.password = connection_info.substr(pos_at + 1);
-        it.second.remember_password = true;
-      }
-    } else if (connection_info.size() > 9 && 'N' == connection_info[9] &&
-               connection_info.size() >= 10) {
-      size_t pos_n = connection_info.find('N');
-
-      if (pos_n == std::string::npos) {
-        LOG_ERROR("Invalid filename");
-        invalid_connection_info = true;
-      } else {
-        it.second.remote_id = connection_info.substr(0, pos_n);
-        it.second.remote_host_name = connection_info.substr(pos_n + 1);
-        it.second.password = "";
-        it.second.remember_password = false;
-      }
-    } else {
-      invalid_connection_info = true;
-    }
-
-    if (invalid_connection_info) {
-      it.second.remote_id = connection_info.substr(
-          0, std::min<size_t>(connection_info.size(), 9));
-      it.second.remote_host_name = "unknown";
-      it.second.password = "";
-      it.second.remember_password = false;
-    }
-
-    std::string display_name = settings_.RecentConnectionDisplayName(it.second);
-    bool online = device_presence_cache_.IsOnline(it.second.remote_id);
-
-    ImVec2 image_pos =
-        ImVec2(ImGui::GetCursorPosX() + recent_connection_image_width * 0.05f,
-               ImGui::GetCursorPosY() + recent_connection_image_height * 0.08f);
-
-    ImGui::SetCursorPos(image_pos);
-    ImVec2 image_screen_pos = ImGui::GetCursorScreenPos();
-    ImGui::Image(
-        (ImTextureID)(intptr_t)it.second.texture,
-        ImVec2(recent_connection_image_width, recent_connection_image_height));
-
-    const bool image_item_hovered = ImGui::IsItemHovered();
-
-    ImVec2 card_screen_min = image_screen_pos;
-    ImVec2 card_screen_max =
-        ImVec2(image_screen_pos.x + recent_connection_image_width,
-               image_screen_pos.y + recent_connection_image_height +
-                   recent_connection_footer_height);
-
-    const bool card_hovered =
-        ImGui::IsMouseHoveringRect(card_screen_min, card_screen_max, true);
-
-    const float recent_connection_toolbar_width =
-        3.0f * recent_connection_button_width;
-
-    const float recent_connection_toolbar_padding =
-        recent_connection_image_width * 0.025f;
-
-    const ImVec2 toolbar_pos = ImVec2(
-        image_pos.x + recent_connection_image_width -
-            recent_connection_toolbar_width - recent_connection_toolbar_padding,
-        image_pos.y + recent_connection_image_height +
-            (recent_connection_footer_height -
-             recent_connection_button_height) *
-                0.5f);
-
-    const ImVec2 toolbar_screen_pos = ImVec2(
-        image_screen_pos.x + recent_connection_image_width -
-            recent_connection_toolbar_width - recent_connection_toolbar_padding,
-        image_screen_pos.y + recent_connection_image_height +
-            (recent_connection_footer_height -
-             recent_connection_button_height) *
-                0.5f);
-
-    const ImVec2 toolbar_screen_end =
-        ImVec2(toolbar_screen_pos.x + recent_connection_toolbar_width,
-               toolbar_screen_pos.y + recent_connection_button_height);
-
-    const bool toolbar_hovered =
-        card_hovered && ImGui::IsMouseHoveringRect(toolbar_screen_pos,
-                                                   toolbar_screen_end, true);
-
-    const bool show_image_tooltip = image_item_hovered && !toolbar_hovered;
-
-    if (show_image_tooltip) {
-      const ImVec2 mouse_pos = ImGui::GetMousePos();
-      const bool place_tooltip_on_left = mouse_pos.x > io.DisplaySize.x * 0.7f;
-      ImGui::SetNextWindowPos(
-          ImVec2(mouse_pos.x + (place_tooltip_on_left ? -12.0f : 12.0f),
-                 mouse_pos.y - 8.0f),
-          ImGuiCond_Always, ImVec2(place_tooltip_on_left ? 1.0f : 0.0f, 1.0f));
-      ImGui::BeginTooltip();
-
-      ImGui::SetWindowFontScale(0.4f);
-
-      ImGui::Text(
-          "%s: %s",
-          localization::device_name[localization_language_index_].c_str(),
-          display_name.c_str());
-
-      if (!it.second.remote_host_name.empty() &&
-          it.second.remote_host_name != display_name) {
-        ImGui::Text("%s", it.second.remote_host_name.c_str());
-      }
-
-      ImGui::Text("%s: %s",
-                  localization::remote_id[localization_language_index_].c_str(),
-                  it.second.remote_id.c_str());
-
-      ImGui::Text("%s",
-                  (online ? localization::online[localization_language_index_]
-                          : localization::offline[localization_language_index_])
-                      .c_str());
-
-      ImGui::SetWindowFontScale(1.0f);
-
-      ImGui::EndTooltip();
-    }
-
-    ImDrawList *draw_list = ImGui::GetWindowDrawList();
-
-    // connection name footer
-    {
-      ImVec2 footer_pos =
-          ImVec2(image_pos.x, image_pos.y + recent_connection_image_height);
-
-      ImVec2 footer_screen_pos =
-          ImVec2(image_screen_pos.x,
-                 image_screen_pos.y + recent_connection_image_height);
-
-      ImVec2 footer_screen_end =
-          ImVec2(footer_screen_pos.x + recent_connection_name_width,
-                 footer_screen_pos.y + recent_connection_footer_height);
-
-      float footer_rounding = recent_connection_footer_height * 0.16f;
-
-      draw_list->AddRectFilled(footer_screen_pos, footer_screen_end,
-                               IM_COL32(0, 0, 0, 40), footer_rounding,
-                               ImDrawFlags_RoundCornersBottom);
-
-      const float status_left_margin = recent_connection_footer_height * 0.22f;
-      const float status_gap = recent_connection_footer_height * 0.20f;
-      const float dot_radius = recent_connection_footer_height * 0.18f;
-
-      const ImVec2 dot_center(
-          footer_screen_pos.x + status_left_margin + dot_radius,
-          footer_screen_pos.y + recent_connection_footer_height * 0.5f);
-      const ImU32 dot_color =
-          online ? IM_COL32(34, 197, 94, 255) : IM_COL32(156, 163, 175, 255);
-
-      // Layered halo simulates a radial gradient glow for the online state.
-      if (online) {
-        const float halo_radius = dot_radius * 2.2f;
-        const int halo_layers = 8;
-        for (int i = halo_layers; i > 0; --i) {
-          const float t = static_cast<float>(i) / halo_layers;
-          const float r = dot_radius + (halo_radius - dot_radius) * t;
-          const int alpha = static_cast<int>(14.0f * (1.0f - t) + 4.0f);
-          draw_list->AddCircleFilled(dot_center, r,
-                                     IM_COL32(74, 222, 128, alpha));
-        }
-      }
-      draw_list->AddCircleFilled(dot_center, dot_radius, dot_color);
-
-      const float status_block_end_x = dot_center.x + dot_radius;
-
-      ImVec2 text_min =
-          ImVec2(status_block_end_x + status_gap, footer_screen_pos.y);
-
-      ImVec2 text_max =
-          ImVec2(card_hovered ? toolbar_screen_pos.x - status_gap
-                              : footer_screen_end.x -
-                                    recent_connection_name_width * 0.05f,
-                 footer_screen_end.y);
-
-      ImGui::SetWindowFontScale(0.52f);
-
-      ImGui::RenderTextClipped(text_min, text_max, display_name.c_str(),
-                               nullptr, nullptr, ImVec2(0.0f, 0.5f));
-
-      ImGui::SetWindowFontScale(1.0f);
-    }
-
-    // Toolbar / three buttons, right-aligned in the connection name footer.
-    if (card_hovered) {
-      float toolbar_rounding = recent_connection_button_height * 0.22f;
-
-      draw_list->AddRectFilled(
-          ImVec2(toolbar_screen_pos.x, toolbar_screen_pos.y + 1.0f),
-          ImVec2(toolbar_screen_end.x, toolbar_screen_end.y + 1.0f),
-          IM_COL32(0, 0, 0, 70), toolbar_rounding);
-
-      draw_list->AddRectFilled(toolbar_screen_pos, toolbar_screen_end,
-                               IM_COL32(96, 100, 106, 140), toolbar_rounding);
-
-      draw_list->AddRect(toolbar_screen_pos, toolbar_screen_end,
-                         IM_COL32(255, 255, 255, 48), toolbar_rounding);
-
-      ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, toolbar_rounding);
-      ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.0f);
-      ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0));
-
-      ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0, 0, 0, 0));
-      ImGui::PushStyleColor(ImGuiCol_ButtonHovered,
-                            ImVec4(1.0f, 1.0f, 1.0f, 0.18f));
-      ImGui::PushStyleColor(ImGuiCol_ButtonActive,
-                            ImVec4(0.35f, 0.55f, 0.95f, 0.45f));
-      ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 1.0f, 1.0f, 0.95f));
-
-      ImGui::SetWindowFontScale(0.5f);
-
-      // edit alias button
-      {
-        ImGui::SetCursorPos(toolbar_pos);
-
-        std::string edit = ICON_FA_PEN;
-        std::string recent_connection_edit_button_name =
-            edit + "##RecentConnectionAlias" + it.first;
-
-        if (ImGui::Button(recent_connection_edit_button_name.c_str(),
-                          ImVec2(recent_connection_button_width,
-                                 recent_connection_button_height))) {
-          settings_.BeginEditRecentConnectionAlias(it.second);
-        }
-
-        if (ImGui::IsItemHovered()) {
-          SetDarkTextTooltip(
-              localization::connection_alias[localization_language_index_]
-                  .c_str());
-        }
-      }
-
-      // trash button
-      {
-        ImVec2 trash_can_button_pos = ImVec2(
-            toolbar_pos.x + recent_connection_button_width, toolbar_pos.y);
-
-        ImGui::SetCursorPos(trash_can_button_pos);
-
-        std::string trash_can = ICON_FA_TRASH_CAN;
-        std::string recent_connection_delete_button_name =
-            trash_can + "##RecentConnectionDelete" + it.first;
-
-        if (ImGui::Button(recent_connection_delete_button_name.c_str(),
-                          ImVec2(recent_connection_button_width,
-                                 recent_connection_button_height))) {
-          show_confirm_delete_connection_ = true;
-          delete_connection_name_ = it.first;
-        }
-        if (ImGui::IsItemHovered()) {
-          SetDarkTextTooltip(
-              localization::delete_connection[localization_language_index_]
-                  .c_str());
-        }
-      }
-
-      // connect button
-      {
-        ImVec2 connect_button_pos = ImVec2(
-            toolbar_pos.x + 2 * recent_connection_button_width, toolbar_pos.y);
-
-        ImGui::SetCursorPos(connect_button_pos);
-
-        std::string connect = ICON_FA_ARROW_RIGHT_LONG;
-        std::string connect_to_this_connection_button_name =
-            connect + "##ConnectionTo" + it.first;
-
-        if (ImGui::Button(connect_to_this_connection_button_name.c_str(),
-                          ImVec2(recent_connection_button_width,
-                                 recent_connection_button_height))) {
-          ConnectTo(it.second.remote_id, it.second.password.c_str(),
-                    it.second.remember_password);
-        }
-        if (ImGui::IsItemHovered()) {
-          SetDarkTextTooltip(localization::connect_to_this_connection
-                                 [localization_language_index_]
-                                     .c_str());
-        }
-      }
-
-      ImGui::SetWindowFontScale(1.0f);
-
-      ImGui::PopStyleColor(4);
-      ImGui::PopStyleVar(3);
-    }
-
-    if (delete_connection_ && delete_connection_name_ == it.first) {
-      if (!thumbnail_->DeleteThumbnail(it.first)) {
-        settings_.EraseRecentConnectionAlias(it.second.remote_id);
-        settings_.SaveRecentConnectionAliases();
-        reload_recent_connections_ = true;
-        delete_connection_ = false;
-      }
-    }
-
-    ImGui::EndChild();
-
-    if (count != recent_connections_count - 1) {
-      ImVec2 line_start =
-          ImVec2(image_screen_pos.x + recent_connection_image_width * 1.18f,
-                 image_screen_pos.y);
-      ImVec2 line_end =
-          ImVec2(image_screen_pos.x + recent_connection_image_width * 1.18f,
-                 image_screen_pos.y + recent_connection_image_height +
-                     recent_connection_footer_height);
-      ImGui::GetWindowDrawList()->AddLine(line_start, line_end,
-                                          IM_COL32(0, 0, 0, 122), 1.0f);
-    }
-
-    count++;
-    ImGui::SameLine(0, count != recent_connections_count
-                           ? recent_connection_spacing
-                           : 0.0f);
-  }
-
-  ImGui::EndChild();
-
-  if (show_confirm_delete_connection_) {
-    ConfirmDeleteConnection();
-  }
-  if (show_edit_connection_alias_window_) {
-    EditRecentConnectionAliasWindow();
-  }
-  if (show_offline_warning_window_) {
-    OfflineWarningWindow();
-  }
-
-  return 0;
-}
-
-int GuiApplication::ConfirmDeleteConnection() {
-  ImGuiIO &io = ImGui::GetIO();
-  ImGui::SetNextWindowPos(
-      ImVec2(io.DisplaySize.x * 0.33f, io.DisplaySize.y * 0.33f));
-  ImGui::SetNextWindowSize(
-      ImVec2(io.DisplaySize.x * 0.33f, io.DisplaySize.y * 0.33f));
-
-  ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, window_rounding_ * 0.5f);
-  ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 1.0f);
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, window_rounding_);
-
-  ImGui::Begin("ConfirmDeleteConnectionWindow", nullptr,
-               ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
-                   ImGuiWindowFlags_NoSavedSettings);
-  ImGui::PopStyleVar(2);
-  ImGui::PopStyleColor();
-
-  auto connection_status_window_width = ImGui::GetWindowSize().x;
-  auto connection_status_window_height = ImGui::GetWindowSize().y;
-
-  std::string text =
-      localization::confirm_delete_connection[localization_language_index_];
-  ImGui::SetCursorPosX(connection_status_window_width * 0.33f);
-  ImGui::SetCursorPosY(connection_status_window_height * 0.67f);
-
-  // ok
-  ImGui::SetWindowFontScale(0.5f);
-  if (ImGui::Button(localization::ok[localization_language_index_].c_str()) ||
-      ImGui::IsKeyPressed(ImGuiKey_Enter)) {
-    delete_connection_ = true;
-    show_confirm_delete_connection_ = false;
-  }
-
-  ImGui::SameLine();
-  // cancel
-  if (ImGui::Button(
-          localization::cancel[localization_language_index_].c_str()) ||
-      ImGui::IsKeyPressed(ImGuiKey_Escape)) {
-    delete_connection_ = false;
-    show_confirm_delete_connection_ = false;
-  }
-
-  auto text_width = ImGui::CalcTextSize(text.c_str()).x;
-  ImGui::SetCursorPosX((connection_status_window_width - text_width) * 0.5f);
-  ImGui::SetCursorPosY(connection_status_window_height * 0.2f);
-  ImGui::Text("%s", text.c_str());
-  ImGui::SetWindowFontScale(1.0f);
-
-  ImGui::End();
-  ImGui::PopStyleVar();
-  return 0;
-}
-
-int GuiApplication::EditRecentConnectionAliasWindow() {
-  ImGuiIO &io = ImGui::GetIO();
-  ImGui::SetNextWindowPos(
-      ImVec2(io.DisplaySize.x * 0.33f, io.DisplaySize.y * 0.33f));
-  ImGui::SetNextWindowSize(
-      ImVec2(io.DisplaySize.x * 0.33f, io.DisplaySize.y * 0.33f));
-
-  ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, window_rounding_ * 0.5f);
-  ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 1.0f);
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, window_rounding_);
-
-  ImGui::Begin("EditRecentConnectionAliasWindow", nullptr,
-               ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
-                   ImGuiWindowFlags_NoSavedSettings);
-  ImGui::PopStyleVar(2);
-  ImGui::PopStyleColor();
-
-  auto window_width = ImGui::GetWindowSize().x;
-  auto window_height = ImGui::GetWindowSize().y;
-  std::string text =
-      localization::input_connection_alias[localization_language_index_];
-
-  ImGui::SetWindowFontScale(0.5f);
-  auto text_width = ImGui::CalcTextSize(text.c_str()).x;
-  ImGui::SetCursorPosX((window_width - text_width) * 0.5f);
-  ImGui::SetCursorPosY(window_height * 0.2f);
-  ImGui::Text("%s", text.c_str());
-
-  ImGui::SetCursorPosX(window_width * 0.2f);
-  ImGui::SetCursorPosY(window_height * 0.4f);
-  ImGui::SetNextItemWidth(window_width * 0.6f);
-  ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f);
-
-  if (focus_on_input_widget_) {
-    ImGui::SetKeyboardFocusHere();
-    focus_on_input_widget_ = false;
-  }
-
-  bool enter_pressed =
-      ImGui::InputText("##recent_connection_alias", edit_connection_alias_,
-                       IM_ARRAYSIZE(edit_connection_alias_),
-                       ImGuiInputTextFlags_EnterReturnsTrue);
-
-  ImGui::PopStyleVar();
-
-  ImGui::SetCursorPosX(window_width * 0.315f);
-  ImGui::SetCursorPosY(window_height * 0.75f);
-
-  if (ImGui::Button(localization::ok[localization_language_index_].c_str()) ||
-      enter_pressed) {
-    std::string alias = TrimConnectionAlias(edit_connection_alias_);
-    if (alias.empty()) {
-      settings_.EraseRecentConnectionAlias(edit_connection_alias_remote_id_);
-    } else {
-      settings_.SetRecentConnectionAlias(edit_connection_alias_remote_id_,
-                                         alias);
-    }
-
-    settings_.SaveRecentConnectionAliases();
-    show_edit_connection_alias_window_ = false;
-    focus_on_input_widget_ = true;
-    memset(edit_connection_alias_, 0, sizeof(edit_connection_alias_));
-    edit_connection_alias_remote_id_.clear();
-  }
-
-  ImGui::SameLine();
-
-  if (ImGui::Button(
-          localization::cancel[localization_language_index_].c_str()) ||
-      ImGui::IsKeyPressed(ImGuiKey_Escape)) {
-    show_edit_connection_alias_window_ = false;
-    focus_on_input_widget_ = true;
-    memset(edit_connection_alias_, 0, sizeof(edit_connection_alias_));
-    edit_connection_alias_remote_id_.clear();
-  }
-
-  ImGui::SetWindowFontScale(1.0f);
-
-  ImGui::End();
-  ImGui::PopStyleVar();
-  return 0;
-}
-
-int GuiApplication::OfflineWarningWindow() {
-  ImGuiIO &io = ImGui::GetIO();
-  ImGui::SetNextWindowPos(
-      ImVec2(io.DisplaySize.x * 0.33f, io.DisplaySize.y * 0.33f));
-  ImGui::SetNextWindowSize(
-      ImVec2(io.DisplaySize.x * 0.33f, io.DisplaySize.y * 0.33f));
-
-  ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, window_rounding_ * 0.5f);
-  ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 1.0f);
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, window_rounding_);
-
-  ImGui::Begin("OfflineWarningWindow", nullptr,
-               ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
-                   ImGuiWindowFlags_NoSavedSettings);
-  ImGui::PopStyleVar(2);
-  ImGui::PopStyleColor();
-
-  auto window_width = ImGui::GetWindowSize().x;
-  auto window_height = ImGui::GetWindowSize().y;
-
-  ImGui::SetCursorPosX(window_width * 0.43f);
-  ImGui::SetCursorPosY(window_height * 0.67f);
-  ImGui::SetWindowFontScale(0.5f);
-  if (ImGui::Button(localization::ok[localization_language_index_].c_str()) ||
-      ImGui::IsKeyPressed(ImGuiKey_Enter) ||
-      ImGui::IsKeyPressed(ImGuiKey_Escape)) {
-    show_offline_warning_window_ = false;
-  }
-
-  auto text_width = ImGui::CalcTextSize(offline_warning_text_.c_str()).x;
-  ImGui::SetCursorPosX((window_width - text_width) * 0.5f);
-  ImGui::SetCursorPosY(window_height * 0.2f);
-  ImGui::Text("%s", offline_warning_text_.c_str());
-  ImGui::SetWindowFontScale(1.0f);
-
-  ImGui::End();
-  ImGui::PopStyleVar();
-  return 0;
-}
-} // namespace crossdesk

apps/desktop/src/gui/views/panels/remote_peer_panel.cpp

@@ -1,167 +0,0 @@
-#include "application/gui_application.h"
-#include "layout_relative.h"
-#include "localization.h"
-#include "rd_log.h"
-
-namespace crossdesk {
-
-static int InputTextCallback(ImGuiInputTextCallbackData *data);
-
-int GuiApplication::RemoteWindow() {
-  ImGuiIO &io = ImGui::GetIO();
-  float remote_window_width = io.DisplaySize.x * 0.5f;
-  float remote_window_height =
-      io.DisplaySize.y * (1 - TITLE_BAR_HEIGHT - STATUS_BAR_HEIGHT);
-  float remote_window_arrow_button_width = io.DisplaySize.x * 0.1f;
-  float remote_window_arrow_button_height = io.DisplaySize.y * 0.078f;
-
-  ImGui::SetNextWindowPos(
-      ImVec2(io.DisplaySize.x * 0.5f, io.DisplaySize.y * TITLE_BAR_HEIGHT),
-      ImGuiCond_Always);
-  ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, window_rounding_ * 0.5f);
-
-  ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4(0, 0, 0, 0));
-  ImGui::BeginChild("RemoteDesktopWindow",
-                    ImVec2(remote_window_width, remote_window_height),
-                    ImGuiChildFlags_None,
-                    ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
-                        ImGuiWindowFlags_NoBringToFrontOnFocus);
-  ImGui::PopStyleColor();
-
-  ImGui::SetCursorPos(
-      ImVec2(io.DisplaySize.x * 0.057f, io.DisplaySize.y * 0.02f));
-
-  ImGui::SetWindowFontScale(0.9f);
-  ImGui::TextColored(
-      ImVec4(0.0f, 0.0f, 0.0f, 0.5f), "%s",
-      localization::remote_desktop[localization_language_index_].c_str());
-
-  ImGui::Spacing();
-  {
-    ImGui::SetNextWindowPos(
-        ImVec2(io.DisplaySize.x * 0.557f, io.DisplaySize.y * 0.15f),
-        ImGuiCond_Always);
-    ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4(239.0f / 255, 240.0f / 255,
-                                                   242.0f / 255, 1.0f));
-    ImGui::PushStyleVar(ImGuiStyleVar_ChildRounding, 10.0f);
-
-    ImGui::BeginChild(
-        "RemoteDesktopWindow_1",
-        ImVec2(remote_window_width * 0.8f, remote_window_height * 0.43f),
-        ImGuiChildFlags_Borders,
-        ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
-            ImGuiWindowFlags_NoBringToFrontOnFocus);
-    ImGui::PopStyleVar();
-    ImGui::PopStyleColor();
-    {
-      ImGui::SetWindowFontScale(0.8f);
-      ImGui::Text(
-          "%s", localization::remote_id[localization_language_index_].c_str());
-
-      ImGui::Spacing();
-      ImGui::SetNextItemWidth(io.DisplaySize.x * 0.25f);
-      ImGui::SetWindowFontScale(1.0f);
-      ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f);
-      if (re_enter_remote_id_) {
-        ImGui::SetKeyboardFocusHere();
-        re_enter_remote_id_ = false;
-        memset(remote_id_display_, 0, sizeof(remote_id_display_));
-      }
-      bool enter_pressed = ImGui::InputText(
-          "##remote_id_", remote_id_display_, IM_ARRAYSIZE(remote_id_display_),
-          ImGuiInputTextFlags_CharsDecimal |
-              ImGuiInputTextFlags_EnterReturnsTrue |
-              ImGuiInputTextFlags_CallbackEdit,
-          InputTextCallback);
-
-      ImGui::PopStyleVar();
-      ImGui::SameLine();
-
-      std::string remote_id = remote_id_display_;
-      remote_id.erase(remove_if(remote_id.begin(), remote_id.end(),
-                                static_cast<int (*)(int)>(&isspace)),
-                      remote_id.end());
-      if (ImGui::Button(ICON_FA_ARROW_RIGHT_LONG,
-                        ImVec2(remote_window_arrow_button_width,
-                               remote_window_arrow_button_height)) ||
-          enter_pressed) {
-        connect_button_pressed_ = true;
-        bool found = false;
-        std::string target_remote_id;
-        std::string target_password;
-        bool should_connect = false;
-        bool already_connected = false;
-
-        for (auto &[id, props] : recent_connections_) {
-          if (id.find(remote_id) != std::string::npos) {
-            found = true;
-            target_remote_id = props.remote_id;
-            target_password = props.password;
-            {
-              // std::shared_lock lock(remote_sessions_mutex_);
-              if (remote_sessions_.find(remote_id) !=
-                  remote_sessions_.end()) {
-                if (!remote_sessions_[remote_id]->connection_established_) {
-                  should_connect = true;
-                } else {
-                  already_connected = true;
-                }
-              } else {
-                should_connect = true;
-              }
-            }
-
-            if (should_connect) {
-              ConnectTo(target_remote_id, target_password.c_str(), false);
-            } else if (already_connected) {
-              LOG_INFO("Already connected to [{}]", remote_id);
-            }
-            break;
-          }
-        }
-        if (!found) {
-          ConnectTo(remote_id, "", false);
-        }
-      }
-
-      // check every 1 second for rejoin
-      if (need_to_rejoin_) {
-        auto now = std::chrono::steady_clock::now();
-        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
-                           now - last_rejoin_check_time_)
-                           .count();
-
-        if (elapsed >= 1000) {
-          last_rejoin_check_time_ = now;
-          need_to_rejoin_ = false;
-          // std::shared_lock lock(remote_sessions_mutex_);
-          for (const auto &[_, props] : remote_sessions_) {
-            if (props->rejoin_) {
-              ConnectTo(props->remote_id_, props->remote_password_,
-                        props->remember_password_);
-            }
-          }
-        }
-      }
-    }
-    ImGui::EndChild();
-  }
-  ImGui::EndChild();
-  ImGui::PopStyleVar();
-
-  return 0;
-}
-
-static int InputTextCallback(ImGuiInputTextCallbackData *data) {
-  if (data->BufTextLen > 3 && data->Buf[3] != ' ') {
-    data->InsertChars(3, " ");
-  }
-
-  if (data->BufTextLen > 7 && data->Buf[7] != ' ') {
-    data->InsertChars(7, " ");
-  }
-
-  return 0;
-}
-
-} // namespace crossdesk

apps/desktop/src/gui/views/toolbars/control_bar.cpp

@@ -1,514 +0,0 @@
-#include <algorithm>
-
-#include <remote_action.h>
-#include <atomic>
-#include <chrono>
-#include <filesystem>
-#include <fstream>
-#include <thread>
-#include <vector>
-
-#include "application/gui_application.h"
-#include "file_transfer.h"
-#include "layout.h"
-#include "localization.h"
-#include "rd_log.h"
-#include "tinyfiledialogs.h"
-
-namespace crossdesk {
-
-namespace {
-
-void ShowControlBarTooltip(const std::string &text) {
-  if (!ImGui::IsItemHovered() || text.empty()) {
-    return;
-  }
-
-  ImGui::BeginTooltip();
-  ImGui::SetWindowFontScale(0.5f);
-  ImGui::Text("%s", text.c_str());
-  ImGui::SetWindowFontScale(1.0f);
-  ImGui::EndTooltip();
-}
-
-} // namespace
-
-int CountDigits(int number) {
-  if (number == 0)
-    return 1;
-  return (int)std::floor(std::log10(std::abs(number))) + 1;
-}
-
-int BitrateDisplay(int bitrate) {
-  int num_of_digits = CountDigits(bitrate);
-  if (num_of_digits <= 3) {
-    ImGui::Text("%d bps", bitrate);
-  } else if (num_of_digits > 3 && num_of_digits <= 6) {
-    ImGui::Text("%d kbps", bitrate / 1000);
-  } else {
-    ImGui::Text("%.1f mbps", bitrate / 1000000.0f);
-  }
-  return 0;
-}
-
-int LossRateDisplay(float loss_rate) {
-  if (loss_rate < 0.01f) {
-    ImGui::Text("0%%");
-  } else {
-    ImGui::Text("%.0f%%", loss_rate * 100);
-  }
-  return 0;
-}
-
-std::string GuiApplication::OpenFileDialog(std::string title) {
-  const char *path = tinyfd_openFileDialog(title.c_str(),
-                                           "",      // default path
-                                           0,       // number of filters
-                                           nullptr, // filters
-                                           nullptr, // filter description
-                                           0        // no multiple selection
-  );
-
-  return path ? path : "";
-}
-
-int GuiApplication::ControlBar(
-    std::shared_ptr<RemoteSession> &props) {
-  float button_width = title_bar_height_ * 0.8f;
-  float button_height = title_bar_height_ * 0.8f;
-  float line_padding = title_bar_height_ * 0.12f;
-  float line_thickness = title_bar_height_ * 0.07f;
-
-  ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, window_rounding_ * 0.5f);
-  if (props->control_bar_expand_) {
-    ImGui::SetCursorPosX(props->is_control_bar_in_left_
-                             ? props->control_window_width_ * 0.03f
-                             : props->control_window_width_ * 0.17f);
-
-    ImDrawList *draw_list = ImGui::GetWindowDrawList();
-    if (!props->is_control_bar_in_left_) {
-      draw_list->AddLine(
-          ImVec2(ImGui::GetCursorScreenPos().x - button_height * 0.5f,
-                 ImGui::GetCursorScreenPos().y + button_height * 0.2f),
-          ImVec2(ImGui::GetCursorScreenPos().x - button_height * 0.5f,
-                 ImGui::GetCursorScreenPos().y + button_height * 0.8f),
-          IM_COL32(178, 178, 178, 255), 2.0f);
-    }
-
-    std::string display = ICON_FA_DISPLAY;
-    ImGui::SetWindowFontScale(0.5f);
-    if (ImGui::Button(display.c_str(), ImVec2(button_width, button_height))) {
-      ImGui::OpenPopup("display");
-    }
-
-    ImVec2 btn_min = ImGui::GetItemRectMin();
-    ImVec2 btn_size_actual = ImGui::GetItemRectSize();
-    ShowControlBarTooltip(
-        localization::select_display[localization_language_index_]);
-
-    props->display_selectable_hovered_ = false;
-    if (ImGui::BeginPopup("display")) {
-      ImGui::SetWindowFontScale(0.5f);
-      for (int i = 0; i < props->display_info_list_.size(); i++) {
-        const std::string display_label = localization::FormatDisplayLabel(
-            static_cast<size_t>(i), props->display_info_list_[i].name,
-            localization_language_index_);
-        if (ImGui::Selectable(display_label.c_str())) {
-          props->selected_display_ = i;
-
-          RemoteAction remote_action;
-          remote_action.type = ControlType::display_id;
-          remote_action.d = i;
-          if (props->connection_status_.load() == ConnectionStatus::Connected) {
-            std::string msg = remote_action.to_json();
-            SendReliableDataFrame(props->peer_, msg.c_str(), msg.size(),
-                                  props->control_data_label_.c_str());
-          }
-        }
-      }
-      props->display_selectable_hovered_ =
-          ImGui::IsWindowHovered(ImGuiHoveredFlags_RootAndChildWindows);
-      ImGui::EndPopup();
-    }
-
-    ImGui::SetWindowFontScale(0.35f);
-    ImVec2 text_size = ImGui::CalcTextSize(
-        std::to_string(props->selected_display_ + 1).c_str());
-    ImVec2 text_pos =
-        ImVec2(btn_min.x + (btn_size_actual.x - text_size.x) * 0.55f,
-               btn_min.y + (btn_size_actual.y - text_size.y) * 0.33f);
-    ImGui::GetWindowDrawList()->AddText(
-        text_pos, IM_COL32(0, 0, 0, 255),
-        std::to_string(props->selected_display_ + 1).c_str());
-
-    auto send_service_command = [&](ServiceCommandFlag flag,
-                                    const char *log_action) {
-      if (props->connection_status_.load() == ConnectionStatus::Connected &&
-          props->peer_) {
-        RemoteAction remote_action;
-        remote_action.type = ControlType::service_command;
-        remote_action.c.flag = flag;
-        std::string msg = remote_action.to_json();
-        int ret = SendReliableDataFrame(props->peer_, msg.c_str(), msg.size(),
-                                        props->control_data_label_.c_str());
-        if (ret != 0) {
-          LOG_WARN("Send {} command failed, remote_id={}, ret={}", log_action,
-                   props->remote_id_, ret);
-        }
-      }
-    };
-
-    ImGui::SameLine();
-    std::string shortcut = ICON_FA_KEYBOARD;
-    ImGui::SetWindowFontScale(0.5f);
-    if (ImGui::Button(shortcut.c_str(), ImVec2(button_width, button_height))) {
-      ImGui::OpenPopup("shortcut");
-    }
-    ShowControlBarTooltip(
-        localization::send_shortcut[localization_language_index_]);
-
-    props->shortcut_selectable_hovered_ = false;
-    if (ImGui::BeginPopup("shortcut")) {
-      ImGui::SetWindowFontScale(0.5f);
-      std::string sas_label = "Ctrl+Alt+Del";
-      std::string lock_label = "Win+L";
-      if (ImGui::Selectable(sas_label.c_str())) {
-        send_service_command(ServiceCommandFlag::send_sas, "SAS");
-      }
-      if (ImGui::Selectable(lock_label.c_str())) {
-        send_service_command(ServiceCommandFlag::lock_workstation,
-                             "remote lock");
-      }
-      props->shortcut_selectable_hovered_ =
-          ImGui::IsWindowHovered(ImGuiHoveredFlags_RootAndChildWindows);
-      ImGui::SetWindowFontScale(1.0f);
-      ImGui::EndPopup();
-    }
-
-    ImGui::SameLine();
-    float mouse_x = ImGui::GetCursorScreenPos().x;
-    float mouse_y = ImGui::GetCursorScreenPos().y;
-    float disable_mouse_x = mouse_x + line_padding;
-    float disable_mouse_y = mouse_y + line_padding;
-    std::string mouse = ICON_FA_COMPUTER_MOUSE;
-    ImGui::SetWindowFontScale(0.5f);
-    if (ImGui::Button(mouse.c_str(), ImVec2(button_width, button_height))) {
-      if (props->connection_established_) {
-        start_keyboard_capturer_ = !start_keyboard_capturer_;
-        props->control_mouse_ = !props->control_mouse_;
-        props->enable_mouse_control_ = !props->enable_mouse_control_;
-        props->mouse_control_button_label_ =
-            props->enable_mouse_control_
-                ? localization::release_mouse[localization_language_index_]
-                : localization::control_mouse[localization_language_index_];
-      }
-    }
-    const bool mouse_button_hovered = ImGui::IsItemHovered();
-    const std::string mouse_tooltip =
-        props->enable_mouse_control_
-            ? localization::release_mouse[localization_language_index_]
-            : localization::control_mouse[localization_language_index_];
-    ShowControlBarTooltip(mouse_tooltip);
-
-    if (!props->enable_mouse_control_) {
-      draw_list->AddLine(ImVec2(disable_mouse_x, disable_mouse_y),
-                         ImVec2(mouse_x + button_width - line_padding,
-                                mouse_y + button_height - line_padding),
-                         IM_COL32(0, 0, 0, 255), line_thickness);
-      draw_list->AddLine(
-          ImVec2(disable_mouse_x - line_thickness * 0.7f,
-                 disable_mouse_y + line_thickness * 0.7f),
-          ImVec2(mouse_x + button_width - line_padding - line_thickness * 0.7f,
-                 mouse_y + button_height - line_padding +
-                     line_thickness * 0.7f),
-          mouse_button_hovered ? IM_COL32(66, 150, 250, 255)
-                               : IM_COL32(179, 213, 253, 255),
-          line_thickness);
-    }
-
-    ImGui::SameLine();
-    // audio capture button
-    float audio_x = ImGui::GetCursorScreenPos().x;
-    float audio_y = ImGui::GetCursorScreenPos().y;
-    float disable_audio_x = audio_x + line_padding;
-    float disable_audio_y = audio_y + line_padding;
-
-    std::string audio = props->audio_capture_button_pressed_
-                            ? ICON_FA_VOLUME_HIGH
-                            : ICON_FA_VOLUME_HIGH;
-    ImGui::SetWindowFontScale(0.5f);
-    if (ImGui::Button(audio.c_str(), ImVec2(button_width, button_height))) {
-      if (props->connection_established_) {
-        props->audio_capture_button_pressed_ =
-            !props->audio_capture_button_pressed_;
-        props->audio_capture_button_label_ =
-            props->audio_capture_button_pressed_
-                ? localization::audio_capture[localization_language_index_]
-                : localization::mute[localization_language_index_];
-
-        RemoteAction remote_action;
-        remote_action.type = ControlType::audio_capture;
-        remote_action.a = props->audio_capture_button_pressed_;
-        std::string msg = remote_action.to_json();
-        SendReliableDataFrame(props->peer_, msg.c_str(), msg.size(),
-                              props->control_data_label_.c_str());
-      }
-    }
-    const bool audio_button_hovered = ImGui::IsItemHovered();
-    const std::string audio_tooltip =
-        props->audio_capture_button_pressed_
-            ? localization::mute[localization_language_index_]
-            : localization::audio_capture[localization_language_index_];
-    ShowControlBarTooltip(audio_tooltip);
-
-    if (!props->audio_capture_button_pressed_) {
-      draw_list->AddLine(ImVec2(disable_audio_x, disable_audio_y),
-                         ImVec2(audio_x + button_width - line_padding,
-                                audio_y + button_height - line_padding),
-                         IM_COL32(0, 0, 0, 255), line_thickness);
-      draw_list->AddLine(
-          ImVec2(disable_audio_x - line_thickness * 0.7f,
-                 disable_audio_y + line_thickness * 0.7f),
-          ImVec2(audio_x + button_width - line_padding - line_thickness * 0.7f,
-                 audio_y + button_height - line_padding +
-                     line_thickness * 0.7f),
-          audio_button_hovered ? IM_COL32(66, 150, 250, 255)
-                               : IM_COL32(179, 213, 253, 255),
-          line_thickness);
-    }
-
-    ImGui::SameLine();
-    std::string open_folder = ICON_FA_FOLDER_OPEN;
-    if (ImGui::Button(open_folder.c_str(),
-                      ImVec2(button_width, button_height))) {
-      std::string title =
-          localization::select_file[localization_language_index_];
-      std::string path = OpenFileDialog(title);
-      transfers_.ProcessSelectedFile(path, props, file_label_);
-    }
-    ShowControlBarTooltip(
-        localization::select_file[localization_language_index_]);
-
-    ImGui::SameLine();
-    // net traffic stats button
-    bool button_color_style_pushed = false;
-    if (props->net_traffic_stats_button_pressed_) {
-      ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(66 / 255.0f, 150 / 255.0f,
-                                                    250 / 255.0f, 1.0f));
-      button_color_style_pushed = true;
-    }
-    std::string net_traffic_stats = ICON_FA_SIGNAL;
-    ImGui::SetWindowFontScale(0.5f);
-    if (ImGui::Button(net_traffic_stats.c_str(),
-                      ImVec2(button_width, button_height))) {
-      props->net_traffic_stats_button_pressed_ =
-          !props->net_traffic_stats_button_pressed_;
-      props->control_window_height_is_changing_ = true;
-      props->net_traffic_stats_button_pressed_time_ = ImGui::GetTime();
-      props->net_traffic_stats_button_label_ =
-          props->net_traffic_stats_button_pressed_
-              ? localization::hide_net_traffic_stats
-                    [localization_language_index_]
-              : localization::show_net_traffic_stats
-                    [localization_language_index_];
-    }
-    const std::string net_traffic_stats_tooltip =
-        props->net_traffic_stats_button_pressed_
-            ? localization::hide_net_traffic_stats[localization_language_index_]
-            : localization::show_net_traffic_stats
-                  [localization_language_index_];
-    ShowControlBarTooltip(net_traffic_stats_tooltip);
-
-    if (button_color_style_pushed) {
-      ImGui::PopStyleColor();
-      button_color_style_pushed = false;
-    }
-
-    ImGui::SameLine();
-    // fullscreen button
-    std::string fullscreen =
-        fullscreen_button_pressed_ ? ICON_FA_COMPRESS : ICON_FA_EXPAND;
-    ImGui::SetWindowFontScale(0.5f);
-    if (ImGui::Button(fullscreen.c_str(),
-                      ImVec2(button_width, button_height))) {
-      fullscreen_button_pressed_ = !fullscreen_button_pressed_;
-      props->fullscreen_button_label_ =
-          fullscreen_button_pressed_
-              ? localization::exit_fullscreen[localization_language_index_]
-              : localization::fullscreen[localization_language_index_];
-
-      if (fullscreen_button_pressed_) {
-        SDL_SetWindowFullscreen(stream_window_, true);
-      } else {
-        SDL_SetWindowFullscreen(stream_window_, false);
-      }
-      props->reset_control_bar_pos_ = true;
-    }
-    const std::string fullscreen_tooltip =
-        fullscreen_button_pressed_
-            ? localization::exit_fullscreen[localization_language_index_]
-            : localization::fullscreen[localization_language_index_];
-    ShowControlBarTooltip(fullscreen_tooltip);
-
-    ImGui::SameLine();
-    // close button
-    std::string close_button = ICON_FA_XMARK;
-    ImGui::SetWindowFontScale(0.5f);
-    if (ImGui::Button(close_button.c_str(),
-                      ImVec2(button_width, button_height))) {
-      CloseRemoteSession(props);
-    }
-    ShowControlBarTooltip(
-        localization::disconnect[localization_language_index_]);
-
-    ImGui::SameLine();
-
-    if (props->is_control_bar_in_left_) {
-      draw_list->AddLine(
-          ImVec2(ImGui::GetCursorScreenPos().x + button_height * 0.13f,
-                 ImGui::GetCursorScreenPos().y + button_height * 0.2f),
-          ImVec2(ImGui::GetCursorScreenPos().x + button_height * 0.13f,
-                 ImGui::GetCursorScreenPos().y + button_height * 0.8f),
-          IM_COL32(178, 178, 178, 255), 2.0f);
-    }
-
-    ImGui::SameLine();
-  }
-
-  float expand_button_pos_x = props->control_bar_expand_
-                                  ? (props->is_control_bar_in_left_
-                                         ? props->control_window_width_ * 0.917f
-                                         : props->control_window_width_ * 0.03f)
-                                  : props->control_window_width_ * 0.11f;
-
-  ImGui::SetCursorPosX(expand_button_pos_x);
-
-  std::string control_bar =
-      props->control_bar_expand_
-          ? (props->is_control_bar_in_left_ ? ICON_FA_ANGLE_LEFT
-                                            : ICON_FA_ANGLE_RIGHT)
-          : (props->is_control_bar_in_left_ ? ICON_FA_ANGLE_RIGHT
-                                            : ICON_FA_ANGLE_LEFT);
-  const std::string control_bar_tooltip =
-      props->control_bar_expand_
-          ? localization::collapse_control_bar[localization_language_index_]
-          : localization::expand_control_bar[localization_language_index_];
-  if (ImGui::Button(control_bar.c_str(),
-                    ImVec2(button_height * 0.6f, button_height))) {
-    props->control_bar_expand_ = !props->control_bar_expand_;
-    props->control_bar_button_pressed_time_ = ImGui::GetTime();
-    props->control_window_width_is_changing_ = true;
-
-    if (!props->control_bar_expand_) {
-      props->control_window_height_ = props->control_window_min_height_;
-      props->net_traffic_stats_button_pressed_ = false;
-    }
-  }
-  ShowControlBarTooltip(control_bar_tooltip);
-
-  if (props->net_traffic_stats_button_pressed_ && props->control_bar_expand_) {
-    NetTrafficStats(props);
-  }
-
-  ImGui::PopStyleVar();
-
-  return 0;
-}
-
-int GuiApplication::NetTrafficStats(
-    std::shared_ptr<RemoteSession> &props) {
-  ImGui::SetCursorPos(ImVec2(props->control_window_width_ * 0.048f,
-                             props->control_window_min_height_));
-  ImGui::SetWindowFontScale(0.5f);
-  if (ImGui::BeginTable("NetTrafficStats", 4, ImGuiTableFlags_BordersH,
-                        ImVec2(props->control_window_max_width_ * 0.9f,
-                               props->control_window_max_height_ - 0.9f))) {
-    ImGui::TableSetupColumn("", ImGuiTableColumnFlags_WidthFixed);
-    ImGui::TableSetupColumn("", ImGuiTableColumnFlags_WidthStretch);
-    ImGui::TableSetupColumn("", ImGuiTableColumnFlags_WidthStretch);
-    ImGui::TableSetupColumn("", ImGuiTableColumnFlags_WidthFixed);
-
-    ImGui::TableNextColumn();
-    ImGui::Text(" ");
-    ImGui::TableNextColumn();
-    ImGui::Text("%s", localization::in[localization_language_index_].c_str());
-    ImGui::TableNextColumn();
-    ImGui::Text("%s", localization::out[localization_language_index_].c_str());
-    ImGui::TableNextColumn();
-    ImGui::Text("%s",
-                localization::loss_rate[localization_language_index_].c_str());
-
-    ImGui::TableNextColumn();
-    ImGui::Text("%s",
-                localization::video[localization_language_index_].c_str());
-    ImGui::TableNextColumn();
-    BitrateDisplay((int)props->net_traffic_stats_.video_inbound_stats.bitrate);
-    ImGui::TableNextColumn();
-    BitrateDisplay((int)props->net_traffic_stats_.video_outbound_stats.bitrate);
-    ImGui::TableNextColumn();
-    LossRateDisplay(props->net_traffic_stats_.video_inbound_stats.loss_rate);
-
-    ImGui::TableNextColumn();
-    ImGui::Text("%s",
-                localization::audio[localization_language_index_].c_str());
-    ImGui::TableNextColumn();
-    BitrateDisplay((int)props->net_traffic_stats_.audio_inbound_stats.bitrate);
-    ImGui::TableNextColumn();
-    BitrateDisplay((int)props->net_traffic_stats_.audio_outbound_stats.bitrate);
-    ImGui::TableNextColumn();
-    LossRateDisplay(props->net_traffic_stats_.audio_inbound_stats.loss_rate);
-
-    ImGui::TableNextColumn();
-    ImGui::Text("%s", localization::data[localization_language_index_].c_str());
-    ImGui::TableNextColumn();
-    BitrateDisplay((int)props->net_traffic_stats_.data_inbound_stats.bitrate);
-    ImGui::TableNextColumn();
-    BitrateDisplay((int)props->net_traffic_stats_.data_outbound_stats.bitrate);
-    ImGui::TableNextColumn();
-    LossRateDisplay(props->net_traffic_stats_.data_inbound_stats.loss_rate);
-
-    ImGui::TableNextColumn();
-    ImGui::Text("%s",
-                localization::total[localization_language_index_].c_str());
-    ImGui::TableNextColumn();
-    BitrateDisplay((int)props->net_traffic_stats_.total_inbound_stats.bitrate);
-    ImGui::TableNextColumn();
-    BitrateDisplay((int)props->net_traffic_stats_.total_outbound_stats.bitrate);
-    ImGui::TableNextColumn();
-    LossRateDisplay(props->net_traffic_stats_.total_inbound_stats.loss_rate);
-
-    ImGui::TableNextColumn();
-    ImGui::Text("FPS:");
-    ImGui::TableNextColumn();
-    ImGui::Text("%d", props->fps_);
-    ImGui::TableNextColumn();
-    ImGui::TableNextColumn();
-
-    ImGui::TableNextColumn();
-    ImGui::Text("%s:",
-                localization::resolution[localization_language_index_].c_str());
-    ImGui::TableNextColumn();
-    ImGui::Text("%dx%d", props->video_width_, props->video_height_);
-    ImGui::TableNextColumn();
-    ImGui::TableNextColumn();
-
-    ImGui::TableNextColumn();
-    ImGui::Text(
-        "%s:",
-        localization::connection_mode[localization_language_index_].c_str());
-    ImGui::TableNextColumn();
-    ImGui::Text(
-        "%s",
-        props->traversal_mode_ == 0
-            ? localization::connection_mode_direct[localization_language_index_]
-                  .c_str()
-            : localization::connection_mode_relay[localization_language_index_]
-                  .c_str());
-
-    ImGui::EndTable();
-  }
-  ImGui::SetWindowFontScale(1.0f);
-
-  return 0;
-}
-} // namespace crossdesk

apps/desktop/src/gui/views/toolbars/status_bar.cpp

@@ -1,56 +0,0 @@
-#include "application/gui_application.h"
-#include "layout_relative.h"
-#include "localization.h"
-
-namespace crossdesk {
-
-int GuiApplication::StatusBar() {
-  ImGuiIO &io = ImGui::GetIO();
-  float status_bar_width = io.DisplaySize.x;
-  float status_bar_height = io.DisplaySize.y * STATUS_BAR_HEIGHT;
-
-  static bool a, b, c, d, e;
-  ImGui::SetNextWindowPos(ImVec2(0, io.DisplaySize.y * (1 - STATUS_BAR_HEIGHT)),
-                          ImGuiCond_Always);
-
-  ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4(1.0f, 1.0f, 1.0f, 0.0f));
-  ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(1.0f, 1.0f, 1.0f, 0.0f));
-  ImGui::BeginChild("StatusBar", ImVec2(status_bar_width, status_bar_height),
-                    ImGuiChildFlags_Borders,
-                    ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
-                        ImGuiWindowFlags_NoBringToFrontOnFocus);
-  ImGui::PopStyleColor(2);
-
-  ImVec2 dot_pos = ImVec2(status_bar_width * 0.025f,
-                          io.DisplaySize.y * (1 - STATUS_BAR_HEIGHT * 0.5f));
-  ImDrawList *draw_list = ImGui::GetWindowDrawList();
-  draw_list->AddCircleFilled(dot_pos, status_bar_height * 0.25f,
-                             ImColor(1.0f, 1.0f, 1.0f), 100);
-  bool tls_cert_error = signal_status_ == SignalStatus::SignalTlsCertError;
-  draw_list->AddCircleFilled(
-      dot_pos, status_bar_height * 0.2f,
-      tls_cert_error ? ImColor(1.0f, 0.65f, 0.0f)
-                     : ImColor(signal_connected_ ? 0.0f : 1.0f,
-                               signal_connected_ ? 1.0f : 0.0f, 0.0f),
-      100);
-
-  ImGui::SetWindowFontScale(0.6f);
-  const char *signal_status_text =
-      tls_cert_error
-          ? localization::signal_tls_cert_error[localization_language_index_]
-                .c_str()
-          : (signal_connected_
-                 ? localization::signal_connected[localization_language_index_]
-                       .c_str()
-                 : localization::signal_disconnected
-                       [localization_language_index_]
-                           .c_str());
-  draw_list->AddText(ImVec2(status_bar_width * 0.045f,
-                            io.DisplaySize.y * (1 - STATUS_BAR_HEIGHT * 0.9f)),
-                     ImColor(0.0f, 0.0f, 0.0f), signal_status_text);
-  ImGui::SetWindowFontScale(1.0f);
-
-  ImGui::EndChild();
-  return 0;
-}
-} // namespace crossdesk

apps/desktop/src/gui/views/toolbars/title_bar.cpp

@@ -1,329 +0,0 @@
-#include "application/gui_application.h"
-#include "layout_relative.h"
-#include "localization.h"
-#include "rd_log.h"
-#include "rounded_corner_button.h"
-
-constexpr double kNewVersionIconBlinkIntervalSec = 2.0;
-constexpr double kNewVersionIconBlinkOnTimeSec = 1.0;
-
-namespace crossdesk {
-
-int GuiApplication::TitleBar(bool main_window) {
-  ImGuiIO &io = ImGui::GetIO();
-  float title_bar_width = title_bar_width_;
-  float title_bar_height = title_bar_height_;
-  float title_bar_height_padding = title_bar_height_;
-  float title_bar_button_width = title_bar_button_width_;
-  float title_bar_button_height = title_bar_button_height_;
-  if (main_window) {
-    // When the main window is minimized, Dear ImGui may report DisplaySize as
-    // (0, 0). Do not overwrite shared title-bar metrics with zeros, otherwise
-    // stream/server windows (which reuse these metrics) will lose their title
-    // bars and appear collapsed.
-    if (io.DisplaySize.x > 0.0f && io.DisplaySize.y > 0.0f) {
-      title_bar_width = io.DisplaySize.x;
-      title_bar_height = io.DisplaySize.y * TITLE_BAR_HEIGHT;
-      title_bar_height_padding = io.DisplaySize.y * TITLE_BAR_HEIGHT;
-      title_bar_button_width = io.DisplaySize.x * TITLE_BAR_BUTTON_WIDTH;
-      title_bar_button_height = io.DisplaySize.y * TITLE_BAR_BUTTON_HEIGHT;
-
-      title_bar_height_ = title_bar_height;
-      title_bar_button_width_ = title_bar_button_width;
-      title_bar_button_height_ = title_bar_button_height;
-    } else {
-      // Keep using last known good values.
-      title_bar_width = title_bar_width_;
-      title_bar_height = title_bar_height_;
-      title_bar_height_padding = title_bar_height_;
-      title_bar_button_width = title_bar_button_width_;
-      title_bar_button_height = title_bar_button_height_;
-    }
-  } else {
-    title_bar_width = io.DisplaySize.x;
-    title_bar_height = title_bar_button_height_;
-    title_bar_button_width = title_bar_button_width_;
-    title_bar_button_height = title_bar_button_height_;
-  }
-
-  ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4(1.0f, 1.0f, 1.0f, 0.0f));
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0));
-  ImGui::SetNextWindowPos(ImVec2(0, 0), ImGuiCond_Always);
-  ImGui::BeginChild(main_window ? "MainTitleBar" : "StreamTitleBar",
-                    ImVec2(title_bar_width, title_bar_height_padding),
-                    ImGuiChildFlags_Borders,
-                    ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
-                        ImGuiWindowFlags_NoBringToFrontOnFocus);
-  ImGui::PopStyleVar();
-  ImGui::PopStyleColor();
-
-  // get draw list
-  ImDrawList *draw_list = ImGui::GetWindowDrawList();
-
-  ImGui::SetCursorPos(
-      ImVec2(title_bar_width - title_bar_button_width * 3, 0.0f));
-  if (main_window) {
-    float bar_pos_x = title_bar_width - title_bar_button_width * 3 +
-                      title_bar_button_width * 0.33f;
-    float bar_pos_y = title_bar_button_height * 0.5f;
-
-    // draw menu icon
-    float menu_bar_line_size = title_bar_button_width * 0.33f;
-    draw_list->AddLine(
-        ImVec2(bar_pos_x, bar_pos_y - title_bar_button_height * 0.15f),
-        ImVec2(bar_pos_x + menu_bar_line_size,
-               bar_pos_y - title_bar_button_height * 0.15f),
-        IM_COL32(0, 0, 0, 255));
-    draw_list->AddLine(ImVec2(bar_pos_x, bar_pos_y),
-                       ImVec2(bar_pos_x + menu_bar_line_size, bar_pos_y),
-                       IM_COL32(0, 0, 0, 255));
-    draw_list->AddLine(
-        ImVec2(bar_pos_x, bar_pos_y + title_bar_button_height * 0.15f),
-        ImVec2(bar_pos_x + menu_bar_line_size,
-               bar_pos_y + title_bar_button_height * 0.15f),
-        IM_COL32(0, 0, 0, 255));
-
-    std::string title_bar_menu_button = "##title_bar_menu"; // ICON_FA_BARS;
-    std::string title_bar_menu = "##title_bar_menu";
-
-    ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0, 0, 0, 0));
-    ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0, 0, 0, 0.1f));
-    ImGui::PushStyleColor(ImGuiCol_ButtonActive,
-                          ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
-    if (ImGui::Button(
-            title_bar_menu_button.c_str(),
-            ImVec2(title_bar_button_width, title_bar_button_height))) {
-      ImGui::OpenPopup(title_bar_menu.c_str());
-    }
-    ImGui::PopStyleColor(3);
-
-    if (ImGui::BeginPopup(title_bar_menu.c_str())) {
-      ImGui::SetWindowFontScale(0.6f);
-      if (ImGui::MenuItem(
-              localization::settings[localization_language_index_].c_str())) {
-        show_settings_window_ = true;
-      }
-
-      show_new_version_icon_in_menu_ = false;
-
-      std::string about_str = localization::about[localization_language_index_];
-      if (update_available_) {
-        const double now_time = ImGui::GetTime();
-
-        // every 2 seconds
-        if (now_time - new_version_icon_last_trigger_time_ >=
-            kNewVersionIconBlinkIntervalSec) {
-          show_new_version_icon_ = true;
-          new_version_icon_render_start_time_ = now_time;
-          new_version_icon_last_trigger_time_ = now_time;
-        }
-
-        // render for 1 second
-        if (show_new_version_icon_) {
-          about_str = about_str + " " + ICON_FA_CIRCLE_ARROW_UP;
-          if (now_time - new_version_icon_render_start_time_ >=
-              kNewVersionIconBlinkOnTimeSec) {
-            show_new_version_icon_ = false;
-          }
-        } else {
-          about_str = about_str + "      ";
-        }
-      }
-
-      if (ImGui::MenuItem(about_str.c_str())) {
-        show_about_window_ = true;
-      }
-
-      if (update_available_ && ImGui::IsItemHovered()) {
-        ImGui::BeginTooltip();
-        ImGui::SetWindowFontScale(0.5f);
-        std::string new_version_available_str =
-            localization::new_version_available[localization_language_index_] +
-            ": " + latest_version_;
-        ImGui::Text("%s", new_version_available_str.c_str());
-        ImGui::SetWindowFontScale(1.0f);
-        ImGui::EndTooltip();
-      }
-
-      ImGui::EndPopup();
-    } else {
-      show_new_version_icon_in_menu_ = true;
-    }
-
-    if (update_available_ && show_new_version_icon_in_menu_) {
-      const double now_time = ImGui::GetTime();
-
-      // every 2 seconds
-      if (now_time - new_version_icon_last_trigger_time_ >=
-          kNewVersionIconBlinkIntervalSec) {
-        show_new_version_icon_ = true;
-        new_version_icon_render_start_time_ = now_time;
-        new_version_icon_last_trigger_time_ = now_time;
-      }
-
-      // render for 1 second
-      if (show_new_version_icon_) {
-        ImGui::SetWindowFontScale(0.6f);
-        ImGui::SetCursorPos(ImVec2(bar_pos_x + title_bar_button_width * 0.21f,
-                                   bar_pos_y - title_bar_button_width * 0.24f));
-        ImGui::Text(ICON_FA_CIRCLE_ARROW_UP);
-        ImGui::SetWindowFontScale(1.0f);
-
-        if (now_time - new_version_icon_render_start_time_ >=
-            kNewVersionIconBlinkOnTimeSec) {
-          show_new_version_icon_ = false;
-        }
-      }
-    }
-
-    {
-      SettingWindow();
-      SelfHostedServerWindow();
-      AboutWindow();
-    }
-  } else {
-    ImGui::SetWindowFontScale(1.2f);
-  }
-
-  ImGui::SetCursorPos(ImVec2(
-      title_bar_width - title_bar_button_width * (main_window ? 2 : 3), 0.0f));
-  ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0, 0, 0, 0));
-  ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0, 0, 0, 0.1f));
-  ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
-
-  float minimize_pos_x = title_bar_width -
-                         title_bar_button_width * (main_window ? 2 : 3) +
-                         title_bar_button_width * 0.33f;
-  float minimize_pos_y = title_bar_button_height * 0.5f;
-  std::string window_minimize_button = "##minimize"; // ICON_FA_MINUS;
-  if (ImGui::Button(window_minimize_button.c_str(),
-                    ImVec2(title_bar_button_width, title_bar_button_height))) {
-    if (main_window) {
-      last_main_minimize_request_tick_ = SDL_GetTicks();
-    } else {
-      last_stream_minimize_request_tick_ = SDL_GetTicks();
-    }
-    SDL_MinimizeWindow(main_window ? main_window_ : stream_window_);
-  }
-  draw_list->AddLine(
-      ImVec2(minimize_pos_x, minimize_pos_y),
-      ImVec2(minimize_pos_x + title_bar_button_width * 0.33f, minimize_pos_y),
-      IM_COL32(0, 0, 0, 255));
-  ImGui::PopStyleColor(3);
-
-  if (!main_window) {
-    ImGui::SetCursorPos(
-        ImVec2(title_bar_width - title_bar_button_width * 2, 0.0f));
-    ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0, 0, 0, 0));
-    ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0, 0, 0, 0.1f));
-    ImGui::PushStyleColor(ImGuiCol_ButtonActive,
-                          ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
-
-    if (window_maximized_) {
-      float pos_x_top = title_bar_width - title_bar_button_width * 1.65f;
-      float pos_y_top = title_bar_button_height * 0.36f;
-      float pos_x_bottom = title_bar_width - title_bar_button_width * 1.6f;
-      float pos_y_bottom = title_bar_button_height * 0.28f;
-      std::string window_restore_button =
-          "##restore"; // ICON_FA_WINDOW_RESTORE;
-      if (ImGui::Button(
-              window_restore_button.c_str(),
-              ImVec2(title_bar_button_width, title_bar_button_height))) {
-        SDL_RestoreWindow(stream_window_);
-        window_maximized_ = false;
-      }
-      draw_list->AddRect(ImVec2(pos_x_top, pos_y_top),
-                         ImVec2(pos_x_top + title_bar_button_height * 0.33f,
-                                pos_y_top + title_bar_button_height * 0.33f),
-                         IM_COL32(0, 0, 0, 255));
-      draw_list->AddRect(ImVec2(pos_x_bottom, pos_y_bottom),
-                         ImVec2(pos_x_bottom + title_bar_button_height * 0.33f,
-                                pos_y_bottom + title_bar_button_height * 0.33f),
-                         IM_COL32(0, 0, 0, 255));
-      if (ImGui::IsItemHovered()) {
-        draw_list->AddRectFilled(
-            ImVec2(pos_x_top + title_bar_button_height * 0.02f,
-                   pos_y_top + title_bar_button_height * 0.01f),
-            ImVec2(pos_x_top + title_bar_button_height * 0.32f,
-                   pos_y_top + title_bar_button_height * 0.31f),
-            IM_COL32(229, 229, 229, 255));
-      } else {
-        draw_list->AddRectFilled(
-            ImVec2(pos_x_top + title_bar_button_height * 0.02f,
-                   pos_y_top + title_bar_button_height * 0.01f),
-            ImVec2(pos_x_top + title_bar_button_height * 0.32f,
-                   pos_y_top + title_bar_button_height * 0.31f),
-            IM_COL32(255, 255, 255, 255));
-      }
-    } else {
-      float maximize_pos_x = title_bar_width - title_bar_button_width * 1.5f -
-                             title_bar_button_height * 0.165f;
-      float maximize_pos_y = title_bar_button_height * 0.33f;
-      std::string window_maximize_button = "##maximize"; // ICON_FA_SQUARE_FULL;
-      if (ImGui::Button(
-              window_maximize_button.c_str(),
-              ImVec2(title_bar_button_width, title_bar_button_height))) {
-        SDL_MaximizeWindow(stream_window_);
-        window_maximized_ = !window_maximized_;
-      }
-      draw_list->AddRect(
-          ImVec2(maximize_pos_x, maximize_pos_y),
-          ImVec2(maximize_pos_x + title_bar_button_height * 0.33f,
-                 maximize_pos_y + title_bar_button_height * 0.33f),
-          IM_COL32(0, 0, 0, 255));
-    }
-    ImGui::PopStyleColor(3);
-  }
-
-  float xmark_button_pos_x = title_bar_width - title_bar_button_width;
-  ImGui::SetCursorPos(ImVec2(xmark_button_pos_x, 0.0f));
-  ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0, 0, 0, 0));
-  ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(1.0f, 0, 0, 1.0f));
-  ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(1.0f, 0, 0, 0.5f));
-
-  float xmark_pos_x = xmark_button_pos_x + title_bar_button_width * 0.5f;
-  float xmark_pos_y = title_bar_button_height * 0.5f;
-  float xmark_size = title_bar_button_width * 0.33f;
-  std::string close_button = "##xmark"; // ICON_FA_XMARK;
-  bool close_button_clicked = false;
-  if (main_window) {
-    close_button_clicked = RoundedCornerButton(
-        close_button.c_str(),
-        ImVec2(title_bar_button_width, title_bar_button_height), 8.5f,
-        ImDrawFlags_RoundCornersTopRight, true, IM_COL32(0, 0, 0, 0),
-        IM_COL32(250, 0, 0, 255), IM_COL32(255, 0, 0, 128));
-  } else {
-    close_button_clicked =
-        ImGui::Button(close_button.c_str(),
-                      ImVec2(title_bar_button_width, title_bar_button_height));
-  }
-
-  if (close_button_clicked) {
-    if (main_window) {
-      if (!MinimizeMainWindowToTray()) {
-        SDL_HideWindow(main_window_);
-      }
-    } else {
-      SDL_Event event;
-      event.type = SDL_EVENT_QUIT;
-      SDL_PushEvent(&event);
-    }
-  }
-
-  draw_list->AddLine(ImVec2(xmark_pos_x - xmark_size / 2 - 0.25f,
-                            xmark_pos_y - xmark_size / 2 + 0.75f),
-                     ImVec2(xmark_pos_x + xmark_size / 2 - 1.5f,
-                            xmark_pos_y + xmark_size / 2 - 0.5f),
-                     IM_COL32(0, 0, 0, 255));
-  draw_list->AddLine(
-      ImVec2(xmark_pos_x + xmark_size / 2 - 1.75f,
-             xmark_pos_y - xmark_size / 2 + 0.75f),
-      ImVec2(xmark_pos_x - xmark_size / 2, xmark_pos_y + xmark_size / 2 - 1.0f),
-      IM_COL32(0, 0, 0, 255));
-
-  ImGui::PopStyleColor(3);
-
-  ImGui::EndChild();
-  return 0;
-}
-} // namespace crossdesk

apps/desktop/src/gui/views/windows/about_window.cpp

@@ -1,148 +0,0 @@
-#include <cstdlib>
-#include <string>
-
-#if defined(_WIN32)
-#include <windows.h>
-#endif
-
-#include "application/gui_application.h"
-#include "layout.h"
-#include "localization.h"
-#include "rd_log.h"
-
-namespace crossdesk {
-
-bool GuiApplication::OpenUrl(const std::string &url) {
-#if defined(_WIN32)
-  int wide_len = MultiByteToWideChar(CP_UTF8, 0, url.c_str(), -1, nullptr, 0);
-  if (wide_len <= 0) {
-    return false;
-  }
-
-  std::wstring wide_url(static_cast<size_t>(wide_len), L'\0');
-  MultiByteToWideChar(CP_UTF8, 0, url.c_str(), -1, &wide_url[0], wide_len);
-  if (!wide_url.empty() && wide_url.back() == L'\0') {
-    wide_url.pop_back();
-  }
-
-  std::wstring cmd = L"cmd.exe /c start \"\" \"" + wide_url + L"\"";
-  STARTUPINFOW startup_info = {sizeof(startup_info)};
-  PROCESS_INFORMATION process_info = {};
-  if (!CreateProcessW(nullptr, &cmd[0], nullptr, nullptr, FALSE,
-                      CREATE_NO_WINDOW, nullptr, nullptr, &startup_info,
-                      &process_info)) {
-    return false;
-  }
-
-  CloseHandle(process_info.hThread);
-  CloseHandle(process_info.hProcess);
-  return true;
-#elif defined(__APPLE__)
-  std::string cmd = "open " + url;
-  return system(cmd.c_str()) == 0;
-#else
-  std::string cmd = "xdg-open " + url;
-  return system(cmd.c_str()) == 0;
-#endif
-}
-
-void GuiApplication::Hyperlink(const std::string &label, const std::string &url,
-                               const float window_width) {
-  ImGui::PushStyleColor(ImGuiCol_Text, IM_COL32(0, 0, 255, 255));
-  ImGui::TextUnformatted(label.c_str());
-  ImGui::PopStyleColor();
-
-  if (ImGui::IsItemHovered()) {
-    ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
-    ImGui::BeginTooltip();
-    ImGui::SetWindowFontScale(0.6f);
-    ImGui::TextUnformatted(url.c_str());
-    ImGui::SetWindowFontScale(1.0f);
-    ImGui::EndTooltip();
-    if (ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
-      OpenUrl(url);
-    }
-  }
-}
-
-int GuiApplication::AboutWindow() {
-  if (show_about_window_) {
-    float about_window_width = title_bar_button_width_ * 7.5f;
-    float about_window_height = latest_version_.empty()
-                                    ? title_bar_button_width_ * 4.0f
-                                    : title_bar_button_width_ * 4.9f;
-
-    const ImGuiViewport *viewport = ImGui::GetMainViewport();
-    ImGui::SetNextWindowPos(ImVec2(
-        (viewport->WorkSize.x - viewport->WorkPos.x - about_window_width) / 2,
-        (viewport->WorkSize.y - viewport->WorkPos.y - about_window_height) /
-            2));
-
-    ImGui::SetNextWindowSize(ImVec2(about_window_width, about_window_height));
-
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 1.0f);
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, window_rounding_);
-    ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, window_rounding_ * 0.5f);
-    ImGui::SetWindowFontScale(0.5f);
-    ImGui::Begin(
-        localization::about[localization_language_index_].c_str(), nullptr,
-        ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse |
-            ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings);
-    ImGui::SetWindowFontScale(1.0f);
-    ImGui::SetWindowFontScale(0.5f);
-
-    std::string version;
-#ifdef CROSSDESK_VERSION
-    version = CROSSDESK_VERSION;
-#else
-    version = "Unknown";
-#endif
-
-    std::string text = localization::version[localization_language_index_] +
-                       ": CrossDesk " + version;
-    ImGui::SetCursorPosX(about_window_width * 0.1f);
-    ImGui::Text("%s", text.c_str());
-
-    if (update_available_ && show_new_version_icon_in_menu_) {
-      std::string new_version_available =
-          localization::new_version_available[localization_language_index_] +
-          ": ";
-      ImGui::SetCursorPosX(about_window_width * 0.1f);
-      ImGui::Text("%s", new_version_available.c_str());
-      std::string access_website =
-          localization::access_website[localization_language_index_];
-      ImGui::SetCursorPosX((about_window_width -
-                            ImGui::CalcTextSize(latest_version_.c_str()).x) /
-                           2.0f);
-      Hyperlink(latest_version_, "https://crossdesk.cn", about_window_width);
-
-      ImGui::Spacing();
-    } else {
-      ImGui::Text("%s", "");
-    }
-
-    std::string copyright_text = "© 2025 by JUNKUN DI. All rights reserved.";
-    std::string license_text = "Licensed under GNU GPL v3.";
-    ImGui::SetCursorPosX(about_window_width * 0.1f);
-    ImGui::Text("%s", copyright_text.c_str());
-    ImGui::SetCursorPosX(about_window_width * 0.1f);
-    ImGui::Text("%s", license_text.c_str());
-
-    ImGui::SetCursorPosX(about_window_width * 0.445f);
-    ImGui::SetCursorPosY(about_window_height * 0.8f);
-    // OK
-    if (ImGui::Button(localization::ok[localization_language_index_].c_str())) {
-      show_about_window_ = false;
-    }
-
-    ImGui::SetWindowFontScale(1.0f);
-    ImGui::SetWindowFontScale(0.5f);
-    ImGui::End();
-    ImGui::SetWindowFontScale(1.0f);
-    ImGui::PopStyleVar(3);
-    ImGui::PopStyleColor();
-  }
-  return 0;
-}
-} // namespace crossdesk

apps/desktop/src/gui/views/windows/connection_status_window.cpp

@@ -1,209 +0,0 @@
-#include "application/gui_application.h"
-#include "layout.h"
-#include "localization.h"
-#include "rd_log.h"
-
-namespace crossdesk {
-
-bool GuiApplication::ConnectionStatusWindow(
-    std::shared_ptr<RemoteSession> &props) {
-  ImGuiIO &io = ImGui::GetIO();
-  bool ret_flag = false;
-
-  ImGui::SetNextWindowPos(
-      ImVec2(io.DisplaySize.x * 0.33f, io.DisplaySize.y * 0.33f));
-  ImGui::SetNextWindowSize(
-      ImVec2(io.DisplaySize.x * 0.33f, io.DisplaySize.y * 0.33f));
-
-  ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, window_rounding_ * 0.5f);
-  ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 1.0f);
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, window_rounding_);
-
-  ImGui::Begin("ConnectionStatusWindow", nullptr,
-               ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
-                   ImGuiWindowFlags_NoSavedSettings);
-  ImGui::PopStyleVar(2);
-  ImGui::PopStyleColor();
-
-  auto connection_status_window_width = ImGui::GetWindowSize().x;
-  auto connection_status_window_height = ImGui::GetWindowSize().y;
-
-  ImGui::SetWindowFontScale(0.5f);
-  std::string text;
-  const ConnectionStatus status = props->connection_status_.load();
-
-  if (ConnectionStatus::Connecting == status) {
-    text = localization::p2p_connecting[localization_language_index_];
-    ImGui::SetCursorPosX(connection_status_window_width * 0.43f);
-    ImGui::SetCursorPosY(connection_status_window_height * 0.67f);
-    // cancel
-    if (ImGui::Button(
-            localization::cancel[localization_language_index_].c_str()) ||
-        ImGui::IsKeyPressed(ImGuiKey_Escape)) {
-      show_connection_status_window_ = false;
-      re_enter_remote_id_ = true;
-      LOG_INFO("User cancelled connecting to [{}]", props->remote_id_);
-      if (props->peer_) {
-        LeaveConnection(props->peer_, props->remote_id_.c_str());
-      }
-      ret_flag = true;
-    }
-  } else if (ConnectionStatus::Gathering == status) {
-    text = localization::p2p_gathering[localization_language_index_];
-    ImGui::SetCursorPosX(connection_status_window_width * 0.43f);
-    ImGui::SetCursorPosY(connection_status_window_height * 0.67f);
-    // cancel
-    if (ImGui::Button(
-            localization::cancel[localization_language_index_].c_str()) ||
-        ImGui::IsKeyPressed(ImGuiKey_Escape)) {
-      show_connection_status_window_ = false;
-      re_enter_remote_id_ = true;
-      LOG_INFO("User cancelled connecting to [{}]", props->remote_id_);
-      if (props->peer_) {
-        LeaveConnection(props->peer_, props->remote_id_.c_str());
-      }
-      ret_flag = true;
-    }
-  } else if (ConnectionStatus::Connected == status) {
-    text = localization::p2p_connected[localization_language_index_];
-    ImGui::SetCursorPosX(connection_status_window_width * 0.43f);
-    ImGui::SetCursorPosY(connection_status_window_height * 0.67f);
-    // ok
-    if (ImGui::Button(localization::ok[localization_language_index_].c_str()) ||
-        ImGui::IsKeyPressed(ImGuiKey_Enter) ||
-        ImGui::IsKeyPressed(ImGuiKey_Escape)) {
-      show_connection_status_window_ = false;
-    }
-  } else if (ConnectionStatus::Disconnected == status) {
-    text = localization::p2p_disconnected[localization_language_index_];
-    ImGui::SetCursorPosX(connection_status_window_width * 0.43f);
-    ImGui::SetCursorPosY(connection_status_window_height * 0.67f);
-    // ok
-    if (ImGui::Button(localization::ok[localization_language_index_].c_str()) ||
-        ImGui::IsKeyPressed(ImGuiKey_Enter) ||
-        ImGui::IsKeyPressed(ImGuiKey_Escape)) {
-      show_connection_status_window_ = false;
-    }
-  } else if (ConnectionStatus::Failed == status) {
-    text = localization::p2p_failed[localization_language_index_];
-    ImGui::SetCursorPosX(connection_status_window_width * 0.43f);
-    ImGui::SetCursorPosY(connection_status_window_height * 0.67f);
-    // ok
-    if (ImGui::Button(localization::ok[localization_language_index_].c_str()) ||
-        ImGui::IsKeyPressed(ImGuiKey_Enter) ||
-        ImGui::IsKeyPressed(ImGuiKey_Escape)) {
-      show_connection_status_window_ = false;
-    }
-  } else if (ConnectionStatus::Closed == status) {
-    text = localization::p2p_closed[localization_language_index_];
-    ImGui::SetCursorPosX(connection_status_window_width * 0.43f);
-    ImGui::SetCursorPosY(connection_status_window_height * 0.67f);
-    // ok
-    if (ImGui::Button(localization::ok[localization_language_index_].c_str()) ||
-        ImGui::IsKeyPressed(ImGuiKey_Enter) ||
-        ImGui::IsKeyPressed(ImGuiKey_Escape)) {
-      show_connection_status_window_ = false;
-    }
-  } else if (ConnectionStatus::IncorrectPassword == status) {
-    if (!password_validating_) {
-      if (password_validating_time_ == 1) {
-        text = localization::input_password[localization_language_index_];
-      } else {
-        text = localization::reinput_password[localization_language_index_];
-      }
-
-      ImGui::SetCursorPosX(connection_status_window_width * 0.336f);
-      ImGui::SetCursorPosY(connection_status_window_height * 0.4f);
-      ImGui::SetNextItemWidth(connection_status_window_width * 0.33f);
-
-      ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f);
-
-      if (focus_on_input_widget_) {
-        ImGui::SetKeyboardFocusHere();
-        focus_on_input_widget_ = false;
-      }
-
-      ImGui::InputText("##password", props->remote_password_,
-                       IM_ARRAYSIZE(props->remote_password_),
-                       ImGuiInputTextFlags_CharsNoBlank);
-
-      ImGui::SetWindowFontScale(0.4f);
-
-      ImVec2 text_size = ImGui::CalcTextSize(
-          localization::remember_password[localization_language_index_]
-              .c_str());
-      ImGui::SetCursorPosX((connection_status_window_width - text_size.x) *
-                           0.45f);
-      ImGui::Checkbox(
-          localization::remember_password[localization_language_index_].c_str(),
-          &(props->remember_password_));
-      ImGui::SetWindowFontScale(0.5f);
-      ImGui::PopStyleVar();
-
-      ImGui::SetCursorPosX(connection_status_window_width * 0.325f);
-      ImGui::SetCursorPosY(connection_status_window_height * 0.75f);
-      // ok
-      if (ImGui::Button(
-              localization::ok[localization_language_index_].c_str()) ||
-          ImGui::IsKeyPressed(ImGuiKey_Enter)) {
-        show_connection_status_window_ = true;
-        password_validating_ = true;
-        props->rejoin_ = true;
-        need_to_rejoin_ = true;
-        focus_on_input_widget_ = true;
-      }
-
-      ImGui::SameLine();
-      // cancel
-      if (ImGui::Button(
-              localization::cancel[localization_language_index_].c_str()) ||
-          ImGui::IsKeyPressed(ImGuiKey_Escape)) {
-        memset(props->remote_password_, 0, sizeof(props->remote_password_));
-        show_connection_status_window_ = false;
-        focus_on_input_widget_ = true;
-      }
-    } else if (password_validating_) {
-      text = localization::validate_password[localization_language_index_];
-      ImGui::SetCursorPosX(connection_status_window_width * 0.43f);
-      ImGui::SetCursorPosY(connection_status_window_height * 0.67f);
-    }
-  } else if (ConnectionStatus::NoSuchTransmissionId == status) {
-    text = localization::no_such_id[localization_language_index_];
-    ImGui::SetCursorPosX(connection_status_window_width * 0.43f);
-    ImGui::SetCursorPosY(connection_status_window_height * 0.67f);
-    // ok
-    if (ImGui::Button(localization::ok[localization_language_index_].c_str()) ||
-        ImGui::IsKeyPressed(ImGuiKey_Enter)) {
-      show_connection_status_window_ = false;
-      re_enter_remote_id_ = true;
-      DestroyPeer(&props->peer_);
-      ret_flag = true;
-    }
-  } else if (ConnectionStatus::RemoteUnavailable == status) {
-    text = localization::device_offline[localization_language_index_];
-    ImGui::SetCursorPosX(connection_status_window_width * 0.43f);
-    ImGui::SetCursorPosY(connection_status_window_height * 0.67f);
-    // ok
-    if (ImGui::Button(localization::ok[localization_language_index_].c_str()) ||
-        ImGui::IsKeyPressed(ImGuiKey_Enter) ||
-        ImGui::IsKeyPressed(ImGuiKey_Escape)) {
-      show_connection_status_window_ = false;
-      re_enter_remote_id_ = true;
-      DestroyPeer(&props->peer_);
-      ret_flag = true;
-    }
-  }
-
-  auto text_width = ImGui::CalcTextSize(text.c_str()).x;
-  ImGui::SetCursorPosX((connection_status_window_width - text_width) * 0.5f);
-  ImGui::SetCursorPosY(connection_status_window_height * 0.2f);
-  ImGui::Text("%s", text.c_str());
-  ImGui::SetWindowFontScale(1.0f);
-
-  ImGui::End();
-  ImGui::PopStyleVar();
-
-  return ret_flag;
-}
-} // namespace crossdesk

apps/desktop/src/gui/views/windows/control_window.cpp

@@ -1,264 +0,0 @@
-#include "application/gui_application.h"
-#include "rd_log.h"
-
-namespace crossdesk {
-
-int GuiApplication::ControlWindow(
-    std::shared_ptr<RemoteSession> &props) {
-  double time_duration =
-      ImGui::GetTime() - props->control_bar_button_pressed_time_;
-  if (props->control_window_width_is_changing_) {
-    if (props->control_bar_expand_) {
-      props->control_window_width_ =
-          (float)(props->control_window_min_width_ +
-                  (props->control_window_max_width_ -
-                   props->control_window_min_width_) *
-                      4 * time_duration);
-    } else {
-      props->control_window_width_ =
-          (float)(props->control_window_max_width_ -
-                  (props->control_window_max_width_ -
-                   props->control_window_min_width_) *
-                      4 * time_duration);
-    }
-  }
-
-  time_duration =
-      ImGui::GetTime() - props->net_traffic_stats_button_pressed_time_;
-  if (props->control_window_height_is_changing_) {
-    if (props->control_bar_expand_ &&
-        props->net_traffic_stats_button_pressed_) {
-      props->control_window_height_ =
-          (float)(props->control_window_min_height_ +
-                  (props->control_window_max_height_ -
-                   props->control_window_min_height_) *
-                      4 * time_duration);
-    } else if (props->control_bar_expand_ &&
-               !props->net_traffic_stats_button_pressed_) {
-      props->control_window_height_ =
-          (float)(props->control_window_max_height_ -
-                  (props->control_window_max_height_ -
-                   props->control_window_min_height_) *
-                      4 * time_duration);
-    }
-  }
-
-  ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0, 0, 0, 0));
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, window_rounding_ * 1.5f);
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
-  ImGui::PushStyleVar(ImGuiStyleVar_ChildRounding, window_rounding_ * 1.5f);
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0));
-
-  float y_boundary = fullscreen_button_pressed_ ? 0.0f : title_bar_height_;
-  float container_x = 0.0f;
-  float container_y = y_boundary;
-  float container_w = stream_window_width_;
-  float container_h = stream_window_height_ - y_boundary;
-
-  ImGui::SetNextWindowSize(ImVec2(container_w, container_h), ImGuiCond_Always);
-  ImGui::SetNextWindowPos(ImVec2(container_x, container_y), ImGuiCond_Always);
-
-  float pos_x = 0;
-  float pos_y = 0;
-
-  std::string container_window_title =
-      props->remote_id_ + "ControlContainerWindow";
-  ImGui::Begin(container_window_title.c_str(), nullptr,
-               ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
-                   ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoDocking |
-                   ImGuiWindowFlags_NoBackground);
-  ImGui::PopStyleVar();
-
-  ImVec2 container_pos = ImGui::GetWindowPos();
-
-  if (ImGui::IsMouseDown(ImGuiMouseButton_Left) &&
-      props->control_bar_hovered_) {
-    float current_x_rel = props->control_window_pos_.x - container_pos.x;
-    float current_y_rel = props->control_window_pos_.y - container_pos.y;
-    ImVec2 delta = ImGui::GetIO().MouseDelta;
-    pos_x = current_x_rel + delta.x;
-    pos_y = current_y_rel + delta.y;
-    if (pos_x < 0.0f)
-      pos_x = 0.0f;
-    if (pos_y < 0.0f)
-      pos_y = 0.0f;
-    if (pos_x + props->control_window_width_ > container_w)
-      pos_x = container_w - props->control_window_width_;
-    if (pos_y + props->control_window_height_ > container_h)
-      pos_y = container_h - props->control_window_height_;
-  } else if (props->reset_control_bar_pos_) {
-    float new_cursor_pos_x = 0.0f;
-    float new_cursor_pos_y = 0.0f;
-
-    // set control window pos
-    float current_y_rel = props->control_window_pos_.y - container_pos.y;
-    if (current_y_rel + props->control_window_height_ > container_h) {
-      pos_y = container_h - props->control_window_height_;
-    } else if (current_y_rel < 0.0f) {
-      pos_y = 0.0f;
-    } else {
-      pos_y = current_y_rel;
-    }
-
-    if (props->is_control_bar_in_left_) {
-      pos_x = 0.0f;
-    } else {
-      pos_x = container_w - props->control_window_width_;
-    }
-
-    if (0 != props->mouse_diff_control_bar_pos_x_ &&
-        0 != props->mouse_diff_control_bar_pos_y_) {
-      // set cursor pos
-      new_cursor_pos_x =
-          container_pos.x + pos_x + props->mouse_diff_control_bar_pos_x_;
-      new_cursor_pos_y =
-          container_pos.y + pos_y + props->mouse_diff_control_bar_pos_y_;
-
-      SDL_WarpMouseInWindow(stream_window_, (int)new_cursor_pos_x,
-                            (int)new_cursor_pos_y);
-    }
-    props->reset_control_bar_pos_ = false;
-  } else if (!props->reset_control_bar_pos_ &&
-                 ImGui::IsMouseReleased(ImGuiMouseButton_Left) ||
-             props->control_window_width_is_changing_) {
-    float current_x_rel = props->control_window_pos_.x - container_pos.x;
-    float current_y_rel = props->control_window_pos_.y - container_pos.y;
-    if (current_x_rel <= container_w * 0.5f) {
-      pos_x = 0.0f;
-      if (current_y_rel + props->control_window_height_ > container_h) {
-        pos_y = container_h - props->control_window_height_;
-      } else {
-        pos_y = current_y_rel;
-      }
-
-      if (props->control_bar_expand_) {
-        if (props->control_window_width_ >= props->control_window_max_width_) {
-          props->control_window_width_ = props->control_window_max_width_;
-          props->control_window_width_is_changing_ = false;
-        } else {
-          props->control_window_width_is_changing_ = true;
-        }
-      } else {
-        if (props->control_window_width_ <= props->control_window_min_width_) {
-          props->control_window_width_ = props->control_window_min_width_;
-          props->control_window_width_is_changing_ = false;
-        } else {
-          props->control_window_width_is_changing_ = true;
-        }
-      }
-      props->is_control_bar_in_left_ = true;
-    } else if (current_x_rel > container_w * 0.5f) {
-      pos_x = container_w - props->control_window_width_;
-      pos_y = (current_y_rel >= 0.0f &&
-               current_y_rel <= container_h - props->control_window_height_)
-                  ? current_y_rel
-                  : (current_y_rel < 0.0f
-                         ? 0.0f
-                         : (container_h - props->control_window_height_));
-
-      if (props->control_bar_expand_) {
-        if (props->control_window_width_ >= props->control_window_max_width_) {
-          props->control_window_width_ = props->control_window_max_width_;
-          props->control_window_width_is_changing_ = false;
-          pos_x = container_w - props->control_window_max_width_;
-        } else {
-          props->control_window_width_is_changing_ = true;
-          pos_x = container_w - props->control_window_width_;
-        }
-      } else {
-        if (props->control_window_width_ <= props->control_window_min_width_) {
-          props->control_window_width_ = props->control_window_min_width_;
-          props->control_window_width_is_changing_ = false;
-          pos_x = container_w - props->control_window_min_width_;
-        } else {
-          props->control_window_width_is_changing_ = true;
-          pos_x = container_w - props->control_window_width_;
-        }
-      }
-      props->is_control_bar_in_left_ = false;
-    }
-
-    if (current_y_rel + props->control_window_height_ > container_h) {
-      pos_y = container_h - props->control_window_height_;
-    } else if (current_y_rel < 0.0f) {
-      pos_y = 0.0f;
-    }
-  } else {
-    float current_x_rel = props->control_window_pos_.x - container_pos.x;
-    float current_y_rel = props->control_window_pos_.y - container_pos.y;
-    pos_x = current_x_rel;
-    pos_y = current_y_rel;
-    if (pos_x < 0.0f)
-      pos_x = 0.0f;
-    if (pos_y < 0.0f)
-      pos_y = 0.0f;
-    if (pos_x + props->control_window_width_ > container_w)
-      pos_x = container_w - props->control_window_width_;
-    if (pos_y + props->control_window_height_ > container_h)
-      pos_y = container_h - props->control_window_height_;
-  }
-
-  if (props->control_bar_expand_ && props->control_window_height_is_changing_) {
-    if (props->net_traffic_stats_button_pressed_) {
-      if (props->control_window_height_ >= props->control_window_max_height_) {
-        props->control_window_height_ = props->control_window_max_height_;
-        props->control_window_height_is_changing_ = false;
-      } else {
-        props->control_window_height_is_changing_ = true;
-      }
-    } else {
-      if (props->control_window_height_ <= props->control_window_min_height_) {
-        props->control_window_height_ = props->control_window_min_height_;
-        props->control_window_height_is_changing_ = false;
-      } else {
-        props->control_window_height_is_changing_ = true;
-      }
-    }
-  }
-
-  std::string control_window_title = props->remote_id_ + "ControlWindow";
-
-  ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
-  static bool a, b, c, d, e;
-  float child_cursor_x = pos_x;
-  float child_cursor_y = pos_y;
-  ImGui::SetCursorPos(ImVec2(child_cursor_x, child_cursor_y));
-
-  std::string control_child_window_title =
-      props->remote_id_ + "ControlChildWindow";
-  ImGui::BeginChild(
-      control_child_window_title.c_str(),
-      ImVec2(props->control_window_width_, props->control_window_height_),
-      ImGuiChildFlags_Borders, ImGuiWindowFlags_NoDecoration);
-  ImGui::PopStyleColor();
-
-  props->control_window_pos_ = ImGui::GetWindowPos();
-  SDL_GetMouseState(&props->mouse_pos_x_, &props->mouse_pos_y_);
-  props->mouse_diff_control_bar_pos_x_ =
-      props->mouse_pos_x_ - props->control_window_pos_.x;
-  props->mouse_diff_control_bar_pos_y_ =
-      props->mouse_pos_y_ - props->control_window_pos_.y;
-
-  if (props->control_window_pos_.y < container_pos.y ||
-      props->control_window_pos_.y + props->control_window_height_ >
-          (container_pos.y + container_h) ||
-      props->control_window_pos_.x < container_pos.x ||
-      props->control_window_pos_.x + props->control_window_width_ >
-          (container_pos.x + container_w)) {
-    ImGui::ClearActiveID();
-    props->reset_control_bar_pos_ = true;
-    props->mouse_diff_control_bar_pos_x_ = 0;
-    props->mouse_diff_control_bar_pos_y_ = 0;
-  }
-
-  ControlBar(props);
-  props->control_bar_hovered_ = ImGui::IsWindowHovered();
-
-  ImGui::EndChild();
-  ImGui::End();
-  ImGui::PopStyleVar(3);
-  ImGui::PopStyleColor();
-
-  return 0;
-}
-} // namespace crossdesk

apps/desktop/src/gui/views/windows/file_transfer_window.cpp

@@ -1,253 +0,0 @@
-#include <algorithm>
-#include <cmath>
-
-#include "IconsFontAwesome6.h"
-#include "application/gui_application.h"
-#include "layout.h"
-#include "localization.h"
-#include "rd_log.h"
-
-namespace crossdesk {
-
-namespace {
-int CountDigits(int number) {
-  if (number == 0)
-    return 1;
-  return (int)std::floor(std::log10(std::abs(number))) + 1;
-}
-
-int BitrateDisplay(int bitrate) {
-  int num_of_digits = CountDigits(bitrate);
-  if (num_of_digits <= 3) {
-    ImGui::Text("%d bps", bitrate);
-  } else if (num_of_digits > 3 && num_of_digits <= 6) {
-    ImGui::Text("%d kbps", bitrate / 1000);
-  } else {
-    ImGui::Text("%.1f mbps", bitrate / 1000000.0f);
-  }
-  return 0;
-}
-} // namespace
-
-int GuiApplication::FileTransferWindow(
-    std::shared_ptr<RemoteSession> &props) {
-  FileTransferState *state = &transfers_.state_for(props);
-  state->file_transfer_window_hovered_ = false;
-
-  // Only show window if there are files in transfer list or currently
-  // transferring
-  std::vector<RemoteSession::FileTransferInfo> file_list;
-  {
-    std::lock_guard<std::mutex> lock(state->file_transfer_list_mutex_);
-    file_list = state->file_transfer_list_;
-  }
-
-  // Sort file list: Sending first, then Completed, then Queued, then Failed
-  std::sort(
-      file_list.begin(), file_list.end(),
-      [](const RemoteSession::FileTransferInfo &a,
-         const RemoteSession::FileTransferInfo &b) {
-        // Priority: Sending > Completed > Queued > Failed
-        auto get_priority =
-            [](RemoteSession::FileTransferStatus status) {
-              switch (status) {
-              case RemoteSession::FileTransferStatus::Sending:
-                return 0;
-              case RemoteSession::FileTransferStatus::Completed:
-                return 1;
-              case RemoteSession::FileTransferStatus::Queued:
-                return 2;
-              case RemoteSession::FileTransferStatus::Failed:
-                return 3;
-              }
-              return 3;
-            };
-        return get_priority(a.status) < get_priority(b.status);
-      });
-
-  // Only show window if file_transfer_window_visible_ is true
-  // Window can be closed by user even during transfer
-  // It will be reopened automatically when:
-  // 1. A file transfer completes (via FileTransferManager)
-  // 2. FileTransferManager starts the next queued file.
-  if (!state->file_transfer_window_visible_) {
-    return 0;
-  }
-
-  // Position window at bottom-left of stream window
-  // Adjust window size based on number of files
-  float file_transfer_window_width = main_window_width_ * 0.6f;
-  float file_transfer_window_height =
-      main_window_height_ * 0.3f; // Dynamic height
-  float pos_x = file_transfer_window_width * 0.05f;
-  float pos_y = stream_window_height_ - file_transfer_window_height -
-                file_transfer_window_width * 0.05;
-
-  const ImVec2 mouse_pos = ImGui::GetMousePos();
-  const bool mouse_in_window_rect =
-      mouse_pos.x >= pos_x &&
-      mouse_pos.x <= pos_x + file_transfer_window_width &&
-      mouse_pos.y >= pos_y &&
-      mouse_pos.y <= pos_y + file_transfer_window_height;
-
-  ImGui::SetNextWindowPos(ImVec2(pos_x, pos_y), ImGuiCond_Always);
-  ImGui::SetNextWindowSize(
-      ImVec2(file_transfer_window_width, file_transfer_window_height),
-      ImGuiCond_Always);
-  if (mouse_in_window_rect) {
-    ImGui::SetNextWindowFocus();
-  }
-
-  // Set Chinese font for proper display
-  const bool has_chinese_font = stream_windows_system_chinese_font_ != nullptr;
-  if (has_chinese_font) {
-    ImGui::PushFont(stream_windows_system_chinese_font_);
-  }
-
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, window_rounding_ * 0.5f);
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 1.0f);
-  ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(1.0f, 1.0f, 1.0f, 0.9f));
-  ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0.0f, 0.0f, 0.0f, 0.3f));
-  ImGui::PushStyleColor(ImGuiCol_TitleBg, ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
-  ImGui::PushStyleColor(ImGuiCol_TitleBgActive, ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
-
-  ImGui::SetWindowFontScale(0.5f);
-  bool window_opened = true;
-  const bool show_contents = ImGui::Begin(
-      localization::file_transfer_progress[localization_language_index_]
-          .c_str(),
-      &window_opened,
-      ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize |
-          ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings |
-          ImGuiWindowFlags_NoScrollbar);
-  ImGui::PopStyleColor(4);
-  ImGui::PopStyleVar(2);
-
-  state->file_transfer_window_hovered_ =
-      mouse_in_window_rect ||
-      ImGui::IsWindowHovered(ImGuiHoveredFlags_RootAndChildWindows);
-
-  if (!window_opened) {
-    state->file_transfer_window_visible_ = false;
-  }
-
-  if (show_contents && window_opened) {
-    ImGui::SetWindowFontScale(1.0f);
-    ImGui::SetWindowFontScale(0.5f);
-
-    // Display file list
-    if (file_list.empty()) {
-      ImGui::Text("No files in transfer queue");
-    } else {
-      // Use a scrollable child window for the file list
-      ImGui::SetWindowFontScale(0.5f);
-      ImGui::BeginChild(
-          "FileList", ImVec2(0, file_transfer_window_height * 0.75f),
-          ImGuiChildFlags_Borders, ImGuiWindowFlags_HorizontalScrollbar);
-      ImGui::SetWindowFontScale(1.0f);
-      ImGui::SetWindowFontScale(0.5f);
-
-      for (size_t i = 0; i < file_list.size(); ++i) {
-        const auto &info = file_list[i];
-        ImGui::PushID(static_cast<int>(i));
-
-        // Status icon and file name
-        const char *status_icon = "";
-        ImVec4 status_color(0.5f, 0.5f, 0.5f, 1.0f);
-        const char *status_text = "";
-
-        switch (info.status) {
-        case RemoteSession::FileTransferStatus::Queued:
-          status_icon = ICON_FA_CLOCK;
-          status_color =
-              ImVec4(0.5f, 0.6f, 0.7f, 1.0f); // Common blue-gray for queued
-          status_text =
-              localization::queued[localization_language_index_].c_str();
-          break;
-        case RemoteSession::FileTransferStatus::Sending:
-          status_icon = ICON_FA_ARROW_UP;
-          status_color = ImVec4(0.2f, 0.6f, 1.0f, 1.0f);
-          status_text =
-              localization::sending[localization_language_index_].c_str();
-          break;
-        case RemoteSession::FileTransferStatus::Completed:
-          status_icon = ICON_FA_CHECK;
-          status_color = ImVec4(0.0f, 0.8f, 0.0f, 1.0f);
-          status_text =
-              localization::completed[localization_language_index_].c_str();
-          break;
-        case RemoteSession::FileTransferStatus::Failed:
-          status_icon = ICON_FA_XMARK;
-          status_color = ImVec4(1.0f, 0.2f, 0.2f, 1.0f);
-          status_text =
-              localization::failed[localization_language_index_].c_str();
-          break;
-        }
-
-        ImGui::TextColored(status_color, "%s", status_icon);
-        ImGui::SameLine();
-        ImGui::Text("%s", info.file_name.c_str());
-        ImGui::SameLine();
-        ImGui::TextColored(status_color, "%s", status_text);
-
-        // Progress bar for sending files
-        if (info.status ==
-                RemoteSession::FileTransferStatus::Sending &&
-            info.file_size > 0) {
-          float progress = static_cast<float>(info.sent_bytes) /
-                           static_cast<float>(info.file_size);
-          progress = (std::max)(0.0f, (std::min)(1.0f, progress));
-
-          float text_height = ImGui::GetTextLineHeight();
-          ImGui::ProgressBar(
-              progress, ImVec2(file_transfer_window_width * 0.5f, text_height),
-              "");
-          ImGui::SameLine();
-
-          ImGui::Text("%.1f%%", progress * 100.0f);
-          ImGui::SameLine();
-
-          float speed_x_pos = file_transfer_window_width * 0.65f;
-          ImGui::SetCursorPosX(speed_x_pos);
-          BitrateDisplay(static_cast<int>(info.rate_bps));
-        } else if (info.status ==
-                   RemoteSession::FileTransferStatus::Completed) {
-          // Show completed size
-          char size_str[64];
-          if (info.file_size < 1024) {
-            snprintf(size_str, sizeof(size_str), "%llu B",
-                     (unsigned long long)info.file_size);
-          } else if (info.file_size < 1024 * 1024) {
-            snprintf(size_str, sizeof(size_str), "%.2f KB",
-                     info.file_size / 1024.0f);
-          } else {
-            snprintf(size_str, sizeof(size_str), "%.2f MB",
-                     info.file_size / (1024.0f * 1024.0f));
-          }
-          ImGui::Text("Size: %s", size_str);
-        }
-
-        ImGui::PopID();
-        ImGui::Spacing();
-      }
-
-      ImGui::SetWindowFontScale(1.0f);
-      ImGui::SetWindowFontScale(0.5f);
-      ImGui::EndChild();
-      ImGui::SetWindowFontScale(1.0f);
-    }
-    ImGui::SetWindowFontScale(1.0f);
-    ImGui::SetWindowFontScale(0.5f);
-  }
-
-  ImGui::End();
-  ImGui::SetWindowFontScale(1.0f);
-
-  if (has_chinese_font) {
-    ImGui::PopFont();
-  }
-
-  return 0;
-}
-
-} // namespace crossdesk

apps/desktop/src/gui/views/windows/main_settings_window.cpp

@@ -1,643 +0,0 @@
-#include "application/gui_application.h"
-#include "layout.h"
-#include "localization.h"
-#include "rd_log.h"
-#include "tinyfiledialogs.h"
-
-#if _WIN32 && CROSSDESK_PORTABLE
-#include "service_host.h"
-#endif
-
-namespace crossdesk {
-
-int GuiApplication::SettingWindow() {
-  ImGuiIO &io = ImGui::GetIO();
-  float portable_y_padding = 0.0f;
-#if _WIN32 && CROSSDESK_PORTABLE
-  portable_y_padding = 0.05f;
-#endif
-
-  if (show_settings_window_) {
-    if (settings_window_pos_reset_) {
-      const ImGuiViewport *viewport = ImGui::GetMainViewport();
-      if (ConfigCenter::LANGUAGE::CHINESE == localization_language_) {
-#if (((defined(_WIN32) || defined(__linux__)) && !defined(__aarch64__) &&      \
-      !defined(__arm__) && USE_CUDA) ||                                        \
-     defined(__APPLE__))
-        ImGui::SetNextWindowPos(
-            ImVec2(io.DisplaySize.x * 0.343f, io.DisplaySize.y * 0.05f));
-        ImGui::SetNextWindowSize(
-            ImVec2(io.DisplaySize.x * 0.315f,
-                   io.DisplaySize.y * (0.9f + portable_y_padding)));
-#else
-        ImGui::SetNextWindowPos(
-            ImVec2(io.DisplaySize.x * 0.343f, io.DisplaySize.y * 0.08f));
-        ImGui::SetNextWindowSize(
-            ImVec2(io.DisplaySize.x * 0.315f,
-                   io.DisplaySize.y * (0.85f + portable_y_padding)));
-#endif
-      } else {
-#if (((defined(_WIN32) || defined(__linux__)) && !defined(__aarch64__) &&      \
-      !defined(__arm__) && USE_CUDA) ||                                        \
-     defined(__APPLE__))
-        ImGui::SetNextWindowPos(
-            ImVec2(io.DisplaySize.x * 0.297f, io.DisplaySize.y * 0.05f));
-        ImGui::SetNextWindowSize(
-            ImVec2(io.DisplaySize.x * 0.42f,
-                   io.DisplaySize.y * (0.9f + portable_y_padding)));
-#else
-        ImGui::SetNextWindowPos(
-            ImVec2(io.DisplaySize.x * 0.297f, io.DisplaySize.y * 0.08f));
-        ImGui::SetNextWindowSize(
-            ImVec2(io.DisplaySize.x * 0.42f,
-                   io.DisplaySize.y * (0.85f + portable_y_padding)));
-#endif
-      }
-
-      settings_window_pos_reset_ = false;
-    }
-
-    // Settings
-    {
-      static int settings_items_padding = title_bar_button_width_ * 0.75f;
-      int settings_items_offset = 0;
-
-      ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
-      ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, window_rounding_);
-      ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, window_rounding_ * 0.5f);
-
-      ImGui::Begin(localization::settings[localization_language_index_].c_str(),
-                   nullptr,
-                   ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse |
-                       ImGuiWindowFlags_NoSavedSettings);
-      ImGui::SetWindowFontScale(0.5f);
-      ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f);
-      {
-        const auto &supported_languages = localization::GetSupportedLanguages();
-        language_button_value_ =
-            localization::detail::ClampLanguageIndex(language_button_value_);
-
-        settings_items_offset += settings_items_padding;
-        ImGui::SetCursorPosY(settings_items_offset);
-        ImGui::AlignTextToFramePadding();
-        ImGui::Text(
-            "%s", localization::language[localization_language_index_].c_str());
-        ImGui::SameLine();
-        if (ConfigCenter::LANGUAGE::CHINESE == localization_language_) {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 3.0f);
-        } else {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 4.7f);
-        }
-
-        ImGui::SetNextItemWidth(title_bar_button_width_ * 1.8f);
-        if (ImGui::BeginCombo("##language",
-                              localization::GetSupportedLanguages()
-                                  [localization::detail::ClampLanguageIndex(
-                                       language_button_value_)]
-                                      .display_name.c_str())) {
-          ImGui::SetWindowFontScale(0.5f);
-          for (int i = 0; i < static_cast<int>(supported_languages.size());
-               ++i) {
-            bool selected = (i == language_button_value_);
-            if (ImGui::Selectable(supported_languages[i].display_name.c_str(),
-                                  selected))
-              language_button_value_ = i;
-            if (selected) {
-              ImGui::SetItemDefaultFocus();
-            }
-          }
-
-          ImGui::EndCombo();
-        }
-      }
-
-      ImGui::Separator();
-
-      if (stream_window_inited_) {
-        ImGui::BeginDisabled();
-      }
-
-      {
-        const char *video_quality_items[] = {
-            localization::video_quality_low[localization_language_index_]
-                .c_str(),
-            localization::video_quality_medium[localization_language_index_]
-                .c_str(),
-            localization::video_quality_high[localization_language_index_]
-                .c_str()};
-
-        settings_items_offset += settings_items_padding;
-        ImGui::SetCursorPosY(settings_items_offset);
-        ImGui::AlignTextToFramePadding();
-        ImGui::Text(
-            "%s",
-            localization::video_quality[localization_language_index_].c_str());
-        ImGui::SameLine();
-        if (ConfigCenter::LANGUAGE::CHINESE == localization_language_) {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 3.0f);
-        } else {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 4.7f);
-        }
-
-        ImGui::SetNextItemWidth(title_bar_button_width_ * 1.8f);
-        if (ImGui::BeginCombo(
-                "##video_quality",
-                video_quality_items[video_quality_button_value_])) {
-          ImGui::SetWindowFontScale(0.5f);
-          for (int i = 0; i < IM_ARRAYSIZE(video_quality_items); i++) {
-            bool selected = (i == video_quality_button_value_);
-            if (ImGui::Selectable(video_quality_items[i], selected))
-              video_quality_button_value_ = i;
-          }
-
-          ImGui::EndCombo();
-        }
-      }
-
-      ImGui::Separator();
-
-      {
-        const char *video_frame_rate_items[] = {"30 fps", "60 fps"};
-
-        settings_items_offset += settings_items_padding;
-        ImGui::SetCursorPosY(settings_items_offset);
-        ImGui::AlignTextToFramePadding();
-        ImGui::Text("%s",
-                    localization::video_frame_rate[localization_language_index_]
-                        .c_str());
-        ImGui::SameLine();
-        if (ConfigCenter::LANGUAGE::CHINESE == localization_language_) {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 3.0f);
-        } else {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 4.7f);
-        }
-
-        ImGui::SetNextItemWidth(title_bar_button_width_ * 1.8f);
-        if (ImGui::BeginCombo(
-                "##video_frame_rate",
-                video_frame_rate_items[video_frame_rate_button_value_])) {
-          ImGui::SetWindowFontScale(0.5f);
-          for (int i = 0; i < IM_ARRAYSIZE(video_frame_rate_items); i++) {
-            bool selected = (i == video_frame_rate_button_value_);
-            if (ImGui::Selectable(video_frame_rate_items[i], selected))
-              video_frame_rate_button_value_ = i;
-          }
-
-          ImGui::EndCombo();
-        }
-      }
-
-      ImGui::Separator();
-
-      {
-        const char *video_encode_format_items[] = {
-            localization::h264[localization_language_index_].c_str(),
-            localization::av1[localization_language_index_].c_str()};
-
-        settings_items_offset += settings_items_padding;
-        ImGui::SetCursorPosY(settings_items_offset);
-        ImGui::AlignTextToFramePadding();
-        ImGui::Text(
-            "%s",
-            localization::video_encode_format[localization_language_index_]
-                .c_str());
-        ImGui::SameLine();
-        if (ConfigCenter::LANGUAGE::CHINESE == localization_language_) {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 3.0f);
-        } else {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 4.7f);
-        }
-
-        ImGui::SetNextItemWidth(title_bar_button_width_ * 1.8f);
-        if (ImGui::BeginCombo(
-                "##video_encode_format",
-                video_encode_format_items[video_encode_format_button_value_])) {
-          ImGui::SetWindowFontScale(0.5f);
-          for (int i = 0; i < IM_ARRAYSIZE(video_encode_format_items); i++) {
-            bool selected = (i == video_encode_format_button_value_);
-            if (ImGui::Selectable(video_encode_format_items[i], selected))
-              video_encode_format_button_value_ = i;
-          }
-
-          ImGui::EndCombo();
-        }
-      }
-
-#if (((defined(_WIN32) || defined(__linux__)) && !defined(__aarch64__) &&      \
-      !defined(__arm__) && USE_CUDA) ||                                        \
-     defined(__APPLE__))
-      ImGui::Separator();
-
-      {
-        settings_items_offset += settings_items_padding;
-        ImGui::SetCursorPosY(settings_items_offset);
-        ImGui::AlignTextToFramePadding();
-        ImGui::Text("%s", localization::enable_hardware_video_codec
-                              [localization_language_index_]
-                                  .c_str());
-        ImGui::SameLine();
-        if (ConfigCenter::LANGUAGE::CHINESE == localization_language_) {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 4.275f);
-        } else {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 5.955f);
-        }
-
-        ImGui::Checkbox("##enable_hardware_video_codec",
-                        &enable_hardware_video_codec_);
-      }
-#endif
-
-      ImGui::Separator();
-
-      {
-        settings_items_offset += settings_items_padding;
-        ImGui::SetCursorPosY(settings_items_offset);
-        ImGui::AlignTextToFramePadding();
-        ImGui::Text(
-            "%s",
-            localization::enable_turn[localization_language_index_].c_str());
-        ImGui::SameLine();
-        if (ConfigCenter::LANGUAGE::CHINESE == localization_language_) {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 4.275f);
-        } else {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 5.955f);
-        }
-
-        ImGui::Checkbox("##enable_turn", &enable_turn_);
-      }
-
-      ImGui::Separator();
-
-      {
-        settings_items_offset += settings_items_padding;
-        ImGui::SetCursorPosY(settings_items_offset + 1);
-        ImGui::AlignTextToFramePadding();
-        if (ImGui::Button(localization::self_hosted_server_config
-                              [localization_language_index_]
-                                  .c_str())) {
-          show_self_hosted_server_config_window_ = true;
-        }
-        ImGui::SameLine();
-        if (ConfigCenter::LANGUAGE::CHINESE == localization_language_) {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 4.275f);
-        } else {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 5.955f);
-        }
-
-        ImGui::Checkbox("##enable_self_hosted", &enable_self_hosted_);
-      }
-
-      ImGui::Separator();
-
-      {
-        settings_items_offset += settings_items_padding;
-        ImGui::SetCursorPosY(settings_items_offset);
-        ImGui::AlignTextToFramePadding();
-        ImGui::Text("%s",
-                    localization::enable_autostart[localization_language_index_]
-                        .c_str());
-        ImGui::SameLine();
-        if (ConfigCenter::LANGUAGE::CHINESE == localization_language_) {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 4.275f);
-        } else {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 5.955f);
-        }
-
-        ImGui::Checkbox("##enable_autostart_", &enable_autostart_);
-      }
-
-      ImGui::Separator();
-
-      {
-        settings_items_offset += settings_items_padding;
-        ImGui::SetCursorPosY(settings_items_offset);
-        ImGui::AlignTextToFramePadding();
-        ImGui::Text(
-            "%s",
-            localization::enable_daemon[localization_language_index_].c_str());
-        ImGui::SameLine();
-        if (ConfigCenter::LANGUAGE::CHINESE == localization_language_) {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 4.275f);
-        } else {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 5.955f);
-        }
-
-        ImGui::Checkbox("##enable_daemon_", &enable_daemon_);
-        if (ImGui::IsItemHovered()) {
-          ImGui::BeginTooltip();
-          ImGui::SetWindowFontScale(0.5f);
-          ImGui::Text("%s", localization::takes_effect_after_restart
-                                [localization_language_index_]
-                                    .c_str());
-          ImGui::SetWindowFontScale(1.0f);
-          ImGui::EndTooltip();
-        }
-      }
-
-      ImGui::Separator();
-
-      {
-        settings_items_offset += settings_items_padding;
-        ImGui::SetCursorPosY(settings_items_offset);
-        ImGui::AlignTextToFramePadding();
-        ImGui::Text(
-            "%s",
-            localization::file_transfer_save_path[localization_language_index_]
-                .c_str());
-        ImGui::SameLine();
-        if (ConfigCenter::LANGUAGE::CHINESE == localization_language_) {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 2.82f);
-        } else {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 4.5f);
-        }
-
-        std::string display_path =
-            strlen(file_transfer_save_path_buf_) > 0
-                ? file_transfer_save_path_buf_
-                : localization::default_desktop[localization_language_index_];
-        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
-        ImGui::PushStyleColor(ImGuiCol_ButtonHovered,
-                              ImVec4(0.95f, 0.95f, 0.95f, 1.0f));
-        ImGui::PushStyleColor(ImGuiCol_ButtonActive,
-                              ImVec4(0.9f, 0.9f, 0.9f, 1.0f));
-        ImGui::PushFont(main_windows_system_chinese_font_);
-        if (ImGui::Button(display_path.c_str(),
-                          ImVec2(title_bar_button_width_ * 2.0f, 0))) {
-          const char *folder =
-              tinyfd_selectFolderDialog(localization::file_transfer_save_path
-                                            [localization_language_index_]
-                                                .c_str(),
-                                        strlen(file_transfer_save_path_buf_) > 0
-                                            ? file_transfer_save_path_buf_
-                                            : nullptr);
-          if (folder) {
-            strncpy(file_transfer_save_path_buf_, folder,
-                    sizeof(file_transfer_save_path_buf_) - 1);
-            file_transfer_save_path_buf_[sizeof(file_transfer_save_path_buf_) -
-                                         1] = '\0';
-          }
-        }
-        if (ImGui::IsItemHovered() &&
-            strlen(file_transfer_save_path_buf_) > 0) {
-          ImGui::BeginTooltip();
-          ImGui::SetWindowFontScale(0.5f);
-          ImGui::Text("%s", file_transfer_save_path_buf_);
-          ImGui::SetWindowFontScale(1.0f);
-          ImGui::EndTooltip();
-        }
-        ImGui::PopFont();
-        ImGui::PopStyleColor(3);
-      }
-
-      if (stream_window_inited_) {
-        ImGui::EndDisabled();
-      }
-
-#if _WIN32 && CROSSDESK_PORTABLE
-      ImGui::Separator();
-
-      {
-        settings_items_offset += settings_items_padding;
-        ImGui::SetCursorPosY(settings_items_offset);
-        ImGui::AlignTextToFramePadding();
-        ImGui::Text("%s", localization::windows_service_settings_label
-                              [localization_language_index_]
-                                  .c_str());
-        ImGui::SameLine();
-        if (ConfigCenter::LANGUAGE::CHINESE == localization_language_) {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 4.0f);
-        } else if (ConfigCenter::LANGUAGE::ENGLISH == localization_language_) {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 5.42f);
-        } else {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 4.6f);
-        }
-
-        const PortableServiceInstallState state =
-            portable_service_install_state_.load(std::memory_order_acquire);
-        const bool service_installed =
-            IsCrossDeskServiceInstalled() ||
-            state == PortableServiceInstallState::succeeded;
-        if (service_installed) {
-          if (ConfigCenter::LANGUAGE::CHINESE == localization_language_) {
-            ImGui::SetCursorPosX(title_bar_button_width_ * 3.9f);
-          } else if (ConfigCenter::LANGUAGE::ENGLISH ==
-                     localization_language_) {
-            ImGui::SetCursorPosX(title_bar_button_width_ * 5.32f);
-          } else {
-            ImGui::SetCursorPosX(title_bar_button_width_ * 4.6f);
-          }
-          ImGui::Text("%s", localization::windows_service_installed
-                                [localization_language_index_]
-                                    .c_str());
-        } else {
-          if (state == PortableServiceInstallState::installing) {
-            ImGui::BeginDisabled();
-          }
-          if (ImGui::Button(localization::install_windows_service
-                                [localization_language_index_]
-                                    .c_str())) {
-            StartPortableWindowsServiceInstall();
-          }
-
-          if (state == PortableServiceInstallState::installing) {
-            ImGui::EndDisabled();
-            ImGui::SameLine();
-            ImGui::Text("%s", localization::installing_windows_service
-                                  [localization_language_index_]
-                                      .c_str());
-          } else if (state == PortableServiceInstallState::failed) {
-            ImGui::SameLine();
-            ImGui::Text(
-                "%s",
-                localization::failed[localization_language_index_].c_str());
-            if (ImGui::IsItemHovered()) {
-              ImGui::BeginTooltip();
-              ImGui::SetWindowFontScale(0.5f);
-              ImGui::PushTextWrapPos(title_bar_button_width_ * 10.0f);
-              ImGui::TextWrapped("%s",
-                                 localization::windows_service_install_failed
-                                     [localization_language_index_]
-                                         .c_str());
-              ImGui::PopTextWrapPos();
-              ImGui::SetWindowFontScale(1.0f);
-              ImGui::EndTooltip();
-            }
-          }
-        }
-      }
-#endif
-
-      if (ConfigCenter::LANGUAGE::CHINESE == localization_language_) {
-        ImGui::SetCursorPosX(title_bar_button_width_ * 1.59f);
-      } else {
-        ImGui::SetCursorPosX(title_bar_button_width_ * 2.22f);
-      }
-
-      settings_items_offset +=
-          settings_items_padding + title_bar_button_width_ * 0.15f;
-      ImGui::SetCursorPosY(settings_items_offset);
-
-      ImGui::PopStyleVar();
-
-      // OK
-      if (ImGui::Button(
-              localization::ok[localization_language_index_].c_str())) {
-        show_settings_window_ = false;
-        show_self_hosted_server_config_window_ = false;
-
-        // Language
-        language_button_value_ =
-            localization::detail::ClampLanguageIndex(language_button_value_);
-        if (language_button_value_ == 0) {
-          localization_language_ = ConfigCenter::LANGUAGE::CHINESE;
-        } else if (language_button_value_ == 1) {
-          localization_language_ = ConfigCenter::LANGUAGE::ENGLISH;
-        } else {
-          localization_language_ = ConfigCenter::LANGUAGE::RUSSIAN;
-        }
-        config_center_->SetLanguage(localization_language_);
-        language_button_value_last_ = language_button_value_;
-        localization_language_index_ = language_button_value_;
-        LOG_INFO("Set localization language: {}",
-                 localization::GetSupportedLanguages()
-                     [localization::detail::ClampLanguageIndex(
-                          localization_language_index_)]
-                         .code.c_str());
-
-        // Video quality
-        if (video_quality_button_value_ == 0) {
-          config_center_->SetVideoQuality(ConfigCenter::VIDEO_QUALITY::LOW);
-        } else if (video_quality_button_value_ == 1) {
-          config_center_->SetVideoQuality(ConfigCenter::VIDEO_QUALITY::MEDIUM);
-        } else {
-          config_center_->SetVideoQuality(ConfigCenter::VIDEO_QUALITY::HIGH);
-        }
-        video_quality_button_value_last_ = video_quality_button_value_;
-
-        if (video_frame_rate_button_value_ == 0) {
-          config_center_->SetVideoFrameRate(
-              ConfigCenter::VIDEO_FRAME_RATE::FPS_30);
-        } else if (video_frame_rate_button_value_ == 1) {
-          config_center_->SetVideoFrameRate(
-              ConfigCenter::VIDEO_FRAME_RATE::FPS_60);
-        }
-        video_frame_rate_button_value_last_ = video_frame_rate_button_value_;
-
-        // Video encode format
-        if (video_encode_format_button_value_ == 0) {
-          config_center_->SetVideoEncodeFormat(
-              ConfigCenter::VIDEO_ENCODE_FORMAT::H264);
-        } else if (video_encode_format_button_value_ == 1) {
-          config_center_->SetVideoEncodeFormat(
-              ConfigCenter::VIDEO_ENCODE_FORMAT::AV1);
-        }
-        video_encode_format_button_value_last_ =
-            video_encode_format_button_value_;
-
-        // Hardware video codec
-        if (enable_hardware_video_codec_) {
-          config_center_->SetHardwareVideoCodec(true);
-        } else {
-          config_center_->SetHardwareVideoCodec(false);
-        }
-        enable_hardware_video_codec_last_ = enable_hardware_video_codec_;
-
-        // TURN mode
-        if (enable_turn_) {
-          config_center_->SetTurn(true);
-        } else {
-          config_center_->SetTurn(false);
-        }
-        enable_turn_last_ = enable_turn_;
-
-        if (enable_self_hosted_) {
-          config_center_->SetSelfHosted(true);
-        } else {
-          config_center_->SetSelfHosted(false);
-        }
-        enable_self_hosted_last_ = enable_self_hosted_;
-
-        if (enable_autostart_) {
-          config_center_->SetAutostart(true);
-        } else {
-          config_center_->SetAutostart(false);
-        }
-        enable_autostart_last_ = enable_autostart_;
-
-        if (enable_daemon_) {
-          config_center_->SetDaemon(true);
-        } else {
-          config_center_->SetDaemon(false);
-        }
-        enable_daemon_last_ = enable_daemon_;
-
-        // File transfer save path
-        config_center_->SetFileTransferSavePath(file_transfer_save_path_buf_);
-        file_transfer_save_path_last_ = file_transfer_save_path_buf_;
-
-        settings_window_pos_reset_ = true;
-
-        // Recreate peer instance
-        settings_.Load();
-
-        // Recreate peer instance
-        if (!stream_window_inited_) {
-          LOG_INFO("Recreate peer instance");
-          CloseAllRemoteSessions();
-          CreateConnectionPeer();
-        }
-      }
-
-      ImGui::SameLine();
-      // Cancel
-      if (ImGui::Button(
-              localization::cancel[localization_language_index_].c_str())) {
-        show_settings_window_ = false;
-        show_self_hosted_server_config_window_ = false;
-
-        if (language_button_value_ != language_button_value_last_) {
-          language_button_value_ = language_button_value_last_;
-        }
-
-        if (video_quality_button_value_ != video_quality_button_value_last_) {
-          video_quality_button_value_ = video_quality_button_value_last_;
-        }
-
-        if (video_frame_rate_button_value_ !=
-            video_frame_rate_button_value_last_) {
-          video_frame_rate_button_value_ = video_frame_rate_button_value_last_;
-        }
-
-        if (video_encode_format_button_value_ !=
-            video_encode_format_button_value_last_) {
-          video_encode_format_button_value_ =
-              video_encode_format_button_value_last_;
-        }
-
-        if (enable_hardware_video_codec_ != enable_hardware_video_codec_last_) {
-          enable_hardware_video_codec_ = enable_hardware_video_codec_last_;
-        }
-
-        if (enable_turn_ != enable_turn_last_) {
-          enable_turn_ = enable_turn_last_;
-        }
-
-        // Restore file transfer save path
-        strncpy(file_transfer_save_path_buf_,
-                file_transfer_save_path_last_.c_str(),
-                sizeof(file_transfer_save_path_buf_) - 1);
-        file_transfer_save_path_buf_[sizeof(file_transfer_save_path_buf_) - 1] =
-            '\0';
-
-        settings_window_pos_reset_ = true;
-      }
-      ImGui::SetWindowFontScale(0.5f);
-      ImGui::End();
-      ImGui::PopStyleVar(2);
-      ImGui::PopStyleColor();
-    }
-  }
-
-  return 0;
-}
-} // namespace crossdesk

apps/desktop/src/gui/views/windows/main_window.cpp

@@ -1,60 +0,0 @@
-#include "application/gui_application.h"
-#include "layout_relative.h"
-#include "localization.h"
-#include "rd_log.h"
-
-namespace crossdesk {
-
-int GuiApplication::MainWindow() {
-  ImGuiIO &io = ImGui::GetIO();
-  float local_remote_window_width = io.DisplaySize.x;
-  float local_remote_window_height =
-      io.DisplaySize.y * (0.56f - TITLE_BAR_HEIGHT);
-
-  ImGui::SetNextWindowPos(ImVec2(0.0f, io.DisplaySize.y * (TITLE_BAR_HEIGHT)),
-                          ImGuiCond_Always);
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
-  ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4(1.0f, 1.0f, 1.0f, 0.0f));
-  ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(1.0f, 1.0f, 1.0f, 0.0f));
-  ImGui::BeginChild(
-      "DeskWindow",
-      ImVec2(local_remote_window_width, local_remote_window_height),
-      ImGuiChildFlags_Borders,
-      ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
-          ImGuiWindowFlags_NoBringToFrontOnFocus);
-  ImGui::PopStyleVar();
-  ImGui::PopStyleColor(2);
-
-  LocalWindow();
-
-  ImDrawList *draw_list = ImGui::GetWindowDrawList();
-  draw_list->AddLine(ImVec2(io.DisplaySize.x * 0.5f, io.DisplaySize.y * 0.1f),
-                     ImVec2(io.DisplaySize.x * 0.5f, io.DisplaySize.y * 0.53f),
-                     IM_COL32(0, 0, 0, 122), 1.0f);
-
-  RemoteWindow();
-  ImGui::EndChild();
-
-  RecentConnectionsWindow();
-  StatusBar();
-
-  if (show_connection_status_window_) {
-    // std::unique_lock lock(remote_sessions_mutex_);
-    for (auto it = remote_sessions_.begin();
-         it != remote_sessions_.end();) {
-      auto &props = it->second;
-      if (focused_remote_id_ == props->remote_id_) {
-        if (ConnectionStatusWindow(props)) {
-          it = remote_sessions_.erase(it);
-        } else {
-          ++it;
-        }
-      } else {
-        ++it;
-      }
-    }
-  }
-
-  return 0;
-}
-} // namespace crossdesk

apps/desktop/src/gui/views/windows/portable_service_install_window.cpp

@@ -1,359 +0,0 @@
-#include "application/gui_application.h"
-
-#if _WIN32 && CROSSDESK_PORTABLE
-
-#include <shellapi.h>
-
-#include <algorithm>
-#include <vector>
-
-#include "localization.h"
-#include "rd_log.h"
-#include "service_host.h"
-
-namespace crossdesk {
-namespace {
-
-std::filesystem::path GetCurrentExecutablePath() {
-  std::vector<wchar_t> buffer(MAX_PATH);
-  while (true) {
-    DWORD length = GetModuleFileNameW(nullptr, buffer.data(),
-                                      static_cast<DWORD>(buffer.size()));
-    if (length == 0) {
-      return {};
-    }
-    if (length < buffer.size()) {
-      return std::filesystem::path(buffer.data(), buffer.data() + length);
-    }
-    if (buffer.size() >= 32768) {
-      return {};
-    }
-    buffer.resize(buffer.size() * 2);
-  }
-}
-
-bool InstallServiceWithElevation() {
-  const std::filesystem::path executable_path = GetCurrentExecutablePath();
-  if (executable_path.empty()) {
-    LOG_ERROR("Portable service install failed: current executable not found");
-    return false;
-  }
-
-  const std::filesystem::path service_path =
-      executable_path.parent_path() / L"crossdesk_service.exe";
-  const std::filesystem::path helper_path =
-      executable_path.parent_path() / L"crossdesk_session_helper.exe";
-  if (!std::filesystem::exists(service_path) ||
-      !std::filesystem::exists(helper_path)) {
-    LOG_ERROR("Portable service install failed: service binaries missing, "
-              "service={}, "
-              "helper={}",
-              service_path.string(), helper_path.string());
-    return false;
-  }
-
-  std::wstring executable = executable_path.wstring();
-  std::wstring working_dir = executable_path.parent_path().wstring();
-  std::wstring parameters = L"--service-install";
-
-  SHELLEXECUTEINFOW execute_info{};
-  execute_info.cbSize = sizeof(execute_info);
-  execute_info.fMask = SEE_MASK_NOCLOSEPROCESS;
-  execute_info.hwnd = nullptr;
-  execute_info.lpVerb = L"runas";
-  execute_info.lpFile = executable.c_str();
-  execute_info.lpParameters = parameters.c_str();
-  execute_info.lpDirectory = working_dir.c_str();
-  execute_info.nShow = SW_HIDE;
-
-  if (!ShellExecuteExW(&execute_info)) {
-    LOG_ERROR("Portable service install failed: ShellExecuteExW error={}",
-              GetLastError());
-    return false;
-  }
-
-  DWORD wait_result = WaitForSingleObject(execute_info.hProcess, INFINITE);
-  DWORD exit_code = 1;
-  if (wait_result == WAIT_OBJECT_0) {
-    GetExitCodeProcess(execute_info.hProcess, &exit_code);
-  } else {
-    LOG_ERROR("Portable service install wait failed, result={}", wait_result);
-  }
-  CloseHandle(execute_info.hProcess);
-
-  if (exit_code != 0) {
-    LOG_ERROR("Portable service install command failed, exit_code={}",
-              exit_code);
-    return false;
-  }
-
-  const bool started = StartCrossDeskService();
-  if (!started) {
-    LOG_WARN("Portable service installed but start failed");
-  }
-  return IsCrossDeskServiceInstalled() && started;
-}
-
-} // namespace
-
-void GuiApplication::CheckPortableWindowsService() {
-  if (portable_service_prompt_checked_) {
-    return;
-  }
-  portable_service_prompt_checked_ = true;
-
-  if (IsCrossDeskServiceInstalled()) {
-    return;
-  }
-
-  if (portable_service_prompt_suppressed_) {
-    return;
-  }
-
-  portable_service_install_state_.store(PortableServiceInstallState::idle,
-                                        std::memory_order_relaxed);
-  show_portable_service_install_window_ = true;
-}
-
-void GuiApplication::StartPortableWindowsServiceInstall() {
-  portable_service_do_not_remind_ = false;
-  PortableServiceInstallState expected = PortableServiceInstallState::idle;
-  if (!portable_service_install_state_.compare_exchange_strong(
-          expected, PortableServiceInstallState::installing,
-          std::memory_order_acq_rel)) {
-    if (expected != PortableServiceInstallState::failed) {
-      return;
-    }
-    portable_service_install_state_.store(
-        PortableServiceInstallState::installing, std::memory_order_release);
-  }
-
-  JoinPortableWindowsServiceInstallThread();
-  portable_service_install_thread_ = std::thread([this]() {
-    const bool installed = InstallServiceWithElevation();
-    portable_service_install_state_.store(
-        installed ? PortableServiceInstallState::succeeded
-                  : PortableServiceInstallState::failed,
-        std::memory_order_release);
-  });
-}
-
-void GuiApplication::JoinPortableWindowsServiceInstallThread() {
-  if (portable_service_install_thread_.joinable()) {
-    portable_service_install_thread_.join();
-  }
-}
-
-int GuiApplication::PortableServiceInstallWindow() {
-  if (!show_portable_service_install_window_ &&
-      !show_portable_service_prompt_suppressed_window_) {
-    return 0;
-  }
-
-  const ImGuiViewport *viewport = ImGui::GetMainViewport();
-  const float window_width =
-      (std::min)(viewport->WorkSize.x * 0.6f, title_bar_button_width_ * 18.0f);
-  const float window_height =
-      (std::min)(viewport->WorkSize.y * 0.5f, title_bar_button_width_ * 8.0f);
-
-  if (show_portable_service_prompt_suppressed_window_) {
-    const float notice_width = window_width;
-    const float notice_height = (std::min)(viewport->WorkSize.y * 0.35f,
-                                           title_bar_button_width_ * 4.6f);
-    ImGui::SetNextWindowPos(
-        ImVec2(viewport->WorkPos.x +
-                   (viewport->WorkSize.x - notice_width) / 2.0f,
-               viewport->WorkPos.y +
-                   (viewport->WorkSize.y - notice_height) / 2.0f),
-        ImGuiCond_Appearing);
-    ImGui::SetNextWindowSize(ImVec2(notice_width, notice_height),
-                             ImGuiCond_Always);
-
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 1.0f);
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, window_rounding_);
-    ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, window_rounding_ * 0.5f);
-
-    ImGui::Begin(
-        localization::notification[localization_language_index_].c_str(),
-        nullptr,
-        ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse |
-            ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings |
-            ImGuiWindowFlags_NoTitleBar);
-
-    ImGui::Spacing();
-    ImGui::SetWindowFontScale(0.55f);
-    ImGui::SetCursorPosX(notice_width * 0.08f);
-    ImGui::Text(
-        "%s", localization::notification[localization_language_index_].c_str());
-
-    ImGui::SetWindowFontScale(0.5f);
-    ImGui::SetCursorPosX(notice_width * 0.06f);
-    ImGui::SetCursorPosY(notice_height * 0.28f);
-    ImGui::PushTextWrapPos(notice_width * 0.88f);
-    ImGui::TextWrapped("%s",
-                       localization::windows_service_prompt_suppressed_message
-                           [localization_language_index_]
-                               .c_str());
-    ImGui::PopTextWrapPos();
-
-    const std::string ok_label = localization::ok[localization_language_index_];
-    const ImGuiStyle &style = ImGui::GetStyle();
-    const float ok_width =
-        ImGui::CalcTextSize(ok_label.c_str()).x + style.FramePadding.x * 2.0f;
-    ImGui::SetCursorPosX((notice_width - ok_width) * 0.5f);
-    ImGui::SetCursorPosY(notice_height * 0.75f);
-    if (ImGui::Button(ok_label.c_str())) {
-      show_portable_service_prompt_suppressed_window_ = false;
-    }
-
-    ImGui::SetWindowFontScale(1.0f);
-    ImGui::End();
-    ImGui::PopStyleVar(3);
-    ImGui::PopStyleColor();
-  }
-
-  if (!show_portable_service_install_window_) {
-    return 0;
-  }
-
-  ImGui::SetNextWindowPos(
-      ImVec2(viewport->WorkPos.x + (viewport->WorkSize.x - window_width) / 2.0f,
-             viewport->WorkPos.y +
-                 (viewport->WorkSize.y - window_height) / 2.0f),
-      ImGuiCond_Appearing);
-  ImGui::SetNextWindowSize(ImVec2(window_width, window_height),
-                           ImGuiCond_Always);
-
-  ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 1.0f);
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, window_rounding_);
-  ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, window_rounding_ * 0.5f);
-
-  ImGui::Begin(
-      localization::windows_service_setup_title[localization_language_index_]
-          .c_str(),
-      nullptr,
-      ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse |
-          ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings |
-          ImGuiWindowFlags_NoTitleBar);
-
-  ImGui::Spacing();
-  ImGui::SetWindowFontScale(0.55f);
-  ImGui::SetCursorPosX(window_width * 0.08f);
-  ImGui::Text(
-      "%s",
-      localization::windows_service_setup_title[localization_language_index_]
-          .c_str());
-
-  const PortableServiceInstallState state =
-      portable_service_install_state_.load(std::memory_order_acquire);
-  const char *status_text = nullptr;
-  if (state == PortableServiceInstallState::installing ||
-      state == PortableServiceInstallState::succeeded ||
-      state == PortableServiceInstallState::failed) {
-    status_text =
-        localization::installing_windows_service[localization_language_index_]
-            .c_str();
-    if (state == PortableServiceInstallState::succeeded) {
-      status_text = localization::windows_service_install_success
-                        [localization_language_index_]
-                            .c_str();
-    } else if (state == PortableServiceInstallState::failed) {
-      status_text = localization::windows_service_install_failed
-                        [localization_language_index_]
-                            .c_str();
-    }
-  }
-
-  ImGui::SetWindowFontScale(0.45f);
-  ImGui::SetCursorPosX(window_width * 0.04f);
-  ImGui::SetCursorPosY(window_height * 0.22f);
-  ImGui::BeginChild("PortableServiceInstallContent",
-                    ImVec2(window_width * 0.92f, window_height * 0.45f),
-                    ImGuiChildFlags_Borders, ImGuiWindowFlags_None);
-  ImGui::SetWindowFontScale(0.5f);
-  const float wrap_pos = ImGui::GetContentRegionAvail().x;
-  ImGui::PushTextWrapPos(wrap_pos);
-  ImGui::TextWrapped(
-      "%s",
-      localization::windows_service_setup_message[localization_language_index_]
-          .c_str());
-  if (status_text != nullptr) {
-    ImGui::Spacing();
-    ImGui::TextWrapped("%s", status_text);
-  }
-  ImGui::PopTextWrapPos();
-  ImGui::EndChild();
-
-  ImGui::SetWindowFontScale(0.5f);
-  ImGui::SetCursorPosX(window_width * 0.08f);
-  ImGui::SetCursorPosY(window_height * 0.71f);
-  ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f);
-  ImGui::Checkbox(
-      localization::do_not_remind_again[localization_language_index_].c_str(),
-      &portable_service_do_not_remind_);
-  ImGui::PopStyleVar();
-
-  const float button_y = window_height * 0.84f;
-  const ImGuiStyle &style = ImGui::GetStyle();
-  const auto default_button_width = [&style](const std::string &label) {
-    return ImGui::CalcTextSize(label.c_str()).x + style.FramePadding.x * 2.0f;
-  };
-  const std::string install_label =
-      localization::install_windows_service[localization_language_index_];
-  const std::string cancel_label =
-      localization::cancel[localization_language_index_];
-  const std::string ok_label = localization::ok[localization_language_index_];
-  const float buttons_width = state == PortableServiceInstallState::succeeded
-                                  ? default_button_width(ok_label)
-                                  : default_button_width(install_label) +
-                                        style.ItemSpacing.x +
-                                        default_button_width(cancel_label);
-  ImGui::SetCursorPosX((window_width - buttons_width) * 0.5f);
-  ImGui::SetCursorPosY(button_y);
-
-  if (state == PortableServiceInstallState::succeeded) {
-    if (ImGui::Button(ok_label.c_str())) {
-      show_portable_service_install_window_ = false;
-      JoinPortableWindowsServiceInstallThread();
-    }
-  } else {
-    if (state == PortableServiceInstallState::installing) {
-      ImGui::BeginDisabled();
-    }
-    if (ImGui::Button(install_label.c_str())) {
-      StartPortableWindowsServiceInstall();
-    }
-    if (state == PortableServiceInstallState::installing) {
-      ImGui::EndDisabled();
-    }
-
-    ImGui::SameLine();
-    if (state == PortableServiceInstallState::installing) {
-      ImGui::BeginDisabled();
-    }
-    if (ImGui::Button(cancel_label.c_str())) {
-      if (portable_service_do_not_remind_) {
-        portable_service_prompt_suppressed_ = true;
-        config_center_->SetPortableServicePromptSuppressed(true);
-        show_portable_service_prompt_suppressed_window_ = true;
-      }
-      show_portable_service_install_window_ = false;
-    }
-    if (state == PortableServiceInstallState::installing) {
-      ImGui::EndDisabled();
-    }
-  }
-
-  ImGui::SetWindowFontScale(1.0f);
-  ImGui::End();
-  ImGui::PopStyleVar(3);
-  ImGui::PopStyleColor();
-
-  return 0;
-}
-
-} // namespace crossdesk
-
-#endif

apps/desktop/src/gui/views/windows/server_settings_window.cpp

@@ -1,165 +0,0 @@
-#include <filesystem>
-#include <vector>
-
-#ifdef _WIN32
-#include <windows.h>
-#endif
-
-#include "application/gui_application.h"
-#include "layout.h"
-#include "localization.h"
-#include "rd_log.h"
-
-namespace crossdesk {
-
-std::vector<std::string> GetRootEntries() {
-  std::vector<std::string> roots;
-#ifdef _WIN32
-  DWORD mask = GetLogicalDrives();
-  for (char letter = 'A'; letter <= 'Z'; ++letter) {
-    if (mask & 1) {
-      roots.push_back(std::string(1, letter) + ":\\");
-    }
-    mask >>= 1;
-  }
-#else
-  roots.push_back("/");
-#endif
-  return roots;
-}
-
-int GuiApplication::SelfHostedServerWindow() {
-  ImGuiIO &io = ImGui::GetIO();
-  if (show_self_hosted_server_config_window_) {
-    if (self_hosted_server_config_window_pos_reset_) {
-      if (ConfigCenter::LANGUAGE::CHINESE == localization_language_) {
-        ImGui::SetNextWindowPos(
-            ImVec2(io.DisplaySize.x * 0.298f, io.DisplaySize.y * 0.25f));
-        ImGui::SetNextWindowSize(
-            ImVec2(io.DisplaySize.x * 0.407f, io.DisplaySize.y * 0.29f));
-      } else {
-        ImGui::SetNextWindowPos(
-            ImVec2(io.DisplaySize.x * 0.27f, io.DisplaySize.y * 0.3f));
-        ImGui::SetNextWindowSize(
-            ImVec2(io.DisplaySize.x * 0.465f, io.DisplaySize.y * 0.29f));
-      }
-
-      self_hosted_server_config_window_pos_reset_ = false;
-    }
-
-    // Settings
-    {
-      ImGui::SetWindowFontScale(0.5f);
-      ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
-      ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, window_rounding_);
-      ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, window_rounding_ * 0.5f);
-
-      ImGui::Begin(localization::self_hosted_server_settings
-                       [localization_language_index_]
-                           .c_str(),
-                   nullptr,
-                   ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse |
-                       ImGuiWindowFlags_NoSavedSettings);
-      ImGui::SetWindowFontScale(1.0f);
-      ImGui::SetWindowFontScale(0.5f);
-      ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f);
-      {
-        ImGui::AlignTextToFramePadding();
-        ImGui::Text("%s", localization::self_hosted_server_address
-                              [localization_language_index_]
-                                  .c_str());
-        ImGui::SameLine();
-        if (ConfigCenter::LANGUAGE::CHINESE == localization_language_) {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 2.5f);
-        } else {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 3.43f);
-        }
-        ImGui::SetNextItemWidth(title_bar_button_width_ * 3.8f);
-
-        ImGui::InputText("##signal_server_ip_self_", signal_server_ip_self_,
-                         IM_ARRAYSIZE(signal_server_ip_self_),
-                         ImGuiInputTextFlags_AlwaysOverwrite);
-      }
-
-      ImGui::Separator();
-
-      {
-        ImGui::AlignTextToFramePadding();
-        ImGui::Text(
-            "%s",
-            localization::self_hosted_server_port[localization_language_index_]
-                .c_str());
-        ImGui::SameLine();
-        if (ConfigCenter::LANGUAGE::CHINESE == localization_language_) {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 2.5f);
-        } else {
-          ImGui::SetCursorPosX(title_bar_button_width_ * 3.43f);
-        }
-        ImGui::SetNextItemWidth(title_bar_button_width_ * 3.8f);
-
-        ImGui::InputText("##signal_server_port_self_", signal_server_port_self_,
-                         IM_ARRAYSIZE(signal_server_port_self_));
-      }
-
-      if (stream_window_inited_) {
-        ImGui::EndDisabled();
-      }
-
-      ImGui::Dummy(ImVec2(0.0f, title_bar_button_width_ * 0.25f));
-
-      if (ConfigCenter::LANGUAGE::CHINESE == localization_language_) {
-        ImGui::SetCursorPosX(title_bar_button_width_ * 2.32f);
-      } else {
-        ImGui::SetCursorPosX(title_bar_button_width_ * 2.7f);
-      }
-
-      ImGui::PopStyleVar();
-
-      // OK
-      if (ImGui::Button(
-              localization::ok[localization_language_index_].c_str())) {
-        show_self_hosted_server_config_window_ = false;
-
-        config_center_->SetServerHost(signal_server_ip_self_);
-        config_center_->SetServerPort(atoi(signal_server_port_self_));
-        strncpy(signal_server_ip_, signal_server_ip_self_,
-                sizeof(signal_server_ip_) - 1);
-        signal_server_ip_[sizeof(signal_server_ip_) - 1] = '\0';
-        strncpy(signal_server_port_, signal_server_port_self_,
-                sizeof(signal_server_port_) - 1);
-        signal_server_port_[sizeof(signal_server_port_) - 1] = '\0';
-        self_hosted_server_config_window_pos_reset_ = true;
-      }
-
-      ImGui::SameLine();
-      // Cancel
-      if (ImGui::Button(
-              localization::cancel[localization_language_index_].c_str())) {
-        show_self_hosted_server_config_window_ = false;
-        self_hosted_server_config_window_pos_reset_ = true;
-        strncpy(signal_server_ip_self_,
-                config_center_->GetSignalServerHost().c_str(),
-                sizeof(signal_server_ip_self_) - 1);
-        signal_server_ip_self_[sizeof(signal_server_ip_self_) - 1] = '\0';
-        int signal_port = config_center_->GetSignalServerPort();
-        if (signal_port > 0) {
-          strncpy(signal_server_port_self_, std::to_string(signal_port).c_str(),
-                  sizeof(signal_server_port_self_) - 1);
-          signal_server_port_self_[sizeof(signal_server_port_self_) - 1] = '\0';
-        } else {
-          signal_server_port_self_[0] = '\0';
-        }
-      }
-
-      ImGui::SetWindowFontScale(1.0f);
-      ImGui::SetWindowFontScale(0.5f);
-      ImGui::End();
-      ImGui::PopStyleVar(2);
-      ImGui::PopStyleColor();
-      ImGui::SetWindowFontScale(1.0f);
-    }
-  }
-
-  return 0;
-}
-} // namespace crossdesk

apps/desktop/src/gui/views/windows/server_window.cpp

@@ -1,388 +0,0 @@
-#include <algorithm>
-#include <cmath>
-#include <cstdio>
-#include <memory>
-#include <shared_mutex>
-#include <string>
-#include <vector>
-
-#include "application/gui_application.h"
-#include "layout_relative.h"
-#include "localization.h"
-#include "rd_log.h"
-#include "rounded_corner_button.h"
-
-namespace crossdesk {
-
-namespace {
-int CountDigits(int number) {
-  if (number == 0)
-    return 1;
-  return (int)std::floor(std::log10(std::abs(number))) + 1;
-}
-
-void BitrateDisplay(uint32_t bitrate) {
-  const int num_of_digits = CountDigits(static_cast<int>(bitrate));
-  if (num_of_digits <= 3) {
-    ImGui::Text("%u bps", bitrate);
-  } else if (num_of_digits > 3 && num_of_digits <= 6) {
-    ImGui::Text("%u kbps", bitrate / 1000);
-  } else {
-    ImGui::Text("%.1f mbps", bitrate / 1000000.0f);
-  }
-}
-
-std::string FormatBytes(uint64_t bytes) {
-  char buf[64];
-  if (bytes < 1024ULL) {
-    std::snprintf(buf, sizeof(buf), "%llu B", (unsigned long long)bytes);
-  } else if (bytes < 1024ULL * 1024ULL) {
-    std::snprintf(buf, sizeof(buf), "%.2f KB", bytes / 1024.0);
-  } else if (bytes < 1024ULL * 1024ULL * 1024ULL) {
-    std::snprintf(buf, sizeof(buf), "%.2f MB", bytes / (1024.0 * 1024.0));
-  } else {
-    std::snprintf(buf, sizeof(buf), "%.2f GB",
-                  bytes / (1024.0 * 1024.0 * 1024.0));
-  }
-  return std::string(buf);
-}
-} // namespace
-
-int GuiApplication::ServerWindow() {
-  ImGui::SetNextWindowSize(ImVec2(server_window_width_, server_window_height_),
-                           ImGuiCond_Always);
-  ImGui::SetNextWindowPos(ImVec2(0, 0), ImGuiCond_Always);
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, window_rounding_);
-  ImGui::Begin("##server_window", nullptr,
-               ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
-                   ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoCollapse |
-                   ImGuiWindowFlags_NoScrollbar |
-                   ImGuiWindowFlags_NoScrollWithMouse);
-  ImGui::PopStyleVar();
-
-  server_window_title_bar_height_ = title_bar_height_;
-
-  ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4(1.0f, 1.0f, 1.0f, 0.0f));
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0));
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, window_rounding_);
-  ImGui::SetNextWindowPos(ImVec2(0, 0), ImGuiCond_Always);
-  ImGui::BeginChild(
-      "ServerTitleBar",
-      ImVec2(server_window_width_, server_window_title_bar_height_),
-      ImGuiChildFlags_Borders,
-      ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
-          ImGuiWindowFlags_NoBringToFrontOnFocus);
-
-  float server_title_bar_button_width = server_window_title_bar_height_;
-  float server_title_bar_button_height = server_window_title_bar_height_;
-
-  // Collapse/expand toggle button (FontAwesome icon).
-  {
-    ImGui::SetCursorPos(ImVec2(0.0f, 0.0f));
-
-    ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0, 0, 0, 0));
-    ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0, 0, 0, 0.1f));
-    ImGui::PushStyleColor(ImGuiCol_ButtonActive,
-                          ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
-
-    ImGui::SetWindowFontScale(0.5f);
-    const char *icon =
-        server_window_collapsed_ ? ICON_FA_ANGLE_DOWN : ICON_FA_ANGLE_UP;
-    std::string toggle_label = std::string(icon) + "##server_toggle";
-
-    bool toggle_clicked = RoundedCornerButton(
-        toggle_label.c_str(),
-        ImVec2(server_title_bar_button_width, server_title_bar_button_height),
-        8.5f, ImDrawFlags_RoundCornersTopLeft, true, IM_COL32(0, 0, 0, 0),
-        IM_COL32(0, 0, 0, 25), IM_COL32(255, 255, 255, 255));
-    if (toggle_clicked) {
-      if (server_window_) {
-        int w = 0;
-        int h = 0;
-        int x = 0;
-        int y = 0;
-        SDL_GetWindowSize(server_window_, &w, &h);
-        SDL_GetWindowPosition(server_window_, &x, &y);
-
-        if (server_window_collapsed_) {
-          const int normal_h = server_window_normal_height_;
-          SDL_SetWindowSize(server_window_, w, normal_h);
-          SDL_SetWindowPosition(server_window_, x, y);
-          server_window_collapsed_ = false;
-        } else {
-          const int collapsed_h = (int)server_window_title_bar_height_;
-          // Collapse upward: keep top edge stable.
-          SDL_SetWindowSize(server_window_, w, collapsed_h);
-          SDL_SetWindowPosition(server_window_, x, y);
-          server_window_collapsed_ = true;
-        }
-      }
-    }
-    ImGui::SetWindowFontScale(1.0f);
-
-    ImGui::PopStyleColor(3);
-  }
-
-  ImGui::EndChild();
-  ImGui::PopStyleVar(2);
-  ImGui::PopStyleColor();
-
-  RemoteClientInfoWindow();
-
-  ImGui::End();
-  return 0;
-}
-
-int GuiApplication::RemoteClientInfoWindow() {
-  float remote_client_info_window_width = server_window_width_ * 0.8f;
-  float remote_client_info_window_height =
-      (server_window_height_ - server_window_title_bar_height_) * 0.9f;
-
-  ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
-  ImGui::PushStyleVar(ImGuiStyleVar_ChildRounding, 5.0f);
-  ImGui::BeginChild(
-      "RemoteClientInfoWindow",
-      ImVec2(remote_client_info_window_width, remote_client_info_window_height),
-      ImGuiChildFlags_Borders,
-      ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
-          ImGuiWindowFlags_NoBringToFrontOnFocus);
-  ImGui::PopStyleVar();
-  ImGui::PopStyleColor();
-
-  float font_scale = localization_language_index_ == 0 ? 0.5f : 0.45f;
-
-  std::vector<std::pair<std::string, std::string>> remote_entries;
-  {
-    std::shared_lock lock(connection_status_mutex_);
-    remote_entries.reserve(connection_status_.size());
-    for (const auto &kv : connection_status_) {
-      const auto host_it = connection_host_names_.find(kv.first);
-      const std::string display_name =
-          (host_it != connection_host_names_.end() && !host_it->second.empty())
-              ? host_it->second
-              : kv.first;
-      remote_entries.emplace_back(kv.first, display_name);
-    }
-  }
-
-  auto find_display_name_by_remote_id =
-      [&remote_entries](const std::string &remote_id) -> std::string {
-    for (const auto &entry : remote_entries) {
-      if (entry.first == remote_id) {
-        return entry.second;
-      }
-    }
-    return {};
-  };
-
-  if (!selected_server_remote_id_.empty() &&
-      find_display_name_by_remote_id(selected_server_remote_id_).empty()) {
-    selected_server_remote_id_.clear();
-    selected_server_remote_hostname_.clear();
-  }
-  if (selected_server_remote_id_.empty() && !remote_entries.empty()) {
-    selected_server_remote_id_ = remote_entries.front().first;
-  }
-  if (!selected_server_remote_id_.empty()) {
-    selected_server_remote_hostname_ =
-        find_display_name_by_remote_id(selected_server_remote_id_);
-  }
-
-  ImGui::SetWindowFontScale(font_scale);
-  ImGui::AlignTextToFramePadding();
-  ImGui::Text("%s",
-              localization::controller[localization_language_index_].c_str());
-  ImGui::SameLine();
-
-  const char *selected_preview = "-";
-  if (!selected_server_remote_hostname_.empty()) {
-    selected_preview = selected_server_remote_hostname_.c_str();
-  } else if (!remote_client_id_.empty()) {
-    selected_preview = remote_client_id_.c_str();
-  }
-
-  ImGui::SetNextItemWidth(remote_client_info_window_width *
-                          (localization_language_index_ == 0 ? 0.68f : 0.62f));
-  ImGui::SetWindowFontScale(localization_language_index_ == 0 ? 0.45f : 0.4f);
-  ImGui::AlignTextToFramePadding();
-  if (ImGui::BeginCombo("##server_remote_id", selected_preview)) {
-    ImGui::SetWindowFontScale(localization_language_index_ == 0 ? 0.45f : 0.4f);
-    for (int i = 0; i < static_cast<int>(remote_entries.size()); i++) {
-      const bool selected =
-          (remote_entries[i].first == selected_server_remote_id_);
-      if (ImGui::Selectable(remote_entries[i].second.c_str(), selected)) {
-        selected_server_remote_id_ = remote_entries[i].first;
-        selected_server_remote_hostname_ = remote_entries[i].second;
-      }
-      if (selected) {
-        ImGui::SetItemDefaultFocus();
-      }
-    }
-    ImGui::EndCombo();
-  }
-
-  ImGui::Separator();
-
-  ImGui::SetWindowFontScale(font_scale);
-
-  if (!selected_server_remote_id_.empty()) {
-    ConnectionStatus status = ConnectionStatus::Closed;
-    {
-      std::shared_lock lock(connection_status_mutex_);
-      auto it = connection_status_.find(selected_server_remote_id_);
-      if (it != connection_status_.end()) {
-        status = it->second;
-      }
-    }
-
-    ImGui::Text(
-        "%s",
-        localization::connection_status[localization_language_index_].c_str());
-    ImGui::SameLine();
-
-    switch (status) {
-    case ConnectionStatus::Connected:
-      ImGui::Text(
-          "%s",
-          localization::p2p_connected[localization_language_index_].c_str());
-      break;
-    case ConnectionStatus::Connecting:
-      ImGui::Text(
-          "%s",
-          localization::p2p_connecting[localization_language_index_].c_str());
-      break;
-    case ConnectionStatus::Disconnected:
-      ImGui::Text(
-          "%s",
-          localization::p2p_disconnected[localization_language_index_].c_str());
-      break;
-    case ConnectionStatus::Failed:
-      ImGui::Text(
-          "%s", localization::p2p_failed[localization_language_index_].c_str());
-      break;
-    case ConnectionStatus::Closed:
-      ImGui::Text(
-          "%s", localization::p2p_closed[localization_language_index_].c_str());
-      break;
-    default:
-      ImGui::Text(
-          "%s", localization::p2p_failed[localization_language_index_].c_str());
-      break;
-    }
-  }
-
-  ImGui::Separator();
-
-  ImGui::AlignTextToFramePadding();
-  ImGui::Text(
-      "%s", localization::file_transfer[localization_language_index_].c_str());
-
-  ImGui::SameLine();
-
-  if (ImGui::Button(
-          localization::select_file[localization_language_index_].c_str())) {
-    std::string title = localization::select_file[localization_language_index_];
-    std::string path = OpenFileDialog(title);
-    LOG_INFO("Selected file path: {}", path.c_str());
-
-    transfers_.ProcessSelectedFile(path, nullptr, file_label_,
-                                   selected_server_remote_id_);
-  }
-
-  auto &file_transfer = transfers_.global_state();
-  if (file_transfer.file_transfer_window_visible_) {
-    ImGui::SameLine();
-    const bool is_sending = file_transfer.file_sending_.load();
-
-    if (is_sending) {
-      // Simple animation: cycle icon every 0.5s while sending.
-      static const char *kFileTransferIcons[] = {ICON_FA_ANGLE_UP,
-                                                 ICON_FA_ANGLES_UP};
-      const int icon_index = static_cast<int>(ImGui::GetTime() / 0.5) %
-                             (static_cast<int>(sizeof(kFileTransferIcons) /
-                                               sizeof(kFileTransferIcons[0])));
-      ImGui::Text("%s", kFileTransferIcons[icon_index]);
-    } else {
-      // Completed.
-      ImGui::Text("%s", ICON_FA_CHECK);
-    }
-
-    if (ImGui::IsItemHovered()) {
-      const uint64_t sent_bytes = file_transfer.file_sent_bytes_.load();
-      const uint64_t total_bytes = file_transfer.file_total_bytes_.load();
-      const uint32_t rate_bps = file_transfer.file_send_rate_bps_.load();
-
-      float progress = 0.0f;
-      if (total_bytes > 0) {
-        progress =
-            static_cast<float>(sent_bytes) / static_cast<float>(total_bytes);
-        progress = (std::max)(0.0f, (std::min)(1.0f, progress));
-      }
-
-      std::string current_file_name;
-      const uint32_t current_file_id = file_transfer.current_file_id_.load();
-      if (current_file_id != 0) {
-        std::lock_guard<std::mutex> lock(
-            file_transfer.file_transfer_list_mutex_);
-        for (const auto &info : file_transfer.file_transfer_list_) {
-          if (info.file_id == current_file_id) {
-            current_file_name = info.file_name;
-            break;
-          }
-        }
-      }
-
-      ImGui::BeginTooltip();
-      if (server_windows_system_chinese_font_) {
-        ImGui::PushFont(server_windows_system_chinese_font_);
-      }
-      ImGui::SetWindowFontScale(0.5f);
-      if (!current_file_name.empty()) {
-        ImGui::Text("%s", current_file_name.c_str());
-      }
-      if (total_bytes > 0) {
-        const std::string sent_str = FormatBytes(sent_bytes);
-        const std::string total_str = FormatBytes(total_bytes);
-        ImGui::Text("%s / %s", sent_str.c_str(), total_str.c_str());
-      }
-
-      const float text_height = ImGui::GetTextLineHeight();
-      char overlay[32];
-      std::snprintf(overlay, sizeof(overlay), "%.1f%%", progress * 100.0f);
-      ImGui::ProgressBar(progress, ImVec2(180.0f, text_height), overlay);
-      BitrateDisplay(rate_bps);
-      ImGui::SetWindowFontScale(1.0f);
-      if (server_windows_system_chinese_font_) {
-        ImGui::PopFont();
-      }
-      ImGui::EndTooltip();
-    }
-  }
-
-  ImGui::SetWindowFontScale(1.0f);
-
-  ImGui::EndChild();
-
-  ImGui::SameLine();
-
-  float close_connection_button_width = server_window_width_ * 0.1f;
-  float close_connection_button_height = remote_client_info_window_height;
-
-  ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(1.0f, 0.0f, 0.0f, 1.0f));
-  ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(1.0f, 0.3f, 0.3f, 1.0f));
-  ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(1.0f, 0.5f, 0.5f, 1.0f));
-  ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, window_rounding_);
-  ImGui::SetWindowFontScale(font_scale);
-  if (ImGui::Button(ICON_FA_XMARK, ImVec2(close_connection_button_width,
-                                          close_connection_button_height))) {
-    if (peer_ && !selected_server_remote_id_.empty()) {
-      LeaveConnection(peer_, selected_server_remote_id_.c_str());
-    }
-  }
-  ImGui::SetWindowFontScale(1.0f);
-  ImGui::PopStyleColor(3);
-  ImGui::PopStyleVar();
-
-  return 0;
-}
-} // namespace crossdesk

apps/desktop/src/gui/views/windows/stream_window.cpp

@@ -1,308 +0,0 @@
-#include "application/gui_application.h"
-#include "localization.h"
-#include "rd_log.h"
-
-namespace crossdesk {
-
-void GuiApplication::DrawConnectionStatusText(
-    std::shared_ptr<RemoteSession> &props) {
-  std::string text;
-  switch (props->connection_status_.load()) {
-  case ConnectionStatus::Disconnected:
-    text = localization::p2p_disconnected[localization_language_index_];
-    break;
-  case ConnectionStatus::Failed:
-    text = localization::p2p_failed[localization_language_index_];
-    break;
-  case ConnectionStatus::Closed:
-    text = localization::p2p_closed[localization_language_index_];
-    break;
-  default:
-    break;
-  }
-
-  if (!text.empty()) {
-    ImVec2 size = ImGui::GetWindowSize();
-    ImVec2 text_size = ImGui::CalcTextSize(text.c_str());
-    ImGui::SetCursorPos(
-        ImVec2((size.x - text_size.x) * 0.5f,
-               (size.y - text_size.y - title_bar_height_) * 0.5f));
-    ImGui::TextColored(ImVec4(1.0f, 1.0f, 1.0f, 1.0f), "%s", text.c_str());
-  }
-}
-
-void GuiApplication::DrawReceivingScreenText(
-    std::shared_ptr<RemoteSession> &props) {
-  if (!props->connection_established_ ||
-      props->connection_status_.load() != ConnectionStatus::Connected) {
-    return;
-  }
-
-  bool has_valid_frame = false;
-  {
-    std::lock_guard<std::mutex> lock(props->video_frame_mutex_);
-    has_valid_frame = props->stream_texture_ != nullptr &&
-                      props->video_width_ > 0 && props->video_height_ > 0 &&
-                      props->front_frame_ && !props->front_frame_->empty();
-  }
-
-  if (has_valid_frame) {
-    return;
-  }
-
-  const std::string &text =
-      localization::receiving_screen[localization_language_index_];
-  ImVec2 size = ImGui::GetWindowSize();
-  ImVec2 text_size = ImGui::CalcTextSize(text.c_str());
-  ImGui::SetCursorPos(
-      ImVec2((size.x - text_size.x) * 0.5f, (size.y - text_size.y) * 0.5f));
-  ImGui::TextColored(ImVec4(1.0f, 1.0f, 1.0f, 0.92f), "%s", text.c_str());
-}
-
-void GuiApplication::CloseTab(decltype(remote_sessions_)::iterator &it) {
-  // std::unique_lock lock(remote_sessions_mutex_);
-  if (it != remote_sessions_.end()) {
-    CloseRemoteSession(it->second);
-    it = remote_sessions_.erase(it);
-    if (remote_sessions_.empty()) {
-      SDL_Event event;
-      event.type = SDL_EVENT_QUIT;
-      SDL_PushEvent(&event);
-    }
-  }
-}
-
-int GuiApplication::StreamWindow() {
-  ImGui::SetNextWindowPos(
-      ImVec2(0, fullscreen_button_pressed_ ? 0 : title_bar_height_),
-      ImGuiCond_Always);
-  ImGui::SetNextWindowSize(ImVec2(stream_window_width_, stream_window_height_),
-                           ImGuiCond_Always);
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
-  ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0, 0, 0, 0));
-  ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0, 0, 0, 0));
-  bool video_bg_opened = ImGui::Begin(
-      "VideoBg", nullptr,
-      ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoDecoration |
-          ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoDocking);
-  ImGui::PopStyleColor(2);
-  ImGui::PopStyleVar();
-
-  if (!video_bg_opened) {
-    return 0;
-  }
-
-  ImGuiWindowFlags stream_window_flag =
-      ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoDecoration |
-      ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoMove;
-
-  if (!fullscreen_button_pressed_) {
-    ImGui::SetNextWindowPos(
-        ImVec2(title_bar_button_width_ * 0.8f, title_bar_button_width_ * 0.1f),
-        ImGuiCond_Always);
-    ImGui::SetNextWindowSize(ImVec2(0, title_bar_button_width_ * 0.8f),
-                             ImGuiCond_Always);
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0, 0, 0, 0.0f));
-    ImGui::Begin("TabBar", nullptr,
-                 ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoDecoration |
-                     ImGuiWindowFlags_NoBringToFrontOnFocus |
-                     ImGuiWindowFlags_NoDocking);
-    ImGui::PopStyleColor();
-    ImGui::PopStyleVar(2);
-
-    if (ImGui::BeginTabBar("StreamTabBar",
-                           ImGuiTabBarFlags_Reorderable |
-                               ImGuiTabBarFlags_AutoSelectNewTabs)) {
-      is_tab_bar_hovered_ = ImGui::IsWindowHovered();
-
-      // std::shared_lock lock(remote_sessions_mutex_);
-      for (auto it = remote_sessions_.begin();
-           it != remote_sessions_.end();) {
-        auto &props = it->second;
-        if (!props->tab_opened_) {
-          std::string remote_id_to_close = props->remote_id_;
-          // lock.unlock();
-          {
-            // std::unique_lock unique_lock(remote_sessions_mutex_);
-            auto close_it = remote_sessions_.find(remote_id_to_close);
-            if (close_it != remote_sessions_.end()) {
-              CloseTab(close_it);
-            }
-          }
-          // lock.lock();
-          it = remote_sessions_.begin();
-          continue;
-        }
-
-        const std::string& tab_label = props->remote_id_;
-        if (ImGui::BeginTabItem(tab_label.c_str(), &props->tab_opened_)) {
-          props->tab_selected_ = true;
-          ImGui::SetWindowFontScale(0.6f);
-
-          ImGui::SetNextWindowSize(
-              ImVec2(stream_window_width_,
-                     stream_window_height_ -
-                         (fullscreen_button_pressed_ ? 0 : title_bar_height_)),
-              ImGuiCond_Always);
-          ImGui::SetNextWindowPos(
-              ImVec2(0, fullscreen_button_pressed_ ? 0 : title_bar_height_),
-              ImGuiCond_Always);
-          ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
-          ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
-          ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0, 0, 0, 0.0f));
-          ImGui::Begin(props->remote_id_.c_str(), nullptr, stream_window_flag);
-          ImGui::PopStyleColor();
-          ImGui::PopStyleVar(2);
-
-          ImVec2 pos = ImGui::GetWindowPos();
-          ImVec2 size = ImGui::GetWindowSize();
-          props->render_window_x_ = pos.x;
-          props->render_window_y_ = pos.y;
-          props->render_window_width_ = size.x;
-          props->render_window_height_ = size.y;
-          UpdateRenderRect();
-
-          ControlWindow(props);
-
-          // Show file transfer window if needed
-          FileTransferWindow(props);
-
-          DrawReceivingScreenText(props);
-
-          focused_remote_id_ = props->remote_id_;
-
-          if (!props->peer_) {
-            std::string remote_id_to_erase = props->remote_id_;
-            // lock.unlock();
-            {
-              // std::unique_lock unique_lock(remote_sessions_mutex_);
-              auto erase_it = remote_sessions_.find(remote_id_to_erase);
-              if (erase_it != remote_sessions_.end()) {
-                // Ensure we flush pending STREAM_REFRESH_EVENT events and
-                // clean up peer resources before erasing the entry, otherwise
-                // SDL events may still hold raw pointers to freed
-                // RemoteSession (including video_frame_mutex_),
-                // leading to std::system_error when locking.
-                CloseTab(erase_it);
-              }
-            }
-            // lock.lock();
-            ImGui::End();
-            ImGui::EndTabItem();
-            it = remote_sessions_.begin();
-            continue;
-          } else {
-            DrawConnectionStatusText(props);
-            ++it;
-          }
-
-          ImGui::End();
-          ImGui::EndTabItem();
-        } else {
-          props->tab_selected_ = false;
-          if (!props->tab_opened_) {
-            std::string remote_id_to_close = props->remote_id_;
-            // lock.unlock();
-            {
-              // std::unique_lock unique_lock(remote_sessions_mutex_);
-              auto close_it = remote_sessions_.find(remote_id_to_close);
-              if (close_it != remote_sessions_.end()) {
-                CloseTab(close_it);
-              }
-            }
-            // lock.lock();
-            it = remote_sessions_.begin();
-            continue;
-          }
-          ++it;
-        }
-      }
-
-      ImGui::EndTabBar();
-    }
-
-    ImGui::End(); // End TabBar
-  } else {
-    // std::shared_lock lock(remote_sessions_mutex_);
-    for (auto it = remote_sessions_.begin();
-         it != remote_sessions_.end();) {
-      auto &props = it->second;
-      if (!props->tab_opened_) {
-        std::string remote_id_to_close = props->remote_id_;
-        // lock.unlock();
-        {
-          // std::unique_lock unique_lock(remote_sessions_mutex_);
-          auto close_it = remote_sessions_.find(remote_id_to_close);
-          if (close_it != remote_sessions_.end()) {
-            CloseTab(close_it);
-          }
-        }
-        // lock.lock();
-        it = remote_sessions_.begin();
-        continue;
-      }
-
-      if (props->tab_selected_) {
-        ImGui::SetNextWindowSize(
-            ImVec2(stream_window_width_,
-                   stream_window_height_ -
-                       (fullscreen_button_pressed_ ? 0 : title_bar_height_)),
-            ImGuiCond_Always);
-        ImGui::SetNextWindowPos(ImVec2(0, 0), ImGuiCond_Always);
-        ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
-        ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
-        ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0, 0, 0, 0.0f));
-        ImGui::Begin(props->remote_id_.c_str(), nullptr, stream_window_flag);
-        ImGui::PopStyleColor();
-        ImGui::PopStyleVar(2);
-
-        ImVec2 pos = ImGui::GetWindowPos();
-        ImVec2 size = ImGui::GetWindowSize();
-        props->render_window_x_ = pos.x;
-        props->render_window_y_ = pos.y;
-        props->render_window_width_ = size.x;
-        props->render_window_height_ = size.y;
-        UpdateRenderRect();
-
-        ControlWindow(props);
-
-        // Show file transfer window if needed
-        FileTransferWindow(props);
-
-        DrawReceivingScreenText(props);
-
-        ImGui::End();
-
-        if (!props->peer_) {
-          fullscreen_button_pressed_ = false;
-          SDL_SetWindowFullscreen(stream_window_, false);
-          std::string remote_id_to_erase = props->remote_id_;
-          // lock.unlock();
-          {
-            // std::unique_lock unique_lock(remote_sessions_mutex_);
-            auto erase_it = remote_sessions_.find(remote_id_to_erase);
-            if (erase_it != remote_sessions_.end()) {
-              CloseTab(erase_it);
-            }
-          }
-          // lock.lock();
-          it = remote_sessions_.begin();
-          continue;
-        } else {
-          DrawConnectionStatusText(props);
-          ++it;
-        }
-      } else {
-        ++it;
-      }
-    }
-  }
-
-  // UpdateRenderRect();
-  ImGui::End(); // End VideoBg
-
-  return 0;
-}
-} // namespace crossdesk

apps/desktop/src/gui/views/windows/update_notification_window.cpp

@@ -1,163 +0,0 @@
-#include <string>
-
-#include "application/gui_application.h"
-#include "layout.h"
-#include "localization.h"
-#include "rd_log.h"
-
-namespace crossdesk {
-
-int GuiApplication::UpdateNotificationWindow() {
-  if (show_update_notification_window_ && update_available_) {
-    const ImGuiViewport* viewport = ImGui::GetMainViewport();
-
-    float update_notification_window_width = title_bar_button_width_ * 10.0f;
-    float update_notification_window_height = title_bar_button_width_ * 8.0f;
-
-    // #ifdef __APPLE__
-    //     float font_scale = 0.3f;
-    // #else
-    //     float font_scale = 0.5f;
-    // #endif
-
-    ImGui::SetNextWindowPos(ImVec2((viewport->WorkSize.x - viewport->WorkPos.x -
-                                    update_notification_window_width) /
-                                       2,
-                                   (viewport->WorkSize.y - viewport->WorkPos.y -
-                                    update_notification_window_height) /
-                                       2),
-                            ImGuiCond_FirstUseEver);
-
-    ImGui::SetNextWindowSize(ImVec2(update_notification_window_width,
-                                    update_notification_window_height));
-
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 1.0f);
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, window_rounding_);
-    ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, window_rounding_ * 0.5f);
-    ImGui::Begin(
-        localization::notification[localization_language_index_].c_str(),
-        nullptr,
-        ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse |
-            ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoTitleBar);
-
-    ImGui::SetCursorPosY(ImGui::GetCursorPosY() +
-                         update_notification_window_height * 0.05f);
-
-    // title: new version available
-    ImGui::SetCursorPosX(update_notification_window_width * 0.1f);
-    ImGui::SetWindowFontScale(0.55f);
-    std::string title =
-        localization::new_version_available[localization_language_index_] +
-        ": " + latest_version_;
-    ImGui::Text("%s", title.c_str());
-    ImGui::SetWindowFontScale(0.1f);
-
-    ImGui::Spacing();
-
-    // website link
-    std::string download_text =
-        localization::access_website[localization_language_index_] +
-        "https://crossdesk.cn";
-    ImGui::SetWindowFontScale(0.5f);
-    ImGui::SetCursorPosX(update_notification_window_width * 0.1f);
-    Hyperlink(download_text, "https://crossdesk.cn",
-              update_notification_window_width);
-    ImGui::SetWindowFontScale(1.0f);
-
-    ImGui::Spacing();
-
-    float scrollable_height =
-        update_notification_window_height - UPDATE_NOTIFICATION_RESERVED_HEIGHT;
-
-    if (main_windows_system_chinese_font_ != nullptr) {
-      ImGui::PushFont(main_windows_system_chinese_font_);
-    }
-    // scrollable content area
-    ImGui::SetCursorPosX(update_notification_window_width * 0.05f);
-    ImGui::BeginChild(
-        "ScrollableContent",
-        ImVec2(update_notification_window_width * 0.9f, scrollable_height),
-        ImGuiChildFlags_Borders, ImGuiWindowFlags_None);
-    ImGui::SetWindowFontScale(0.5f);
-    // set text wrap position to current available width (accounts for
-    // scrollbar)
-    float wrap_pos = ImGui::GetContentRegionAvail().x;
-    ImGui::PushTextWrapPos(wrap_pos);
-
-    // release name
-    if (latest_version_info_.contains("releaseName") &&
-        latest_version_info_["releaseName"].is_string() &&
-        !latest_version_info_["releaseName"].empty()) {
-      ImGui::SetCursorPosX(update_notification_window_width * 0.05f);
-      std::string release_name =
-          latest_version_info_["releaseName"].get<std::string>();
-      ImGui::TextWrapped("%s", release_name.c_str());
-      ImGui::Spacing();
-    }
-
-    // release notes
-    if (!release_notes_.empty()) {
-      ImGui::SetCursorPosX(update_notification_window_width * 0.05f);
-      ImGui::TextWrapped("%s", release_notes_.c_str());
-      ImGui::Spacing();
-    }
-
-    // release date
-    if (latest_version_info_.contains("releaseDate") &&
-        latest_version_info_["releaseDate"].is_string() &&
-        !latest_version_info_["releaseDate"].empty()) {
-      ImGui::SetCursorPosX(update_notification_window_width * 0.05f);
-      std::string date_label =
-          localization::release_date[localization_language_index_];
-      std::string release_date = latest_version_info_["releaseDate"];
-      std::string date_text = date_label + release_date;
-      ImGui::Text("%s", date_text.c_str());
-      ImGui::Spacing();
-    }
-
-    // pop text wrap position
-    ImGui::PopTextWrapPos();
-
-    ImGui::EndChild();
-
-    // pop system font
-    if (main_windows_system_chinese_font_ != nullptr) {
-      ImGui::PopFont();
-    }
-
-    ImGui::Spacing();
-
-    if (ConfigCenter::LANGUAGE::CHINESE == localization_language_) {
-      ImGui::SetCursorPosX(update_notification_window_width * 0.407f);
-    } else {
-      ImGui::SetCursorPosX(update_notification_window_width * 0.367f);
-    }
-
-    ImGui::SetWindowFontScale(0.5f);
-    // update button
-    if (ImGui::Button(
-            localization::update[localization_language_index_].c_str())) {
-      // open download page
-      std::string url = "https://crossdesk.cn";
-      OpenUrl(url);
-      show_update_notification_window_ = false;
-    }
-
-    ImGui::SameLine();
-
-    if (ImGui::Button(
-            localization::cancel[localization_language_index_].c_str())) {
-      show_update_notification_window_ = false;
-    }
-
-    ImGui::SetWindowFontScale(1.0f);
-
-    ImGui::End();
-    ImGui::PopStyleVar(3);
-    ImGui::PopStyleColor();
-  }
-  return 0;
-}
-
-}  // namespace crossdesk

apps/desktop/src/platform/macos/gui/views/request_permission_window.mm

@@ -1,187 +0,0 @@
-#include "application/gui_application.h"
-#include "layout.h"
-#include "localization.h"
-
-namespace crossdesk {
-
-bool GuiApplication::DrawToggleSwitch(const char *id, bool active,
-                                      bool enabled) {
-  const float TRACK_HEIGHT = ImGui::GetFrameHeight();
-  const float TRACK_WIDTH = TRACK_HEIGHT * 1.8f;
-  const float TRACK_RADIUS = TRACK_HEIGHT * 0.5f;
-  const float KNOB_PADDING = 2.0f;
-  const float KNOB_HEIGHT = TRACK_HEIGHT - 4.0f;
-  const float KNOB_WIDTH = KNOB_HEIGHT * 1.2f;
-  const float KNOB_RADIUS = KNOB_HEIGHT * 0.5f;
-  const float DISABLED_ALPHA = 0.6f;
-  const float KNOB_ALPHA_DISABLED = 0.9f;
-
-  const ImVec4 COLOR_ACTIVE = ImVec4(0.0f, 0.0f, 1.0f, 1.0f);
-  const ImVec4 COLOR_ACTIVE_HOVER = ImVec4(0.26f, 0.59f, 0.98f, 1.0f);
-  const ImVec4 COLOR_INACTIVE = ImVec4(0.60f, 0.60f, 0.60f, 1.0f);
-  const ImVec4 COLOR_INACTIVE_HOVER = ImVec4(0.70f, 0.70f, 0.70f, 1.0f);
-  const ImVec4 COLOR_KNOB = ImVec4(1.0f, 1.0f, 1.0f, 1.0f);
-
-  ImDrawList *draw_list = ImGui::GetWindowDrawList();
-  ImVec2 track_pos = ImGui::GetCursorScreenPos();
-
-  ImGui::InvisibleButton(id, ImVec2(TRACK_WIDTH, TRACK_HEIGHT));
-  bool hovered = ImGui::IsItemHovered();
-  bool clicked = ImGui::IsItemClicked() && enabled;
-
-  ImVec4 track_color =
-      active ? (hovered && enabled ? COLOR_ACTIVE_HOVER : COLOR_ACTIVE)
-             : (hovered && enabled ? COLOR_INACTIVE_HOVER : COLOR_INACTIVE);
-
-  if (!enabled) {
-    track_color.w *= DISABLED_ALPHA;
-  }
-
-  ImVec2 track_min = ImVec2(track_pos.x, track_pos.y + 0.5f);
-  ImVec2 track_max =
-      ImVec2(track_pos.x + TRACK_WIDTH, track_pos.y + TRACK_HEIGHT - 0.5f);
-  draw_list->AddRectFilled(track_min, track_max,
-                           ImGui::GetColorU32(track_color), TRACK_RADIUS);
-
-  float knob_position = active ? 1.0f : 0.0f;
-  float knob_min_x = track_pos.x + KNOB_PADDING;
-  float knob_max_x = track_pos.x + TRACK_WIDTH - KNOB_WIDTH - KNOB_PADDING;
-  float knob_x = knob_min_x + knob_position * (knob_max_x - knob_min_x);
-  float knob_y = track_pos.y + (TRACK_HEIGHT - KNOB_HEIGHT) * 0.5f;
-
-  ImVec4 knob_color = COLOR_KNOB;
-  if (!enabled) {
-    knob_color.w = KNOB_ALPHA_DISABLED;
-  }
-
-  ImVec2 knob_min = ImVec2(knob_x, knob_y);
-  ImVec2 knob_max = ImVec2(knob_x + KNOB_WIDTH, knob_y + KNOB_HEIGHT);
-  draw_list->AddRectFilled(knob_min, knob_max, ImGui::GetColorU32(knob_color),
-                           KNOB_RADIUS);
-
-  return clicked;
-}
-
-int GuiApplication::RequestPermissionWindow() {
-  RefreshMacPermissionStatus(false);
-
-  const bool screen_recording_granted =
-      mac_screen_recording_permission_granted_;
-  const bool accessibility_granted = mac_accessibility_permission_granted_;
-
-  show_request_permission_window_ =
-      !screen_recording_granted || !accessibility_granted;
-
-  if (!show_request_permission_window_) {
-    return 0;
-  }
-
-  const ImGuiViewport *viewport = ImGui::GetMainViewport();
-  float window_width = localization_language_index_ == 0
-                           ? REQUEST_PERMISSION_WINDOW_WIDTH_CN
-                           : REQUEST_PERMISSION_WINDOW_WIDTH_EN;
-  float window_height = localization_language_index_ == 0
-                            ? REQUEST_PERMISSION_WINDOW_HEIGHT_CN
-                            : REQUEST_PERMISSION_WINDOW_HEIGHT_EN;
-
-  float checkbox_padding = localization_language_index_ == 0
-                               ? REQUEST_PERMISSION_WINDOW_CHECKBOX_PADDING_CN
-                               : REQUEST_PERMISSION_WINDOW_CHECKBOX_PADDING_EN;
-
-  ImVec2 center_pos = ImVec2(
-      (viewport->WorkSize.x - window_width) * 0.5f + viewport->WorkPos.x,
-      (viewport->WorkSize.y - window_height) * 0.5f + viewport->WorkPos.y);
-  ImGui::SetNextWindowPos(center_pos, ImGuiCond_Once);
-
-  ImGui::SetNextWindowSize(ImVec2(window_width, window_height),
-                           ImGuiCond_Always);
-
-  ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 1.0f);
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, window_rounding_);
-  ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, window_rounding_ * 0.5f);
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
-
-  ImGui::Begin(
-      localization::request_permissions[localization_language_index_].c_str(),
-      nullptr,
-      ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse |
-          ImGuiWindowFlags_NoSavedSettings);
-
-  ImGui::SetWindowFontScale(0.3f);
-
-  // use system font
-  if (main_windows_system_chinese_font_ != nullptr) {
-    ImGui::PushFont(main_windows_system_chinese_font_);
-  }
-
-  ImGui::SetCursorPosY(ImGui::GetCursorPosY() + ImGui::GetTextLineHeight() +
-                       5.0f);
-  ImGui::SetCursorPosX(10.0f);
-  ImGui::TextWrapped(
-      "%s",
-      localization::permission_required_message[localization_language_index_]
-          .c_str());
-
-  ImGui::Spacing();
-  ImGui::Spacing();
-  ImGui::Spacing();
-
-  // accessibility permission
-  ImGui::SetCursorPosX(10.0f);
-  ImGui::AlignTextToFramePadding();
-  ImGui::Text(
-      "1. %s:",
-      localization::accessibility_permission[localization_language_index_]
-          .c_str());
-  ImGui::SameLine();
-  ImGui::AlignTextToFramePadding();
-  ImGui::SetCursorPosX(checkbox_padding);
-  if (accessibility_granted) {
-    DrawToggleSwitch("accessibility_toggle_on", true, false);
-  } else {
-    if (DrawToggleSwitch("accessibility_toggle", false, true)) {
-      OpenAccessibilityPreferences();
-      mac_accessibility_permission_requested_ = true;
-      RefreshMacPermissionStatus(true);
-    }
-  }
-
-  ImGui::Spacing();
-
-  // screen recording permission
-  ImGui::SetCursorPosX(10.0f);
-  ImGui::AlignTextToFramePadding();
-  ImGui::Text(
-      "2. %s:",
-      localization::screen_recording_permission[localization_language_index_]
-          .c_str());
-  ImGui::SameLine();
-  ImGui::AlignTextToFramePadding();
-  ImGui::SetCursorPosX(checkbox_padding);
-  if (screen_recording_granted) {
-    DrawToggleSwitch("screen_recording_toggle_on", true, false);
-  } else {
-    if (DrawToggleSwitch("screen_recording_toggle", false, true)) {
-      OpenScreenRecordingPreferences();
-      mac_screen_recording_permission_requested_ = true;
-      RefreshMacPermissionStatus(true);
-    }
-  }
-
-  ImGui::SetWindowFontScale(1.0f);
-  ImGui::SetWindowFontScale(0.45f);
-
-  // pop system font
-  if (main_windows_system_chinese_font_ != nullptr) {
-    ImGui::PopFont();
-  }
-
-  ImGui::End();
-  ImGui::SetWindowFontScale(1.0f);
-  ImGui::PopStyleVar(4);
-  ImGui::PopStyleColor();
-
-  return 0;
-}
-} // namespace crossdesk

apps/desktop/src/platform/macos/gui/window_util_mac.h

@@ -1,25 +0,0 @@
-/*
- * @Author: DI JUNKUN
- * @Date: 2026-01-20
- * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
- */
-
-#ifndef _WINDOW_UTIL_MAC_H_
-#define _WINDOW_UTIL_MAC_H_
-
-struct SDL_Window;
-
-namespace crossdesk {
-
-// Best-effort: keep an SDL window above normal windows on macOS.
-// No-op on non-macOS builds.
-void MacSetWindowAlwaysOnTop(::SDL_Window* window, bool always_on_top);
-
-// Best-effort: exclude an SDL window from the Window menu and window cycling.
-// Note: Cmd-Tab switches apps (not individual windows), so this primarily
-// affects the Window menu and Cmd-` window cycling.
-void MacSetWindowExcludedFromWindowMenu(::SDL_Window* window, bool excluded);
-
-}  // namespace crossdesk
-
-#endif

apps/desktop/src/platform/macos/gui/window_util_mac.mm

@@ -1,64 +0,0 @@
-#include "window_util_mac.h"
-
-#if defined(__APPLE__)
-
-#include <SDL3/SDL.h>
-
-#import <Cocoa/Cocoa.h>
-
-namespace crossdesk {
-
-static NSWindow* GetNSWindowFromSDL(::SDL_Window* window) {
-  if (!window) {
-    return nil;
-  }
-
-#if !defined(SDL_PROP_WINDOW_COCOA_WINDOW_POINTER)
-  return nil;
-#else
-  SDL_PropertiesID props = SDL_GetWindowProperties(window);
-  void* cocoa_window_ptr =
-      SDL_GetPointerProperty(props, SDL_PROP_WINDOW_COCOA_WINDOW_POINTER, NULL);
-  if (!cocoa_window_ptr) {
-    return nil;
-  }
-  return (__bridge NSWindow*)cocoa_window_ptr;
-#endif
-}
-
-void MacSetWindowAlwaysOnTop(::SDL_Window* window, bool always_on_top) {
-  NSWindow* ns_window = GetNSWindowFromSDL(window);
-  if (!ns_window) {
-    (void)always_on_top;
-    return;
-  }
-
-  // Keep above normal windows.
-  const NSInteger level = always_on_top ? NSFloatingWindowLevel : NSNormalWindowLevel;
-  [ns_window setLevel:level];
-
-  // Optional: keep visible across Spaces/fullscreen. Safe as best-effort.
-  NSWindowCollectionBehavior behavior = [ns_window collectionBehavior];
-  behavior |= NSWindowCollectionBehaviorCanJoinAllSpaces;
-  behavior |= NSWindowCollectionBehaviorFullScreenAuxiliary;
-  [ns_window setCollectionBehavior:behavior];
-}
-
-void MacSetWindowExcludedFromWindowMenu(::SDL_Window* window, bool excluded) {
-  NSWindow* ns_window = GetNSWindowFromSDL(window);
-  if (!ns_window) {
-    (void)excluded;
-    return;
-  }
-
-  [ns_window setExcludedFromWindowsMenu:excluded];
-
-  NSWindowCollectionBehavior behavior = [ns_window collectionBehavior];
-  behavior |= NSWindowCollectionBehaviorIgnoresCycle;
-  behavior |= NSWindowCollectionBehaviorTransient;
-  [ns_window setCollectionBehavior:behavior];
-}
-
-}  // namespace crossdesk
-
-#endif  // __APPLE__

apps/desktop/src/platform/windows/gui/runtime/windows_service_runtime.cpp

@@ -10,6 +10,7 @@
 #include "rd_log.h"
 
 #if _WIN32
+#include "interactive_desktop.h"
 #include "interactive_state.h"
 #include "service_host.h"
 #endif
@@ -19,6 +20,7 @@ namespace {
 #if _WIN32
 struct WindowsServiceInteractiveStatus {
   bool available = false;
+  bool session_mismatch = false;
   bool sas_secure_desktop_grace_active = false;
   unsigned int error_code = 0;
   std::string interactive_stage;
@@ -65,6 +67,14 @@ bool QueryWindowsServiceInteractiveStatus(
   if (!status->available) {
     status->error = json.value("error", std::string("service_unavailable"));
     status->error_code = json.value("code", 0u);
+    status->session_mismatch = status->error == "service_session_mismatch";
+    return true;
+  }
+
+  if (!IsCurrentProcessSession(json.value("active_session_id", 0xFFFFFFFFu))) {
+    status->available = false;
+    status->session_mismatch = true;
+    status->error = "service_session_mismatch";
     return true;
   }
 
@@ -145,6 +155,9 @@ void GuiRuntime::HandleWindowsServiceIntegration() {
 
   WindowsServiceInteractiveStatus status;
   const bool status_ok = QueryWindowsServiceInteractiveStatus(&status);
+  const bool user_desktop_recovered =
+      !status.available && IsCurrentSessionUserDesktopActive();
+  if (user_desktop_recovered) status.interactive_stage = "user-desktop";
   WindowsServiceInteractiveStatus broadcast_status = status;
   const bool previous_secure_desktop_interaction =
       IsSecureDesktopInteractionRequired(local_interactive_stage_);
@@ -167,8 +180,11 @@ void GuiRuntime::HandleWindowsServiceIntegration() {
       local_interactive_stage_ = status.interactive_stage;
       optimistic_windows_secure_desktop_until_tick_ = 0;
     }
-  } else if (!previous_secure_desktop_interaction) {
-    local_interactive_stage_.clear();
+  } else if (status.session_mismatch || user_desktop_recovered ||
+             !previous_secure_desktop_interaction) {
+    // A verified local desktop or a different service session invalidates the
+    // cached secure stage. An unexplained IPC failure alone still does not.
+    local_interactive_stage_ = status.interactive_stage;
     optimistic_windows_secure_desktop_until_tick_ = 0;
   }
 
@@ -184,9 +200,9 @@ void GuiRuntime::HandleWindowsServiceIntegration() {
         LOG_INFO(
             "Local Windows service available for secure desktop integration");
       } else if (IsTransientWindowsServiceStatusError(status.error)) {
-        LOG_INFO("Local Windows service temporarily unavailable, keeping last "
-                 "secure desktop state: error={}, code={}",
-                 status.error, status.error_code);
+        LOG_INFO("Local Windows service temporarily unavailable: error={}, "
+                 "code={}, local_stage='{}'",
+                 status.error, status.error_code, local_interactive_stage_);
       } else {
         LOG_WARN(
             "Local Windows service unavailable, secure desktop integration "

apps/desktop/src/platform/windows/input/keyboard/keyboard_capturer.cpp

@@ -3,7 +3,9 @@
 #include <hidusage.h>
 
 #include "rd_log.h"
+#include "windows_input_injector.h"
 #include "windows_input_marker.h"
+#include "windows_key_metadata.h"
 
 namespace crossdesk {
 namespace {
@@ -264,6 +266,11 @@ void PlatformKeyboardCapturer::HandleRawInput(HRAWINPUT raw_input_handle) {
 // Apply remote keyboard commands to the local machine.
 int PlatformKeyboardCapturer::SendKeyboardCommand(int key_code, bool is_down,
                                           uint32_t scan_code, bool extended) {
+  if (scan_code == 0) {
+    // Some layouts omit the E0 prefix for navigation keys in MapVirtualKey.
+    // Preserve explicit metadata, including non-extended numpad navigation.
+    LookupWindowsKeyMetadataFromVk(key_code, &scan_code, &extended);
+  }
   INPUT input = {0};
   input.type = INPUT_KEYBOARD;
   input.ki.dwExtraInfo =
@@ -304,7 +311,7 @@ int PlatformKeyboardCapturer::SendKeyboardCommand(int key_code, bool is_down,
     input.ki.dwFlags |= KEYEVENTF_KEYUP;
   }
 
-  const UINT sent = SendInput(1, &input, sizeof(INPUT));
+  const UINT sent = SendInputOnUserDesktop(input);
   if (sent != 1) {
     LOG_WARN("SendInput failed for key_code={}, is_down={}, err={}", key_code,
              is_down, GetLastError());

apps/desktop/src/platform/windows/input/mouse/mouse_controller.cpp

@@ -6,9 +6,10 @@
 #include <algorithm>
 #include <cmath>
 
-#include "../../windows_thread_dpi.h"
 #include "rd_log.h"
+#include "windows_input_injector.h"
 #include "windows_input_marker.h"
+#include "windows_thread_dpi.h"
 
 namespace crossdesk {
 
@@ -17,11 +18,28 @@ PlatformMouseController::PlatformMouseController() {}
 PlatformMouseController::~PlatformMouseController() { Destroy(); }
 
 int PlatformMouseController::Init(std::vector<DisplayInfo> display_info_list) {
+  std::lock_guard<std::mutex> lock(display_info_mutex_);
   display_info_list_ = display_info_list;
 
   return 0;
 }
 
+void PlatformMouseController::UpdateDisplayInfoList(
+    const std::vector<DisplayInfo>& display_info_list) {
+  if (display_info_list.empty()) return;
+  std::lock_guard<std::mutex> lock(display_info_mutex_);
+  if (std::equal(display_info_list.begin(), display_info_list.end(),
+                 display_info_list_.begin(), display_info_list_.end(),
+                 [](const auto& a, const auto& b) {
+                   return a.handle == b.handle && a.left == b.left &&
+                          a.top == b.top && a.width == b.width &&
+                          a.height == b.height;
+                 })) return;
+  display_info_list_ = display_info_list;
+  LOG_INFO("Windows mouse display geometry updated: displays={}",
+           display_info_list_.size());
+}
+
 int PlatformMouseController::Destroy() { return ReleasePressedButtons(); }
 
 int PlatformMouseController::ReleasePressedButtons() {
@@ -33,7 +51,7 @@ int PlatformMouseController::ReleasePressedButtons() {
   if (pressed & 1) input.mi.dwFlags |= MOUSEEVENTF_LEFTUP;
   if (pressed & 2) input.mi.dwFlags |= MOUSEEVENTF_RIGHTUP;
   if (pressed & 4) input.mi.dwFlags |= MOUSEEVENTF_MIDDLEUP;
-  if (SendInput(1, &input, sizeof(INPUT)) != 1) {
+  if (SendInputOnUserDesktop(input) != 1) {
     LOG_WARN("Release remote mouse buttons failed, error={}", GetLastError());
     return -1;
   }
@@ -43,13 +61,19 @@ int PlatformMouseController::ReleasePressedButtons() {
 
 int PlatformMouseController::SendMouseCommand(RemoteAction remote_action,
                                               int display_index) {
+  std::unique_lock<std::mutex> geometry_lock(display_info_mutex_);
   if (display_index < 0 ||
-      display_index >= static_cast<int>(display_info_list_.size())) {
+      display_index >= static_cast<int>(display_info_list_.size()) ||
+      display_info_list_[display_index].width <= 0 ||
+      display_info_list_[display_index].height <= 0) {
     LOG_WARN("Mouse command skipped, invalid display_index={}, displays={}",
              display_index, display_info_list_.size());
     return -1;
   }
 
+  const auto display = display_info_list_[display_index];
+  geometry_lock.unlock();
+
   INPUT ip = {0};
   ScopedWindowsPhysicalCoordinates physical_coordinates;
 
@@ -58,11 +82,9 @@ int PlatformMouseController::SendMouseCommand(RemoteAction remote_action,
     return -1;
   ip.type = INPUT_MOUSE;
   ip.mi.dx = (LONG)(std::clamp(remote_action.m.x, 0.0f, 1.0f) *
-                    (display_info_list_[display_index].width - 1)) +
-             display_info_list_[display_index].left;
+                    (display.width - 1)) + display.left;
   ip.mi.dy = (LONG)(std::clamp(remote_action.m.y, 0.0f, 1.0f) *
-                    (display_info_list_[display_index].height - 1)) +
-             display_info_list_[display_index].top;
+                    (display.height - 1)) + display.top;
 
   switch (remote_action.m.flag) {
     case MouseFlag::left_down:
@@ -105,16 +127,22 @@ int PlatformMouseController::SendMouseCommand(RemoteAction remote_action,
   }
   // Pixel centres in the virtual desktop, including negative monitor origins.
   // SetCursorPos cannot carry dwExtraInfo through the privacy mouse hook.
-  ip.mi.dx = static_cast<LONG>(
-      (static_cast<int64_t>(ip.mi.dx - virtual_left) * 65536 + 32768) /
-      virtual_width);
-  ip.mi.dy = static_cast<LONG>(
-      (static_cast<int64_t>(ip.mi.dy - virtual_top) * 65536 + 32768) /
-      virtual_height);
+  const int virtual_width_range = (std::max)(1, virtual_width - 1);
+  const int virtual_height_range = (std::max)(1, virtual_height - 1);
+  ip.mi.dx = static_cast<LONG>(std::clamp<int64_t>(
+      (static_cast<int64_t>(ip.mi.dx - virtual_left) * 65535 +
+       virtual_width_range / 2) /
+          virtual_width_range,
+      0, 65535));
+  ip.mi.dy = static_cast<LONG>(std::clamp<int64_t>(
+      (static_cast<int64_t>(ip.mi.dy - virtual_top) * 65535 +
+       virtual_height_range / 2) /
+          virtual_height_range,
+      0, 65535));
   ip.mi.dwFlags |=
       MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_VIRTUALDESK;
   ip.mi.dwExtraInfo = kInjectedMouseInputMarker;
-  const UINT sent = SendInput(1, &ip, sizeof(INPUT));
+  const UINT sent = SendInputOnUserDesktop(ip);
   if (sent != 1) {
     LOG_WARN("SendInput failed for mouse x={}, y={}, wheel={}, flag={}, err={}",
              ip.mi.dx, ip.mi.dy, remote_action.m.s,

apps/desktop/src/platform/windows/input/mouse/mouse_controller.h

@@ -9,6 +9,7 @@
 
 #include <vector>
 #include <atomic>
+#include <mutex>
 
 #include <remote_action.h>
 
@@ -26,10 +27,13 @@ class PlatformMouseController final : public MouseController {
   virtual int Init(std::vector<DisplayInfo> display_info_list);
   virtual int Destroy();
   virtual int SendMouseCommand(RemoteAction remote_action, int display_index);
+  void UpdateDisplayInfoList(
+      const std::vector<DisplayInfo>& display_info_list) override;
   int ReleasePressedButtons();
 
  private:
   std::vector<DisplayInfo> display_info_list_;
+  std::mutex display_info_mutex_;
   std::atomic<unsigned> pressed_buttons_{0};
 };
 }  // namespace crossdesk

apps/desktop/src/platform/windows/input/windows_input_injector.cpp

@@ -0,0 +1,108 @@
+#include "windows_input_injector.h"
+
+#include <condition_variable>
+#include <future>
+#include <mutex>
+#include <queue>
+#include <thread>
+#include <utility>
+
+#include "interactive_desktop.h"
+#include "rd_log.h"
+
+namespace crossdesk {
+namespace {
+
+DWORD InjectOnUserDesktop(INPUT input) {
+  if (!IsCurrentSessionUnlocked()) {
+    return ERROR_REQUIRES_INTERACTIVE_WINDOWSTATION;
+  }
+  ScopedInteractiveDesktop desktop;
+  if (!desktop.Bind(L"")) {
+    const DWORD error = GetLastError();
+    return error != ERROR_SUCCESS ? error : ERROR_GEN_FAILURE;
+  }
+  if (!desktop.IsReceivingInput()) {
+    return ERROR_REQUIRES_INTERACTIVE_WINDOWSTATION;
+  }
+  // Lock screens and UAC still require the session-checked service path.
+  if (_wcsicmp(desktop.name().c_str(), L"Default") != 0) {
+    return ERROR_ACCESS_DENIED;
+  }
+  SetLastError(ERROR_SUCCESS);
+  if (SendInput(1, &input, sizeof(INPUT)) == 1) return ERROR_SUCCESS;
+  const DWORD error = GetLastError();
+  return error != ERROR_SUCCESS ? error : ERROR_GEN_FAILURE;
+}
+
+class UserDesktopInputWorker {
+ public:
+  UserDesktopInputWorker() : thread_([this] { Run(); }) {}
+
+  ~UserDesktopInputWorker() {
+    {
+      std::lock_guard<std::mutex> lock(mutex_);
+      stopping_ = true;
+    }
+    wake_.notify_one();
+    thread_.join();
+  }
+
+  DWORD Send(INPUT input) {
+    std::packaged_task<DWORD()> task(
+        [input] { return InjectOnUserDesktop(input); });
+    auto result = task.get_future();
+    {
+      std::lock_guard<std::mutex> lock(mutex_);
+      pending_.push(std::move(task));
+    }
+    wake_.notify_one();
+    return result.get();
+  }
+
+ private:
+  void Run() {
+    std::unique_lock<std::mutex> lock(mutex_);
+    for (;;) {
+      wake_.wait(lock, [this] { return stopping_ || !pending_.empty(); });
+      if (pending_.empty()) return;
+      auto task = std::move(pending_.front());
+      pending_.pop();
+      lock.unlock();
+      task();
+      lock.lock();
+    }
+  }
+
+  std::mutex mutex_;
+  std::condition_variable wake_;
+  std::queue<std::packaged_task<DWORD()>> pending_;
+  bool stopping_ = false;
+  std::thread thread_;
+};
+
+}  // namespace
+
+UINT SendInputOnUserDesktop(const INPUT& input) {
+  static UserDesktopInputWorker worker;
+  const DWORD error = worker.Send(input);
+  if (error != ERROR_SUCCESS) {
+    // Include session identity even when Windows reports no useful SendInput
+    // error (for example UIPI). Keep repeated mouse-move failures bounded.
+    static std::mutex log_mutex;
+    static ULONGLONG last_log_tick = 0;
+    std::lock_guard<std::mutex> lock(log_mutex);
+    const ULONGLONG now = GetTickCount64();
+    if (last_log_tick == 0 || now - last_log_tick >= 2000) {
+      DWORD session_id = 0xFFFFFFFF;
+      ProcessIdToSessionId(GetCurrentProcessId(), &session_id);
+      LOG_WARN("User desktop input unavailable: session_id={}, error={}",
+               session_id, error);
+      last_log_tick = now;
+    }
+  }
+  SetLastError(error);
+  return error == ERROR_SUCCESS ? 1 : 0;
+}
+
+}  // namespace crossdesk

apps/desktop/src/platform/windows/input/windows_input_injector.h

@@ -0,0 +1,21 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-19
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _WINDOWS_INPUT_INJECTOR_H_
+#define _WINDOWS_INPUT_INJECTOR_H_
+
+#include <Windows.h>
+
+namespace crossdesk {
+
+// Executes on a worker without windows or hooks, attached to this process's
+// current user input desktop. Returns a SendInput count and preserves the
+// worker's failure code in the calling thread's last-error value.
+UINT SendInputOnUserDesktop(const INPUT& input);
+
+}  // namespace crossdesk
+
+#endif

apps/desktop/src/platform/windows/privacy/band_module/main.cpp

@@ -14,6 +14,8 @@
 
 #include "../../windows_thread_dpi.h"
 #include "../privacy_band_ipc.h"
+#include "../privacy_capture_exclusion.h"
+#include "../privacy_topology.h"
 #include "privacy_cover_renderer.h"
 
 namespace {
@@ -24,11 +26,6 @@ constexpr DWORD kCoverStyles = WS_EX_TOPMOST | WS_EX_NOACTIVATE |
                                WS_EX_TRANSPARENT;
 HMODULE module = nullptr;
 
-bool SameRect(const RECT& a, const RECT& b) {
-  return a.left == b.left && a.top == b.top && a.right == b.right &&
-         a.bottom == b.bottom;
-}
-
 class Windows {
  public:
   explicit Windows(PrivacyBandShared* shared) : shared_(shared) {}
@@ -59,6 +56,7 @@ class Windows {
     return atom_ ? Reconcile() : Fail(L"Register high-band window class");
   }
   bool Reconcile() {
+    InterlockedExchange(&shared_->topology_pending, 1);
     std::vector<RECT> monitors;
     if (!EnumDisplayMonitors(
             nullptr, nullptr,
@@ -68,16 +66,37 @@ class Windows {
               result.push_back(*rect);
               return TRUE;
             },
-            reinterpret_cast<LPARAM>(&monitors)) ||
-        monitors.empty())
+            reinterpret_cast<LPARAM>(&monitors)))
       return Fail(L"Enumerate high-band displays");
-    bool changed = monitors.size() != windows_.size();
+    const bool changed = monitors.size() != windows_.size() ||
+        std::any_of(monitors.begin(), monitors.end(), [&](const RECT& rect) {
+          return std::none_of(windows_.begin(), windows_.end(),
+                              [&](const auto& window) { return SameRect(rect, window.rect); });
+        });
+    // Mark the shared snapshot busy BEFORE replacing/destroying any HWND.
+    // Readers must not validate a stale handle from a previous topology.
+    struct PublishGuard {
+      PrivacyBandShared* shared;
+      ~PublishGuard() { InterlockedIncrement(&shared->sequence); }
+    } publishing{shared_};
+    InterlockedIncrement(&shared_->sequence);
     for (const auto& rect : monitors) {
       const auto found =
           std::find_if(windows_.begin(), windows_.end(),
                        [&](const auto& w) { return SameRect(w.rect, rect); });
-      if (found != windows_.end()) continue;
-      changed = true;
+      if (found != windows_.end()) {
+        // Windows can reposition a top-level window during DPI/hotplug before
+        // delivering WM_DISPLAYCHANGE. Restore the intended monitor bounds.
+        HWND hwnd = reinterpret_cast<HWND>(found->hwnd);
+        RECT actual{};
+        if ((!GetWindowRect(hwnd, &actual) || !SameRect(actual, rect) ||
+             !IsWindowVisible(hwnd)) &&
+            !SetWindowPos(hwnd, nullptr, rect.left, rect.top,
+                          rect.right - rect.left, rect.bottom - rect.top,
+                          SWP_NOZORDER | SWP_NOACTIVATE | SWP_SHOWWINDOW))
+          return Fail(L"Reposition high-band cover");
+        continue;
+      }
       HWND hwnd = create_(kCoverStyles, atom_, L"CrossDesk Privacy", WS_POPUP,
                           rect.left, rect.top, rect.right - rect.left,
                           rect.bottom - rect.top, nullptr, nullptr, module,
@@ -86,7 +105,7 @@ class Windows {
       windows_.push_back({reinterpret_cast<uint64_t>(hwnd), rect});
       if (!SetLayeredWindowAttributes(hwnd, 0, 255, LWA_ALPHA))
         return Fail(L"Make high-band cover opaque");
-      if (!SetWindowDisplayAffinity(hwnd, 0x11))
+      if (!ExcludePrivacyWindowFromCapture(hwnd))
         return Fail(L"Exclude high-band cover from capture");
       const BOOL yes = TRUE;
       const HRESULT peek = DwmSetWindowAttribute(hwnd, DWMWA_EXCLUDED_FROM_PEEK,
@@ -114,13 +133,16 @@ class Windows {
           ++it;
       }
     }
-    if (!Validate()) return false;
-    if (changed) {
-      InterlockedIncrement(&shared_->sequence);
-      shared_->count = static_cast<uint32_t>(windows_.size());
-      std::copy(windows_.begin(), windows_.end(), shared_->windows);
-      InterlockedIncrement(&shared_->sequence);
+    if (!Validate()) {
+      // Another topology event can race enumeration/presentation. Retry while
+      // retaining every surviving cover; actual validation errors stay fatal.
+      return InterlockedCompareExchange(&shared_->error, 0, 0) == ERROR_SUCCESS;
     }
+    // A previous reconciliation may have changed windows_ but failed geometry
+    // validation. Publish on every success so retries cannot leave stale HWNDs.
+    shared_->count = static_cast<uint32_t>(windows_.size());
+    std::copy(windows_.begin(), windows_.end(), shared_->windows);
+    InterlockedExchange(&shared_->topology_pending, 0);
     return true;
   }
   bool Validate() {
@@ -130,13 +152,17 @@ class Windows {
       DWORD band = 0, affinity = 0, flags = 0, cloaked = 0;
       BYTE alpha = 0;
       RECT rect{};
+      if (!GetWindowRect(hwnd, &rect) || !SameRect(rect, w.rect)) {
+        changed = true;
+        return false;
+      }
       if ((GetWindowLongPtrW(hwnd, GWL_EXSTYLE) & kCoverStyles) !=
               kCoverStyles ||
           !get_band_(hwnd, &band) || band != kPrivacyWindowBand ||
-          !GetWindowDisplayAffinity(hwnd, &affinity) || affinity != 0x11 ||
+          !GetWindowDisplayAffinity(hwnd, &affinity) ||
+          affinity != kPrivacyWindowDisplayAffinity ||
           !GetLayeredWindowAttributes(hwnd, nullptr, &alpha, &flags) ||
           alpha != 255 || flags != LWA_ALPHA || !IsWindowVisible(hwnd) ||
-          !GetWindowRect(hwnd, &rect) || !SameRect(rect, w.rect) ||
           FAILED(DwmGetWindowAttribute(hwnd, DWMWA_CLOAKED, &cloaked,
                                        sizeof(cloaked))) ||
           cloaked)
@@ -192,7 +218,7 @@ class Windows {
   GetPrivacyWindowBand get_band_ = nullptr;
 };
 
-DWORD WINAPI Run(void*) {
+DWORD Run() {
   wchar_t bootstrap[256]{};
   if (!GetEnvironmentVariableW(kPrivacyBandBootstrap, bootstrap, 256))
     return ERROR_INVALID_PARAMETER;
@@ -239,8 +265,8 @@ DWORD WINAPI Run(void*) {
       auto last_check = GetTickCount64();
       HANDLE watched[] = {parent, stop};
       // Once enabled, retain surviving covers on a validation/layout fault.
-      // The parent pauses the session after reading the latched error. Only
-      // an explicit stop or parent death tears the remaining windows down.
+      // The parent releases privacy after reading the latched error. Only an
+      // explicit stop or parent death tears the remaining windows down.
       while (initialized) {
         const DWORD wait = MsgWaitForMultipleObjectsEx(
             2, watched, 100, QS_ALLINPUT, MWMO_INPUTAVAILABLE);
@@ -273,21 +299,26 @@ DWORD WINAPI Run(void*) {
   }
   UnmapViewOfFile(shared);
   for (HANDLE handle : handles) CloseHandle(handle);
-  // This module runs only in the dedicated process created for this session.
-  // Exit outside DllMain/loader lock, after HWND destruction on their UI
-  // thread.
-  ExitProcess(exit_code);
   return exit_code;
 }
+
+void CALLBACK RunBeforeBrokerEntryPoint(ULONG_PTR) {
+  // The LoadLibraryW startup APC has returned, so the loader lock is no longer
+  // held. Own the primary thread until privacy stops, including startup errors.
+  // Never return into RuntimeBroker's COM server startup: an elevated launch
+  // can fail there with CO_E_WRONG_SERVER_IDENTITY and kill healthy covers.
+  ExitProcess(Run());
+}
 }  // namespace
 
 BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID) {
   if (reason == DLL_PROCESS_ATTACH) {
     module = instance;
-    // Keep thread notifications enabled: this module uses the static CRT.
-    HANDLE thread = CreateThread(nullptr, 0, Run, nullptr, 0, nullptr);
-    if (!thread) return FALSE;
-    CloseHandle(thread);
+    // Loaded by the startup APC on our dedicated, suspended broker's primary
+    // thread. Queue the window loop after that APC instead of starting a worker
+    // alongside RuntimeBroker's own entry point. Do not run it under loader lock.
+    if (!QueueUserAPC(RunBeforeBrokerEntryPoint, GetCurrentThread(), 0))
+      return FALSE;
   }
   return TRUE;
 }

apps/desktop/src/platform/windows/privacy/privacy_backend_win.cpp

@@ -16,15 +16,13 @@
 #include "../windows_thread_dpi.h"
 #include "privacy_backend.h"
 #include "privacy_band_guard.h"
+#include "privacy_capture_exclusion.h"
 #include "privacy_cursor_guard.h"
 #include "privacy_input_guard.h"
+#include "privacy_topology.h"
 #include "privacy_window_visibility.h"
 #include "rd_log.h"
 
-#ifndef WDA_EXCLUDEFROMCAPTURE
-#define WDA_EXCLUDEFROMCAPTURE 0x00000011
-#endif
-
 namespace crossdesk {
 namespace {
 
@@ -46,11 +44,6 @@ bool DesktopName(HDESK desktop, wchar_t (&name)[256]) {
                                               sizeof(name), &needed);
 }
 
-bool SameRect(const RECT& a, const RECT& b) {
-  return a.left == b.left && a.top == b.top && a.right == b.right &&
-         a.bottom == b.bottom;
-}
-
 struct MonitorEnumeration {
   std::vector<RECT> rects;
   bool ok = true;
@@ -141,6 +134,7 @@ class WindowsPrivacyBackend final : public PrivacyBackend {
       return false;
     if (!band_guard_.Start(text, error)) return false;
     if (!ReconcileMonitors(error)) return false;
+    layout_changed_ = false;
     event_owner_ = this;
     for (DWORD event : {EVENT_OBJECT_SHOW, EVENT_OBJECT_REORDER,
                         EVENT_OBJECT_LOCATIONCHANGE}) {
@@ -193,6 +187,8 @@ class WindowsPrivacyBackend final : public PrivacyBackend {
     last_obstruction_ = nullptr;
     last_obstruction_log_ = 0;
     layout_changed_ = false;
+    topology_pending_ = false;
+    topology_pending_since_ = 0;
     coverage_dirty_ = false;
     emergency_ = false;
     health_error_.clear();
@@ -235,12 +231,14 @@ class WindowsPrivacyBackend final : public PrivacyBackend {
       std::string error;
       if (!input_guard_.Healthy(error)) return {error, false};
     }
-    if (windows_.empty()) return {health_error_, false};
+    if (band_guard_.stopped()) return {health_error_, false};
     // Input messages wake the thread immediately; expensive health queries
     // must retain their own cadence instead of running once per input event.
-    if (!layout_changed_ &&
-        GetTickCount64() - last_check_ < 100) {
-      if (coverage_dirty_ && last_health_.failure.empty()) {
+    // Window events only dirty the coverage check, which is cheap enough to
+    // run between the throttled full health passes.
+    if (!layout_changed_ && GetTickCount64() - last_check_ < 100) {
+      if (coverage_dirty_ && last_health_.failure.empty() &&
+          !topology_pending_) {
         coverage_dirty_ = false;
         last_health_ = CheckCoverage();
       }
@@ -253,6 +251,21 @@ class WindowsPrivacyBackend final : public PrivacyBackend {
   }
 
  private:
+  // The broker reconciles hotplug asynchronously; while it does, coverage
+  // cannot be verified. Preserve intent for a bounded time only: a broker that
+  // never settles must not keep privacy "on" without any verification.
+  static constexpr uint64_t kTopologyPendingLimitMs = 3000;
+
+  PrivacyHealth TopologyPending() {
+    const uint64_t now = GetTickCount64();
+    if (topology_pending_since_ == 0) topology_pending_since_ = now;
+    if (now - topology_pending_since_ >= kTopologyPendingLimitMs) {
+      return {"Privacy cover topology did not settle after a display change",
+              false};
+    }
+    return {{}, false, false};
+  }
+
   PrivacyHealth CheckHealth() {
     if (!health_error_.empty()) return {health_error_, false};
     if (!band_guard_.Healthy(health_error_)) return {health_error_, false};
@@ -273,40 +286,23 @@ class WindowsPrivacyBackend final : public PrivacyBackend {
           "Exclusive fullscreen or unknown display presentation",
           false};
     }
-    MonitorEnumeration monitors;
-    if (!EnumDisplayMonitors(nullptr, nullptr, EnumMonitor,
-                             reinterpret_cast<LPARAM>(&monitors)) ||
-        !monitors.ok) {
-      return {Error("EnumDisplayMonitors"), false};
-    }
-    const bool changed =
-        monitors.rects.size() != windows_.size() ||
-        std::any_of(monitors.rects.begin(), monitors.rects.end(),
-                    [this](const RECT& rect) {
-                      return std::none_of(windows_.begin(), windows_.end(),
-                                          [&](const auto& w) {
-                                            return SameRect(w.rect, rect);
-                                          });
-                    });
-    if (changed || layout_changed_) {
-      layout_changed_ = false;
-      // Retain old covers until the monitor check completes, then release
-      // privacy so capture can refresh its display mapping independently.
-      std::string error;
-      if (!ReconcileMonitors(error))
-        health_error_ = error;
-      else
-        health_error_ =
-            "Display layout/DPI changed; privacy screen will turn off";
-    }
-    if (!health_error_.empty()) return {health_error_, false};
+    if (!ReconcileMonitors(health_error_)) return {health_error_, false};
+    if (topology_pending_) return TopologyPending();
     BOOL composed = FALSE;
     if (FAILED(DwmIsCompositionEnabled(&composed)) || !composed) {
       return {
           "Desktop composition stopped; privacy coverage cannot be guaranteed",
           false};
     }
-    return CheckCoverage();
+    auto coverage = CheckCoverage();
+    if (!coverage.failure.empty()) {
+      // The broker may replace an HWND after the snapshot above. Refresh once
+      // before treating a stale geometry/handle as loss of privacy coverage.
+      if (!ReconcileMonitors(health_error_)) return {health_error_, false};
+      if (topology_pending_) return TopologyPending();
+      coverage = CheckCoverage();
+    }
+    return coverage;
   }
 
   PrivacyHealth CheckCoverage() {
@@ -328,7 +324,7 @@ class WindowsPrivacyBackend final : public PrivacyBackend {
                                       &layered_flags) ||
           alpha != 255 || layered_flags != LWA_ALPHA ||
           !GetWindowDisplayAffinity(w.cover, &affinity) ||
-          affinity != WDA_EXCLUDEFROMCAPTURE ||
+          affinity != kPrivacyWindowDisplayAffinity ||
           FAILED(DwmGetWindowAttribute(w.cover, DWMWA_CLOAKED, &cloaked,
                                        sizeof(cloaked))) ||
           cloaked) {
@@ -430,40 +426,42 @@ class WindowsPrivacyBackend final : public PrivacyBackend {
   }
 
   bool ReconcileMonitors(std::string& error) {
+    const auto wait_for_broker = [&] {
+      topology_pending_ = true;
+      // Preserve intent while a healthy broker reconciles hotplug. Broker
+      // failure/heartbeat checks still detect real faults independently.
+      error.clear();
+      return true;
+    };
     MonitorEnumeration monitors;
     if (!EnumDisplayMonitors(nullptr, nullptr, EnumMonitor,
-                             reinterpret_cast<LPARAM>(&monitors)) ||
-        !monitors.ok || monitors.rects.empty()) {
+                             reinterpret_cast<LPARAM>(&monitors)) || !monitors.ok) {
       error = Error("EnumDisplayMonitors");
       return false;
     }
     std::vector<PrivacyBandWindow> covers;
-    if (!band_guard_.Windows(covers, error)) return false;
-    for (const RECT& rect : monitors.rects) {
-      auto existing =
-          std::find_if(windows_.begin(), windows_.end(),
-                       [&](const auto& w) { return SameRect(w.rect, rect); });
-      if (existing != windows_.end()) continue;
-      const auto cover = std::find_if(covers.begin(), covers.end(),
-                                      [&](const auto& candidate) {
-                                        return SameRect(candidate.rect, rect);
-                                      });
-      if (cover == covers.end()) {
-        error = "High-band broker has not covered every physical monitor";
-        return false;
-      }
-      windows_.push_back({rect, reinterpret_cast<HWND>(cover->hwnd)});
-      LOG_INFO(
-          "Privacy high-band cover ready: bounds=({}, {})-({}, {}), "
-          "affinity=0x11, alpha=255",
-          rect.left, rect.top, rect.right, rect.bottom);
+    if (!band_guard_.Windows(covers, error)) {
+      if (GetLastError() == ERROR_RETRY) return wait_for_broker();
+      return false;
     }
-    // Cover windows are owned and released by the broker.
-    windows_.erase(std::remove_if(windows_.begin(), windows_.end(),
-        [&](const auto& window) {
-          return std::none_of(monitors.rects.begin(), monitors.rects.end(),
-              [&](const RECT& rect) { return SameRect(window.rect, rect); });
-        }), windows_.end());
+    if (!MatchPrivacyTopology(monitors.rects, covers)) return wait_for_broker();
+
+    std::vector<Window> updated;
+    for (const auto& cover : covers) {
+      HWND hwnd = reinterpret_cast<HWND>(cover.hwnd);
+      if (std::none_of(windows_.begin(), windows_.end(), [&](const auto& old) {
+            return old.cover == hwnd && SameRect(old.rect, cover.rect);
+          })) {
+        LOG_INFO("Privacy: reconciled local cover without changing session state: "
+                 "bounds=({}, {})-({}, {}), affinity=0x11",
+                 cover.rect.left, cover.rect.top, cover.rect.right, cover.rect.bottom);
+      }
+      updated.push_back({cover.rect, hwnd});
+    }
+    windows_ = std::move(updated);
+    layout_changed_ = false;
+    topology_pending_ = false;
+    topology_pending_since_ = 0;
     return true;
   }
 
@@ -526,6 +524,8 @@ class WindowsPrivacyBackend final : public PrivacyBackend {
   bool hotkey_ = false;
   bool emergency_ = false;
   bool layout_changed_ = false;
+  bool topology_pending_ = false;
+  uint64_t topology_pending_since_ = 0;
   bool coverage_dirty_ = false;
   uint64_t last_check_ = 0;
   PrivacyHealth last_health_;

apps/desktop/src/platform/windows/privacy/privacy_band_guard.cpp

@@ -119,10 +119,12 @@ bool PrivacyBandGuard::Start(const PrivacyScreenText& text,
   // Keep both images immutable throughout creation/injection and the session.
   image_lock_ = CreateFileW(broker_path_.c_str(), GENERIC_READ, FILE_SHARE_READ,
                             nullptr, OPEN_EXISTING, 0, nullptr);
+  if (image_lock_ == INVALID_HANDLE_VALUE)
+    return Failed("Lock privacy broker image", error);
   dll_lock_ = CreateFileW(dll.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr,
                           OPEN_EXISTING, 0, nullptr);
-  if (image_lock_ == INVALID_HANDLE_VALUE || dll_lock_ == INVALID_HANDLE_VALUE)
-    return Failed("Lock privacy broker images", error);
+  if (dll_lock_ == INVALID_HANDLE_VALUE)
+    return Failed("Lock privacy window module", error);
 
   SECURITY_ATTRIBUTES inherit{sizeof(inherit), nullptr, TRUE};
   ScopedHandle parent;
@@ -131,14 +133,14 @@ bool PrivacyBandGuard::Start(const PrivacyScreenText& text,
                        SYNCHRONIZE | PROCESS_QUERY_LIMITED_INFORMATION, TRUE,
                        0))
     return Failed("Duplicate privacy parent process handle", error);
+  // Check each object as it is created so the reported error is its own.
   stop_ = CreateEventW(&inherit, TRUE, FALSE, nullptr);
+  if (!stop_) return Failed("Create high-band broker stop event", error);
   ready_ = CreateEventW(&inherit, TRUE, FALSE, nullptr);
+  if (!ready_) return Failed("Create high-band broker ready event", error);
   mapping_ = CreateFileMappingW(INVALID_HANDLE_VALUE, &inherit, PAGE_READWRITE,
                                 0, sizeof(PrivacyBandShared), nullptr);
-  if (!stop_ || !ready_ || !mapping_) {
-    const auto code = GetLastError();
-    return Failed("Create high-band broker IPC", error, code);
-  }
+  if (!mapping_) return Failed("Create high-band broker shared memory", error);
   shared_ = static_cast<PrivacyBandShared*>(MapViewOfFile(
       mapping_, FILE_MAP_ALL_ACCESS, 0, 0, sizeof(PrivacyBandShared)));
   if (!shared_) {
@@ -271,25 +273,30 @@ bool PrivacyBandGuard::Healthy(std::string& error) {
 bool PrivacyBandGuard::Windows(std::vector<PrivacyBandWindow>& windows,
                                std::string& error) {
   if (!Healthy(error)) return false;
+  const auto retry = [&] {
+    error = "High-band monitor snapshot is being updated";
+    SetLastError(ERROR_RETRY);
+    return false;
+  };
+  if (InterlockedCompareExchange(&shared_->topology_pending, 0, 0)) return retry();
   for (int attempt = 0; attempt < 4; ++attempt) {
     const LONG before = InterlockedCompareExchange(&shared_->sequence, 0, 0);
     if (before & 1) continue;
     const auto count = shared_->count;
-    if (count == 0 || count > kPrivacyMaxMonitors) break;
+    if (count > kPrivacyMaxMonitors) break;
     windows.assign(shared_->windows, shared_->windows + count);
-    if (before == InterlockedCompareExchange(&shared_->sequence, 0, 0)) {
+    if (before == InterlockedCompareExchange(&shared_->sequence, 0, 0) &&
+        !InterlockedCompareExchange(&shared_->topology_pending, 0, 0)) {
       for (const auto& window : windows) {
         DWORD pid = 0;
         GetWindowThreadProcessId(reinterpret_cast<HWND>(window.hwnd), &pid);
         if (pid != process_id())
-          return Failed("Invalid high-band window owner", error,
-                        ERROR_INVALID_HANDLE);
+          return retry();
       }
       return true;
     }
   }
-  return Failed("High-band monitor snapshot is changing or invalid", error,
-                ERROR_RETRY);
+  return retry();
 }
 
 bool PrivacyBandGuard::Stop(std::string& error) {

apps/desktop/src/platform/windows/privacy/privacy_band_ipc.h

@@ -14,7 +14,7 @@
 namespace crossdesk {
 
 constexpr uint32_t kPrivacyBandMagic = 0x43534231;
-constexpr uint32_t kPrivacyBandVersion = 2;
+constexpr uint32_t kPrivacyBandVersion = 3;
 constexpr DWORD kPrivacyWindowBand = 18;  // ZBID_ABOVELOCK_UX, current desktop.
 constexpr size_t kPrivacyMaxMonitors = 64;
 constexpr wchar_t kPrivacyBandBootstrap[] = L"CROSSDESK_PRIVACY_BAND_BOOTSTRAP";
@@ -36,6 +36,7 @@ struct PrivacyBandShared {
   volatile LONG sequence = 0;
   volatile LONG error = ERROR_IO_PENDING;
   volatile LONG active = 0;
+  volatile LONG topology_pending = 0;
   alignas(8) volatile LONG64 heartbeat = 0;
   wchar_t operation[128]{};
   wchar_t unlock_hint[128]{};

apps/desktop/src/platform/windows/privacy/privacy_capture_exclusion.h

@@ -0,0 +1,30 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-21
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _PRIVACY_CAPTURE_EXCLUSION_H_
+#define _PRIVACY_CAPTURE_EXCLUSION_H_
+
+#include <Windows.h>
+
+namespace crossdesk {
+
+// WDA_EXCLUDEFROMCAPTURE: show the opaque cover locally while capture receives
+// the desktop behind it. WDA_MONITOR would instead produce an empty/black area.
+inline constexpr DWORD kPrivacyWindowDisplayAffinity = 0x00000011;
+
+inline bool ExcludePrivacyWindowFromCapture(HWND window) {
+  if (!SetWindowDisplayAffinity(window, kPrivacyWindowDisplayAffinity))
+    return false;
+  DWORD affinity = 0;
+  if (!GetWindowDisplayAffinity(window, &affinity)) return false;
+  if (affinity == kPrivacyWindowDisplayAffinity) return true;
+  SetLastError(ERROR_INVALID_STATE);
+  return false;
+}
+
+}  // namespace crossdesk
+
+#endif

apps/desktop/src/platform/windows/privacy/privacy_topology.h

@@ -0,0 +1,34 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-21
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _PRIVACY_TOPOLOGY_H_
+#define _PRIVACY_TOPOLOGY_H_
+
+#include <algorithm>
+#include <vector>
+
+#include "privacy_band_ipc.h"
+
+namespace crossdesk {
+
+inline bool SameRect(const RECT& a, const RECT& b) {
+  return a.left == b.left && a.top == b.top && a.right == b.right &&
+         a.bottom == b.bottom;
+}
+
+inline bool MatchPrivacyTopology(const std::vector<RECT>& monitors,
+                                 const std::vector<PrivacyBandWindow>& covers) {
+  return monitors.size() == covers.size() &&
+      std::all_of(monitors.begin(), monitors.end(), [&](const RECT& monitor) {
+        return std::any_of(covers.begin(), covers.end(), [&](const auto& cover) {
+          return SameRect(cover.rect, monitor);
+        });
+      });
+}
+
+}  // namespace crossdesk
+
+#endif

apps/desktop/src/platform/windows/screen_capturer/capture_backend_policy.h

@@ -0,0 +1,31 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-23
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _CAPTURE_BACKEND_POLICY_H_
+#define _CAPTURE_BACKEND_POLICY_H_
+
+#include <vector>
+
+#include "screen_capture_method.h"
+
+namespace crossdesk {
+
+inline std::vector<ScreenCaptureMethod> WindowsCaptureBackendOrder(
+    ScreenCaptureMethod requested, bool headless, bool usbmmidd) {
+  if (requested != ScreenCaptureMethod::Auto) return {requested};
+  if (headless) return {ScreenCaptureMethod::Gdi};
+  // usbmmidd may put its software cursor directly into a DXGI/GDI image.
+  // WGC can exclude it at capture time. Keep WGC for both cursor modes so a
+  // native client joining/leaving never needs to inherit an embedded cursor.
+  // Do not silently fall back to a backend that cannot exclude that cursor.
+  if (usbmmidd) return {ScreenCaptureMethod::Wgc};
+  return {ScreenCaptureMethod::Dxgi, ScreenCaptureMethod::Wgc,
+          ScreenCaptureMethod::Gdi};
+}
+
+}  // namespace crossdesk
+
+#endif

apps/desktop/src/platform/windows/screen_capturer/cursor_frame_compositor.h

@@ -0,0 +1,93 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-18
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _CURSOR_FRAME_COMPOSITOR_H_
+#define _CURSOR_FRAME_COMPOSITOR_H_
+
+#include <windows.h>
+
+#include <cstdint>
+#include <cstring>
+
+#include "cursor_draw.h"
+
+namespace crossdesk {
+
+// Keep the source texture free of cursors. Each draw starts from the original
+// pixels, including when a static desktop is replayed after a cursor toggle.
+class CursorFrameCompositor {
+ public:
+  CursorFrameCompositor() = default;
+  ~CursorFrameCompositor() { Reset(); }
+  CursorFrameCompositor(const CursorFrameCompositor&) = delete;
+  CursorFrameCompositor& operator=(const CursorFrameCompositor&) = delete;
+
+  const uint8_t* Draw(const uint8_t* source, int stride, int width, int height,
+                      const CURSORINFO& cursor, int left, int top) {
+    if (!source || width <= 0 || height <= 0 || !EnsureSurface(width, height))
+      return nullptr;
+    const size_t row_bytes = static_cast<size_t>(width) * 4;
+    for (int y = 0; y < height; ++y) {
+      std::memcpy(static_cast<uint8_t*>(bits_) + y * row_bytes,
+                  source + static_cast<size_t>(y) * stride, row_bytes);
+    }
+    const bool drawn =
+        DrawCursorInCapture(dc_, cursor, left, top, width, height);
+    GdiFlush();
+    return drawn ? static_cast<const uint8_t*>(bits_) : nullptr;
+  }
+
+ private:
+  bool EnsureSurface(int width, int height) {
+    if (bits_ && width_ == width && height_ == height) return true;
+    Reset();
+    dc_ = CreateCompatibleDC(nullptr);
+    if (!dc_) return false;
+    BITMAPINFO info{};
+    info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+    info.bmiHeader.biWidth = width;
+    info.bmiHeader.biHeight = -height;
+    info.bmiHeader.biPlanes = 1;
+    info.bmiHeader.biBitCount = 32;
+    info.bmiHeader.biCompression = BI_RGB;
+    bitmap_ = CreateDIBSection(dc_, &info, DIB_RGB_COLORS, &bits_, nullptr, 0);
+    if (!bitmap_ || !bits_) {
+      Reset();
+      return false;
+    }
+    previous_ = SelectObject(dc_, bitmap_);
+    if (!previous_ || previous_ == HGDI_ERROR) {
+      previous_ = nullptr;
+      Reset();
+      return false;
+    }
+    width_ = width;
+    height_ = height;
+    return true;
+  }
+
+  void Reset() {
+    if (dc_ && previous_) SelectObject(dc_, previous_);
+    if (bitmap_) DeleteObject(bitmap_);
+    if (dc_) DeleteDC(dc_);
+    dc_ = nullptr;
+    bitmap_ = nullptr;
+    previous_ = nullptr;
+    bits_ = nullptr;
+    width_ = height_ = 0;
+  }
+
+  HDC dc_ = nullptr;
+  HBITMAP bitmap_ = nullptr;
+  HGDIOBJ previous_ = nullptr;
+  void* bits_ = nullptr;
+  int width_ = 0;
+  int height_ = 0;
+};
+
+}  // namespace crossdesk
+
+#endif

apps/desktop/src/platform/windows/screen_capturer/display_label.h

@@ -0,0 +1,41 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-20
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef CROSSDESK_DISPLAY_LABEL_H_
+#define CROSSDESK_DISPLAY_LABEL_H_
+
+#include <Windows.h>
+
+#include <string>
+
+namespace crossdesk {
+
+inline std::string WideToUtf8(const std::wstring& wstr) {
+  if (wstr.empty()) return {};
+  const int size_needed =
+      WideCharToMultiByte(CP_UTF8, 0, wstr.data(), static_cast<int>(wstr.size()),
+                          nullptr, 0, nullptr, nullptr);
+  if (size_needed <= 0) return {};
+  std::string result(static_cast<size_t>(size_needed), '\0');
+  WideCharToMultiByte(CP_UTF8, 0, wstr.data(), static_cast<int>(wstr.size()),
+                      result.data(), size_needed, nullptr, nullptr);
+  return result;
+}
+
+// "\\.\DISPLAY1" -> "DISPLAY1": the label every Windows backend reports so
+// the wrapper can alias older plugins that identify streams by name.
+inline std::string GetDisplayLabel(const std::wstring& wide_name) {
+  std::string name = WideToUtf8(wide_name);
+  constexpr char kDevicePrefix[] = "\\\\.\\";
+  if (name.rfind(kDevicePrefix, 0) == 0) {
+    name.erase(0, sizeof(kDevicePrefix) - 1);
+  }
+  return name;
+}
+
+}  // namespace crossdesk
+
+#endif  // CROSSDESK_DISPLAY_LABEL_H_

apps/desktop/src/platform/windows/screen_capturer/display_presence.h

@@ -0,0 +1,150 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-20
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef CROSSDESK_DISPLAY_PRESENCE_H_
+#define CROSSDESK_DISPLAY_PRESENCE_H_
+
+#include <Windows.h>
+
+#include <algorithm>
+#include <cstddef>
+#include <vector>
+
+#include "../virtual_display/usbmmidd_policy.h"
+
+namespace crossdesk {
+
+// Without any attached monitor, Windows keeps the desktop on a phantom display
+// target with an OS-chosen resolution. DXGI has no output to duplicate there,
+// but GDI still reads the composed desktop and input injection keeps working.
+enum class DisplayPresence { present, headless, unknown };
+
+struct DisplayPresenceProbe {
+  bool query_succeeded = false;   // QueryDisplayConfig returned a topology
+  size_t active_paths = 0;        // active display paths, phantom included
+  size_t available_targets = 0;   // active paths whose monitor is present
+  size_t desktop_devices = 0;     // adapters attached to the desktop
+  size_t attached_monitors = 0;   // monitor devices reported active
+  size_t identified_targets = 0; // EDID, monitor interface or built-in/IDD target
+  size_t unidentified_targets = 0; // available targets with no monitor identity
+  size_t target_query_failures = 0;
+  size_t embedded_or_virtual_targets = 0; // independent of an external monitor
+  size_t edid_targets = 0;
+  size_t monitor_path_targets = 0;
+};
+
+// Pure policy, kept separate from Win32 so it can be tested with fixtures.
+inline DisplayPresence ClassifyDisplayPresence(
+    const DisplayPresenceProbe& probe, bool capture_stalled = false) {
+  if (probe.query_succeeded) {
+    if (probe.available_targets > 0) {
+      // NVIDIA can retain both availability AND EDID/interface identity after
+      // the last unplug. Those describe a target, not a connected monitor.
+      // Require stalled capture plus a desktop adapter with no active monitor,
+      // and exempt built-in/wireless/IDD targets and failed target queries.
+      // A remaining physical monitor (even without EDID) prevents takeover.
+      if (capture_stalled && probe.desktop_devices > 0 &&
+          probe.attached_monitors == 0 &&
+          probe.embedded_or_virtual_targets == 0 &&
+          probe.target_query_failures == 0) {
+        return DisplayPresence::headless;
+      }
+      return DisplayPresence::present;
+    }
+    // A successful empty topology is also headless (e.g. hot unplug), not an
+    // API failure. The caller suppresses recovery on the secure desktop.
+    return DisplayPresence::headless;
+  }
+  if (probe.attached_monitors > 0) return DisplayPresence::present;
+  if (probe.desktop_devices > 0) return DisplayPresence::headless;
+  return DisplayPresence::unknown;
+}
+
+inline bool IsEmbeddedOrVirtualTarget(
+    DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY technology) {
+  switch (technology) {
+    case DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INTERNAL:
+    case DISPLAYCONFIG_OUTPUT_TECHNOLOGY_LVDS:
+    case DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EMBEDDED:
+    case DISPLAYCONFIG_OUTPUT_TECHNOLOGY_UDI_EMBEDDED:
+    case DISPLAYCONFIG_OUTPUT_TECHNOLOGY_MIRACAST:
+    case DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INDIRECT_WIRED:
+    case DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INDIRECT_VIRTUAL:
+      return true;
+    default:
+      return false;
+  }
+}
+
+inline bool HasDisplayTargetIdentity(
+    const DISPLAYCONFIG_TARGET_DEVICE_NAME& target) {
+  return IsEmbeddedOrVirtualTarget(target.outputTechnology) ||
+         target.flags.edidIdsValid ||
+         (target.monitorDevicePath[0] != L'\0' &&
+          !ContainsCaseInsensitive(target.monitorDevicePath, L"Default_Monitor"));
+}
+
+inline DisplayPresenceProbe ProbeDisplayPresence() {
+  DisplayPresenceProbe probe;
+  // The buffer size can change between the two calls during a topology
+  // change; a few retries cover that window.
+  for (int attempt = 0; attempt < 4 && !probe.query_succeeded; ++attempt) {
+    UINT32 path_count = 0;
+    UINT32 mode_count = 0;
+    if (GetDisplayConfigBufferSizes(QDC_ONLY_ACTIVE_PATHS, &path_count,
+                                    &mode_count) != ERROR_SUCCESS) break;
+    std::vector<DISPLAYCONFIG_PATH_INFO> paths((std::max)(path_count, 1u));
+    std::vector<DISPLAYCONFIG_MODE_INFO> modes((std::max)(mode_count, 1u));
+    const LONG status = QueryDisplayConfig(QDC_ONLY_ACTIVE_PATHS, &path_count,
+                                           paths.data(), &mode_count,
+                                           modes.data(), nullptr);
+    if (status == ERROR_INSUFFICIENT_BUFFER) continue;
+    if (status != ERROR_SUCCESS) break;
+    probe.query_succeeded = true;
+    for (UINT32 index = 0; index < path_count; ++index) {
+      if (!(paths[index].flags & DISPLAYCONFIG_PATH_ACTIVE)) continue;
+      ++probe.active_paths;
+      // A removed monitor can leave its path active while the target is gone.
+      const auto& info = paths[index].targetInfo;
+      if (!info.targetAvailable) continue;
+      ++probe.available_targets;
+      if (IsEmbeddedOrVirtualTarget(info.outputTechnology))
+        ++probe.embedded_or_virtual_targets;
+      DISPLAYCONFIG_TARGET_DEVICE_NAME target{};
+      target.header.type = DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME;
+      target.header.size = sizeof(target);
+      target.header.adapterId = info.adapterId;
+      target.header.id = info.id;
+      if (DisplayConfigGetDeviceInfo(&target.header) != ERROR_SUCCESS) {
+        ++probe.target_query_failures;
+      } else {
+        if (target.flags.edidIdsValid) ++probe.edid_targets;
+        if (target.monitorDevicePath[0] != L'\0') ++probe.monitor_path_targets;
+        if (HasDisplayTargetIdentity(target)) {
+          ++probe.identified_targets;
+        } else {
+          ++probe.unidentified_targets;
+        }
+      }
+    }
+  }
+  for (DWORD index = 0;; ++index) {
+    DISPLAY_DEVICEW adapter{sizeof(adapter)};
+    if (!EnumDisplayDevicesW(nullptr, index, &adapter, 0)) break;
+    if (!(adapter.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP)) continue;
+    ++probe.desktop_devices;
+    for (DWORD child = 0;; ++child) {
+      DISPLAY_DEVICEW monitor{sizeof(monitor)};
+      if (!EnumDisplayDevicesW(adapter.DeviceName, child, &monitor, 0)) break;
+      if (monitor.StateFlags & DISPLAY_DEVICE_ACTIVE) ++probe.attached_monitors;
+    }
+  }
+  return probe;
+}
+
+}  // namespace crossdesk
+
+#endif  // CROSSDESK_DISPLAY_PRESENCE_H_

apps/desktop/src/platform/windows/screen_capturer/dxgi_cursor_state.h

@@ -13,6 +13,15 @@ namespace crossdesk {
 // coordinates or the wire protocol.
 class DxgiCursorState {
  public:
+  void BeginOutput(void* monitor, bool software_cursor) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    // usbmmidd can composite the cursor into the desktop without ever sending
+    // a separate pointer update. Preserve this output-specific default across
+    // privacy restoration; an explicit DXGI update can still override it.
+    software_cursor_monitor_ = software_cursor ? monitor : nullptr;
+    embedded_monitor_ = privacy_cursor_hidden_ ? nullptr : software_cursor_monitor_;
+  }
+
   void Update(int64_t last_mouse_update_time, bool separate_pointer_visible,
               void* monitor) {
     // PointerPosition is undefined on desktop-only updates. Retain the last
@@ -26,15 +35,16 @@ class DxgiCursorState {
   void Reset() {
     std::lock_guard<std::mutex> lock(mutex_);
     embedded_monitor_ = nullptr;
+    software_cursor_monitor_ = nullptr;
   }
 
   void SetPrivacyCursorHidden(bool hidden) {
     std::lock_guard<std::mutex> lock(mutex_);
     if (privacy_cursor_hidden_ == hidden) return;
     privacy_cursor_hidden_ = hidden;
-    // Pointer updates from before/during suppression cannot describe whether
-    // the restored cursor is embedded. Wait for a fresh DXGI pointer update.
-    embedded_monitor_ = nullptr;
+    // Discard stale pointer-plane updates, then restore the output's default.
+    // A software-cursor IDD may never send a fresh pointer-plane update.
+    embedded_monitor_ = hidden ? nullptr : software_cursor_monitor_;
   }
 
   bool ShouldDrawCursor(bool system_cursor_visible, void* cursor_monitor) const {
@@ -53,6 +63,7 @@ class DxgiCursorState {
  private:
   mutable std::mutex mutex_;
   void* embedded_monitor_ = nullptr;
+  void* software_cursor_monitor_ = nullptr;
   bool privacy_cursor_hidden_ = false;
 };
 

apps/desktop/src/platform/windows/screen_capturer/headless_recovery.h

@@ -0,0 +1,47 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-23
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _HEADLESS_RECOVERY_H_
+#define _HEADLESS_RECOVERY_H_
+
+#include <cstdint>
+
+namespace crossdesk {
+
+// Management-thread policy. Debounce mode changes and bound retries after a
+// failed install. Capture progress is intentionally separate from DXGI retries.
+class HeadlessRecovery {
+ public:
+  void Reset() { *this = {}; }
+
+  bool ShouldProvision(uint64_t now, bool headless, bool busy, bool active) {
+    if (!headless) {
+      suspected_ = false;
+      return false;
+    }
+    if (!suspected_) {
+      suspected_ = true;
+      since_ = now;
+    }
+    return !busy && !active && now - since_ >= 1000 &&
+           (!attempted_ || now - last_attempt_ >= 15000);
+  }
+
+  void Attempted(uint64_t now) {
+    attempted_ = true;
+    last_attempt_ = now;
+  }
+
+ private:
+  bool suspected_ = false;
+  bool attempted_ = false;
+  uint64_t since_ = 0;
+  uint64_t last_attempt_ = 0;
+};
+
+}  // namespace crossdesk
+
+#endif

apps/desktop/src/platform/windows/screen_capturer/screen_capturer_dxgi.cpp

@@ -7,36 +7,30 @@
 #include <string>
 #include <vector>
 
+#include "captured_cursor_state.h"
+#include "cursor_frame_compositor.h"
+#include "display_label.h"
 #include "dxgi_cursor_state.h"
 #include "libyuv.h"
 #include "rd_log.h"
+#include "windows_thread_dpi.h"
+#include "../virtual_display/usbmmidd_virtual_display.h"
 
 namespace crossdesk {
 
 namespace {
-std::string WideToUtf8(const std::wstring& wstr) {
-  if (wstr.empty()) return {};
-  int size_needed = WideCharToMultiByte(
-      CP_UTF8, 0, wstr.data(), (int)wstr.size(), nullptr, 0, nullptr, nullptr);
-  std::string result(size_needed, 0);
-  WideCharToMultiByte(CP_UTF8, 0, wstr.data(), (int)wstr.size(), result.data(),
-                      size_needed, nullptr, nullptr);
-  return result;
-}
-
-std::string GetDisplayLabel(const std::wstring& wide_name) {
-  std::string name = WideToUtf8(wide_name);
-  constexpr char kDevicePrefix[] = "\\\\.\\";
-  if (name.rfind(kDevicePrefix, 0) == 0) {
-    name.erase(0, sizeof(kDevicePrefix) - 1);
+std::wstring GetOutputDeviceId(const std::wstring& device_name) {
+  DISPLAY_DEVICEW device{sizeof(device)};
+  if (!EnumDisplayDevicesW(device_name.c_str(), 0, &device,
+                           EDD_GET_DEVICE_INTERFACE_NAME)) {
+    return {};
   }
-  return name;
+  return device.DeviceID;
 }
 }  // namespace
 
 ScreenCapturerDxgi::ScreenCapturerDxgi() {}
 ScreenCapturerDxgi::~ScreenCapturerDxgi() {
-  Stop();
   Destroy();
 }
 
@@ -48,11 +42,9 @@ int ScreenCapturerDxgi::Init(const int fps, cb_desktop_data cb) {
     return -1;
   }
 
-  if (!InitializeDxgi()) {
-    LOG_ERROR("DXGI: initialize DXGI failed");
-    return -2;
-  }
-
+  display_slots_.Reset();
+  display_info_list_.clear();
+  topology_refresh_requested_.store(false);
   EnumerateDisplays();
   if (display_info_list_.empty()) {
     LOG_ERROR("DXGI: no displays found");
@@ -60,7 +52,6 @@ int ScreenCapturerDxgi::Init(const int fps, cb_desktop_data cb) {
   }
 
   monitor_index_ = 0;
-  initial_monitor_index_ = monitor_index_;
   return 0;
 }
 
@@ -68,9 +59,10 @@ int ScreenCapturerDxgi::Destroy() {
   Stop();
   ReleaseDuplication();
   outputs_.clear();
+  display_info_list_.clear();
+  display_slots_.Reset();
   d3d_context_.Reset();
   d3d_device_.Reset();
-  dxgi_factory_.Reset();
   if (nv12_frame_) {
     delete[] nv12_frame_;
     nv12_frame_ = nullptr;
@@ -120,13 +112,24 @@ int ScreenCapturerDxgi::SwitchTo(int monitor_index) {
     LOG_ERROR("DXGI: invalid monitor index {}", monitor_index);
     return -1;
   }
+  if (monitor_index == monitor_index_ && (!running_ || duplication_)) return 0;
+  // Select before Start without allocating a second D3D device/duplication.
+  if (!running_) {
+    monitor_index_ = monitor_index;
+    return 0;
+  }
   paused_ = true;
-  monitor_index_ = monitor_index;
+  const int previous = monitor_index_.exchange(monitor_index);
   ReleaseDuplication();
-  if (!CreateDuplicationForMonitor(monitor_index_)) {
-    LOG_ERROR("DXGI: create duplication failed for monitor {}",
-              monitor_index_.load());
-    paused_ = false;  // Reset paused_ on failure
+  if (!CreateDuplicationForMonitor(monitor_index)) {
+    LOG_ERROR("DXGI: create duplication failed for monitor {}", monitor_index);
+    // Keep the backend on the output it was capturing so the wrapper's index
+    // and ours do not diverge after a rejected switch.
+    monitor_index_ = previous;
+    if (!CreateDuplicationForMonitor(previous)) {
+      LOG_WARN("DXGI: could not restore duplication for monitor {}", previous);
+    }
+    paused_ = false;
     return -2;
   }
   paused_ = false;
@@ -136,107 +139,134 @@ int ScreenCapturerDxgi::SwitchTo(int monitor_index) {
 }
 
 int ScreenCapturerDxgi::ResetToInitialMonitor() {
-  std::lock_guard<std::mutex> lock(switch_mutex_);
-  if (display_info_list_.empty()) return -1;
-  int target = initial_monitor_index_;
-  if (target < 0 || target >= (int)display_info_list_.size()) return -1;
-  if (monitor_index_ == target) return 0;
-  if (running_) {
-    paused_ = true;
-    monitor_index_ = target;
-    ReleaseDuplication();
-    if (!CreateDuplicationForMonitor(monitor_index_)) {
-      paused_ = false;
-      return -2;
-    }
-    paused_ = false;
-    LOG_INFO("DXGI: reset to initial monitor {}:{}", monitor_index_.load(),
-             display_info_list_[monitor_index_].name);
-  } else {
-    monitor_index_ = target;
-  }
-  return 0;
+  return SwitchTo(0);
 }
 
-bool ScreenCapturerDxgi::InitializeDxgi() {
-  UINT flags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
-#ifdef _DEBUG
-  flags |= D3D11_CREATE_DEVICE_DEBUG;
-#endif
-
-  D3D_FEATURE_LEVEL feature_levels[] = {
-      D3D_FEATURE_LEVEL_11_1, D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1,
-      D3D_FEATURE_LEVEL_10_0};
-
-  D3D_FEATURE_LEVEL out_level{};
-  HRESULT hr = D3D11CreateDevice(
-      nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, flags, feature_levels,
-      ARRAYSIZE(feature_levels), D3D11_SDK_VERSION, d3d_device_.GetAddressOf(),
-      &out_level, d3d_context_.GetAddressOf());
-  if (FAILED(hr)) {
-    hr = D3D11CreateDevice(nullptr, D3D_DRIVER_TYPE_WARP, nullptr, flags,
-                           feature_levels, ARRAYSIZE(feature_levels),
-                           D3D11_SDK_VERSION, d3d_device_.GetAddressOf(),
-                           &out_level, d3d_context_.GetAddressOf());
-    if (FAILED(hr)) {
-      LOG_ERROR("DXGI: D3D11CreateDevice failed, hr={}", (int)hr);
-      return false;
-    }
-  }
-
-  hr = CreateDXGIFactory1(
-      __uuidof(IDXGIFactory1),
-      reinterpret_cast<void**>(dxgi_factory_.GetAddressOf()));
-  if (FAILED(hr)) {
-    LOG_ERROR("DXGI: CreateDXGIFactory1 failed, hr={}", (int)hr);
+bool ScreenCapturerDxgi::EnumerateDisplays() {
+  ScopedWindowsPhysicalCoordinates physical_coordinates;
+  // Factories cache adapter topology. Refresh the factory as well as outputs.
+  Microsoft::WRL::ComPtr<IDXGIFactory1> factory;
+  const HRESULT factory_result =
+      CreateDXGIFactory1(IID_PPV_ARGS(factory.GetAddressOf()));
+  if (FAILED(factory_result)) {
+    LOG_ERROR("DXGI: CreateDXGIFactory1 failed, hr={}", (int)factory_result);
     return false;
   }
-  return true;
-}
-
-void ScreenCapturerDxgi::EnumerateDisplays() {
-  display_info_list_.clear();
-  outputs_.clear();
-
+  struct Output {
+    DisplayInfo display;
+    Microsoft::WRL::ComPtr<IDXGIOutput> output;
+    std::string identity;
+  };
+  std::vector<Output> current;
   Microsoft::WRL::ComPtr<IDXGIAdapter> adapter;
   for (UINT a = 0;
-       dxgi_factory_->EnumAdapters(a, adapter.ReleaseAndGetAddressOf()) !=
-       DXGI_ERROR_NOT_FOUND;
-       ++a) {
+       factory->EnumAdapters(a, adapter.ReleaseAndGetAddressOf()) !=
+       DXGI_ERROR_NOT_FOUND; ++a) {
+    if (!adapter) break;
     Microsoft::WRL::ComPtr<IDXGIOutput> output;
     for (UINT o = 0; adapter->EnumOutputs(o, output.ReleaseAndGetAddressOf()) !=
-                     DXGI_ERROR_NOT_FOUND;
-         ++o) {
+                       DXGI_ERROR_NOT_FOUND; ++o) {
+      if (!output) break;
       DXGI_OUTPUT_DESC desc{};
-      if (FAILED(output->GetDesc(&desc))) {
-        continue;
-      }
-      std::string name = GetDisplayLabel(desc.DeviceName);
+      if (FAILED(output->GetDesc(&desc)) || !desc.AttachedToDesktop) continue;
       MONITORINFOEX mi{};
-      mi.cbSize = sizeof(MONITORINFOEX);
-      if (GetMonitorInfo(desc.Monitor, &mi)) {
-        bool is_primary = (mi.dwFlags & MONITORINFOF_PRIMARY) ? true : false;
-        DisplayInfo info((void*)desc.Monitor, name, is_primary,
-                         mi.rcMonitor.left, mi.rcMonitor.top,
-                         mi.rcMonitor.right, mi.rcMonitor.bottom);
-        // primary first
-        if (is_primary) {
-          display_info_list_.insert(display_info_list_.begin(), info);
-          outputs_.insert(outputs_.begin(), output);
-        } else {
-          display_info_list_.push_back(info);
-          outputs_.push_back(output);
-        }
-      }
+      mi.cbSize = sizeof(mi);
+      if (!GetMonitorInfo(desc.Monitor, &mi)) continue;
+      const auto device_id = GetOutputDeviceId(desc.DeviceName);
+      current.push_back({
+          DisplayInfo(desc.Monitor, GetDisplayLabel(desc.DeviceName),
+                       (mi.dwFlags & MONITORINFOF_PRIMARY) != 0,
+                       mi.rcMonitor.left, mi.rcMonitor.top,
+                       mi.rcMonitor.right, mi.rcMonitor.bottom),
+          output, WideToUtf8(device_id.empty() ? desc.DeviceName : device_id)});
     }
   }
+  std::stable_partition(current.begin(), current.end(),
+                         [](const auto& item) { return item.display.is_primary; });
+  std::vector<std::string> identities;
+  for (const auto& item : current) identities.push_back(item.identity);
+  const auto slots = display_slots_.Update(identities);
+  std::vector<DisplayInfo> displays;
+  std::vector<Microsoft::WRL::ComPtr<IDXGIOutput>> outputs;
+  bool changed = slots.size() != display_info_list_.size();
+  for (size_t slot = 0; slot < slots.size(); ++slot) {
+    if (slots[slot] < 0) {
+      auto missing = display_info_list_[slot];
+      missing.handle = nullptr;
+      missing.left = missing.top = missing.right = missing.bottom = 0;
+      missing.width = missing.height = 0;
+      missing.is_primary = false;
+      displays.push_back(std::move(missing));
+      outputs.emplace_back();
+    } else {
+      const auto& item = current[slots[slot]];
+      displays.push_back(item.display);
+      outputs.push_back(item.output);
+    }
+    if (slot >= display_info_list_.size()) continue;
+    const auto& before = display_info_list_[slot];
+    const auto& after = displays.back();
+    changed = changed || before.handle != after.handle ||
+              before.left != after.left || before.top != after.top ||
+              before.right != after.right || before.bottom != after.bottom ||
+              before.is_primary != after.is_primary || before.name != after.name;
+  }
+  display_info_list_ = std::move(displays);
+  outputs_ = std::move(outputs);
+  if (changed) {
+    for (size_t slot = 0; slot < display_info_list_.size(); ++slot) {
+      const auto& display = display_info_list_[slot];
+      LOG_INFO("DXGI: session display slot={} name='{}' available={} "
+               "bounds=({},{};{},{}), selected={}",
+               slot, display.name, outputs_[slot] != nullptr,
+               display.left, display.top, display.right, display.bottom,
+               static_cast<int>(slot) == monitor_index_.load());
+    }
+  }
+  return changed;
 }
 
 bool ScreenCapturerDxgi::CreateDuplicationForMonitor(int monitor_index) {
   SharedDxgiCursorState().Reset();
-  if (monitor_index < 0 || monitor_index >= (int)outputs_.size()) return false;
+  if (monitor_index < 0 || monitor_index >= (int)outputs_.size() ||
+      !outputs_[monitor_index]) return false;
+
+  // Outputs may move between GPU adapters when the display topology changes.
+  // Desktop Duplication requires the D3D device to be created from the same
+  // adapter as the selected IDXGIOutput.
+  Microsoft::WRL::ComPtr<IDXGIAdapter> output_adapter;
+  HRESULT hr = outputs_[monitor_index]->GetParent(
+      IID_PPV_ARGS(output_adapter.GetAddressOf()));
+  if (FAILED(hr) || !output_adapter) {
+    LOG_ERROR("DXGI: get adapter for output {} failed, hr={}", monitor_index,
+              (int)hr);
+    return false;
+  }
+
+  UINT flags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
+#ifdef _DEBUG
+  flags |= D3D11_CREATE_DEVICE_DEBUG;
+#endif
+  D3D_FEATURE_LEVEL feature_levels[] = {
+      D3D_FEATURE_LEVEL_11_1, D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1,
+      D3D_FEATURE_LEVEL_10_0};
+  D3D_FEATURE_LEVEL out_level{};
+  Microsoft::WRL::ComPtr<ID3D11Device> output_device;
+  Microsoft::WRL::ComPtr<ID3D11DeviceContext> output_context;
+  hr = D3D11CreateDevice(
+      output_adapter.Get(), D3D_DRIVER_TYPE_UNKNOWN, nullptr, flags,
+      feature_levels, ARRAYSIZE(feature_levels), D3D11_SDK_VERSION,
+      output_device.GetAddressOf(), &out_level, output_context.GetAddressOf());
+  if (FAILED(hr)) {
+    LOG_ERROR("DXGI: create D3D device for output adapter {} failed, hr={}",
+              monitor_index, (int)hr);
+    return false;
+  }
+  d3d_context_ = std::move(output_context);
+  d3d_device_ = std::move(output_device);
+
   Microsoft::WRL::ComPtr<IDXGIOutput1> output1;
-  HRESULT hr = outputs_[monitor_index]->QueryInterface(
+  hr = outputs_[monitor_index]->QueryInterface(
       IID_PPV_ARGS(output1.GetAddressOf()));
   if (FAILED(hr)) {
     LOG_ERROR("DXGI: Query IDXGIOutput1 failed, hr={}", (int)hr);
@@ -254,37 +284,21 @@ bool ScreenCapturerDxgi::CreateDuplicationForMonitor(int monitor_index) {
   DXGI_OUTDUPL_DESC desc{};
   duplication_->GetDesc(&desc);
   rotation_ = desc.Rotation;
-  LOG_INFO("DXGI: duplication ready, monitor={}, rotation={}", monitor_index,
-           static_cast<int>(rotation_));
+  DXGI_ADAPTER_DESC adapter_desc{};
+  output_adapter->GetDesc(&adapter_desc);
+  DXGI_OUTPUT_DESC output_desc{};
+  software_cursor_output_ =
+      SUCCEEDED(outputs_[monitor_index]->GetDesc(&output_desc)) &&
+      IsUsbmmiddDisplayDevice(output_desc.DeviceName);
+  SharedDxgiCursorState().BeginOutput(
+      display_info_list_[monitor_index].handle, software_cursor_output_);
+  last_logged_cursor_embedding_ = -1;
+  LOG_INFO("DXGI: duplication ready, monitor={}, rotation={}, adapter='{}'",
+           monitor_index, static_cast<int>(rotation_),
+           WideToUtf8(adapter_desc.Description));
   return true;
 }
 
-bool ScreenCapturerDxgi::RecreateDuplicationForCurrentMonitor() {
-  std::lock_guard<std::mutex> lock(switch_mutex_);
-  ReleaseDuplication();
-  int current_monitor = monitor_index_.load();
-  if (CreateDuplicationForMonitor(current_monitor)) {
-    return true;
-  }
-
-  EnumerateDisplays();
-  if (display_info_list_.empty()) {
-    LOG_ERROR("DXGI: no displays found while recreating duplication");
-    return false;
-  }
-  if (current_monitor < 0 ||
-      current_monitor >= static_cast<int>(display_info_list_.size())) {
-    current_monitor = 0;
-    monitor_index_ = 0;
-  }
-  if (CreateDuplicationForMonitor(current_monitor)) {
-    LOG_INFO("DXGI: recreated duplication for monitor {}",
-             monitor_index_.load());
-    return true;
-  }
-  return false;
-}
-
 void ScreenCapturerDxgi::ReleaseDuplication() {
   SharedDxgiCursorState().Reset();
   ++duplication_generation_;
@@ -295,14 +309,114 @@ void ScreenCapturerDxgi::ReleaseDuplication() {
   duplication_.Reset();
 }
 
+bool ScreenCapturerDxgi::ConvertFrame(int frame_monitor, bool* cursor_embedded,
+                                      CursorFrameCompositor& compositor) {
+  *cursor_embedded = false;
+  if (!staging_) return false;
+  D3D11_TEXTURE2D_DESC src_desc{};
+  staging_->GetDesc(&src_desc);
+  D3D11_MAPPED_SUBRESOURCE mapped{};
+  const HRESULT hr =
+      d3d_context_->Map(staging_.Get(), 0, D3D11_MAP_READ, 0, &mapped);
+  if (FAILED(hr)) {
+    return false;
+  }
+
+  auto pixels = static_cast<const uint8_t*>(mapped.pData);
+  int stride = static_cast<int>(mapped.RowPitch);
+  int logical_width = static_cast<int>(src_desc.Width);
+  int logical_height = static_cast<int>(src_desc.Height);
+  libyuv::RotationMode rotation = libyuv::kRotate0;
+  switch (rotation_) {
+    case DXGI_MODE_ROTATION_ROTATE90:
+      rotation = libyuv::kRotate90;
+      break;
+    case DXGI_MODE_ROTATION_ROTATE180:
+      rotation = libyuv::kRotate180;
+      break;
+    case DXGI_MODE_ROTATION_ROTATE270:
+      rotation = libyuv::kRotate270;
+      break;
+    default:
+      break;
+  }
+  if (rotation != libyuv::kRotate0) {
+    const bool swap_axes = rotation != libyuv::kRotate180;
+    const int rotated_width = swap_axes ? logical_height : logical_width;
+    rotated_frame_.resize(static_cast<size_t>(logical_width) * logical_height *
+                          4);
+    if (libyuv::ARGBRotate(pixels, stride, rotated_frame_.data(),
+                           rotated_width * 4, logical_width, logical_height,
+                           rotation) != 0) {
+      d3d_context_->Unmap(staging_.Get(), 0);
+      return false;
+    }
+    pixels = rotated_frame_.data();
+    stride = rotated_width * 4;
+    if (swap_axes) std::swap(logical_width, logical_height);
+  }
+  int even_width = logical_width & ~1;
+  int even_height = logical_height & ~1;
+  if (even_width <= 0 || even_height <= 0) {
+    d3d_context_->Unmap(staging_.Get(), 0);
+    return false;
+  }
+
+  if (frame_monitor >= 0 &&
+      frame_monitor < static_cast<int>(display_info_list_.size())) {
+    const auto& display = display_info_list_[frame_monitor];
+    CURSORINFO cursor{};
+    cursor.cbSize = sizeof(cursor);
+    if (GetCursorInfo(&cursor)) {
+      const bool visible = (cursor.flags & CURSOR_SHOWING) != 0;
+      const bool should_draw = SharedDxgiCursorState().ShouldDrawCursor(
+          visible, display.handle);
+      // show_cursor controls our extra composition, not cursors the OS has
+      // already put in the texture. Publish that distinction for native
+      // controllers as well, so they do not draw a second cursor.
+      *cursor_embedded = visible && !should_draw &&
+          MonitorFromPoint(cursor.ptScreenPos, MONITOR_DEFAULTTONULL) ==
+              display.handle;
+      if (show_cursor_.load(std::memory_order_relaxed) && should_draw) {
+        if (const auto* composited =
+                compositor.Draw(pixels, stride, even_width, even_height, cursor,
+                                display.left, display.top)) {
+          pixels = composited;
+          stride = even_width * 4;
+          *cursor_embedded = true;
+        }
+      }
+    }
+  }
+
+  int nv12_size = even_width * even_height * 3 / 2;
+  if (!nv12_frame_ || nv12_width_ != even_width ||
+      nv12_height_ != even_height) {
+    delete[] nv12_frame_;
+    nv12_frame_ = new unsigned char[nv12_size];
+    nv12_width_ = even_width;
+    nv12_height_ = even_height;
+  }
+
+  const int converted =
+      libyuv::ARGBToNV12(pixels, stride, nv12_frame_, even_width,
+                         nv12_frame_ + even_width * even_height, even_width,
+                         even_width, even_height);
+
+  d3d_context_->Unmap(staging_.Get(), 0);
+  return converted == 0;
+}
+
 void ScreenCapturerDxgi::CaptureLoop() {
+  ScopedWindowsPhysicalCoordinates physical_coordinates;
+  CursorFrameCompositor cursor_compositor;
   const int timeout_ms = (std::max)(1, 1000 / (std::max)(1, fps_));
   bool cached_frame_valid = false;
+  bool cached_cursor_embedded = false;
   int cached_monitor = -1;
   uint64_t cached_generation = 0;
-  std::vector<uint8_t> rotated_frame;
-  auto last_duplication_retry =
-      std::chrono::steady_clock::now() - std::chrono::milliseconds(1000);
+  auto next_topology_check = std::chrono::steady_clock::now();
+  unsigned acquire_failures = 0;
   while (running_) {
     if (paused_) {
       cached_frame_valid = false;
@@ -314,14 +428,25 @@ void ScreenCapturerDxgi::CaptureLoop() {
     // replace them in SwitchTo while AcquireNextFrame/Map is using them.
     std::unique_lock capture_lock(switch_mutex_);
     if (paused_ || !running_) continue;
+    const auto now = std::chrono::steady_clock::now();
+    const bool refresh = topology_refresh_requested_.exchange(false);
+    if (refresh || now >= next_topology_check) {
+      next_topology_check = now + std::chrono::milliseconds(500);
+      const bool changed = EnumerateDisplays();
+      if (changed || refresh || !duplication_) {
+        cached_frame_valid = false;
+        ReleaseDuplication();
+        CreateDuplicationForMonitor(monitor_index_.load());
+        capture_lock.unlock();
+        if (callback_)
+          callback_(nullptr, ScreenCapturer::kDisplayTopologyChanged,
+                    0, 0, "", nullptr);
+        continue;
+      }
+    }
     if (!duplication_) {
       cached_frame_valid = false;
       capture_lock.unlock();
-      const auto now = std::chrono::steady_clock::now();
-      if (now - last_duplication_retry >= std::chrono::milliseconds(500)) {
-        last_duplication_retry = now;
-        RecreateDuplicationForCurrentMonitor();
-      }
       std::this_thread::sleep_for(std::chrono::milliseconds(10));
       continue;
     }
@@ -336,25 +461,40 @@ void ScreenCapturerDxgi::CaptureLoop() {
       // successfully acquired for this monitor to keep delivering static frames.
       if (cached_frame_valid && cached_generation == duplication_generation_ &&
           cached_monitor == monitor_index_.load() && callback_ && nv12_frame_) {
+        // Recompose from the clean staging texture while showing a cursor, or
+        // once after disabling it. Never replay a baked-in stale cursor.
+        if (show_cursor_.load(std::memory_order_relaxed) ||
+            cached_cursor_embedded) {
+          if (!ConvertFrame(cached_monitor, &cached_cursor_embedded,
+                            cursor_compositor)) {
+            cached_frame_valid = false;
+            continue;
+          }
+        }
         const auto stream_id = MakeDisplayStreamId(cached_monitor);
         capture_lock.unlock();
+        CapturedCursorFrameScope cursor_scope(cached_cursor_embedded);
         callback_(nv12_frame_, nv12_width_ * nv12_height_ * 3 / 2, nv12_width_,
                   nv12_height_, stream_id.c_str(), nullptr);
       }
       continue;
     }
     // Never replay a cached image after an acquisition/conversion failure or
-    // a backend rebuild. Normal error/reset handling releases optional privacy.
+    // a backend rebuild. Display recovery retains the session privacy state.
     cached_frame_valid = false;
     if (FAILED(hr)) {
-      SharedDxgiCursorState().Reset();
       LOG_ERROR("DXGI: AcquireNextFrame failed, hr={}", (int)hr);
-      capture_lock.unlock();
-      if (callback_)
-        callback_(nullptr, ScreenCapturer::kBackendReset, 0, 0, "", nullptr);
-      RecreateDuplicationForCurrentMonitor();
+      ReleaseDuplication();
+      // A single ACCESS_LOST (mode switch, fullscreen toggle, UAC return) is
+      // rebuilt on the next iteration. Only repeated failures fall back to
+      // the 500 ms topology cadence so a broken output does not spin while
+      // recreating D3D devices.
+      if (++acquire_failures == 1) {
+        next_topology_check = std::chrono::steady_clock::now();
+      }
       continue;
     }
+    acquire_failures = 0;
 
     if (frame_monitor >= 0 &&
         frame_monitor < static_cast<int>(display_info_list_.size())) {
@@ -397,86 +537,37 @@ void ScreenCapturerDxgi::CaptureLoop() {
 
     d3d_context_->CopyResource(staging_.Get(), acquired_tex.Get());
 
-    D3D11_MAPPED_SUBRESOURCE mapped{};
-    hr = d3d_context_->Map(staging_.Get(), 0, D3D11_MAP_READ, 0, &mapped);
-    if (FAILED(hr)) {
-      duplication_->ReleaseFrame();
-      continue;
-    }
-
-    auto pixels = static_cast<const uint8_t*>(mapped.pData);
-    int stride = static_cast<int>(mapped.RowPitch);
-    int logical_width = static_cast<int>(src_desc.Width);
-    int logical_height = static_cast<int>(src_desc.Height);
-    libyuv::RotationMode rotation = libyuv::kRotate0;
-    switch (rotation_) {
-      case DXGI_MODE_ROTATION_ROTATE90:
-        rotation = libyuv::kRotate90;
-        break;
-      case DXGI_MODE_ROTATION_ROTATE180:
-        rotation = libyuv::kRotate180;
-        break;
-      case DXGI_MODE_ROTATION_ROTATE270:
-        rotation = libyuv::kRotate270;
-        break;
-      default:
-        break;
-    }
-    if (rotation != libyuv::kRotate0) {
-      const bool swap_axes = rotation != libyuv::kRotate180;
-      const int rotated_width = swap_axes ? logical_height : logical_width;
-      rotated_frame.resize(static_cast<size_t>(logical_width) * logical_height *
-                           4);
-      if (libyuv::ARGBRotate(pixels, stride, rotated_frame.data(),
-                             rotated_width * 4, logical_width, logical_height,
-                             rotation) != 0) {
-        d3d_context_->Unmap(staging_.Get(), 0);
-        duplication_->ReleaseFrame();
-        continue;
-      }
-      pixels = rotated_frame.data();
-      stride = rotated_width * 4;
-      if (swap_axes) std::swap(logical_width, logical_height);
-    }
-    int even_width = logical_width & ~1;
-    int even_height = logical_height & ~1;
-    if (even_width <= 0 || even_height <= 0) {
-      d3d_context_->Unmap(staging_.Get(), 0);
-      duplication_->ReleaseFrame();
-      continue;
-    }
-
-    int nv12_size = even_width * even_height * 3 / 2;
-    if (!nv12_frame_ || nv12_width_ != even_width ||
-        nv12_height_ != even_height) {
-      delete[] nv12_frame_;
-      nv12_frame_ = new unsigned char[nv12_size];
-      nv12_width_ = even_width;
-      nv12_height_ = even_height;
-    }
-
-    const int converted =
-        libyuv::ARGBToNV12(pixels, stride, nv12_frame_, even_width,
-                           nv12_frame_ + even_width * even_height, even_width,
-                           even_width, even_height);
+    bool cursor_embedded = false;
+    const bool converted =
+        ConvertFrame(frame_monitor, &cursor_embedded, cursor_compositor);
 
+    const std::string stream_id = MakeDisplayStreamId(frame_monitor);
     cached_generation = duplication_generation_;
-    d3d_context_->Unmap(staging_.Get(), 0);
+    if (converted && frame_monitor == monitor_index_.load() && callback_) {
+      if (last_logged_cursor_embedding_ < 0 ||
+          (software_cursor_output_ &&
+           last_logged_cursor_embedding_ != static_cast<int>(cursor_embedded))) {
+        LOG_INFO("DXGI cursor: monitor={} usbmmidd={} mouse_update={} "
+                 "separate_pointer_visible={} pointer_shape_bytes={} "
+                 "compose_cursor={} embedded={}",
+                 frame_monitor, software_cursor_output_,
+                 frame_info.LastMouseUpdateTime.QuadPart,
+                 frame_info.PointerPosition.Visible != FALSE,
+                 frame_info.PointerShapeBufferSize,
+                 show_cursor_.load(std::memory_order_relaxed), cursor_embedded);
+        last_logged_cursor_embedding_ = static_cast<int>(cursor_embedded);
+      }
+    }
     duplication_->ReleaseFrame();
     capture_lock.unlock();
 
-    if (converted == 0 && frame_monitor == monitor_index_.load() && callback_) {
-      int idx = frame_monitor;
-      if (idx >= 0 && idx < static_cast<int>(display_info_list_.size())) {
-        const std::string stream_id = MakeDisplayStreamId(idx);
-        callback_(nv12_frame_, nv12_size, even_width, even_height,
-                  stream_id.c_str(), nullptr);
-        cached_monitor = idx;
-        cached_frame_valid = true;
-      } else {
-        LOG_ERROR("DXGI: CaptureLoop invalid monitor_index {} (list size {})",
-                  idx, display_info_list_.size());
-      }
+    if (converted && frame_monitor == monitor_index_.load() && callback_) {
+      CapturedCursorFrameScope cursor_scope(cursor_embedded);
+      callback_(nv12_frame_, nv12_width_ * nv12_height_ * 3 / 2, nv12_width_,
+                nv12_height_, stream_id.c_str(), nullptr);
+      cached_cursor_embedded = cursor_embedded;
+      cached_monitor = frame_monitor;
+      cached_frame_valid = true;
     }
   }
 }

apps/desktop/src/platform/windows/screen_capturer/screen_capturer_dxgi.h

@@ -22,9 +22,12 @@
 
 #include "rd_log.h"
 #include "screen_capturer.h"
+#include "stable_display_slots.h"
 
 namespace crossdesk {
 
+class CursorFrameCompositor;
+
 class ScreenCapturerDxgi : public ScreenCapturer {
  public:
   ScreenCapturerDxgi();
@@ -35,6 +38,9 @@ class ScreenCapturerDxgi : public ScreenCapturer {
   int Destroy() override;
   int Start(bool show_cursor) override;
   int Stop() override;
+  void SetCursorCapture(bool enabled) {
+    show_cursor_.store(enabled, std::memory_order_relaxed);
+  }
 
   int Pause(int monitor_index) override;
   int Resume(int monitor_index) override;
@@ -42,34 +48,43 @@ class ScreenCapturerDxgi : public ScreenCapturer {
   int SwitchTo(int monitor_index) override;
   int ResetToInitialMonitor() override;
 
+  // Rebuild the selected output on the capture thread, never on the caller.
+  void RequestTopologyRefresh() { topology_refresh_requested_.store(true); }
+
   std::vector<DisplayInfo> GetDisplayInfoList() override {
+    std::lock_guard<std::mutex> lock(switch_mutex_);
     return display_info_list_;
   }
+  int GetCurrentMonitorIndex() const override {
+    return monitor_index_.load(std::memory_order_relaxed);
+  }
 
  private:
-  bool InitializeDxgi();
-  void EnumerateDisplays();
+  bool EnumerateDisplays();
   bool CreateDuplicationForMonitor(int monitor_index);
-  bool RecreateDuplicationForCurrentMonitor();
   void CaptureLoop();
+  bool ConvertFrame(int frame_monitor, bool* cursor_embedded,
+                    CursorFrameCompositor& compositor);
   void ReleaseDuplication();
 
  private:
   std::vector<DisplayInfo> display_info_list_;
   std::vector<Microsoft::WRL::ComPtr<IDXGIOutput>> outputs_;
+  StableDisplaySlots display_slots_;
+  std::atomic<bool> topology_refresh_requested_{false};
 
-  Microsoft::WRL::ComPtr<IDXGIFactory1> dxgi_factory_;
   Microsoft::WRL::ComPtr<ID3D11Device> d3d_device_;
   Microsoft::WRL::ComPtr<ID3D11DeviceContext> d3d_context_;
   Microsoft::WRL::ComPtr<IDXGIOutputDuplication> duplication_;
   Microsoft::WRL::ComPtr<ID3D11Texture2D> staging_;
   DXGI_MODE_ROTATION rotation_ = DXGI_MODE_ROTATION_IDENTITY;
   uint64_t duplication_generation_ = 0;
+  bool software_cursor_output_ = false;
+  int last_logged_cursor_embedding_ = -1;
 
   std::atomic<bool> running_{false};
   std::atomic<bool> paused_{false};
   std::atomic<int> monitor_index_{0};
-  int initial_monitor_index_ = 0;
   std::atomic<bool> show_cursor_{true};
   std::thread thread_;
   int fps_ = 60;
@@ -79,6 +94,7 @@ class ScreenCapturerDxgi : public ScreenCapturer {
   unsigned char* nv12_frame_ = nullptr;
   int nv12_width_ = 0;
   int nv12_height_ = 0;
+  std::vector<uint8_t> rotated_frame_;
 };
 }  // namespace crossdesk
 

apps/desktop/src/platform/windows/screen_capturer/screen_capturer_gdi.cpp

@@ -8,32 +8,12 @@
 #include <display_stream_id.h>
 #include "captured_cursor_state.h"
 #include "cursor_draw.h"
+#include "display_label.h"
 #include "libyuv.h"
 #include "rd_log.h"
 
 namespace crossdesk {
 
-namespace {
-std::string WideToUtf8(const std::wstring& wstr) {
-  if (wstr.empty()) return {};
-  int size_needed = WideCharToMultiByte(
-      CP_UTF8, 0, wstr.data(), (int)wstr.size(), nullptr, 0, nullptr, nullptr);
-  std::string result(size_needed, 0);
-  WideCharToMultiByte(CP_UTF8, 0, wstr.data(), (int)wstr.size(), result.data(),
-                      size_needed, nullptr, nullptr);
-  return result;
-}
-
-std::string GetDisplayLabel(const std::wstring& wide_name) {
-  std::string name = WideToUtf8(wide_name);
-  constexpr char kDevicePrefix[] = "\\\\.\\";
-  if (name.rfind(kDevicePrefix, 0) == 0) {
-    name.erase(0, sizeof(kDevicePrefix) - 1);
-  }
-  return name;
-}
-}  // namespace
-
 ScreenCapturerGdi::ScreenCapturerGdi() {}
 ScreenCapturerGdi::~ScreenCapturerGdi() {
   Stop();
@@ -142,15 +122,25 @@ int ScreenCapturerGdi::ResetToInitialMonitor() {
 void ScreenCapturerGdi::CaptureLoop() {
   int interval_ms = fps_ > 0 ? (1000 / fps_) : 16;
   HDC screen_dc = GetDC(nullptr);
+  bool dc_error_logged = false;
   while (running_) {
     if (paused_) {
       std::this_thread::sleep_for(std::chrono::milliseconds(10));
       continue;
     }
     if (!screen_dc) {
-      std::this_thread::sleep_for(std::chrono::milliseconds(10));
+      // The screen DC can be unavailable during a desktop switch; retry so
+      // capture resumes once the desktop is reachable again.
+      if (!dc_error_logged) {
+        LOG_WARN("GDI: GetDC(nullptr) failed, error={}; retrying",
+                 GetLastError());
+        dc_error_logged = true;
+      }
+      std::this_thread::sleep_for(std::chrono::milliseconds(interval_ms));
+      screen_dc = GetDC(nullptr);
       continue;
     }
+    dc_error_logged = false;
 
     int idx = monitor_index_.load();
     if (idx < 0 || idx >= static_cast<int>(display_info_list_.size())) {
@@ -177,11 +167,22 @@ void ScreenCapturerGdi::CaptureLoop() {
     bmi.bmiHeader.biBitCount = 32;
     bmi.bmiHeader.biCompression = BI_RGB;
 
+    // GDI is the only backend on a headless desktop, where odd DIB sizes and
+    // exhausted GDI handles are plausible; never dereference a failed alloc.
     void* bits = nullptr;
     HDC mem_dc = CreateCompatibleDC(screen_dc);
-    HBITMAP dib =
-        CreateDIBSection(mem_dc, &bmi, DIB_RGB_COLORS, &bits, nullptr, 0);
-    HGDIOBJ old = SelectObject(mem_dc, dib);
+    HBITMAP dib = mem_dc ? CreateDIBSection(mem_dc, &bmi, DIB_RGB_COLORS,
+                                            &bits, nullptr, 0)
+                         : nullptr;
+    HGDIOBJ old = (dib && bits) ? SelectObject(mem_dc, dib) : nullptr;
+    if (!old) {
+      LOG_WARN("GDI: frame buffer allocation failed ({}x{}), error={}", width,
+               height, GetLastError());
+      if (dib) DeleteObject(dib);
+      if (mem_dc) DeleteDC(mem_dc);
+      std::this_thread::sleep_for(std::chrono::milliseconds(interval_ms));
+      continue;
+    }
 
     BitBlt(mem_dc, 0, 0, width, height, screen_dc, left, top,
            SRCCOPY | CAPTUREBLT);
@@ -222,7 +223,7 @@ void ScreenCapturerGdi::CaptureLoop() {
 
     std::this_thread::sleep_for(std::chrono::milliseconds(interval_ms));
   }
-  ReleaseDC(nullptr, screen_dc);
+  if (screen_dc) ReleaseDC(nullptr, screen_dc);
 }
 
 }  // namespace crossdesk

apps/desktop/src/platform/windows/screen_capturer/screen_capturer_gdi.h

@@ -44,6 +44,9 @@ class ScreenCapturerGdi : public ScreenCapturer {
   std::vector<DisplayInfo> GetDisplayInfoList() override {
     return display_info_list_;
   }
+  int GetCurrentMonitorIndex() const override {
+    return monitor_index_.load(std::memory_order_relaxed);
+  }
 
  private:
   static BOOL CALLBACK EnumMonitorProc(HMONITOR hMonitor, HDC, LPRECT,

apps/desktop/src/platform/windows/screen_capturer/screen_capturer_wgc.cpp

@@ -9,6 +9,7 @@
 
 #include <display_stream_id.h>
 #include "captured_cursor_state.h"
+#include "display_label.h"
 #include "libyuv.h"
 #include "rd_log.h"
 
@@ -16,25 +17,6 @@ namespace crossdesk {
 
 static std::vector<DisplayInfo> gs_display_list;
 
-std::string WideToUtf8(const std::wstring& wstr) {
-  if (wstr.empty()) return {};
-  int size_needed = WideCharToMultiByte(
-      CP_UTF8, 0, wstr.data(), (int)wstr.size(), nullptr, 0, nullptr, nullptr);
-  std::string result(size_needed, 0);
-  WideCharToMultiByte(CP_UTF8, 0, wstr.data(), (int)wstr.size(), result.data(),
-                      size_needed, nullptr, nullptr);
-  return result;
-}
-
-std::string GetDisplayLabel(const std::wstring& wide_name) {
-  std::string name = WideToUtf8(wide_name);
-  constexpr char kDevicePrefix[] = "\\\\.\\";
-  if (name.rfind(kDevicePrefix, 0) == 0) {
-    name.erase(0, sizeof(kDevicePrefix) - 1);
-  }
-  return name;
-}
-
 BOOL WINAPI EnumMonitorProc(HMONITOR hmonitor, [[maybe_unused]] HDC hdc,
                             [[maybe_unused]] LPRECT lprc, LPARAM data) {
   MONITORINFOEX monitor_info_;

apps/desktop/src/platform/windows/screen_capturer/screen_capturer_win.cpp

@@ -1,7 +1,9 @@
 #include "screen_capturer_win.h"
 
 #include <Windows.h>
+#include <roapi.h>
 
+#include <algorithm>
 #include <chrono>
 #include <cmath>
 #include <cstring>
@@ -17,7 +19,12 @@
 #include <display_stream_id.h>
 #include "captured_nv12_frame.h"
 #include "captured_cursor_state.h"
+#include "capture_backend_policy.h"
+#include "display_presence.h"
+#include "display_label.h"
+#include "virtual_display_binding.h"
 #include "dxgi_cursor_state.h"
+#include "interactive_desktop.h"
 #include "interactive_state.h"
 #include "named_pipe_deadline.h"
 #include "rd_log.h"
@@ -28,6 +35,7 @@
 #include "secure_desktop_status_poller.h"
 #include "service_host.h"
 #include "session_helper_shared.h"
+#include "../virtual_display/usbmmidd_virtual_display.h"
 #include "wgc_plugin_api.h"
 
 namespace crossdesk {
@@ -45,10 +53,26 @@ constexpr DWORD kSecureDesktopTransientErrorGraceMs = 1500;
 constexpr DWORD kSecureDesktopTransientErrorLogIntervalMs = 5000;
 constexpr DWORD kPostSecureDesktopRestartRetryMs = 500;
 constexpr DWORD kPostSecureDesktopRestartTimeoutMs = 10000;
+constexpr ULONGLONG kCaptureStallTimeoutMs = 3000;
 constexpr int kSecureDesktopCaptureMinFps = 30;
 constexpr int kSecureDesktopCaptureMaxIntervalMs =
     1000 / kSecureDesktopCaptureMinFps;
 
+class CaptureThreadApartment {
+ public:
+  CaptureThreadApartment() : result_(RoInitialize(RO_INIT_MULTITHREADED)) {
+    if (FAILED(result_) && result_ != RPC_E_CHANGED_MODE)
+      LOG_WARN("Windows capturer: WinRT initialization failed, hr={}",
+               static_cast<int>(result_));
+  }
+  ~CaptureThreadApartment() {
+    if (SUCCEEDED(result_)) RoUninitialize();
+  }
+
+ private:
+  HRESULT result_;
+};
+
 class WgcPluginCapturer final : public ScreenCapturer {
  public:
   using CreateFn = ScreenCapturer* (*)();
@@ -177,6 +201,71 @@ const char* CaptureBackendName(const ScreenCapturer* capturer) {
   return "unavailable";
 }
 
+bool CapturesUsbmmiddOutput(ScreenCapturer* capturer) {
+  if (!capturer) return false;
+  const auto displays = capturer->GetDisplayInfoList();
+  const int selected = capturer->GetCurrentMonitorIndex();
+  if (selected < 0 || selected >= static_cast<int>(displays.size())) return false;
+  MONITORINFOEXW info{};
+  info.cbSize = sizeof(info);
+  return displays[selected].handle &&
+         GetMonitorInfoW(static_cast<HMONITOR>(displays[selected].handle), &info) &&
+         IsUsbmmiddDisplayDevice(info.szDevice);
+}
+
+// Debug aid: CROSSDESK_FORCE_HEADLESS=1 makes a host that has monitors behave
+// as if it had none until a usbmmidd monitor is plugged, so the virtual
+// display path can be exercised without unplugging cables. Once the virtual
+// monitor is attached the real probe takes over again.
+bool ForcedHeadlessForTesting() {
+  static const bool forced = [] {
+    wchar_t value[8] = {0};
+    const DWORD length =
+        GetEnvironmentVariableW(L"CROSSDESK_FORCE_HEADLESS", value, 8);
+    return length > 0 && length < 8 && value[0] == L'1';
+  }();
+  return forced && CountUsbmmiddMonitors() == 0;
+}
+
+// Headless compatibility mode: no monitor is attached, so the desktop lives on
+// a phantom target at an OS-chosen resolution. DXGI cannot duplicate it and
+// WGC has no real monitor item; GDI reads the composed desktop. This is a
+// best-effort baseline that needs no driver. Only an explicit Auto selection
+// takes this shortcut; a pinned method keeps its own failure semantics.
+bool DetectHeadlessDesktop(ScreenCaptureMethod method,
+                           bool capture_stalled = false,
+                           bool log_probe = false) {
+  if (method != ScreenCaptureMethod::Auto) return false;
+  if (ForcedHeadlessForTesting()) {
+    static std::atomic<bool> logged{false};
+    if (!logged.exchange(true)) {
+      LOG_WARN("Windows capturer: CROSSDESK_FORCE_HEADLESS=1 set; treating the "
+               "desktop as headless until a usbmmidd monitor is plugged");
+    }
+    return true;
+  }
+  const auto probe = ProbeDisplayPresence();
+  const auto presence = ClassifyDisplayPresence(probe, capture_stalled);
+  // Sessions probe repeatedly; report transitions rather than every probe.
+  static std::atomic<int> last_logged{-1};
+  if (last_logged.exchange(static_cast<int>(presence)) !=
+      static_cast<int>(presence) || log_probe) {
+    LOG_INFO("Windows capturer: display probe presence={} query_ok={} "
+             "active_paths={} available_targets={} identified_targets={} "
+             "unidentified_targets={} target_query_failures={} "
+             "embedded_or_virtual_targets={} edid_targets={} monitor_paths={} "
+             "desktop_devices={} monitors={} capture_stalled={}",
+             presence == DisplayPresence::headless ? "headless" :
+             presence == DisplayPresence::present ? "present" : "unknown",
+             probe.query_succeeded, probe.active_paths, probe.available_targets,
+             probe.identified_targets, probe.unidentified_targets,
+             probe.target_query_failures, probe.embedded_or_virtual_targets,
+             probe.edid_targets, probe.monitor_path_targets, probe.desktop_devices,
+             probe.attached_monitors, capture_stalled);
+  }
+  return presence == DisplayPresence::headless;
+}
+
 std::string BuildSecureCaptureCommand(int left, int top, int width, int height,
                                       bool show_cursor,
                                       const std::string& stage,
@@ -269,7 +358,7 @@ bool ParseSecureDesktopFrameResponse(const std::vector<uint8_t>& response,
   return true;
 }
 
-SecureDesktopServiceStatus QuerySecureDesktopServiceStatus() {
+SecureDesktopServiceStatus ReadSecureDesktopServiceStatus() {
   SecureDesktopServiceStatus status;
   std::vector<uint8_t> response;
   DWORD error_code = 0;
@@ -289,6 +378,14 @@ SecureDesktopServiceStatus QuerySecureDesktopServiceStatus() {
   if (!status.service_available) {
     status.error = json.value("error", std::string("service_unavailable"));
     status.error_code = json.value("code", 0u);
+    status.desktop_state_known = status.error == "service_session_mismatch";
+    return status;
+  }
+
+  if (!IsCurrentProcessSession(json.value("active_session_id", 0xFFFFFFFFu))) {
+    status.service_available = false;
+    status.desktop_state_known = true;
+    status.error = "service_session_mismatch";
     return status;
   }
 
@@ -326,6 +423,16 @@ SecureDesktopServiceStatus QuerySecureDesktopServiceStatus() {
   return status;
 }
 
+SecureDesktopServiceStatus QuerySecureDesktopServiceStatus() {
+  auto status = ReadSecureDesktopServiceStatus();
+  if (!status.service_available && IsCurrentSessionUserDesktopActive()) {
+    status.desktop_state_known = true;
+    status.capture_active = false;
+    status.interactive_stage = "user-desktop";
+  }
+  return status;
+}
+
 bool QuerySecureDesktopHelperCommand(DWORD session_id,
                                      const std::string& command,
                                      std::vector<uint8_t>* response_out,
@@ -392,6 +499,7 @@ int ScreenCapturerWin::Init(const int fps, cb_desktop_data cb) {
   cb_orig_ = cb;
   native_output_logged_.store(false, std::memory_order_relaxed);
   native_output_error_logged_.store(false, std::memory_order_relaxed);
+  last_capture_progress_tick_.store(0, std::memory_order_relaxed);
   try {
     native_frame_pool_ = CapturedNv12FramePool::Create();
   } catch (...) {
@@ -399,13 +507,23 @@ int ScreenCapturerWin::Init(const int fps, cb_desktop_data cb) {
     return -1;
   }
   cb_ = [this](unsigned char* data, int size, int w, int h,
-               const char* reported_stream_id,
-               const MiniRtcNativeVideoFrame* native_frame) {
+              const char* reported_stream_id,
+              const MiniRtcNativeVideoFrame* native_frame) {
+    if (size == ScreenCapturer::kDisplayTopologyChanged) {
+      SharedCapturedCursorState().Reset();
+      RebuildAliasesFromImpl(true);
+      display_probe_requested_.store(true, std::memory_order_relaxed);
+      return;
+    }
     if (size == ScreenCapturer::kBackendReset) {
       SharedCapturedCursorState().Reset();
-      if (privacy_) privacy_->Fail("Capture restarted; privacy screen will turn off");
+      // Backend recovery is not a user request to disable local privacy.
       return;
     }
+    if (data && size > 0 && w > 0 && h > 0) {
+      last_capture_progress_tick_.store(GetTickCount64(),
+                                     std::memory_order_relaxed);
+    }
     if (secure_desktop_capture_active_.load(std::memory_order_relaxed)) {
       SharedDxgiCursorState().Reset();
       SharedCapturedCursorState().Reset();
@@ -421,6 +539,9 @@ int ScreenCapturerWin::Init(const int fps, cb_desktop_data cb) {
       if (it != stream_id_alias_.end()) {
         mapped_stream_id = it->second;
       } else {
+        // During IDD takeover, never relabel a late frame from the old output
+        // as the virtual display's stream.
+        if (!virtual_display_name_.empty()) return;
         // Unknown backend labels are presentation data, not wire IDs.
         // Resolve them through the selected logical display instead.
         mapped_stream_id.clear();
@@ -471,28 +592,24 @@ int ScreenCapturerWin::Init(const int fps, cb_desktop_data cb) {
   };
 
   impl_.reset();
+  const bool headless = DetectHeadlessDesktop(capture_method_);
+  headless_compat_.store(headless, std::memory_order_relaxed);
   int ret = -1;
-  auto try_init = [&](std::unique_ptr<ScreenCapturer> candidate) {
+  for (const auto& create : PreferredBackends(headless)) {
+    std::unique_ptr<ScreenCapturer> candidate = create();
     ret = candidate ? candidate->Init(fps_, cb_) : -1;
-    if (ret != 0) {
-      LOG_WARN("Windows capturer: {} init failed (ret={})",
-               CaptureBackendName(candidate.get()), ret);
-      return false;
+    if (ret == 0) {
+      impl_ = std::move(candidate);
+      break;
     }
-    impl_ = std::move(candidate);
-    return true;
-  };
-  // Short-circuiting also keeps the unused WGC plugin unloaded.
-  if ((IsBackendEnabled(ScreenCaptureMethod::Dxgi) &&
-       try_init(std::make_unique<ScreenCapturerDxgi>())) ||
-      (IsBackendEnabled(ScreenCaptureMethod::Wgc) &&
-       try_init(WgcPluginCapturer::Create())) ||
-      (IsBackendEnabled(ScreenCaptureMethod::Gdi) &&
-       try_init(std::make_unique<ScreenCapturerGdi>()))) {
-    LOG_INFO("Windows capturer: using {}", CaptureBackendName(impl_.get()));
+    LOG_WARN("Windows capturer: {} init failed (ret={})",
+             CaptureBackendName(candidate.get()), ret);
+  }
+  if (impl_) {
+    LOG_INFO("Windows capturer: using {}{}", CaptureBackendName(impl_.get()),
+             headless ? " (headless compatibility mode)" : "");
     BuildCanonicalFromImpl();
     monitor_index_.store(0, std::memory_order_relaxed);
-    initial_monitor_index_ = 0;
     return 0;
   }
 
@@ -503,6 +620,9 @@ int ScreenCapturerWin::Init(const int fps, cb_desktop_data cb) {
 
 int ScreenCapturerWin::Destroy() {
   Stop();
+  // Stop() releases the virtual display on a worker; finish it here so the
+  // provisioner is idle before its owner goes away.
+  JoinVirtualDisplayThread();
   paused_.store(false, std::memory_order_relaxed);
   if (impl_) {
     impl_->Destroy();
@@ -548,6 +668,8 @@ void ScreenCapturerWin::EmitCapturedFrame(
   } restore_source{
       std::exchange(current_frame_from_secure_desktop, from_secure_desktop)};
 
+  // Privacy is a local, capture-excluded window. Always deliver the actual
+  // desktop pixels, including while that window is starting or stopping.
   if (native_frame) {
     if (!native_output_logged_.exchange(true, std::memory_order_relaxed)) {
       LOG_INFO("Windows capturer native frame output enabled (type={})",
@@ -585,9 +707,7 @@ void ScreenCapturerWin::EmitCapturedFrame(
 
 void ScreenCapturerWin::RestoreMonitor(int monitor_index) {
   RebuildAliasesFromImpl();
-  if (monitor_index > 0 && impl_->SwitchTo(monitor_index) != 0) {
-    monitor_index_.store(0, std::memory_order_relaxed);
-  }
+  if (monitor_index >= 0) SwitchTo(monitor_index);
 }
 
 bool ScreenCapturerWin::TryStartBackend(
@@ -598,9 +718,34 @@ bool ScreenCapturerWin::TryStartBackend(
   }
   const char* name = CaptureBackendName(candidate.get());
   const bool show_cursor = show_cursor_.load(std::memory_order_relaxed);
-  int ret = candidate->Init(fps_, cb_);
-  if (ret == 0)
+  // A candidate may deliver immediately from Start(). Publish frames only
+  // after its display selection and wire aliases have been committed.
+  auto committed = std::make_shared<std::atomic<bool>>(false);
+  int ret = candidate->Init(fps_, [this, committed](
+      unsigned char* data, int size, int width, int height,
+      const char* stream, const MiniRtcNativeVideoFrame* native) {
+    if (committed->load(std::memory_order_acquire))
+      cb_(data, size, width, height, stream, native);
+  });
+  std::string required_display;
+  {
+    std::lock_guard<std::mutex> lock(alias_mutex_);
+    required_display = virtual_display_name_;
+  }
+  if (ret == 0 && !required_display.empty()) {
+    const auto displays = candidate->GetDisplayInfoList();
+    const auto found = std::find_if(displays.begin(), displays.end(),
+        [&](const DisplayInfo& display) {
+          return display.name == required_display &&
+                 display.width > 0 && display.height > 0;
+        });
+    ret = found == displays.end() ? -1 :
+        candidate->SwitchTo(static_cast<int>(found - displays.begin()));
+  }
+  if (ret == 0) {
+    last_capture_progress_tick_.store(GetTickCount64(), std::memory_order_relaxed);
     ret = candidate->Start(show_cursor);
+  }
   if (ret != 0) {
     LOG_WARN("Windows capturer: {} initialization/start failed (ret={})", name,
              ret);
@@ -609,13 +754,72 @@ bool ScreenCapturerWin::TryStartBackend(
   }
   // Commit only after the replacement is running. Failed candidates release
   // their resources without replacing the current backend.
-  impl_ = std::move(candidate);
+  {
+    std::lock_guard<std::mutex> lock(impl_mutex_);
+    impl_ = std::move(candidate);
+  }
   applied_show_cursor_ = show_cursor;
   RestoreMonitor(monitor_index);
+  committed->store(true, std::memory_order_release);
   LOG_INFO("Windows capturer: started {}", name);
   return true;
 }
 
+std::vector<ScreenCapturerWin::BackendFactory>
+ScreenCapturerWin::PreferredBackends(bool headless, bool usbmmidd) const {
+  std::vector<BackendFactory> factories;
+  for (const auto backend :
+       WindowsCaptureBackendOrder(capture_method_, headless, usbmmidd)) {
+    switch (backend) {
+      case ScreenCaptureMethod::Dxgi:
+        factories.push_back([] { return std::make_unique<ScreenCapturerDxgi>(); });
+        break;
+      case ScreenCaptureMethod::Wgc:
+        factories.push_back([] { return WgcPluginCapturer::Create(); });
+        break;
+      case ScreenCaptureMethod::Gdi:
+        factories.push_back([] { return std::make_unique<ScreenCapturerGdi>(); });
+        break;
+      default:
+        break;
+    }
+  }
+  return factories;
+}
+
+bool ScreenCapturerWin::StartPreferredBackend(bool headless,
+                                              int monitor_index,
+                                              bool usbmmidd) {
+  if (usbmmidd && capture_method_ == ScreenCaptureMethod::Auto) {
+    LOG_INFO("Windows capturer: usbmmidd uses WGC with cursor capture={}",
+             show_cursor_.load(std::memory_order_relaxed));
+  }
+  for (const auto& create : PreferredBackends(headless, usbmmidd)) {
+    if (TryStartBackend(create(), monitor_index)) return true;
+  }
+  return false;
+}
+
+void ScreenCapturerWin::ResetPostSecureDesktopState() {
+  secure_desktop_capture_active_.store(false, std::memory_order_relaxed);
+  post_secure_desktop_waiting_for_frame_.store(false,
+                                               std::memory_order_relaxed);
+  post_secure_desktop_drop_logged_.store(false, std::memory_order_relaxed);
+  post_secure_desktop_started_tick_.store(0, std::memory_order_relaxed);
+  SharedSecureDesktopCursorState().SetActive(false);
+}
+
+int ScreenCapturerWin::MarkStarted() {
+  running_.store(true, std::memory_order_relaxed);
+  NotifyPrivacyCapture(true);
+  ResetPostSecureDesktopState();
+  if (!secure_capture_thread_.joinable()) {
+    secure_capture_thread_ =
+        std::thread([this]() { SecureDesktopCaptureLoop(); });
+  }
+  return 0;
+}
+
 int ScreenCapturerWin::Start(bool show_cursor) {
   if (!impl_) return -1;
   if (running_.load(std::memory_order_relaxed)) {
@@ -628,21 +832,66 @@ int ScreenCapturerWin::Start(bool show_cursor) {
   SharedCapturedCursorState().Reset();
   paused_.store(false, std::memory_order_relaxed);
   invalid_stream_id_logged_.store(false, std::memory_order_relaxed);
+  last_capture_progress_tick_.store(0, std::memory_order_relaxed);
 
   // Refresh physical monitor identities before every session. HMONITOR and
   // DXGI output handles may change after an HDMI hotplug while CrossDesk stays
   // open; logical stream IDs must remain stable.
   const int requested_monitor =
       monitor_index_.load(std::memory_order_relaxed);
+  // A monitor may have been attached or removed since the last session. Pick
+  // the backend for the desktop as it is now, not as it was at Init.
+  JoinVirtualDisplayThread();
+  {
+    std::lock_guard<std::mutex> lock(alias_mutex_);
+    virtual_display_name_.clear();
+    virtual_display_slot_ = -1;
+  }
+  const bool headless = DetectHeadlessDesktop(capture_method_, false, true);
+  const bool usbmmidd = !headless && CapturesUsbmmiddOutput(impl_.get());
+  // The virtual display is provisioned off this thread (Start() runs on the
+  // UI thread and a driver install can take minutes). Begin in compatibility
+  // mode; MaybeAdoptVirtualDisplay() switches to a GPU backend once ready.
+  virtual_display_ready_.store(false, std::memory_order_relaxed);
+  display_probe_requested_.store(true, std::memory_order_relaxed);
+  last_display_probe_tick_ = 0;
+  last_capture_retry_tick_ = 0;
+  last_virtual_adoption_tick_ = 0;
+  headless_recovery_.Reset();
+  const bool was_headless =
+      headless_compat_.exchange(headless, std::memory_order_relaxed);
+  const bool backend_is_gdi = dynamic_cast<ScreenCapturerGdi*>(impl_.get()) != nullptr;
+  int ret = 0;
+  const bool needs_wgc = usbmmidd &&
+      capture_method_ == ScreenCaptureMethod::Auto &&
+      dynamic_cast<WgcPluginCapturer*>(impl_.get()) == nullptr;
+  if (headless != was_headless || (headless && !backend_is_gdi) || needs_wgc) {
+    LOG_INFO("Windows capturer: reselecting capture backend "
+             "(headless={}, usbmmidd={})", headless, usbmmidd);
+    impl_->Destroy();
+    // Keep an instance around on failure so the next Start can retry.
+    std::unique_ptr<ScreenCapturer> previous;
+    {
+      std::lock_guard<std::mutex> lock(impl_mutex_);
+      previous = std::move(impl_);
+    }
+    if (!StartPreferredBackend(headless, requested_monitor, usbmmidd)) {
+      std::lock_guard<std::mutex> lock(impl_mutex_);
+      impl_ = std::move(previous);
+      LOG_ERROR("Windows capturer: no capture backend could start");
+      return -1;
+    }
+    return MarkStarted();
+  }
   impl_->Destroy();
-  int ret = impl_->Init(fps_, cb_);
+  ret = impl_->Init(fps_, cb_);
   if (ret == 0) {
     RebuildAliasesFromImpl();
+    // Canonical wire/input slots may differ from this backend's refreshed
+    // enumeration. Select through the mapping before its first callback.
+    SwitchTo(requested_monitor);
+    last_capture_progress_tick_.store(GetTickCount64(), std::memory_order_relaxed);
     ret = impl_->Start(show_cursor);
-    if (ret == 0 && requested_monitor > 0 &&
-        impl_->SwitchTo(requested_monitor) != 0) {
-      monitor_index_.store(0, std::memory_order_relaxed);
-    }
   }
   if (ret != 0) {
     if (capture_method_ != ScreenCaptureMethod::Auto) {
@@ -654,11 +903,13 @@ int ScreenCapturerWin::Start(bool show_cursor) {
              ret);
 
     bool fallback_started = false;
-    if (dynamic_cast<ScreenCapturerDxgi*>(impl_.get()) &&
+    if (usbmmidd) {
+      fallback_started = StartPreferredBackend(false, requested_monitor, true);
+    } else if (dynamic_cast<ScreenCapturerDxgi*>(impl_.get()) &&
         TryStartBackend(WgcPluginCapturer::Create(), requested_monitor)) {
       fallback_started = true;
     }
-    if (!fallback_started && (dynamic_cast<WgcPluginCapturer*>(impl_.get()) ||
+    if (!usbmmidd && !fallback_started && (dynamic_cast<WgcPluginCapturer*>(impl_.get()) ||
                               dynamic_cast<ScreenCapturerDxgi*>(impl_.get()))) {
       fallback_started = TryStartBackend(std::make_unique<ScreenCapturerGdi>(),
                                          requested_monitor);
@@ -670,70 +921,157 @@ int ScreenCapturerWin::Start(bool show_cursor) {
     }
   }
 
-  running_.store(true, std::memory_order_relaxed);
-  NotifyPrivacyCapture(true);
-  SharedSecureDesktopCursorState().SetActive(false);
-  secure_desktop_capture_active_.store(false, std::memory_order_relaxed);
-  post_secure_desktop_waiting_for_frame_.store(false,
-                                               std::memory_order_relaxed);
-  post_secure_desktop_drop_logged_.store(false, std::memory_order_relaxed);
-  post_secure_desktop_started_tick_.store(0, std::memory_order_relaxed);
-  if (!secure_capture_thread_.joinable()) {
-    secure_capture_thread_ =
-        std::thread([this]() { SecureDesktopCaptureLoop(); });
-  }
-  return 0;
+  return MarkStarted();
 }
 
 int ScreenCapturerWin::Stop() {
   NotifyPrivacyCapture(false);
   running_.store(false, std::memory_order_relaxed);
-  secure_desktop_capture_active_.store(false, std::memory_order_relaxed);
-  post_secure_desktop_waiting_for_frame_.store(false,
-                                               std::memory_order_relaxed);
-  post_secure_desktop_drop_logged_.store(false, std::memory_order_relaxed);
-  post_secure_desktop_started_tick_.store(0, std::memory_order_relaxed);
+  last_capture_progress_tick_.store(0, std::memory_order_relaxed);
   int ret = 0;
   // Drain management operations before stopping/replacing their backend.
+  virtual_display_.RequestCancel();
   StopSecureCaptureThread();
+  JoinVirtualDisplayThread();
+  ResetPostSecureDesktopState();
   if (impl_) {
     ret = impl_->Stop();
   }
   SharedCapturedCursorState().Reset();
-  SharedSecureDesktopCursorState().SetActive(false);
   StopSecureDesktopSharedCapture(secure_shared_session_id_);
+  // After the backend released its duplication of the virtual output. The
+  // unplug itself can take seconds; do not hold the UI thread for it.
+  BeginVirtualDisplayRelease();
   return ret;
 }
 
+void ScreenCapturerWin::JoinVirtualDisplayThread() {
+  if (virtual_display_thread_.joinable()) virtual_display_thread_.join();
+}
+
+void ScreenCapturerWin::BeginVirtualDisplayProvisioning() {
+  if (virtual_display_busy_.load(std::memory_order_acquire)) return;
+  JoinVirtualDisplayThread();
+  virtual_display_.PrepareAcquire();
+  if (!running_.load(std::memory_order_relaxed)) return;
+  virtual_display_busy_.store(true, std::memory_order_release);
+  virtual_display_thread_ = std::thread([this] {
+    // A usbmmidd virtual monitor turns the phantom desktop into a real
+    // display target, so the GPU backends and a chosen resolution apply.
+    std::string error;
+    if (virtual_display_.Acquire(kDefaultVirtualDisplayMode, &error)) {
+      virtual_display_ready_.store(true, std::memory_order_release);
+    } else if (error != "cancelled") {
+      LOG_WARN("Windows capturer: no usbmmidd virtual display ({}); "
+               "will retry while headless",
+               error);
+    }
+    virtual_display_busy_.store(false, std::memory_order_release);
+  });
+}
+
+void ScreenCapturerWin::BeginVirtualDisplayRelease() {
+  JoinVirtualDisplayThread();
+  virtual_display_ready_.store(false, std::memory_order_relaxed);
+  if (!virtual_display_.NeedsRelease()) return;
+  virtual_display_thread_ = std::thread([this] { virtual_display_.Release(); });
+}
+
+void ScreenCapturerWin::MaybeAdoptVirtualDisplay() {
+  if (!virtual_display_ready_.load(std::memory_order_acquire))
+    return;
+  if (!running_.load(std::memory_order_relaxed)) return;
+  const auto now = GetTickCount64();
+  if (last_virtual_adoption_tick_ != 0 &&
+      now - last_virtual_adoption_tick_ < 3000) return;
+  last_virtual_adoption_tick_ = now;
+  const auto virtual_name = GetDisplayLabel(FindUsbmmiddDisplayDeviceName());
+  if (virtual_name.empty()) return;
+  const int current_monitor = monitor_index_.load(std::memory_order_relaxed);
+  LOG_INFO("Windows capturer: adopting usbmmidd display '{}' in stream slot {}",
+           virtual_name, current_monitor);
+  NotifyPrivacyCapture(false);
+  // Drain callbacks while impl_ still names their backend. A topology callback
+  // can rebuild aliases and must not observe the temporary null during a swap.
+  if (impl_) impl_->Stop();
+  // Public entry points dereference impl_ under impl_mutex_; take the old
+  // backend out under the lock, then tear it down without holding it.
+  std::unique_ptr<ScreenCapturer> previous;
+  {
+    std::lock_guard<std::mutex> lock(impl_mutex_);
+    previous = std::move(impl_);
+  }
+  if (previous) previous->Destroy();
+  {
+    std::lock_guard<std::mutex> lock(alias_mutex_);
+    virtual_display_name_ = virtual_name;
+    virtual_display_slot_ = current_monitor;
+  }
+  if (StartPreferredBackend(false, current_monitor, true)) {
+    virtual_display_ready_.store(false, std::memory_order_release);
+    headless_compat_.store(false, std::memory_order_relaxed);
+    // The owner refreshes its display list and input mapping every tick from
+    // GetDisplayInfoList(), so the new geometry is picked up without a hint.
+  } else {
+    LOG_ERROR("Windows capturer: WGC could not start on usbmmidd; "
+              "will retry cursor-excluding capture");
+    {
+      std::lock_guard<std::mutex> lock(alias_mutex_);
+      virtual_display_name_.clear();
+      virtual_display_slot_ = -1;
+    }
+    {
+      std::lock_guard<std::mutex> lock(impl_mutex_);
+      impl_ = std::move(previous);
+    }
+    // Retain the stopped instance for Stop()/the next retry, but do not start
+    // DXGI/GDI on the now-attached IDD: it can bake the cursor into the video.
+  }
+  NotifyPrivacyCapture(true);
+}
+
 int ScreenCapturerWin::Pause(int monitor_index) {
   paused_.store(true, std::memory_order_relaxed);
+  std::lock_guard<std::mutex> lock(impl_mutex_);
   if (!impl_) return -1;
   return impl_->Pause(monitor_index);
 }
 
 int ScreenCapturerWin::Resume(int monitor_index) {
   paused_.store(false, std::memory_order_relaxed);
+  std::lock_guard<std::mutex> lock(impl_mutex_);
   if (!impl_) return -1;
   return impl_->Resume(monitor_index);
 }
 
 int ScreenCapturerWin::SwitchTo(int monitor_index) {
+  std::lock_guard<std::mutex> impl_lock(impl_mutex_);
   if (!impl_) return -1;
-  const int ret = impl_->SwitchTo(monitor_index);
+  int backend_index = -1;
+  {
+    std::lock_guard<std::mutex> lock(alias_mutex_);
+    if (monitor_index < 0 ||
+        monitor_index >= static_cast<int>(canonical_displays_.size()) ||
+        canonical_displays_[monitor_index].width <= 0 ||
+        canonical_displays_[monitor_index].height <= 0) return -1;
+    const auto found = std::find(backend_to_canonical_.begin(),
+                                  backend_to_canonical_.end(), monitor_index);
+    if (found != backend_to_canonical_.end())
+      backend_index = static_cast<int>(found - backend_to_canonical_.begin());
+  }
+  if (backend_index < 0) return -1;
+  const int ret = impl_->SwitchTo(backend_index);
   if (ret == 0) {
     monitor_index_.store(monitor_index, std::memory_order_relaxed);
-  } else if (privacy_) {
-    privacy_->Fail("Display switch failed; privacy screen will turn off");
   }
   return ret;
 }
 
 int ScreenCapturerWin::ResetToInitialMonitor() {
+  std::lock_guard<std::mutex> lock(impl_mutex_);
   if (!impl_) return -1;
   const int ret = impl_->ResetToInitialMonitor();
-  if (ret == 0) {
-    monitor_index_.store(initial_monitor_index_, std::memory_order_relaxed);
-  }
+  RebuildAliasesFromImpl(true);
   return ret;
 }
 
@@ -743,11 +1081,16 @@ std::vector<DisplayInfo> ScreenCapturerWin::GetDisplayInfoList() {
   return canonical_displays_;
 }
 
+int ScreenCapturerWin::GetCurrentMonitorIndex() const {
+  return monitor_index_.load(std::memory_order_relaxed);
+}
+
 void ScreenCapturerWin::BuildCanonicalFromImpl() {
   std::lock_guard<std::mutex> lock(alias_mutex_);
   handle_to_canonical_index_.clear();
   stream_id_alias_.clear();
   canonical_displays_ = impl_->GetDisplayInfoList();
+  backend_to_canonical_.clear();
   std::unordered_map<std::string, size_t> name_counts;
   for (const auto& display : canonical_displays_) {
     if (!display.name.empty()) {
@@ -755,6 +1098,7 @@ void ScreenCapturerWin::BuildCanonicalFromImpl() {
     }
   }
   for (size_t i = 0; i < canonical_displays_.size(); ++i) {
+    backend_to_canonical_.push_back(static_cast<int>(i));
     auto& di = canonical_displays_[i];
     const std::string stream_id = MakeDisplayStreamId(i);
     if (di.name.empty()) {
@@ -769,11 +1113,32 @@ void ScreenCapturerWin::BuildCanonicalFromImpl() {
   }
 }
 
-void ScreenCapturerWin::RebuildAliasesFromImpl() {
+void ScreenCapturerWin::RebuildAliasesFromImpl(bool preserve_backend_slots) {
   std::lock_guard<std::mutex> lock(alias_mutex_);
   stream_id_alias_.clear();
   auto current = impl_->GetDisplayInfoList();
   if (current.empty() || canonical_displays_.empty()) return;
+  if (!virtual_display_name_.empty() && virtual_display_slot_ >= 0 &&
+      virtual_display_slot_ < static_cast<int>(canonical_displays_.size())) {
+    // A headless session deliberately replaces its selected output with IDD.
+    // Bind by device name, not primary status/enumeration order: the phantom
+    // NVIDIA output can remain first even after usbmmidd is ready.
+    handle_to_canonical_index_.clear();
+    const int i = BindVirtualDisplayToStream(current, virtual_display_name_,
+        virtual_display_slot_, &canonical_displays_, &backend_to_canonical_);
+    if (i >= 0) {
+      const auto stream = MakeDisplayStreamId(virtual_display_slot_);
+      stream_id_alias_[MakeDisplayStreamId(i)] = stream;
+      stream_id_alias_[current[i].name] = stream;
+      if (current[i].handle)
+        handle_to_canonical_index_[current[i].handle] = virtual_display_slot_;
+      monitor_index_.store(virtual_display_slot_, std::memory_order_relaxed);
+    }
+    return;
+  }
+  const bool stable_slots = preserve_backend_slots &&
+                           dynamic_cast<ScreenCapturerDxgi*>(impl_.get());
+  if (!stable_slots) backend_to_canonical_.assign(current.size(), -1);
   const auto previous_handles = handle_to_canonical_index_;
   handle_to_canonical_index_.clear();
   std::unordered_map<std::string, size_t> name_counts;
@@ -794,8 +1159,14 @@ void ScreenCapturerWin::RebuildAliasesFromImpl() {
        ++current_index) {
     const auto& di = current[current_index];
     int canonical_index = -1;
+    if (stable_slots) {
+      // New outputs have no registered wire stream in this session.
+      if (current_index >= backend_to_canonical_.size() ||
+          backend_to_canonical_[current_index] < 0) continue;
+      canonical_index = backend_to_canonical_[current_index];
+    }
     auto old_handle = previous_handles.find(di.handle);
-    if (old_handle != previous_handles.end() &&
+    if (canonical_index < 0 && old_handle != previous_handles.end() &&
         old_handle->second < canonical_displays_.size() &&
         !used[old_handle->second]) {
       canonical_index = static_cast<int>(old_handle->second);
@@ -821,6 +1192,7 @@ void ScreenCapturerWin::RebuildAliasesFromImpl() {
     }
 
     used[canonical_index] = true;
+    backend_to_canonical_[current_index] = canonical_index;
     auto& canonical = canonical_displays_[canonical_index];
     const std::string backend_stream_id =
         MakeDisplayStreamId(current_index);
@@ -830,13 +1202,18 @@ void ScreenCapturerWin::RebuildAliasesFromImpl() {
     if (!di.name.empty() && name_counts[di.name] == 1) {
       stream_id_alias_[di.name] = stable_stream_id;
     }
-    handle_to_canonical_index_[di.handle] =
-        static_cast<size_t>(canonical_index);
+    if (di.handle)
+      handle_to_canonical_index_[di.handle] =
+          static_cast<size_t>(canonical_index);
     canonical = di;
     if (canonical.name.empty()) {
       canonical.name = stable_stream_id;
     }
   }
+  const int active = impl_->GetCurrentMonitorIndex();
+  if (active >= 0 && active < static_cast<int>(backend_to_canonical_.size()) &&
+      backend_to_canonical_[active] >= 0)
+    monitor_index_.store(backend_to_canonical_[active]);
 }
 
 void ScreenCapturerWin::StopSecureCaptureThread() {
@@ -853,6 +1230,7 @@ bool ScreenCapturerWin::RestartCaptureBackendAfterSecureDesktop() {
 
   const bool show_cursor = show_cursor_.load(std::memory_order_relaxed);
   const int current_monitor = monitor_index_.load(std::memory_order_relaxed);
+  const bool usbmmidd = virtual_display_.active() || CapturesUsbmmiddOutput(impl_.get());
 
   LOG_INFO("Windows capturer: restarting capture backend after secure desktop");
   impl_->Stop();
@@ -878,30 +1256,79 @@ bool ScreenCapturerWin::RestartCaptureBackendAfterSecureDesktop() {
     return true;
   }
 
-  if ((IsBackendEnabled(ScreenCaptureMethod::Dxgi) &&
-       TryStartBackend(std::make_unique<ScreenCapturerDxgi>(), current_monitor)) ||
-      (IsBackendEnabled(ScreenCaptureMethod::Wgc) &&
-       TryStartBackend(WgcPluginCapturer::Create(), current_monitor)) ||
-      (IsBackendEnabled(ScreenCaptureMethod::Gdi) &&
-       TryStartBackend(std::make_unique<ScreenCapturerGdi>(), current_monitor))) {
+  if (StartPreferredBackend(headless_compat_.load(std::memory_order_relaxed),
+                            current_monitor, usbmmidd)) {
     return true;
   }
 
-  if (impl_) {
-    LOG_WARN(
-        "Windows capturer: all backend restart attempts after secure desktop "
-        "failed (last_ret={})",
-        ret);
-  }
+  LOG_WARN(
+      "Windows capturer: all backend restart attempts after secure desktop "
+      "failed (last_ret={})",
+      ret);
   return false;
 }
 
+void ScreenCapturerWin::CheckDisplayPresence(ULONGLONG now) {
+  if (capture_method_ != ScreenCaptureMethod::Auto) return;
+  // Topology events accelerate the next probe, but driver rebuild callbacks
+  // must not flood QueryDisplayConfig. Polling also covers WGC/GDI and unplug
+  // events that NVIDIA does not expose as a changed DXGI output.
+  const auto elapsed = now - last_display_probe_tick_;
+  if (last_display_probe_tick_ != 0 &&
+      (elapsed < 250 || (elapsed < 1000 &&
+       !display_probe_requested_.load(std::memory_order_relaxed)))) return;
+  last_display_probe_tick_ = now;
+  const bool topology_changed =
+      display_probe_requested_.exchange(false, std::memory_order_relaxed);
+  if (!IsWindowsPrivacyDesktopAvailable()) {
+    headless_recovery_.ShouldProvision(now, false, false, false);
+    return;
+  }
+  const auto last_progress =
+      last_capture_progress_tick_.load(std::memory_order_relaxed);
+  const bool stalled = last_progress != 0 && now >= last_progress &&
+                       now - last_progress >= kCaptureStallTimeoutMs;
+  const bool headless = DetectHeadlessDesktop(capture_method_, stalled,
+                                             topology_changed);
+  if (!headless_recovery_.ShouldProvision(
+          now, headless, virtual_display_busy_.load(std::memory_order_acquire),
+          virtual_display_.active())) return;
+  if (!running_.load(std::memory_order_relaxed)) return;
+  headless_recovery_.Attempted(now);
+  headless_compat_.store(true, std::memory_order_relaxed);
+  LOG_WARN("Windows capturer: confirmed headless desktop during capture "
+           "(stalled={}); provisioning usbmmidd", stalled);
+  BeginVirtualDisplayProvisioning();
+}
+
+void ScreenCapturerWin::CheckCaptureProgress(ULONGLONG now) {
+  if (capture_method_ != ScreenCaptureMethod::Auto || !running_.load()) return;
+  auto* dxgi = dynamic_cast<ScreenCapturerDxgi*>(impl_.get());
+  if (!dxgi) return;
+
+  const auto last_progress =
+      last_capture_progress_tick_.load(std::memory_order_relaxed);
+  // A capture callback may have advanced the tick after this loop sampled now.
+  if (last_progress == 0 || now < last_progress ||
+       now - last_progress < kCaptureStallTimeoutMs) return;
+  if (last_capture_retry_tick_ != 0 &&
+      now - last_capture_retry_tick_ < kCaptureStallTimeoutMs) return;
+  // Probe/recovery is handled separately. When another real monitor remains,
+  // retry only the pinned output instead of silently selecting that monitor.
+  LOG_WARN("Windows capturer: DXGI has delivered no frame for {} ms; "
+           "refreshing the selected output", now - last_progress);
+  dxgi->RequestTopologyRefresh();
+  last_capture_retry_tick_ = now;
+}
+
 void ScreenCapturerWin::ApplyCursorCaptureSetting() {
   const bool requested = show_cursor_.load(std::memory_order_relaxed);
   if (!impl_ || requested == applied_show_cursor_) return;
   int ret = 0;
   if (auto* gdi = dynamic_cast<ScreenCapturerGdi*>(impl_.get())) {
     gdi->SetCursorCapture(requested);
+  } else if (auto* dxgi = dynamic_cast<ScreenCapturerDxgi*>(impl_.get())) {
+    dxgi->SetCursorCapture(requested);
   } else if (auto* wgc = dynamic_cast<WgcPluginCapturer*>(impl_.get())) {
     ret = wgc->SetCursorCapture(requested);
   }
@@ -1185,6 +1612,9 @@ bool ScreenCapturerWin::StartSecureDesktopSharedCapture(
 }
 
 void ScreenCapturerWin::SecureDesktopCaptureLoop() {
+  // Virtual-display adoption constructs WGC on this std::thread, which does
+  // not inherit the UI thread's WinRT apartment.
+  CaptureThreadApartment apartment;
   const int frame_interval_ms =
       fps_ > 0 ? (std::min)(kSecureDesktopCaptureMaxIntervalMs, 1000 / fps_)
                : kSecureDesktopCaptureMaxIntervalMs;
@@ -1260,9 +1690,8 @@ void ScreenCapturerWin::SecureDesktopCaptureLoop() {
         } else if (IsTransientWindowsServiceStatusError(status.error)) {
           LOG_INFO(
               "Windows capturer secure desktop service temporarily "
-              "unavailable; "
-              "keeping last capture state: error={}, code={}",
-              status.error, status.error_code);
+              "unavailable: error={}, code={}, capture_active={}",
+              status.error, status.error_code, status.capture_active);
         } else {
           LOG_WARN(
               "Windows capturer secure desktop service unavailable: "
@@ -1317,6 +1746,9 @@ void ScreenCapturerWin::SecureDesktopCaptureLoop() {
 
     if (!status.capture_active || status.active_session_id == 0xFFFFFFFF) {
       StopSecureDesktopSharedCapture(secure_shared_session_id_);
+      CheckDisplayPresence(now);
+      MaybeAdoptVirtualDisplay();
+      CheckCaptureProgress(now);
       if (post_secure_restart_pending) {
         if (now >= post_secure_restart_deadline_tick) {
           LOG_WARN(

apps/desktop/src/platform/windows/screen_capturer/screen_capturer_win.h

@@ -12,6 +12,7 @@
 #include <atomic>
 #include <cstddef>
 #include <cstdint>
+#include <functional>
 #include <memory>
 #include <mutex>
 #include <string>
@@ -22,6 +23,9 @@
 #include "screen_capturer.h"
 #include "screen_capture_method.h"
 #include "privacy_controller.h"
+// Relative: platform include directories stay private to the capture target.
+#include "../virtual_display/virtual_display_provisioner.h"
+#include "headless_recovery.h"
 
 namespace crossdesk {
 
@@ -49,6 +53,9 @@ class ScreenCapturerWin : public ScreenCapturer {
   int ResetToInitialMonitor() override;
 
   std::vector<DisplayInfo> GetDisplayInfoList() override;
+  int GetCurrentMonitorIndex() const override;
+  // True while this session captures a usbmmidd monitor it plugged itself.
+  bool IsVirtualDisplayActive() const { return virtual_display_.active(); }
   void SetPrivacyController(PrivacyController* privacy) override { privacy_ = privacy; }
   // Set before Init(), while capture is stopped.
   void SetCaptureMethod(ScreenCaptureMethod method) { capture_method_ = method; }
@@ -57,7 +64,12 @@ class ScreenCapturerWin : public ScreenCapturer {
   static bool CurrentFrameIsFromSecureDesktop();
 
  private:
+  using BackendFactory = std::function<std::unique_ptr<ScreenCapturer>()>;
   std::unique_ptr<ScreenCapturer> impl_;
+  // Serializes backend replacement (secure-desktop recovery runs on the
+  // management thread) against the public entry points that dereference it.
+  // Lock order: impl_mutex_ before alias_mutex_; never the reverse.
+  std::mutex impl_mutex_;
   ScreenCaptureMethod capture_method_ = ScreenCaptureMethod::Auto;
   bool IsBackendEnabled(ScreenCaptureMethod method) const {
     return capture_method_ == ScreenCaptureMethod::Auto ||
@@ -73,15 +85,36 @@ class ScreenCapturerWin : public ScreenCapturer {
   std::unordered_map<std::string, std::string> stream_id_alias_;
   std::mutex alias_mutex_;
   std::vector<DisplayInfo> canonical_displays_;
+  std::vector<int> backend_to_canonical_;
   std::atomic<bool> invalid_stream_id_logged_{false};
   std::atomic<bool> native_output_logged_{false};
   std::atomic<bool> native_output_error_logged_{false};
   std::atomic<bool> running_{false};
+  std::atomic<ULONGLONG> last_capture_progress_tick_{0};
+  std::atomic<bool> display_probe_requested_{false};
+  ULONGLONG last_display_probe_tick_ = 0;
+  ULONGLONG last_capture_retry_tick_ = 0;
+  HeadlessRecovery headless_recovery_;
   std::atomic<bool> paused_{false};
   std::atomic<bool> show_cursor_{true};
   bool applied_show_cursor_ = true;
+  std::atomic<bool> headless_compat_{false};
+  // Session-scoped: plugged on a headless desktop after Start() returns and
+  // released after Stop(), so an attached physical monitor is never shadowed
+  // between sessions. Both run on virtual_display_thread_ because the helper
+  // may need up to two minutes to install the driver; Start() itself begins
+  // in GDI compatibility mode and the management thread adopts the virtual
+  // display (switching to a GPU backend) once virtual_display_ready_ is set.
+  VirtualDisplayProvisioner virtual_display_;
+  std::thread virtual_display_thread_;
+  std::atomic<bool> virtual_display_ready_{false};
+  std::atomic<bool> virtual_display_busy_{false};
+  ULONGLONG last_virtual_adoption_tick_ = 0;
+  // Protected by alias_mutex_. A session-created display replaces the active
+  // wire slot explicitly, even if Windows retains the old phantom output.
+  std::string virtual_display_name_;
+  int virtual_display_slot_ = -1;
   std::atomic<int> monitor_index_{0};
-  int initial_monitor_index_ = 0;
   std::atomic<bool> secure_desktop_capture_active_{false};
   std::atomic<bool> post_secure_desktop_waiting_for_frame_{false};
   std::atomic<bool> post_secure_desktop_drop_logged_{false};
@@ -104,16 +137,35 @@ class ScreenCapturerWin : public ScreenCapturer {
   std::shared_ptr<CapturedNv12FramePool> native_frame_pool_;
 
   void BuildCanonicalFromImpl();
-  void RebuildAliasesFromImpl();
+  void RebuildAliasesFromImpl(bool preserve_backend_slots = false);
   void RestoreMonitor(int monitor_index);
+  // Backends in preference order for the current desktop; each factory is
+  // invoked lazily so an unused WGC plugin is never loaded.
+  std::vector<BackendFactory> PreferredBackends(bool headless,
+                                               bool usbmmidd = false) const;
   bool TryStartBackend(std::unique_ptr<ScreenCapturer> candidate,
                        int monitor_index);
+  bool StartPreferredBackend(bool headless, int monitor_index,
+                              bool usbmmidd = false);
+  void ResetPostSecureDesktopState();
+  // Common tail of every successful Start(): publish running state and
+  // launch the management thread.
+  int MarkStarted();
   void EmitCapturedFrame(unsigned char* data, int size, int width, int height,
                          const char* stream_id,
                          const MiniRtcNativeVideoFrame* native_frame = nullptr,
                          bool from_secure_desktop = false);
   void StopSecureCaptureThread();
   bool RestartCaptureBackendAfterSecureDesktop();
+  void CheckCaptureProgress(ULONGLONG now);
+  void CheckDisplayPresence(ULONGLONG now);
+  // Virtual display provisioning runs off the caller's thread.
+  void JoinVirtualDisplayThread();
+  void BeginVirtualDisplayProvisioning();
+  void BeginVirtualDisplayRelease();
+  // Management thread: once the worker plugged the virtual display, replace
+  // the GDI compatibility backend with a GPU backend on that display.
+  void MaybeAdoptVirtualDisplay();
   void ApplyCursorCaptureSetting();
   void SecureDesktopCaptureLoop();
   bool GetCurrentCaptureRegion(int* left, int* top, int* width, int* height,