[fix] add missing colon to remote preview setting label

.github/workflows/build.yml

@@ -149,6 +149,11 @@ jobs:
           xmake run --root crossdesk_wire_test
           xmake run --root keyboard_state_wire_test
 
+      - name: Install Linux headless runtime dependencies
+        run: |
+          apt-get update
+          apt-get install -y --no-install-recommends xvfb xfce4 dbus
+
       - name: Package
         run: |
           chmod +x ${{ matrix.package_script }}
@@ -271,7 +276,7 @@ jobs:
 
       - name: Build CrossDesk
         run: |
-          xmake f --target_minver=${MACOSX_DEPLOYMENT_TARGET} --CROSSDESK_VERSION=${VERSION_NUM} --USE_CUDA=false -y
+          xmake f --target_minver=${MACOSX_DEPLOYMENT_TARGET} --CROSSDESK_VERSION=${VERSION_NUM} --USE_CUDA=false -vyD
           xmake b -vy crossdesk
 
       - name: Package CrossDesk app
@@ -370,6 +375,16 @@ jobs:
 
       - name: Checkout code
         uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Select corresponding source tag
+        shell: bash
+        run: |
+          if [[ "${GITHUB_REF_TYPE}" == "tag" ]]; then
+            echo "CROSSDESK_SOURCE_TAG=${GITHUB_REF_NAME}" >> "${GITHUB_ENV}"
+            echo "CROSSDESK_RELEASE_BUILD=YES" >> "${GITHUB_ENV}"
+          fi
 
       - name: Read independent iOS version
         id: ios_version
@@ -398,15 +413,23 @@ jobs:
         uses: actions/cache@v5
         with:
           path: apps/ios/.xmake/packages
-          key: "${{ runner.os }}-xmake${{ env.XMAKE_VERSION }}-deps-ios-arm64-xcode26.6-xrepo1211093-min16-${{ github.run_id }}"
+          key: "${{ runner.os }}-xmake${{ env.XMAKE_VERSION }}-deps-ios-arm64-source-v1-xcode26.6-xrepo1211093-min16-${{ github.run_id }}"
           restore-keys: |
-            ${{ runner.os }}-xmake${{ env.XMAKE_VERSION }}-deps-ios-arm64-xcode26.6-xrepo1211093-min16-
+            ${{ runner.os }}-xmake${{ env.XMAKE_VERSION }}-deps-ios-arm64-source-v1-xcode26.6-xrepo1211093-min16-
 
       - name: Set up Python
         uses: actions/setup-python@v6
         with:
           python-version: "3.13"
 
+      - name: Verify iOS license catalog
+        run: |
+          python3 -B -m unittest discover -s apps/ios/tests -p 'third_party_licenses_test.py' -v
+          python3 -B apps/ios/scripts/generate_third_party_licenses.py
+
+      - name: Verify iOS privacy controls
+        run: python3 -B -m unittest discover -s apps/ios/tests -p 'privacy_controls_test.py' -v
+
       - name: Install xmake
         uses: xmake-io/github-action-setup-xmake@v1
         with:
@@ -472,6 +495,11 @@ jobs:
             exit 1
           fi
 
+          VERIFY_FLAGS=()
+          if [[ "${CROSSDESK_RELEASE_BUILD:-NO}" == "YES" ]]; then
+            VERIFY_FLAGS+=(--require-release)
+          fi
+          python3 apps/ios/scripts/verify_app_bundle.py "${APP_PATH}" "${VERIFY_FLAGS[@]}"
           xcrun lipo -info "${EXECUTABLE_PATH}"
           echo "Minimum iOS version: ${MINIMUM_OS}"
 
@@ -484,6 +512,9 @@ jobs:
 
           mkdir -p "${PACKAGE_DIR}"
           cp -R "${APP_PATH}" "${PACKAGE_DIR}/"
+          cp apps/ios/licenses/sources.json "${PACKAGE_DIR}/ThirdPartySources.json"
+          cp apps/ios/licenses/OPEN_SOURCE_NOTICE.txt "${PACKAGE_DIR}/OPEN_SOURCE_NOTICE.txt"
+          cp "${APP_PATH}/SourceMetadata.json" "${PACKAGE_DIR}/SourceMetadata.json"
 
           DSYM_PATH="${DERIVED_DATA}/Build/Products/Release-iphoneos/CrossDeskMobile.app.dSYM"
           if [[ -d "${DSYM_PATH}" ]]; then
@@ -682,7 +713,10 @@ jobs:
           $portableFiles = @(
             @("crossdesk.exe", "CrossDesk.exe"),
             @("crossdesk_service.exe", "crossdesk_service.exe"),
-            @("crossdesk_session_helper.exe", "crossdesk_session_helper.exe")
+            @("crossdesk_session_helper.exe", "crossdesk_session_helper.exe"),
+            @("crossdesk_privacy_cursor_helper.exe", "crossdesk_privacy_cursor_helper.exe"),
+            @("crossdesk_privacy_window.dll", "crossdesk_privacy_window.dll"),
+            @("slint_cpp.dll", "slint_cpp.dll")
           )
 
           foreach ($file in $portableFiles) {
@@ -696,6 +730,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)) {
@@ -777,23 +818,19 @@ jobs:
           echo "PATCH_NUMBER=${PATCH_NUMBER}" >> $GITHUB_OUTPUT
 
       - name: Prepare release notes
-        env:
-          RELEASE_TAG: ${{ steps.version.outputs.VERSION_WITH_V }}
-          VERSION_BASE: ${{ steps.version.outputs.VERSION_BASE }}
         run: |
-          if [[ -f "docs/releases/${RELEASE_TAG}.md" ]]; then
-            cp "docs/releases/${RELEASE_TAG}.md" release-notes.md
-          elif [[ -f "docs/releases/v${VERSION_BASE}.md" ]]; then
-            cp "docs/releases/v${VERSION_BASE}.md" release-notes.md
-          else
-            cat > release-notes.md << 'EOF'
-          Binary release only. Source code is not included.
+          cat > "$RUNNER_TEMP/release-notes.md" << EOF
+          ## Corresponding source
+
+          Source for these binaries: [${GITHUB_REF_NAME}](https://github.com/${GITHUB_REPOSITORY}/tree/${GITHUB_SHA}).
+          Clone that version with recursive submodules. The repository includes the build scripts and dependency patches.
+          [iOS source, modification and rebuild instructions](https://github.com/${GITHUB_REPOSITORY}/blob/${GITHUB_SHA}/apps/ios/README.md).
+          The iOS archive also contains the exact source revision and third-party source catalog with archive checksums.
 
           ## Code signing policy
 
           Free code signing provided by [SignPath.io](https://signpath.io/), certificate by [SignPath Foundation](https://signpath.org/).
           EOF
-          fi
 
       - name: Rename artifacts
         run: |
@@ -819,7 +856,7 @@ jobs:
           prerelease: false
           files: release/*
           generate_release_notes: false
-          body_path: release-notes.md
+          body_path: ${{ runner.temp }}/release-notes.md
 
       - name: Create or update 'latest' tag
         run: |
@@ -837,7 +874,7 @@ jobs:
           prerelease: false
           files: release/*
           generate_release_notes: false
-          body_path: release-notes.md
+          body_path: ${{ runner.temp }}/release-notes.md
 
       - name: Upload artifacts to server
         uses: burnett01/rsync-deployments@5.2
@@ -889,7 +926,7 @@ jobs:
           }
           EOF
           jq --arg release_name "Release ${{ steps.version.outputs.VERSION_WITH_V }}" \
-            --rawfile release_notes release-notes.md \
+            --rawfile release_notes "$RUNNER_TEMP/release-notes.md" \
             '.releaseName = $release_name | .releaseNotes = $release_notes' \
             version.json > version-with-notes.json
           mv version-with-notes.json version.json

PRIVACY.md

@@ -1,99 +1,147 @@
 # CrossDesk Privacy Policy
 
-Last updated: August 8, 2026
+Last updated: September 28, 2026
 
 [中文](#中文) | [English](#english)
 
 ## 中文
 
-### 适用范围
+更新日期：2026 年 9 月 28 日
 
-本隐私政策适用于 CrossDesk 桌面客户端及项目提供的默认网络服务。用户自行部署或指定的服务器由相应服务器运营者负责，其数据处理方式不在本政策控制范围内。
+CrossDesk 重视您的个人信息与隐私保护。本政策说明我们在提供远程桌面服务时如何处理相关信息，以及您可以如何管理授权、保存的内容和数据请求。请在使用前阅读并了解本政策。
 
-### 网络通信
+### 一、适用范围
 
-CrossDesk 是远程桌面软件，需要通过网络完成设备发现、连接协商及远程会话。客户端可能进行以下网络通信：
+本政策适用于 CrossDesk 桌面客户端、iOS 客户端，以及由 CrossDesk 项目维护者（以下简称“我们”）提供的默认网络服务。
 
-- **默认服务：** 未启用自托管时，客户端会连接预配置的 CrossDesk 服务（`api.crossdesk.cn`），用于设备注册、信令、网络地址转换（NAT）穿透，并在无法建立直接连接时提供中继。
-- **版本检查：** 客户端启动时会从 CrossDesk 版本服务（`version.crossdesk.cn`）获取最新版本信息。当前即使启用自托管，版本检查仍会访问 CrossDesk 版本服务。
-- **远程会话：** 用户主动发起或接受远程连接后，CrossDesk 会根据使用的功能在设备之间传输屏幕画面、音频、键盘和鼠标输入、剪贴板文本以及用户选择传输的文件。剪贴板文本可能在远程会话期间自动同步。这些数据可能通过直接连接传输，也可能在必要时通过配置的中继服务器转发。
-- **自托管：** 用户可以在设置中指定自己的信令及中继服务器。自托管服务器的日志、数据保存和访问规则由其运营者决定。
+如果您选择自行部署或使用其他运营者提供的服务器，该服务器所处理的信息、保存期限及安全管理由相应运营者负责。请在使用前了解其隐私政策。本政策中有关客户端本地数据处理的说明仍适用。
 
-### 处理的信息
+### 二、我们处理的信息及用途
 
-为提供上述功能，CrossDesk 可能处理：
+**设备连接与身份验证。** 为登记设备、验证连接权限、查询在线状态及建立远程连接，客户端与服务端会处理设备 ID、认证信息及在线状态。服务端还会保存设备身份及认证校验信息、在线与离线时间、客户端版本与平台、设备关联记录，并生成必要的运行和安全日志，用于维持服务、排查故障及防止滥用。
 
-- 连接所需的设备标识及认证信息；
-- IP 地址、端口、连接时间、连接状态等必要的网络元数据；
-- 版本检查请求产生的标准网络请求信息；
-- 用户授权的远程会话中处理的屏幕、音频、控制指令、剪贴板及文件内容。
+**必要的网络信息。** 建立连接、网络地址转换穿透及中继转发需要处理 IP 地址、端口等网络信息。这些信息用于通信和网络诊断，不等同于读取设备的定位权限。连接服务、中继服务及网络请求可能产生相应日志。
 
-### 信息的使用与保存
+**远程会话内容。** 您发起或接受远程连接后，软件根据使用的功能在参与会话的设备之间传输画面、音频、键盘和鼠标操作、剪贴板文本及文件。会话内容可能包含个人或工作信息，请仅连接您拥有或已获授权使用的设备，并按需管理共享内容。
 
-- 设备标识、连接设置及用户偏好会保存在本地设备上，以便后续使用。
-- 通过官方信令和中继服务处理的信息仅用于建立、维持和转发 CrossDesk 连接，以及服务运行、安全防护和故障排查。
-- 中继传输的远程会话内容仅用于实时转发，不用于广告或用户画像。
-- CrossDesk 桌面客户端不包含广告功能，也不会主动上传诊断日志、崩溃报告或用户行为分析数据。
-- 自托管服务器可能保存的日志和数据由其运营者控制，请向相应运营者了解其隐私与保存政策。
+**版本检查。** 桌面客户端启动后会获取版本信息；iOS 客户端在连接成功并收到远端版本信息后，会获取最新桌面版本信息，用于提示升级。该请求不携带设备 ID 或远端版本号，但网络服务会处理完成请求所必需的网络信息。
 
-### 用户选择
+CrossDesk 未集成广告投放、广告追踪或用户行为分析功能。客户端不会主动上传诊断日志、崩溃报告或用户行为分析数据。您主动向我们提交问题或日志时，请先移除与问题无关的个人信息及连接凭据。
 
-用户可以：
+### 三、数据传输与相关服务
 
-- 配置自托管服务器，以替代默认信令和中继服务；
-- 决定是否发起或接受远程会话；
-- 决定是否选择并传输文件；
-- 结束远程会话，以停止会话数据传输；
-- 删除 CrossDesk 的本地配置、缓存及日志文件。
+我们提供设备登记、连接协商、中继转发及版本检查服务。即使您使用自托管连接服务，客户端仍会按前述条件访问我们提供的版本服务。
 
-### 政策更新与联系方式
+远程会话内容优先在参与会话的设备间直接传输，必要时通过配置的中继服务器转发。中继服务用于实时转发，不提供会话录像或文件归档。客户端本地保存的画面预览和接收文件，按本政策相关说明处理。
 
-本政策可能随着 CrossDesk 功能或网络服务的变化而更新。更新内容将在本文件中发布。如有隐私相关问题，请联系 [junkun.di@hotmail.com](mailto:junkun.di@hotmail.com)。
+自托管服务器由您选择的运营者管理。更换连接服务器后，设备登记、连接协商及中继数据将由相应运营者处理。
+
+### 四、信息保存与安全措施
+
+**客户端本地数据。** 软件会在本机保存连接设置、用户偏好、最近连接记录及必要的运行日志，以支持后续使用和故障排查。iOS 中的本机登录凭据及您选择记住的远程连接密码保存在系统钥匙串中，不通过 iCloud 钥匙串同步；旧版偏好中的本机登录凭据在成功迁入钥匙串后删除。
+
+**远程画面预览。** iOS 默认不保存远程画面预览。只有您在“设置 → 隐私”单独开启并确认后，才会从下一次连接起，每次连接保存一张远程画面，用于最近连接预览。预览仅保存在本机，不上传，并设置为不纳入设备备份。您可以单独清除预览；关闭保存或撤回隐私授权也会清除已有预览。旧版本未经此选择保存的预览会在升级后清理。
+
+**接收的文件。** iOS 接收文件保存在本应用的文件目录中，您可通过系统“文件”应用管理或删除。清除画面预览不会删除接收文件或最近连接记录。
+
+**服务端记录。** 为支持再次连接、服务运维和安全排查，设备身份、状态、关联记录及运行日志可能在连接结束后继续保存。保存范围和期限受服务运行需要、部署规则及适用的保留要求约束。您可以通过下述联系方式查询与您设备相关的信息及保存期限，或提出删除请求。撤回隐私授权、删除本地记录或卸载客户端，不会自动删除已产生的服务端记录；日志、备份和快照需分别核查和处理。
+
+iOS 通过系统钥匙串和文件保护机制保护相应本地数据，默认信令连接进行 TLS 证书校验。请妥善保管设备和连接凭据，避免向无关人员共享访问密码。
+
+### 五、iOS 权限与授权选择
+
+**隐私授权。** 首次使用，或从未提供此选择的旧版升级时，您需阅读本政策、主动勾选并点击同意后，客户端才会登记本机身份、连接信令服务和查询设备在线状态。拒绝后仍可查看设置、离线隐私政策和本地连接记录，远程连接功能暂不可用。
+
+**撤回同意。** 您可以在“设置 → 隐私 → 隐私与授权”中查看隐私政策、授权状态或撤回授权。客户端将停止远程会话、信令连接和版本检查，关闭并清除本地画面预览。再次使用连接功能前需重新同意；重新同意不会自动开启画面预览保存。撤回不影响撤回前已经发生的信息处理，也不等同于删除服务端数据。
+
+**系统权限与会话功能。** iOS 客户端作为控制端接收远程电脑的画面与音频，不采集本机屏幕、摄像头或麦克风。局域网访问权限用于连接本地网络中的设备，您可在系统设置中管理。发送文件通过系统文件选择器选择，不要求开放整个文件库。当前 iOS 界面不读取或发送本机剪贴板文本；远端发送的剪贴板文本可在会话中写入本机剪贴板。
+
+应用及通信组件使用本地文件元数据、应用偏好和计时接口实现文件传输、设置保存及网络计时，不使用这些信息制作设备指纹或进行广告追踪。
+
+### 六、查询与删除请求
+
+您可以管理本地最近连接记录、保存的画面预览及接收文件。删除某条最近连接记录时，其预览及已保存的远程连接密码也会删除。
+
+如需查询、获取数据摘要或删除默认服务中与您设备相关的记录，请通过下述邮箱联系我们，说明设备 ID 和请求范围。为避免未经授权的披露或删除，我们会核实请求权限；请勿通过邮件发送访问密码、私钥或其他敏感凭据。
+
+删除服务端设备身份后，原身份及对应凭据将失效，再次连接可能登记为新设备。数据库记录的删除不表示日志、备份或其他设备上已接收的内容同时删除。使用自托管服务时，请向相应服务器运营者提出服务端数据请求。
+
+### 七、政策更新与联系方式
+
+本政策可能随功能及服务方式调整而更新，更新后的内容和日期将在隐私政策中公布。您可随时在应用设置中查阅当前随应用提供的政策文本。
+
+如对本政策或个人信息处理有疑问，请联系：
+
+邮箱：[junkun.di@hotmail.com](mailto:junkun.di@hotmail.com)
 
 ---
 
 ## English
 
-### Scope
+Updated: September 28, 2026
 
-This Privacy Policy applies to the CrossDesk desktop client and the default network services provided by the project. Servers deployed or selected by users are operated by their respective administrators, and their data-processing practices are outside the control of this policy.
+CrossDesk respects your privacy. This policy explains how information is processed when we provide remote desktop services and how you can manage consent, locally saved content and data requests. Please read this policy before using the software.
 
-### Network communications
+### 1. Scope
 
-CrossDesk is remote desktop software and requires network communications for device discovery, connection negotiation, and remote sessions. The client may perform the following communications:
+This policy applies to the CrossDesk desktop and iOS clients and the default network services provided by the CrossDesk project maintainers ("we" or "us").
 
-- **Default services:** Unless self-hosting is enabled, the client connects to preconfigured CrossDesk services (`api.crossdesk.cn`) for device registration, signaling, network address translation (NAT) traversal, and relay when a direct connection cannot be established.
-- **Update checks:** On startup, the client retrieves current release information from the CrossDesk version service (`version.crossdesk.cn`). Update checks currently continue to use the CrossDesk version service even when self-hosting is enabled.
-- **Remote sessions:** After a user initiates or accepts a remote connection, CrossDesk transmits the data required by enabled features between devices. This may include screen content, audio, keyboard and mouse input, clipboard text, and files selected by the user. Clipboard text may be synchronized automatically during a remote session. Data may travel over a direct connection or through the configured relay server when necessary.
-- **Self-hosting:** Users may configure their own signaling and relay servers. Logging, retention, and access policies for a self-hosted server are determined by its operator.
+If you deploy your own server or choose a server provided by another operator, that operator is responsible for its data processing, retention and security practices. Please review its privacy policy before use. The descriptions of local client data processing in this policy still apply.
 
-### Information processed
+### 2. Information processed and its purposes
 
-To provide these functions, CrossDesk may process:
+**Device connections and authentication.** To register devices, verify connection permissions, query availability and establish remote connections, the clients and server process device IDs, authentication information and presence. The server also retains device identity and authentication verification records, online and offline times, client versions and platforms, and device associations. Necessary operational and security logs support service operation, troubleshooting and abuse prevention.
 
-- device identifiers and authentication information required for connections;
-- necessary network metadata, such as IP addresses, ports, connection times, and connection status;
-- standard network request information generated by update checks; and
-- screen, audio, control, clipboard, and file content processed during a remote session authorized by the user.
+**Necessary network information.** Connections, network address translation traversal and relay forwarding require IP addresses, ports and other network information. This supports communication and network diagnostics and does not involve reading the device's location permission. Connection services, relay services and network requests may generate related logs.
 
-### Use and storage of information
+**Remote-session content.** After you initiate or accept a remote connection, the software transfers content between participating devices according to the features used. This includes screens, audio, keyboard and mouse input, clipboard text and files. Such content may contain personal or work information. Connect only to devices you own or are authorized to access, and manage shared content accordingly.
 
-- Device identifiers, connection settings, and user preferences are stored locally for subsequent use.
-- Information processed by the official signaling and relay services is used only to establish, maintain, and relay CrossDesk connections and for service operation, security, and troubleshooting.
-- Remote-session content passing through a relay is used only for real-time forwarding and is not used for advertising or user profiling.
-- The CrossDesk desktop client does not contain advertising functionality and does not intentionally upload diagnostic logs, crash reports, or behavioral analytics.
-- Logs and data that may be retained by self-hosted servers are controlled by their operators. Contact the relevant operator for its privacy and retention practices.
+**Version checks.** The desktop client retrieves release information after startup. After connecting and receiving the remote host's version, the iOS client retrieves the latest desktop release information to suggest updates. These requests do not contain device IDs or the remote host's version, but the service processes network information necessary to complete the request.
 
-### User choices
+CrossDesk does not integrate advertising, advertising tracking or behavioral analytics. The clients do not proactively upload diagnostic logs, crash reports or behavioral analytics data. If you choose to submit an issue or logs, remove unrelated personal information and connection credentials first.
 
-Users may:
+### 3. Data transmission and related services
 
-- configure a self-hosted server instead of the default signaling and relay services;
-- choose whether to initiate or accept a remote session;
-- choose whether to select and transfer files;
-- end a remote session to stop session-data transmission; and
-- remove local CrossDesk configuration, cache, and log files.
+We provide device registration, connection negotiation, relay forwarding and version checks. Even when you use a self-hosted connection service, the client still accesses our version service under the conditions described above.
 
-### Changes and contact
+Remote-session content is transmitted directly between participating devices where possible, or through the configured relay server when needed. The relay service forwards content in real time and does not provide session recording or file archiving. Locally saved previews and received files are handled as described in this policy.
 
-This policy may be updated as CrossDesk features or network services change. Updates will be published in this file. For privacy-related questions, contact [junkun.di@hotmail.com](mailto:junkun.di@hotmail.com).
+Self-hosted servers are managed by the operator you choose. If you change the connection server, the corresponding operator will process device registration, connection negotiation and relay data.
+
+### 4. Storage and security measures
+
+**Local client data.** The software stores connection settings, preferences, recent connections and necessary operational logs on the device for subsequent use and troubleshooting. On iOS, local login credentials and remote connection passwords you choose to remember are stored in the system Keychain without iCloud Keychain synchronization. Legacy local login credentials in preferences are removed after successful migration to the Keychain.
+
+**Remote desktop previews.** Saving previews is off by default on iOS. Only after you separately enable and confirm it in Settings → Privacy will the app save one remote frame per connection, starting with the next connection, for recent-connection previews. Previews remain local, are not uploaded and are marked as excluded from device backups. You can clear them separately. Disabling saving or withdrawing network consent also clears them. Previews saved by older versions without this choice are cleared on upgrade.
+
+**Received files.** Received files on iOS are stored in the app's file directory and can be managed or deleted through Files. Clearing previews does not delete received files or recent-connection records.
+
+**Server records.** Device identities, presence, associations and operational logs may remain after a connection ends to support reconnection, service operation and security troubleshooting. Their scope and retention depend on operational needs, deployment rules and applicable retention requirements. You can contact us below to ask about records and retention periods related to your device or request deletion. Withdrawing network consent, deleting local records or uninstalling the client does not automatically delete existing server records. Logs, backups and snapshots require separate review and handling.
+
+On iOS, the system Keychain and file protection mechanisms protect the relevant local data, and default signaling connections validate TLS certificates. Keep your devices and connection credentials secure and avoid sharing access passwords with unrelated people.
+
+### 5. iOS permissions and consent choices
+
+**Privacy authorization.** On first use, or when upgrading from a version without this choice, you must read this policy, actively select the checkbox and agree before the client registers a local identity, connects to signaling or queries device presence. If you decline, settings, the offline policy and local connection history remain available, while remote connections are unavailable.
+
+**Withdrawal.** You can review the privacy policy and your authorization status or withdraw consent in Settings → Privacy → Privacy and Authorization. The client stops remote sessions, signaling and version checks, disables preview saving and clears local previews. Consent is required again before reconnecting. Agreeing again does not automatically enable preview saving. Withdrawal does not undo processing that already occurred or delete server data.
+
+**System permissions and session features.** The iOS client receives remote computer screens and audio as a controller; it does not capture the local screen, camera or microphone. Local network access supports connections to devices on your network and can be managed in system settings. File sending uses the system document picker without requiring access to the entire file library. The current iOS interface does not read or send local clipboard text. Text sent by the remote device may be written to the local clipboard during a session.
+
+The app and its communication components use local file metadata, preferences and timing APIs for file transfer, settings and network timing, not for device fingerprinting or advertising tracking.
+
+### 6. Access and deletion requests
+
+You can manage local recent connections, saved previews and received files. Removing a recent connection also removes its preview and remembered remote connection password.
+
+To request access to information, a data summary or deletion of records associated with your device in the default service, contact the email address below with the device ID and scope of your request. We verify the requester's authority to avoid unauthorized disclosure or deletion. Do not send access passwords, private keys or other sensitive credentials by email.
+
+Deleting a server-side device identity invalidates that identity and its credentials; reconnecting may register a new device. Deleting database records does not mean that logs, backups or content already received by other devices are also deleted. For a self-hosted service, direct server-side data requests to its operator.
+
+### 7. Policy changes and contact
+
+This policy may be updated as features and services change. Updated text and its date will be published in the privacy policy. You can review the policy bundled with your app in its settings at any time.
+
+For questions about this policy or the processing of personal information, contact:
+
+Email: [junkun.di@hotmail.com](mailto:junkun.di@hotmail.com)

README.md

@@ -48,11 +48,13 @@ CrossDesk 支持 Windows、macOS、Linux 之间的远程访问，也可从浏览
 | 能力 | 当前支持 |
 | --- | --- |
 | 跨平台控制 | Windows / macOS / Linux 桌面互控；浏览器与原生 iOS 作为控制端 |
-| 实时画面与声音 | H.264 / AV1、30 / 60 fps 设置、硬件编解码选项、远端声音播放；实际能力取决于设备与构建配置 |
+| 实时画面与声音 | H.264 / AV1、硬件编解码、远端声音播放；会话中可调整画质、30 / 60 fps 与画面偏好 |
 | 多设备与多显示器 | 近期连接、设备别名、会话标签与远端显示器切换 |
 | 输入与协作 | 键鼠输入、远端光标同步、组合键、文本剪贴板同步、文件传输 |
-| 网络与部署 | P2P 直连、TURN 中继、SRTP 加密选项、自托管信令与中继服务 |
+| 网络与部署 | P2P 直连、TURN 中继与强制中继、SRTP 媒体加密、自托管信令与中继服务 |
+| 隐私屏 | 被连接时自动开启，或在会话工具栏切换；可用性取决于被控端系统与采集方式 |
 | Windows 锁屏控制 | 通过 CrossDesk Service 支持锁屏、登录界面及安全桌面的输入转发 |
+| Linux 无头运行 | 复用已有桌面和应用，或创建独立 Xvfb 虚拟桌面；终端控制台可查看状态、修改密码和设置，见 [运行说明](docs/HEADLESS.md) |
 
 各客户端的入口和能力有所不同；桌面会话操作见下文，iOS 的具体功能见 [开发说明](apps/ios/README.md)。
 
@@ -89,11 +91,11 @@ sudo apt install "./crossdesk-linux-amd64-<version>.deb"
 3. **完成密码验证。** 按弹窗输入被控电脑当前的连接密码，确认后等待远程画面出现。需要保存密码时勾选“记住密码”。
 4. **再次连接。** 成功连接过的设备会出现在“近期连接”中，可通过卡片重连，也可编辑别名或删除记录。
 
-本机密码旁的眼睛按钮用于显示 / 隐藏密码，铅笔按钮用于修改密码。修改时使用 **6 位数字或英文字母**，并保持连接服务器；等待修改成功、客户端重新连接后，再复制当前密码。已保存旧密码的控制端需重新输入。
+本机密码旁的眼睛按钮用于显示 / 隐藏密码，刷新按钮用于生成新的随机密码，铅笔按钮用于手动修改。密码统一为 **6 位数字或英文字母**。修改或刷新时需保持连接服务器；等待修改成功、客户端重新连接后，再复制当前密码。已保存旧密码的控制端需重新输入。
 
 ### 从浏览器连接
 
-1. 保持被控电脑上的 CrossDesk 运行，并确认已连接服务器；在被控端“设置”中保持 **启用 SRTP** 开启。
+1. 保持被控电脑上的 CrossDesk 运行，并确认已连接服务器。
 2. 打开 [Web 客户端](https://web.crossdesk.cn/)，输入 **远程设备 ID** 和 **密码**，点击“连接”。
 3. 连接后使用页面提供的显示器、鼠标模式和键盘控件操作远端；手机和平板也可通过浏览器访问。
 
@@ -112,33 +114,53 @@ sudo apt install "./crossdesk-linux-amd64-<version>.deb"
 | 鼠标 | 控制 / 释放远端鼠标 |
 | 扬声器 | 播放声音 / 静音 |
 | 文件夹 | 选择文件发送到远端，并查看传输进度 |
-| 网络状态 | 查看流量、丢包率、帧率、分辨率及直连 / 中继状态 |
+| 画面设置 | 在当前会话中调整画面质量、采集帧率与画面偏好 |
+| 网络状态 | 查看流量、丢包率、帧率、分辨率、直连 / 中继及加密状态 |
+| 隐私屏 | 开启或关闭被控电脑的隐私屏；悬停查看当前状态与可用操作 |
 | 全屏 | 进入 / 退出全屏 |
 | 断开连接 | 结束当前远程会话 |
 
 桌面端可同步文本剪贴板。接收文件的位置可在“设置 → 文件保存路径”调整。关闭主窗口会隐藏窗口并保持程序运行；需要完全退出时使用系统托盘或菜单栏中的退出入口。
 
-<a id="settings"></a>
+### 在会话中调整画面
 
-## 调整画面与连接设置
-
-点击主窗口右上角 **☰ → 设置**，修改后点击“确认”保存。建议在建立连接前调整；会话进行中部分选项不可修改。设置列表可向下滚动，查看自托管、启动方式与文件保存路径。
+连接成功后，点击工具栏中的 **画面设置**（滑杆图标），直接选择低 / 中 / 高画质、**30 / 60 fps**，以及帧率优先 / 画质优先 / 平衡。选项会发送给当前被控端，无需断开重连；实际画面效果取决于网络、设备与编码器能力。旧版被控端不支持时，菜单会提示并禁用选项。
 
 <p align="center">
-  <img src="docs/images/desktop-settings-zh.png" width="720" alt="当前设置界面：画质、帧率、画面偏好、编解码、中继与 SRTP" />
+  <img src="docs/images/desktop-stream-video-settings-zh.png" width="800" alt="当前远程会话的画面设置菜单：画面质量、采集帧率与画面偏好；背景为公开页面演示图" />
+</p>
+
+<a id="settings"></a>
+
+## 客户端设置与更新
+
+点击主窗口右上角 **☰ → 设置**，修改后点击“确认”保存。编码与连接选项建议在建立连接前调整；会话进行中部分选项不可修改。设置列表可向下滚动，查看自托管、启动方式与文件保存路径。画质、帧率和画面偏好在远程会话工具栏中调整。
+
+<p align="center">
+  <img src="docs/images/desktop-settings-zh.png" width="720" alt="当前客户端设置：编码格式、硬件编解码、中继、强制中继与自动隐私屏" />
 </p>
 
 | 设置 | 说明 |
 | --- | --- |
-| 画面质量 / 帧率 | 选择低、中、高画质与 30 / 60 fps；实际帧率取决于网络和设备 |
-| 画面偏好 | 在帧率优先、画质优先、平衡之间选择 |
+| 语言 | 中文、English、Русский |
+| 采集方式（Windows） | 自动 / DXGI / WGC / GDI；无显示器主机使用“自动”启用自动适配 |
 | 视频编码格式 | H.264 / AV1；硬件编解码是否可用取决于平台、硬件与构建选项 |
 | 启用中继服务 | 允许借助 TURN 中继建立连接；P2P 连接失败时先检查此项 |
-| 启用 SRTP | 媒体传输加密选项，两端配置需兼容 |
-| 自托管配置 | 设置服务器地址、信令端口与中继端口，并勾选启用 |
+| 强制中继连接 | 启用中继服务后可勾选，让连接通过中继建立；关闭中继服务会同时关闭此项 |
+| 保存远程画面预览 | 默认开启，保存远程画面预览；关闭后缩略图区域显示被控端平台，并清除已有预览，保留连接记录和密码 |
+| 被连接时开启隐私屏 | 设置本机被远程连接时是否自动启用隐私屏；会话中可从控制端工具栏切换 |
+| 自托管配置 | 填写服务器地址和信令服务端口，并勾选启用 |
 | 开机自启 / 启用守护进程 | 调整启动与进程守护行为，按界面提示重启后生效 |
 | 文件保存路径 | 选择接收文件的目录 |
 
+### 检查更新
+
+客户端启动后会在后台检查版本。发现新版本时，主窗口菜单入口会显示更新提示；打开 **☰ → 关于** 可查看版本，也可点击 **检查更新** 手动检查。发现更新后可查看更新说明并前往下载页面。
+
+<p align="center">
+  <img src="docs/images/desktop-about-zh.png" width="720" alt="关于窗口与检查更新按钮，版本号和检查结果为演示数据" />
+</p>
+
 <a id="ios"></a>
 
 ## 原生 iOS / iPadOS 客户端

README_EN.md

@@ -48,11 +48,13 @@ See the [screenshot notes](docs/images/README.md) for image sources and refresh
 | Capability | Current support |
 | --- | --- |
 | Cross-platform control | Windows / macOS / Linux desktop control; browser and native iOS controllers |
-| Live video and audio | H.264 / AV1, 30 / 60 fps settings, hardware codec options, and remote audio; availability depends on hardware and build configuration |
+| Live video and audio | H.264 / AV1, hardware codecs, and remote audio; adjust quality, 30 / 60 fps, and video preference during a session |
 | Devices and displays | Recent connections, device aliases, session tabs, and remote display switching |
 | Input and sharing | Keyboard/mouse input, remote cursor synchronization, shortcuts, text clipboard synchronization, and file transfer |
-| Networking and deployment | Direct P2P connections, TURN relay, an SRTP encryption option, and self-hosted signaling/relay services |
+| Networking and deployment | Direct P2P connections, TURN relay and forced relay, SRTP media encryption, and self-hosted signaling/relay services |
+| Privacy screen | Enable automatically when connected to, or toggle from the session toolbar; availability depends on the host OS and capture method |
 | Windows protected desktops | CrossDesk Service forwards input on lock screens, sign-in screens, and secure desktops |
+| Linux headless operation | Reuse existing desktops and applications or create separate Xvfb desktops; use the terminal console to check status and change passwords or settings; see [setup](docs/HEADLESS_EN.md) |
 
 Controls and capabilities vary by client. Desktop controls are described below; see the [iOS guide](apps/ios/README.md) for native mobile features.
 
@@ -89,11 +91,11 @@ sudo apt install "./crossdesk-linux-amd64-<version>.deb"
 3. **Verify the password.** Enter the host's current connection password when prompted and confirm. Select **Remember password** if you want to save it.
 4. **Reconnect later.** Previously connected devices appear under **Recent Connections**. Reconnect from a card, edit its alias, or remove its record.
 
-The eye button shows or hides the local password; the pencil button changes it. Use **6 ASCII letters or digits** and stay connected to the server while changing it. Wait for the change to succeed and the client to reconnect, then copy the current password. Controllers that saved the old password must enter it again.
+The eye button shows or hides the local password, the refresh button generates a new random password, and the pencil button lets you edit it. Passwords use **6 ASCII letters or digits**. Stay connected to the server when editing or refreshing a password. Wait for the change to succeed and the client to reconnect, then copy the current password. Controllers that saved the old password must enter it again.
 
 ### Connect from a browser
 
-1. Keep CrossDesk running and connected to the server on the host computer, with **Enable SRTP** enabled in its Settings.
+1. Keep CrossDesk running and connected to the server on the host computer.
 2. Open the [Web Client](https://web.crossdesk.cn/), enter the **Remote Device ID** and **Password**, and click **Connect**.
 3. Use the page's display, mouse-mode, and keyboard controls during the session. Phone and tablet browsers can also connect.
 
@@ -112,33 +114,53 @@ Switch devices using session tabs. Expand the control bar if it is collapsed, an
 | Mouse | Enable / release remote mouse control |
 | Speaker | Play / mute remote audio |
 | Folder | Select a file to send and view transfer progress |
-| Network statistics | Inspect traffic, packet loss, frame rate, resolution, and direct / relay mode |
+| Video settings | Adjust video quality, capture frame rate, and video preference during the current session |
+| Network statistics | Inspect traffic, packet loss, frame rate, resolution, direct / relay mode, and encryption status |
+| Privacy screen | Enable or disable the host's privacy screen; hover to see its status and available actions |
 | Fullscreen | Enter / exit fullscreen |
 | Disconnect | End the current remote session |
 
 Desktop clients synchronize text clipboard contents. Configure the receiving directory under **Settings → File Save Path**. Closing the main window hides it and keeps the app running; use the system tray or menu-bar exit command to quit completely.
 
-<a id="settings"></a>
+### Adjust video during a session
 
-## Video and connection settings
-
-Open **☰ → Settings** in the top-right corner and click **OK** to save. Configure the session before connecting; some settings are disabled during an active session. Scroll down for self-hosting, startup behavior, and the file save path.
+After connecting, open **Video settings** (the sliders icon) in the toolbar. Choose low / medium / high quality, **30 / 60 fps**, and frame-rate priority / quality priority / balanced adaptation. Changes are sent to the current host without reconnecting; actual results depend on the network, device, and encoder. For older hosts that do not support live video settings, the menu explains the limitation and disables the options.
 
 <p align="center">
-  <img src="docs/images/desktop-settings-en.png" width="720" alt="Current settings for quality, frame rate, video preference, codecs, relay, and SRTP" />
+  <img src="docs/images/desktop-stream-video-settings-en.png" width="800" alt="Current session video menu with quality, capture frame rate, and video preference; the background is a public page used for demonstration" />
+</p>
+
+<a id="settings"></a>
+
+## Client settings and updates
+
+Open **☰ → Settings** in the top-right corner and click **OK** to save. Configure codecs and connections before connecting; some settings are disabled during an active session. Scroll down for self-hosting, startup behavior, and the file save path. Adjust quality, frame rate, and video preference from the remote session toolbar.
+
+<p align="center">
+  <img src="docs/images/desktop-settings-en.png" width="720" alt="Current client settings with codec, hardware codecs, TURN, forced relay, and automatic privacy screen options" />
 </p>
 
 | Setting | Purpose |
 | --- | --- |
-| Video Quality / Video Capture Frame Rate | Low, medium, or high quality and 30 / 60 fps; actual performance depends on the connection and device |
-| Video Preference | Choose frame-rate priority, quality priority, or balanced adaptation |
+| Language | 中文, English, Русский |
+| Capture Method (Windows) | Auto / DXGI / WGC / GDI; choose Auto for automatic headless adaptation |
 | Video Encode Format | H.264 / AV1; hardware codec availability depends on the platform, device, and build options |
 | Enable TURN Service | Allow relay-assisted connections; check this setting if P2P fails |
-| SRTP | Media encryption option; configurations on both ends must be compatible |
-| Self-Hosted Config | Set the host, signaling port, and TURN port, then enable the checkbox |
+| Force Relay | Require relay connections when TURN is enabled; turning TURN off also disables this option |
+| Save remote screen previews | On by default. When disabled, the thumbnail area shows the remote device’s platform and existing previews are cleared; connection records and passwords are preserved |
+| Privacy screen on connect | Automatically enable privacy when this computer is controlled remotely; the controller can toggle it from the session toolbar |
+| Self-Hosted Config | Set the server address and signaling port, then enable the checkbox |
 | Auto Start / Enable Daemon | Configure startup and process supervision; restart as indicated by the UI |
 | File Save Path | Choose where received files are saved |
 
+### Check for updates
+
+The client checks for updates in the background after launch. A new version adds an update indicator to the main window menu. Open **☰ → About** to view the version or click **Check for updates** to check manually. When an update is available, you can view its release notes and open the download page.
+
+<p align="center">
+  <img src="docs/images/desktop-about-en.png" width="720" alt="About dialog with the Check for updates button; version and check result are demonstration data" />
+</p>
+
 <a id="ios"></a>
 
 ## Native iOS / iPadOS client

apps/desktop/resources/windows/crossdesk_privacy_window.rc

@@ -0,0 +1,13 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-11
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+IDI_CROSSDESK_LOGO ICON "crossdesk.ico"
+
+#define CROSSDESK_FILE_DESCRIPTION "CrossDesk Privacy Window"
+#define CROSSDESK_ORIGINAL_FILENAME "crossdesk_privacy_window.dll"
+#define CROSSDESK_FILE_TYPE VFT_DLL
+
+#include "version_info.rcinc"

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/linux/package_deb.sh

@@ -21,6 +21,10 @@ DESCRIPTION="A simple cross-platform remote desktop client."
 ALSA_RUNTIME_DEP="libasound2 | libasound2t64"
 PORTAL_RUNTIME_RECOMMENDS="xdg-desktop-portal, xdg-desktop-portal-gtk | xdg-desktop-portal-kde | xdg-desktop-portal-wlr"
 TRAY_RUNTIME_RECOMMENDS="libayatana-appindicator3-1 | libappindicator3-1"
+# Every published package includes the prerequisites for all Linux headless
+# paths, including a complete independent desktop. Older Ubuntu releases ship
+# dbus-run-session in dbus; newer releases split it into dbus-daemon.
+HEADLESS_RUNTIME_DEPS="xvfb, xfce4, dbus-daemon | dbus"
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../../.." && pwd)"
@@ -87,7 +91,7 @@ if [[ ! -x "$BUILD_BINARY" ]]; then
     exit 1
 fi
 
-for command_name in readelf ldd dpkg-deb; do
+for command_name in readelf ldd dpkg-deb strip; do
     if ! command -v "$command_name" >/dev/null 2>&1; then
         echo "Required packaging command is missing: $command_name" >&2
         exit 1
@@ -128,6 +132,9 @@ if [[ -n "$SLINT_NEEDED" ]]; then
         exit 1
     fi
     install -m 0755 "$SLINT_LIBRARY" "$PRIVATE_DIR/$SLINT_NEEDED"
+    # Keep dynamic exports/relocations while removing unneeded symbols from the
+    # staged copy. Never strip Xmake's cached runtime in place.
+    strip --strip-unneeded "$PRIVATE_DIR/$SLINT_NEEDED"
 fi
 
 cat > "$BIN_DIR/$PKG_NAME" <<'EOF'
@@ -161,10 +168,11 @@ Architecture: $DEBIAN_ARCH
 Maintainer: $MAINTAINER
 Description: $DESCRIPTION
 Depends: libc6 (>= 2.31), libstdc++6 (>= 10), libx11-6, libxext6,
- libxrender1, libxft2, libxrandr2, libxfixes3, libxcursor1, libxcb1, libxcb-randr0,
+ libxrender1, libxft2, libxrandr2, libxfixes3, libxcursor1, libxi6, libxcb1, libxcb-randr0,
  libxcb-xtest0, libxcb-xinerama0, libxcb-shape0, libxcb-xkb1,
  libxcb-xfixes0, libxv1, libxtst6, $ALSA_RUNTIME_DEP, libsndio7.0,
- libxcb-shm0, libpulse0, libdrm2, libdbus-1-3, libgl1
+ libxcb-shm0, libpulse0, libdrm2, libdbus-1-3, libgl1,
+ $HEADLESS_RUNTIME_DEPS
 Recommends: $RECOMMENDS
 Priority: optional
 Section: utils

apps/desktop/scripts/macos/bundle_app.sh

@@ -11,7 +11,7 @@ EXPECTED_ARCH="$2"
 APP_EXECUTABLE="$APP_BUNDLE/Contents/MacOS/CrossDesk"
 FRAMEWORKS_DIR="$APP_BUNDLE/Contents/Frameworks"
 
-for command_name in codesign install_name_tool lipo otool; do
+for command_name in codesign install_name_tool lipo otool strip; do
     if ! command -v "$command_name" >/dev/null 2>&1; then
         echo "Required bundling command is missing: $command_name" >&2
         exit 1
@@ -123,7 +123,11 @@ if ! otool -l "$APP_EXECUTABLE" | awk '
     install_name_tool -add_rpath "@executable_path/../Frameworks" "$APP_EXECUTABLE"
 fi
 
-# install_name_tool invalidates the linker's ad-hoc signature. Sign nested code
+# Strip only the staged runtime, retaining exported symbols for Slint's C ABI.
+# The package cache remains intact for debugging and other consumers.
+strip -S -x "$FRAMEWORKS_DIR/$SLINT_NAME"
+
+# install_name_tool and strip invalidate the linker's ad-hoc signature. Sign nested code
 # first, then seal the complete app bundle so local packages remain launchable.
 codesign --force --sign - "$FRAMEWORKS_DIR/$SLINT_NAME"
 codesign --force --deep --sign - "$APP_BUNDLE"

apps/desktop/scripts/windows/nsis_script.nsi

@@ -88,8 +88,16 @@ installApp:
     ; Bundle service-side binaries required by the Windows service flow
     File "..\..\..\..\build\windows\x64\release\crossdesk_service.exe"
     File "..\..\..\..\build\windows\x64\release\crossdesk_session_helper.exe"
-    ; Bundle runtime DLLs from the release output directory
-    File "..\..\..\..\build\windows\x64\release\*.dll"
+    File "..\..\..\..\build\windows\x64\release\crossdesk_privacy_cursor_helper.exe"
+    File "..\..\..\..\build\windows\x64\release\crossdesk_privacy_window.dll"
+    ; Require the Slint runtime so an incomplete build cannot be packaged.
+    File "..\..\..\..\build\windows\x64\release\slint_cpp.dll"
+    ; Bundle the remaining runtime DLLs from the release output directory
+    File /x crossdesk_privacy_window.dll /x slint_cpp.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
 
@@ -140,13 +148,19 @@ cancelUninstall:
 
 uninstallApp:
     Call un.UnregisterInstalledService
+    Call un.RemoveUsbmmiddDriver
 
     ; Delete main executable and uninstaller
     Delete "$INSTDIR\CrossDesk.exe"
     Delete "$INSTDIR\crossdesk_service.exe"
     Delete "$INSTDIR\crossdesk_session_helper.exe"
+    Delete "$INSTDIR\crossdesk_privacy_cursor_helper.exe"
+    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"
 
@@ -244,3 +258,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/app/main.cpp

@@ -6,6 +6,7 @@
 #endif
 #endif
 
+#include <cstdlib>
 #include <cstring>
 #include <filesystem>
 #include <iostream>
@@ -22,8 +23,17 @@
 #include "config_center.h"
 #include "daemon.h"
 #include "path_manager.h"
+#include "platform/single_instance.h"
+#include "rd_log.h"
 #include "render.h"
 
+#ifdef __linux__
+#include "SimpleIni.h"
+#include "platform/linux/headless/headless_console.h"
+#include "platform/linux/headless/headless_session.h"
+#include "platform/linux/privacy/privacy_guard.h"
+#endif
+
 #ifdef _WIN32
 namespace {
 
@@ -174,31 +184,37 @@ int HandleServiceCliCommand(const std::string& command) {
 }  // namespace
 #endif
 
-int main(int argc, char* argv[]) {
-#ifdef _WIN32
-  if (argc == 2 &&
-      std::strcmp(argv[1], crossdesk::kSlintRendererProbeArgument) == 0) {
-    return crossdesk::RunSlintRendererProbe();
+static bool IsDaemonChild(int argc, char* argv[]) {
+  for (int i = 1; i < argc; ++i) {
+    if (std::strcmp(argv[i], "--child") == 0) return true;
   }
-  if (argc > 1 && IsServiceCliCommand(argv[1])) {
-    return HandleServiceCliCommand(argv[1]);
-  }
-#endif
+  return false;
+}
 
-  // check if running as child process
-  bool is_child = false;
-  for (int i = 1; i < argc; i++) {
-    if (strcmp(argv[i], "--child") == 0) {
-      is_child = true;
-      break;
-    }
+static crossdesk::platform::InstanceResult AcquireInstance(
+    crossdesk::platform::SingleInstanceGuard& guard,
+    crossdesk::platform::InstanceRole role) {
+  std::string error;
+  const auto result = guard.TryAcquire(role, error);
+  if (result == crossdesk::platform::InstanceResult::kAlreadyRunning) {
+    std::cerr << "CrossDesk is already running for this user.\n";
+  } else if (result == crossdesk::platform::InstanceResult::kError) {
+    std::cerr << "CrossDesk cannot start: " << error << '\n';
   }
+  return result;
+}
 
-  if (is_child) {
+static int RunApplication(
+    int argc, char* argv[],
+    crossdesk::platform::SingleInstanceGuard& client_instance) {
+  // The instance guards are held before any configuration or logger is opened.
+  auto path_manager = std::make_unique<crossdesk::PathManager>("CrossDesk");
+  crossdesk::InitLogger(path_manager->GetLogPath().string());
+
+  if (IsDaemonChild(argc, argv)) {
     // child process: run render directly
     crossdesk::Render render;
-    render.Run();
-    return 0;
+    return render.Run();
   }
 
 #ifdef _WIN32
@@ -206,19 +222,38 @@ int main(int argc, char* argv[]) {
 #endif
 
   bool enable_daemon = false;
-  auto path_manager = std::make_unique<crossdesk::PathManager>("CrossDesk");
   if (path_manager) {
     std::string cache_path = path_manager->GetCachePath().string();
     crossdesk::ConfigCenter config_center(cache_path + "/config.ini");
     enable_daemon = config_center.IsEnableDaemon();
   }
 
+#ifdef __linux__
+  // The headless supervisor owns the display and application lifetime. A
+  // detached daemon would outlive its display; systemd can restart the whole
+  // session instead.
+  if (std::getenv("CROSSDESK_HEADLESS_ACTIVE") ||
+      crossdesk::HeadlessConsole::Instance().active()) enable_daemon = false;
+#endif
+
   if (enable_daemon) {
+    // The launcher lease stays in main for the supervisor's entire lifetime.
+    // Each --child must acquire its own client lease, so it is neither blocked
+    // by its supervisor nor able to bypass the single-client restriction.
+    client_instance.Release();
     // start daemon with restart monitoring
     Daemon daemon("CrossDesk");
 
     // define main loop function: run render and stop daemon on normal exit
-    Daemon::MainLoopFunc main_loop = [&daemon]() {
+    Daemon::MainLoopFunc main_loop = [&daemon, &client_instance]() {
+      // Executable discovery can fail and make the supervisor run the GUI in
+      // process. This fallback must retain the same client ownership rule.
+      if (AcquireInstance(client_instance,
+                          crossdesk::platform::InstanceRole::kClient) !=
+          crossdesk::platform::InstanceResult::kAcquired) {
+        daemon.stop();
+        return;
+      }
       crossdesk::Render render;
       render.Run();
       daemon.stop();
@@ -231,6 +266,71 @@ int main(int argc, char* argv[]) {
 
   // run without daemon: direct execution
   crossdesk::Render render;
-  render.Run();
-  return 0;
-}
+  return render.Run();
+}
+
+int main(int argc, char* argv[]) {
+#ifdef __linux__
+  // Run before GUI, configuration, logging or display initialization.
+  if (argc == 2 &&
+      std::strcmp(argv[1], crossdesk::kLinuxPrivacyGuardArgument) == 0) {
+    return crossdesk::RunLinuxPrivacyGuard();
+  }
+  auto& console = crossdesk::HeadlessConsole::Instance();
+  if (argc == 2 && std::strcmp(argv[1], "--headless-help") == 0) {
+    crossdesk::PathManager paths("CrossDesk");
+    CSimpleIniA config;
+    config.SetUnicode(true);
+    config.LoadFile((paths.GetCachePath() / "config.ini").string().c_str());
+    console.SetLanguage(static_cast<int>(config.GetLongValue("Settings", "language", 0)));
+    std::cout << console.Text("console_cli_help");
+    return 0;
+  }
+#endif
+#ifdef _WIN32
+  if (argc == 2 &&
+      std::strcmp(argv[1], crossdesk::kSlintRendererProbeArgument) == 0) {
+    return crossdesk::RunSlintRendererProbe();
+  }
+  if (argc > 1 && IsServiceCliCommand(argv[1])) {
+    EnsureConsoleForCli();
+    crossdesk::platform::SingleInstanceGuard cli_instance;
+    if (AcquireInstance(cli_instance, crossdesk::platform::InstanceRole::kServiceCli) !=
+        crossdesk::platform::InstanceResult::kAcquired) return 1;
+    crossdesk::PathManager paths("CrossDesk");
+    crossdesk::InitLogger(paths.GetLogPath().string(), "crossdesk-service-cli");
+    return HandleServiceCliCommand(argv[1]);
+  }
+#endif
+
+  using crossdesk::platform::InstanceResult;
+  using crossdesk::platform::InstanceRole;
+  crossdesk::platform::SingleInstanceGuard launcher_instance;
+  crossdesk::platform::SingleInstanceGuard client_instance;
+  if (!IsDaemonChild(argc, argv)) {
+    const auto result = AcquireInstance(launcher_instance, InstanceRole::kLauncher);
+    if (result != InstanceResult::kAcquired)
+      return result == InstanceResult::kAlreadyRunning ? 0 : 1;
+  }
+  const auto result = AcquireInstance(client_instance, InstanceRole::kClient);
+  if (result != InstanceResult::kAcquired)
+    return result == InstanceResult::kAlreadyRunning ? 0 : 1;
+
+#ifdef __linux__
+  const int exit_code = crossdesk::RunWithLinuxDisplay(
+      argc, argv, [&] { return RunApplication(argc, argv, client_instance); }, [&] {
+        crossdesk::PathManager paths("CrossDesk");
+        if (console.Enable(paths.GetLogPath(), paths.GetCachePath() / "config.ini")) return true;
+        std::cerr << "无法初始化日志或控制台，启动失败。\n";
+        return false;
+      });
+  if (console.active()) {
+    console.Notify(exit_code == 0 ? console.Text("console_exited")
+        : console.Text("console_stopped") + " " + std::to_string(exit_code) +
+          "; " + console.Text("console_log_file") + ": " + console.diagnostic_path());
+  }
+  return exit_code;
+#else
+  return RunApplication(argc, argv, client_instance);
+#endif
+}

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/common/task_queue_lock_free.cpp

@@ -1,5 +1,7 @@
 #include "task_queue_lock_free.h"
 
+#include <concurrentqueue.h>
+
 #include <exception>
 #include <new>
 #include <stdexcept>
@@ -7,8 +9,15 @@
 
 namespace crossdesk {
 
+struct TaskQueueLockFree::QueueStorage {
+  moodycamel::ConcurrentQueue<TaskItem> tasks;
+  // All submissions share one producer so different caller threads keep FIFO.
+  moodycamel::ProducerToken producer{tasks};
+};
+
 TaskQueueLockFree::TaskQueueLockFree()
-    : producer_(task_queue_), worker_([this] { WorkerThread(); }) {}
+    : queue_(std::make_unique<QueueStorage>()),
+      worker_([this] { WorkerThread(); }) {}
 
 TaskQueueLockFree::~TaskQueueLockFree() { Stop(); }
 
@@ -24,7 +33,7 @@ std::future<void> TaskQueueLockFree::PostTask(std::function<void()> task) {
 
     // Count before publishing: the worker may dequeue as soon as enqueue returns.
     ++pending_tasks_;
-    if (!task_queue_.enqueue(producer_, std::move(item))) {
+    if (!queue_->tasks.enqueue(queue_->producer, std::move(item))) {
       --pending_tasks_;
       throw std::bad_alloc();
     }
@@ -48,7 +57,7 @@ void TaskQueueLockFree::Stop() {
 void TaskQueueLockFree::WorkerThread() {
   while (true) {
     TaskItem item;
-    while (task_queue_.try_dequeue(item)) {
+    while (queue_->tasks.try_dequeue(item)) {
       --pending_tasks_;
 
       std::exception_ptr error;

apps/desktop/src/common/task_queue_lock_free.h

@@ -12,11 +12,10 @@
 #include <cstddef>
 #include <functional>
 #include <future>
+#include <memory>
 #include <mutex>
 #include <thread>
 
-#include <concurrentqueue.h>
-
 namespace crossdesk {
 
 // A single worker executes tasks in submission order. The concurrent queue
@@ -41,9 +40,8 @@ class TaskQueueLockFree {
 
   void WorkerThread();
 
-  moodycamel::ConcurrentQueue<TaskItem> task_queue_;
-  // All submissions share one producer so different caller threads keep FIFO.
-  moodycamel::ProducerToken producer_;
+  struct QueueStorage;
+  std::unique_ptr<QueueStorage> queue_;
   std::atomic<std::size_t> pending_tasks_{0};
   std::mutex mutex_;
   std::condition_variable wake_;

apps/desktop/src/config_center/config_center.cpp

@@ -1,10 +1,20 @@
 #include "config_center.h"
 
+#include <algorithm>
+#include <chrono>
+#include <cstring>
+#include <filesystem>
+#include <optional>
+#include <vector>
+
+#include "SimpleIni.h"
 #include "autostart.h"
 #include "rd_log.h"
 
 namespace crossdesk {
 
+struct ConfigCenter::IniStorage : CSimpleIniA {};
+
 namespace {
 
 bool IsValidTurnModeValue(long value) {
@@ -12,39 +22,38 @@ bool IsValidTurnModeValue(long value) {
          value <= static_cast<long>(ConfigCenter::TURN_MODE::FORCE_TCP);
 }
 
-bool IsValidVideoAdaptationPolicyValue(long value) {
-  using Policy = ConfigCenter::VIDEO_ADAPTATION_POLICY;
-  return value >= static_cast<long>(Policy::FRAME_RATE_PRIORITY) &&
-         value <= static_cast<long>(Policy::BALANCED);
-}
-
 }  // namespace
 
 ConfigCenter::ConfigCenter(const std::string& config_path)
-    : config_path_(config_path) {
-  ini_.SetUnicode(true);
+    : config_path_(config_path), ini_(std::make_unique<IniStorage>()) {
+  ini_->SetUnicode(true);
   Load();
 }
 
 ConfigCenter::~ConfigCenter() {}
 
 int ConfigCenter::Load() {
-  SI_Error rc = ini_.LoadFile(config_path_.c_str());
+  SI_Error rc = ini_->LoadFile(config_path_.c_str());
   if (rc < 0) {
     Save();
     return -1;
   }
 
   bool persist_config_migration = false;
-  persist_config_migration |= ini_.Delete(section_, "video_content_type");
-  persist_config_migration |= ini_.Delete(section_, "screen_content");
+  // These options now belong only to the active remote connection. Discard
+  // legacy local defaults so they cannot affect this host or new connections.
+  persist_config_migration |= ini_->Delete(section_, "video_quality");
+  persist_config_migration |= ini_->Delete(section_, "video_frame_rate");
+  persist_config_migration |= ini_->Delete(section_, "video_adaptation_policy");
+  persist_config_migration |= ini_->Delete(section_, "video_content_type");
+  persist_config_migration |= ini_->Delete(section_, "screen_content");
   persist_config_migration |=
-      ini_.Delete(section_, "enable_desktop_quality_optimization");
+      ini_->Delete(section_, "enable_desktop_quality_optimization");
   persist_config_migration |=
-      ini_.Delete(section_, "enable_minimize_to_tray");
+      ini_->Delete(section_, "enable_minimize_to_tray");
 
   const long language_value =
-      ini_.GetLongValue(section_, "language", static_cast<long>(language_));
+      ini_->GetLongValue(section_, "language", static_cast<long>(language_));
   if (language_value < static_cast<long>(LANGUAGE::CHINESE) ||
       language_value > static_cast<long>(LANGUAGE::RUSSIAN)) {
     language_ = LANGUAGE::ENGLISH;
@@ -52,33 +61,23 @@ int ConfigCenter::Load() {
     language_ = static_cast<LANGUAGE>(language_value);
   }
 
-  video_quality_ = static_cast<VIDEO_QUALITY>(ini_.GetLongValue(
-      section_, "video_quality", static_cast<long>(video_quality_)));
-
-  video_frame_rate_ = static_cast<VIDEO_FRAME_RATE>(ini_.GetLongValue(
-      section_, "video_frame_rate", static_cast<long>(video_frame_rate_)));
-
-  const long video_adaptation_policy_value = ini_.GetLongValue(
-      section_, "video_adaptation_policy",
-      static_cast<long>(video_adaptation_policy_));
-  if (IsValidVideoAdaptationPolicyValue(video_adaptation_policy_value)) {
-    video_adaptation_policy_ =
-        static_cast<VIDEO_ADAPTATION_POLICY>(video_adaptation_policy_value);
-  } else {
-    LOG_WARN("Invalid video adaptation policy [{}], using quality priority",
-             video_adaptation_policy_value);
-    video_adaptation_policy_ = VIDEO_ADAPTATION_POLICY::QUALITY_PRIORITY;
-  }
+  const long screen_capture_method_value = ini_->GetLongValue(
+      section_, "screen_capture_method",
+      static_cast<long>(ScreenCaptureMethod::Auto));
+  screen_capture_method_ = IsValidScreenCaptureMethod(screen_capture_method_value)
+                               ? static_cast<ScreenCaptureMethod>(
+                                     screen_capture_method_value)
+                               : ScreenCaptureMethod::Auto;
 
   video_encode_format_ = static_cast<VIDEO_ENCODE_FORMAT>(
-      ini_.GetLongValue(section_, "video_encode_format",
+      ini_->GetLongValue(section_, "video_encode_format",
                         static_cast<long>(video_encode_format_)));
 
-  hardware_video_codec_ = ini_.GetBoolValue(section_, "hardware_video_codec",
+  hardware_video_codec_ = ini_->GetBoolValue(section_, "hardware_video_codec",
                                             hardware_video_codec_);
-  const char* turn_mode_value = ini_.GetValue(section_, "turn_mode", nullptr);
+  const char* turn_mode_value = ini_->GetValue(section_, "turn_mode", nullptr);
   if (turn_mode_value != nullptr && strlen(turn_mode_value) > 0) {
-    const long parsed_turn_mode = ini_.GetLongValue(
+    const long parsed_turn_mode = ini_->GetLongValue(
         section_, "turn_mode", static_cast<long>(turn_mode_));
     if (IsValidTurnModeValue(parsed_turn_mode)) {
       turn_mode_ = static_cast<TURN_MODE>(parsed_turn_mode);
@@ -88,19 +87,24 @@ int ConfigCenter::Load() {
       turn_mode_ = TURN_MODE::AUTO_UDP_TCP;
     }
   } else {
-    const bool legacy_enable_turn = ini_.GetBoolValue(
+    const bool legacy_enable_turn = ini_->GetBoolValue(
         section_, "enable_turn", turn_mode_ != TURN_MODE::DISABLED);
     turn_mode_ = legacy_enable_turn ? TURN_MODE::AUTO_UDP_TCP
                                     : TURN_MODE::DISABLED;
-    ini_.SetLongValue(section_, "turn_mode", static_cast<long>(turn_mode_));
+    ini_->SetLongValue(section_, "turn_mode", static_cast<long>(turn_mode_));
+    persist_config_migration = true;
+  }
+  // Migrate the former user switch. Keep true in the file for older builds,
+  // while the current application always requests encrypted native media.
+  if (!ini_->GetBoolValue(section_, "enable_srtp", false)) {
+    ini_->SetBoolValue(section_, "enable_srtp", true);
     persist_config_migration = true;
   }
-  enable_srtp_ = ini_.GetBoolValue(section_, "enable_srtp", enable_srtp_);
   enable_self_hosted_ =
-      ini_.GetBoolValue(section_, "enable_self_hosted", enable_self_hosted_);
+      ini_->GetBoolValue(section_, "enable_self_hosted", enable_self_hosted_);
 
   const char* signal_server_host_value =
-      ini_.GetValue(section_, "signal_server_host", nullptr);
+      ini_->GetValue(section_, "signal_server_host", nullptr);
   if (signal_server_host_value != nullptr &&
       strlen(signal_server_host_value) > 0) {
     signal_server_host_ = signal_server_host_value;
@@ -108,33 +112,27 @@ int ConfigCenter::Load() {
     signal_server_host_ = "";
   }
   const char* signal_server_port_value =
-      ini_.GetValue(section_, "signal_server_port", nullptr);
+      ini_->GetValue(section_, "signal_server_port", nullptr);
   if (signal_server_port_value != nullptr &&
       strlen(signal_server_port_value) > 0) {
     signal_server_port_ =
-        static_cast<int>(ini_.GetLongValue(section_, "signal_server_port", 0));
+        static_cast<int>(ini_->GetLongValue(section_, "signal_server_port", 0));
   } else {
     signal_server_port_ = 0;
   }
-  const char* coturn_server_port_value =
-      ini_.GetValue(section_, "coturn_server_port", nullptr);
-  if (coturn_server_port_value != nullptr &&
-      strlen(coturn_server_port_value) > 0) {
-    coturn_server_port_ =
-        static_cast<int>(ini_.GetLongValue(section_, "coturn_server_port", 0));
-  } else {
-    coturn_server_port_ = 0;
-  }
-
   enable_autostart_ =
-      ini_.GetBoolValue(section_, "enable_autostart", enable_autostart_);
-  enable_daemon_ = ini_.GetBoolValue(section_, "enable_daemon", enable_daemon_);
+      ini_->GetBoolValue(section_, "enable_autostart", enable_autostart_);
+  enable_daemon_ = ini_->GetBoolValue(section_, "enable_daemon", enable_daemon_);
+  enable_privacy_screen_.store(
+      ini_->GetBoolValue(section_, "enable_privacy_screen", true));
+  save_remote_previews_.store(
+      ini_->GetBoolValue(section_, "save_remote_previews", true));
   portable_service_prompt_suppressed_ =
-      ini_.GetBoolValue(section_, "portable_service_prompt_suppressed",
+      ini_->GetBoolValue(section_, "portable_service_prompt_suppressed",
                         portable_service_prompt_suppressed_);
 
   const char* file_transfer_save_path_value =
-      ini_.GetValue(section_, "file_transfer_save_path", nullptr);
+      ini_->GetValue(section_, "file_transfer_save_path", nullptr);
   if (file_transfer_save_path_value != nullptr &&
       strlen(file_transfer_save_path_value) > 0) {
     file_transfer_save_path_ = file_transfer_save_path_value;
@@ -142,48 +140,91 @@ int ConfigCenter::Load() {
     file_transfer_save_path_ = "";
   }
 
-  if (persist_config_migration && ini_.SaveFile(config_path_.c_str()) < 0) {
+  if (persist_config_migration && CommitIni() < 0) {
     return -1;
   }
 
   return 0;
 }
 
+int ConfigCenter::CommitIni() {
+  // Write beside the destination and rename only after a complete save. A
+  // failed write must not truncate the last usable configuration.
+  static std::atomic<unsigned long> sequence{0};
+  const std::string temporary = config_path_ + ".tmp-" +
+      std::to_string(std::chrono::steady_clock::now().time_since_epoch().count()) +
+      "-" + std::to_string(sequence++);
+  std::error_code error;
+  if (ini_->SaveFile(temporary.c_str()) < 0) {
+    LOG_ERROR("Failed to write configuration: {}", config_path_);
+    std::filesystem::remove(temporary, error);
+    return -1;
+  }
+  const auto previous = std::filesystem::status(config_path_, error);
+  if (!error && std::filesystem::is_regular_file(previous)) {
+    std::filesystem::permissions(temporary, previous.permissions(), error);
+    if (error) {
+      LOG_ERROR("Failed to preserve configuration permissions: {}", error.message());
+      std::filesystem::remove(temporary, error);
+      return -1;
+    }
+  }
+  std::filesystem::rename(temporary, config_path_, error);
+  if (!error) return 0;
+  LOG_ERROR("Failed to replace configuration {}: {}", config_path_, error.message());
+  std::filesystem::remove(temporary, error);
+  return -1;
+}
+
+int ConfigCenter::StoreValues(
+    std::initializer_list<std::pair<const char*, std::string>> values) {
+  std::vector<std::pair<const char*, std::optional<std::string>>> previous;
+  for (const auto& value : values) {
+    const char* old = ini_->GetValue(section_, value.first, nullptr);
+    previous.emplace_back(value.first, old ? std::optional<std::string>(old) : std::nullopt);
+    ini_->SetValue(section_, value.first, value.second.c_str());
+  }
+  if (CommitIni() == 0) return 0;
+  for (const auto& value : previous) {
+    if (value.second) ini_->SetValue(section_, value.first, value.second->c_str());
+    else ini_->Delete(section_, value.first);
+  }
+  return -1;
+}
+
 int ConfigCenter::Save() {
-  ini_.SetLongValue(section_, "language", static_cast<long>(language_));
-  ini_.SetLongValue(section_, "video_quality",
-                    static_cast<long>(video_quality_));
-  ini_.SetLongValue(section_, "video_frame_rate",
-                    static_cast<long>(video_frame_rate_));
-  ini_.SetLongValue(section_, "video_adaptation_policy",
-                    static_cast<long>(video_adaptation_policy_));
-  ini_.SetLongValue(section_, "video_encode_format",
+  ini_->SetLongValue(section_, "language", static_cast<long>(language_));
+  ini_->SetLongValue(section_, "screen_capture_method",
+                    static_cast<long>(screen_capture_method_));
+  ini_->SetLongValue(section_, "video_encode_format",
                     static_cast<long>(video_encode_format_));
-  ini_.SetBoolValue(section_, "hardware_video_codec", hardware_video_codec_);
-  ini_.SetLongValue(section_, "turn_mode", static_cast<long>(turn_mode_));
-  ini_.SetBoolValue(section_, "enable_turn",
+  ini_->SetBoolValue(section_, "hardware_video_codec", hardware_video_codec_);
+  ini_->SetLongValue(section_, "turn_mode", static_cast<long>(turn_mode_));
+  ini_->SetBoolValue(section_, "enable_turn",
                     turn_mode_ != TURN_MODE::DISABLED);
-  ini_.SetBoolValue(section_, "enable_srtp", enable_srtp_);
-  ini_.SetBoolValue(section_, "enable_self_hosted", enable_self_hosted_);
+  ini_->SetBoolValue(section_, "enable_srtp", true);
+  ini_->SetBoolValue(section_, "enable_self_hosted", enable_self_hosted_);
 
   // only save when self hosted
   if (enable_self_hosted_) {
-    ini_.SetValue(section_, "signal_server_host", signal_server_host_.c_str());
-    ini_.SetLongValue(section_, "signal_server_port",
+    ini_->SetValue(section_, "signal_server_host", signal_server_host_.c_str());
+    ini_->SetLongValue(section_, "signal_server_port",
                       static_cast<long>(signal_server_port_));
-    ini_.SetLongValue(section_, "coturn_server_port",
-                      static_cast<long>(coturn_server_port_));
   }
 
-  ini_.SetBoolValue(section_, "enable_autostart", enable_autostart_);
-  ini_.SetBoolValue(section_, "enable_daemon", enable_daemon_);
-  ini_.SetBoolValue(section_, "portable_service_prompt_suppressed",
+  ini_->SetBoolValue(section_, "enable_autostart", enable_autostart_);
+  ini_->SetBoolValue(section_, "enable_daemon", enable_daemon_);
+  ini_->SetBoolValue(section_, "enable_privacy_screen",
+                    enable_privacy_screen_.load());
+  ini_->SetBoolValue(section_, "save_remote_previews",
+                    save_remote_previews_.load());
+  ini_->SetBoolValue(section_, "portable_service_prompt_suppressed",
                     portable_service_prompt_suppressed_);
 
-  ini_.SetValue(section_, "file_transfer_save_path",
+  ini_->SetValue(section_, "file_transfer_save_path",
                 file_transfer_save_path_.c_str());
 
-  SI_Error rc = ini_.SaveFile(config_path_.c_str());
+  SI_Error rc = CommitIni();
   if (rc < 0) {
     return -1;
   }
@@ -194,220 +235,136 @@ int ConfigCenter::Save() {
 // setters
 
 int ConfigCenter::SetLanguage(LANGUAGE language) {
+  const int value = static_cast<int>(language);
+  if (value < 0 || value > 2 || StoreValues({{"language", std::to_string(value)}}) != 0) return -1;
   language_ = language;
-  ini_.SetLongValue(section_, "language", static_cast<long>(language_));
-  SI_Error rc = ini_.SaveFile(config_path_.c_str());
-  if (rc < 0) {
-    return -1;
-  }
   return 0;
 }
 
-int ConfigCenter::SetVideoQuality(VIDEO_QUALITY video_quality) {
-  video_quality_ = video_quality;
-  ini_.SetLongValue(section_, "video_quality",
-                    static_cast<long>(video_quality_));
-  SI_Error rc = ini_.SaveFile(config_path_.c_str());
-  if (rc < 0) {
+int ConfigCenter::SetScreenCaptureMethod(ScreenCaptureMethod method) {
+  if (!IsValidScreenCaptureMethod(static_cast<long>(method))) {
     return -1;
   }
+  ini_->SetLongValue(section_, "screen_capture_method", static_cast<long>(method));
+  if (CommitIni() < 0) {
+    ini_->SetLongValue(section_, "screen_capture_method",
+                      static_cast<long>(screen_capture_method_));
+    return -1;
+  }
+  screen_capture_method_ = method;
   return 0;
 }
 
-int ConfigCenter::SetVideoFrameRate(VIDEO_FRAME_RATE video_frame_rate) {
-  video_frame_rate_ = video_frame_rate;
-  ini_.SetLongValue(section_, "video_frame_rate",
-                    static_cast<long>(video_frame_rate_));
-  SI_Error rc = ini_.SaveFile(config_path_.c_str());
-  if (rc < 0) {
-    return -1;
-  }
+int ConfigCenter::SetVideoEncodeFormat(VIDEO_ENCODE_FORMAT format) {
+  if (format != VIDEO_ENCODE_FORMAT::H264 && format != VIDEO_ENCODE_FORMAT::AV1) return -1;
+  if (StoreValues({{"video_encode_format", std::to_string(static_cast<int>(format))}}) != 0) return -1;
+  video_encode_format_ = format;
   return 0;
 }
 
-int ConfigCenter::SetVideoAdaptationPolicy(
-    VIDEO_ADAPTATION_POLICY policy) {
-  video_adaptation_policy_ = policy;
-  ini_.SetLongValue(section_, "video_adaptation_policy",
-                    static_cast<long>(video_adaptation_policy_));
-  SI_Error rc = ini_.SaveFile(config_path_.c_str());
-  if (rc < 0) {
-    return -1;
-  }
+int ConfigCenter::SetHardwareVideoCodec(bool enabled) {
+  if (enabled && !IsHardwareVideoCodecAvailable()) return -1;
+  if (StoreValues({{"hardware_video_codec", enabled ? "true" : "false"}}) != 0) return -1;
+  hardware_video_codec_ = enabled;
   return 0;
 }
 
-int ConfigCenter::SetVideoEncodeFormat(
-    VIDEO_ENCODE_FORMAT video_encode_format) {
-  video_encode_format_ = video_encode_format;
-  ini_.SetLongValue(section_, "video_encode_format",
-                    static_cast<long>(video_encode_format_));
-  SI_Error rc = ini_.SaveFile(config_path_.c_str());
-  if (rc < 0) {
-    return -1;
-  }
+int ConfigCenter::SetTurnMode(TURN_MODE mode) {
+  if (!IsValidTurnModeValue(static_cast<long>(mode))) return -1;
+  if (StoreValues({{"turn_mode", std::to_string(static_cast<int>(mode))},
+                   {"enable_turn", mode == TURN_MODE::DISABLED ? "false" : "true"}}) != 0) return -1;
+  turn_mode_ = mode;
   return 0;
 }
 
-int ConfigCenter::SetHardwareVideoCodec(bool hardware_video_codec) {
-  hardware_video_codec_ = hardware_video_codec;
-  ini_.SetBoolValue(section_, "hardware_video_codec", hardware_video_codec_);
-  SI_Error rc = ini_.SaveFile(config_path_.c_str());
-  if (rc < 0) {
-    return -1;
-  }
-  return 0;
-}
-
-int ConfigCenter::SetTurnMode(TURN_MODE turn_mode) {
-  if (!IsValidTurnModeValue(static_cast<long>(turn_mode))) {
-    return -1;
-  }
-
-  turn_mode_ = turn_mode;
-  ini_.SetLongValue(section_, "turn_mode", static_cast<long>(turn_mode_));
-  ini_.SetBoolValue(section_, "enable_turn",
-                    turn_mode_ != TURN_MODE::DISABLED);
-  SI_Error rc = ini_.SaveFile(config_path_.c_str());
-  if (rc < 0) {
-    return -1;
-  }
-  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::SetSrtp(bool enable_srtp) {
-  enable_srtp_ = enable_srtp;
-  ini_.SetBoolValue(section_, "enable_srtp", enable_srtp_);
-  SI_Error rc = ini_.SaveFile(config_path_.c_str());
-  if (rc < 0) {
-    return -1;
-  }
+int ConfigCenter::SetServerHost(const std::string& host) {
+  if (host.empty() || host.size() > 253 || host.find_first_of("/\\@?#") != std::string::npos ||
+      std::any_of(host.begin(), host.end(), [](unsigned char c) { return c <= 32 || c == 127; })) return -1;
+  if (StoreValues({{"signal_server_host", host}}) != 0) return -1;
+  signal_server_host_ = host;
   return 0;
 }
 
-int ConfigCenter::SetServerHost(const std::string& signal_server_host) {
-  signal_server_host_ = signal_server_host;
-  ini_.SetValue(section_, "signal_server_host", signal_server_host_.c_str());
-  SI_Error rc = ini_.SaveFile(config_path_.c_str());
-  if (rc < 0) {
-    return -1;
-  }
+int ConfigCenter::SetServerPort(int port) {
+  if (port < 1 || port > 65535 || StoreValues({{"signal_server_port", std::to_string(port)}}) != 0) return -1;
+  signal_server_port_ = port;
   return 0;
 }
 
-int ConfigCenter::SetServerPort(int signal_server_port) {
-  signal_server_port_ = signal_server_port;
-  ini_.SetLongValue(section_, "signal_server_port",
-                    static_cast<long>(signal_server_port_));
-  SI_Error rc = ini_.SaveFile(config_path_.c_str());
-  if (rc < 0) {
-    return -1;
-  }
+int ConfigCenter::SetSelfHosted(bool enabled) {
+  if (enabled && (signal_server_host_.empty() || signal_server_port_ < 1 || signal_server_port_ > 65535)) return -1;
+  if (StoreValues({{"enable_self_hosted", enabled ? "true" : "false"}}) != 0) return -1;
+  enable_self_hosted_ = enabled;
   return 0;
 }
 
-int ConfigCenter::SetCoturnServerPort(int coturn_server_port) {
-  coturn_server_port_ = coturn_server_port;
-  ini_.SetLongValue(section_, "coturn_server_port",
-                    static_cast<long>(coturn_server_port_));
-  SI_Error rc = ini_.SaveFile(config_path_.c_str());
-  if (rc < 0) {
-    return -1;
-  }
-  return 0;
-}
-
-int ConfigCenter::SetSelfHosted(bool enable_self_hosted) {
-  enable_self_hosted_ = enable_self_hosted;
-  ini_.SetBoolValue(section_, "enable_self_hosted", enable_self_hosted_);
-
-  // load from config if self hosted is enabled
-  if (enable_self_hosted_) {
-    const char* signal_server_host_value =
-        ini_.GetValue(section_, "signal_server_host", nullptr);
-    if (signal_server_host_value != nullptr &&
-        strlen(signal_server_host_value) > 0) {
-      signal_server_host_ = signal_server_host_value;
-    }
-    const char* signal_server_port_value =
-        ini_.GetValue(section_, "signal_server_port", nullptr);
-    if (signal_server_port_value != nullptr &&
-        strlen(signal_server_port_value) > 0) {
-      signal_server_port_ = static_cast<int>(
-          ini_.GetLongValue(section_, "signal_server_port", 0));
-    }
-    const char* coturn_server_port_value =
-        ini_.GetValue(section_, "coturn_server_port", nullptr);
-    if (coturn_server_port_value != nullptr &&
-        strlen(coturn_server_port_value) > 0) {
-      coturn_server_port_ = static_cast<int>(
-          ini_.GetLongValue(section_, "coturn_server_port", 0));
-    }
-
-    ini_.SetValue(section_, "signal_server_host", signal_server_host_.c_str());
-    ini_.SetLongValue(section_, "signal_server_port",
-                      static_cast<long>(signal_server_port_));
-    ini_.SetLongValue(section_, "coturn_server_port",
-                      static_cast<long>(coturn_server_port_));
-  }
-
-  SI_Error rc = ini_.SaveFile(config_path_.c_str());
-  if (rc < 0) {
-    return -1;
-  }
-  return 0;
-}
-
-int ConfigCenter::SetAutostart(bool enable_autostart) {
-  enable_autostart_ = enable_autostart;
-  bool success = false;
-  if (enable_autostart) {
-    success = EnableAutostart("CrossDesk");
-  } else {
-    success = DisableAutostart("CrossDesk");
-  }
-
-  ini_.SetBoolValue(section_, "enable_autostart", enable_autostart_);
-  SI_Error rc = ini_.SaveFile(config_path_.c_str());
-  if (rc < 0) {
-    return -1;
-  }
-
-  if (!success) {
+int ConfigCenter::SetAutostart(bool enabled) {
+  const bool previous = IsAutostartEnabled("CrossDesk");
+  if (enabled != previous && !(enabled ? EnableAutostart("CrossDesk") : DisableAutostart("CrossDesk"))) {
     LOG_ERROR("SetAutostart failed");
     return -1;
   }
-
+  if (StoreValues({{"enable_autostart", enabled ? "true" : "false"}}) != 0) {
+    if (enabled != previous) {
+      if (previous) EnableAutostart("CrossDesk");
+      else DisableAutostart("CrossDesk");
+    }
+    return -1;
+  }
+  enable_autostart_ = enabled;
   return 0;
 }
 
-int ConfigCenter::SetDaemon(bool enable_daemon) {
-  enable_daemon_ = enable_daemon;
+int ConfigCenter::SetDaemon(bool enabled) {
+  if (StoreValues({{"enable_daemon", enabled ? "true" : "false"}}) != 0) return -1;
+  enable_daemon_ = enabled;
+  return 0;
+}
 
-  ini_.SetBoolValue(section_, "enable_daemon", enable_daemon_);
-  SI_Error rc = ini_.SaveFile(config_path_.c_str());
-  if (rc < 0) {
+int ConfigCenter::SetPrivacyScreen(bool enable_privacy_screen) {
+  const bool previous = enable_privacy_screen_.load();
+  if (previous == enable_privacy_screen) return 0;
+  ini_->SetBoolValue(section_, "enable_privacy_screen", enable_privacy_screen);
+  if (CommitIni() < 0) {
+    ini_->SetBoolValue(section_, "enable_privacy_screen", previous);
+    LOG_ERROR("Failed to save automatic privacy screen preference");
     return -1;
   }
-
+  // RTC callbacks read only the value committed by the settings thread.
+  enable_privacy_screen_.store(enable_privacy_screen);
+  LOG_INFO("Privacy screen on incoming connection: {}", enable_privacy_screen);
   return 0;
 }
 
+int ConfigCenter::SetSaveRemotePreviews(bool enabled) {
+  if (StoreValues({{"save_remote_previews", enabled ? "true" : "false"}}) != 0) {
+    return -1;
+  }
+  save_remote_previews_.store(enabled);
+  return 0;
+}
+
+bool ConfigCenter::IsSaveRemotePreviews() const {
+  return save_remote_previews_.load();
+}
+
 int ConfigCenter::SetPortableServicePromptSuppressed(bool suppressed) {
   portable_service_prompt_suppressed_ = suppressed;
-  ini_.SetBoolValue(section_, "portable_service_prompt_suppressed",
+  ini_->SetBoolValue(section_, "portable_service_prompt_suppressed",
                     portable_service_prompt_suppressed_);
-  SI_Error rc = ini_.SaveFile(config_path_.c_str());
+  SI_Error rc = CommitIni();
   if (rc < 0) {
     return -1;
   }
@@ -419,25 +376,26 @@ int ConfigCenter::SetPortableServicePromptSuppressed(bool suppressed) {
 
 ConfigCenter::LANGUAGE ConfigCenter::GetLanguage() const { return language_; }
 
-ConfigCenter::VIDEO_QUALITY ConfigCenter::GetVideoQuality() const {
-  return video_quality_;
-}
-
-ConfigCenter::VIDEO_FRAME_RATE ConfigCenter::GetVideoFrameRate() const {
-  return video_frame_rate_;
-}
-
-ConfigCenter::VIDEO_ADAPTATION_POLICY
-ConfigCenter::GetVideoAdaptationPolicy() const {
-  return video_adaptation_policy_;
+ScreenCaptureMethod ConfigCenter::GetScreenCaptureMethod() const {
+  return screen_capture_method_;
 }
 
 ConfigCenter::VIDEO_ENCODE_FORMAT ConfigCenter::GetVideoEncodeFormat() const {
   return video_encode_format_;
 }
 
+bool ConfigCenter::IsHardwareVideoCodecAvailable() {
+#if (((defined(_WIN32) || defined(__linux__)) && !defined(__aarch64__) && \
+      !defined(__arm__) && USE_CUDA) ||                                   \
+     defined(__APPLE__))
+  return true;
+#else
+  return false;
+#endif
+}
+
 bool ConfigCenter::IsHardwareVideoCodec() const {
-  return hardware_video_codec_;
+  return IsHardwareVideoCodecAvailable() && hardware_video_codec_;
 }
 
 ConfigCenter::TURN_MODE ConfigCenter::GetTurnMode() const {
@@ -448,7 +406,11 @@ bool ConfigCenter::IsEnableTurn() const {
   return turn_mode_ != TURN_MODE::DISABLED;
 }
 
-bool ConfigCenter::IsEnableSrtp() const { return enable_srtp_; }
+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 {
   return signal_server_host_;
@@ -456,8 +418,6 @@ std::string ConfigCenter::GetSignalServerHost() const {
 
 int ConfigCenter::GetSignalServerPort() const { return signal_server_port_; }
 
-int ConfigCenter::GetCoturnServerPort() const { return coturn_server_port_; }
-
 std::string ConfigCenter::GetDefaultServerHost() const {
   return signal_server_host_default_;
 }
@@ -466,32 +426,30 @@ int ConfigCenter::GetDefaultSignalServerPort() const {
   return server_port_default_;
 }
 
-int ConfigCenter::GetDefaultCoturnServerPort() const {
-  return coturn_server_port_default_;
-}
-
 bool ConfigCenter::IsSelfHosted() const { return enable_self_hosted_; }
 
 bool ConfigCenter::IsEnableAutostart() const { return enable_autostart_; }
 
 bool ConfigCenter::IsEnableDaemon() const { return enable_daemon_; }
 
+bool ConfigCenter::IsEnablePrivacyScreen() const {
+  return enable_privacy_screen_.load();
+}
+
 bool ConfigCenter::IsPortableServicePromptSuppressed() const {
   return portable_service_prompt_suppressed_;
 }
 
 int ConfigCenter::SetFileTransferSavePath(const std::string& path) {
+  if (path.size() >= 512 || std::any_of(path.begin(), path.end(), [](unsigned char c) { return c < 32 || c == 127; })) return -1;
+  std::lock_guard<std::mutex> lock(file_path_mutex_);
+  if (StoreValues({{"file_transfer_save_path", path}}) != 0) return -1;
   file_transfer_save_path_ = path;
-  ini_.SetValue(section_, "file_transfer_save_path",
-                file_transfer_save_path_.c_str());
-  SI_Error rc = ini_.SaveFile(config_path_.c_str());
-  if (rc < 0) {
-    return -1;
-  }
   return 0;
 }
 
 std::string ConfigCenter::GetFileTransferSavePath() const {
+  std::lock_guard<std::mutex> lock(file_path_mutex_);
   return file_transfer_save_path_;
 }
 }  // namespace crossdesk

apps/desktop/src/config_center/config_center.h

@@ -7,22 +7,20 @@
 #ifndef _CONFIG_CENTER_H_
 #define _CONFIG_CENTER_H_
 
+#include <atomic>
+#include <initializer_list>
+#include <memory>
+#include <mutex>
+#include <utility>
 #include <string>
 
-#include "SimpleIni.h"
+#include "screen_capturer/screen_capture_method.h"
 
 namespace crossdesk {
 
 class ConfigCenter {
  public:
   enum class LANGUAGE { CHINESE = 0, ENGLISH = 1, RUSSIAN = 2 };
-  enum class VIDEO_QUALITY { LOW = 0, MEDIUM = 1, HIGH = 2 };
-  enum class VIDEO_FRAME_RATE { FPS_30 = 0, FPS_60 = 1 };
-  enum class VIDEO_ADAPTATION_POLICY {
-    FRAME_RATE_PRIORITY = 0,
-    QUALITY_PRIORITY = 1,
-    BALANCED = 2
-  };
   enum class VIDEO_ENCODE_FORMAT { H264 = 0, AV1 = 1 };
   enum class TURN_MODE {
     DISABLED = 0,
@@ -37,43 +35,42 @@ class ConfigCenter {
 
   // write config
   int SetLanguage(LANGUAGE language);
-  int SetVideoQuality(VIDEO_QUALITY video_quality);
-  int SetVideoFrameRate(VIDEO_FRAME_RATE video_frame_rate);
-  int SetVideoAdaptationPolicy(VIDEO_ADAPTATION_POLICY policy);
+  int SetScreenCaptureMethod(ScreenCaptureMethod method);
   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 SetSrtp(bool enable_srtp);
+  int SetTurn(bool enable_turn, bool force_relay);
   int SetServerHost(const std::string& signal_server_host);
   int SetServerPort(int signal_server_port);
-  int SetCoturnServerPort(int coturn_server_port);
   int SetSelfHosted(bool enable_self_hosted);
   int SetAutostart(bool enable_autostart);
   int SetDaemon(bool enable_daemon);
+  int SetPrivacyScreen(bool enable_privacy_screen);
+  int SetSaveRemotePreviews(bool enabled);
   int SetPortableServicePromptSuppressed(bool suppressed);
   int SetFileTransferSavePath(const std::string& path);
 
   // read config
 
   LANGUAGE GetLanguage() const;
-  VIDEO_QUALITY GetVideoQuality() const;
-  VIDEO_FRAME_RATE GetVideoFrameRate() const;
-  VIDEO_ADAPTATION_POLICY GetVideoAdaptationPolicy() const;
+  ScreenCaptureMethod GetScreenCaptureMethod() const;
   VIDEO_ENCODE_FORMAT GetVideoEncodeFormat() const;
+  // Whether this build includes a hardware video codec backend.
+  static bool IsHardwareVideoCodecAvailable();
   bool IsHardwareVideoCodec() const;
   TURN_MODE GetTurnMode() const;
   bool IsEnableTurn() const;
+  bool IsForceRelay() const;
   bool IsEnableSrtp() const;
   std::string GetSignalServerHost() const;
   int GetSignalServerPort() const;
-  int GetCoturnServerPort() const;
   std::string GetDefaultServerHost() const;
   int GetDefaultSignalServerPort() const;
-  int GetDefaultCoturnServerPort() const;
   bool IsSelfHosted() const;
   bool IsEnableAutostart() const;
   bool IsEnableDaemon() const;
+  bool IsEnablePrivacyScreen() const;
+  bool IsSaveRemotePreviews() const;
   bool IsPortableServicePromptSuppressed() const;
   std::string GetFileTransferSavePath() const;
 
@@ -81,28 +78,28 @@ class ConfigCenter {
   int Save();
 
  private:
+  int CommitIni();
+  int StoreValues(std::initializer_list<std::pair<const char*, std::string>> values);
+  mutable std::mutex file_path_mutex_;
   std::string config_path_;
-  CSimpleIniA ini_;
+  struct IniStorage;
+  std::unique_ptr<IniStorage> ini_;
   const char* section_ = "Settings";
 
   LANGUAGE language_ = LANGUAGE::CHINESE;
-  VIDEO_QUALITY video_quality_ = VIDEO_QUALITY::HIGH;
-  VIDEO_FRAME_RATE video_frame_rate_ = VIDEO_FRAME_RATE::FPS_60;
-  VIDEO_ADAPTATION_POLICY video_adaptation_policy_ =
-      VIDEO_ADAPTATION_POLICY::QUALITY_PRIORITY;
+  ScreenCaptureMethod screen_capture_method_ = ScreenCaptureMethod::Auto;
   VIDEO_ENCODE_FORMAT video_encode_format_ = VIDEO_ENCODE_FORMAT::H264;
   bool hardware_video_codec_ = false;
   TURN_MODE turn_mode_ = TURN_MODE::AUTO_UDP_TCP;
-  bool enable_srtp_ = false;
   std::string signal_server_host_ = "";
   std::string signal_server_host_default_ = "api.crossdesk.cn";
   int signal_server_port_ = 0;
   int server_port_default_ = 9099;
-  int coturn_server_port_ = 0;
-  int coturn_server_port_default_ = 3478;
   bool enable_self_hosted_ = false;
   bool enable_autostart_ = false;
   bool enable_daemon_ = false;
+  std::atomic<bool> enable_privacy_screen_{true};
+  std::atomic<bool> save_remote_previews_{true};
   bool portable_service_prompt_suppressed_ = false;
   std::string file_transfer_save_path_ = "";
 };

apps/desktop/src/device_controller/device_controller.h

@@ -42,6 +42,9 @@ class KeyboardCapturer : public DeviceController {
 
   virtual int Hook(OnKeyAction on_key_action, void* user_ptr) = 0;
   virtual int Unhook() = 0;
+  // Backends with an asynchronous capture loop override this so the UI can
+  // fall back to window events if that loop stops unexpectedly.
+  virtual bool IsHookActive() const { return true; }
   virtual int SendKeyboardCommand(int key_code, bool is_down,
                                   uint32_t scan_code = 0,
                                   bool extended = false) = 0;

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

@@ -10,79 +10,29 @@
 #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;
   bool mouse_controller_is_started_ = false;
   bool start_screen_capturer_ = false;
   bool screen_capturer_is_started_ = false;
-  bool start_speaker_capturer_ = false;
-  bool speaker_capturer_is_started_ = false;
   bool start_keyboard_capturer_ = false;
-  bool show_cursor_ = 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;
@@ -90,39 +40,24 @@ 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_;
 };
 
 struct UpdateState {
-  nlohmann::json latest_version_info_ = nlohmann::json{};
   bool update_available_ = false;
   std::string latest_version_;
   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 {
@@ -133,60 +68,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,
@@ -198,4 +95,4 @@ struct ApplicationState : MainWindowState,
 
 }  // namespace crossdesk::gui_detail
 
-#endif
+#endif

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

@@ -19,6 +19,8 @@
 
 namespace crossdesk {
 
+class UpdateChecker;
+
 // Slint application shell. GuiRuntime remains the owner of transport, media,
 // device, clipboard, transfer and settings behavior.
 class GuiApplication final : private GuiRuntime {
@@ -48,10 +50,13 @@ private:
   void BindStreamCallbacks();
   void BindServerCallbacks();
   void Tick();
+  void PollUpdateCheck();
   void ShareLocalCursorState();
+  bool RequestPasswordChange(const std::string &password);
   void HandlePasswordChangeResult();
   void HandleCredentialRecovery();
   void SyncMainWindow();
+  void SyncAnnouncements();
   void SyncConnectionDialog();
   void SyncPlatformDialogs();
   void SyncStreamWindow();
@@ -67,6 +72,7 @@ private:
   void UpdateLocalization();
   void ResetSettingsUi();
   void SaveSettingsFromUi();
+  void ApplySettingsFromConfig(bool reconnect);
 #if _WIN32 && CROSSDESK_PORTABLE
   void CheckPortableWindowsService();
   void StartPortableWindowsServiceInstall();
@@ -87,6 +93,7 @@ private:
   bool OpenUrl(const std::string &url);
 
   std::unique_ptr<SlintUi> ui_;
+  std::unique_ptr<UpdateChecker> update_checker_;
   CursorStateProvider cursor_state_provider_;
   std::unordered_map<std::string, CursorDeliveryState>
       cursor_delivery_states_;
@@ -100,4 +107,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();
-        SendDataFrame(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();
-        SendDataFrame(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,85 +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_SRTP_CHECKBOX_PADDING_CN 171 * dpi_scale_
-#define ENABLE_SRTP_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,89 +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_SRTP_CHECKBOX_PADDING_CN 171
-#define ENABLE_SRTP_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

@@ -20,11 +20,92 @@ struct TranslationRow {
 
 // Single source of truth for all UI strings.
 #define CROSSDESK_LOCALIZATION_ALL(X)                                          \
+  X(messages, u8"消息", "Messages", u8"Сообщения") \
+  X(message_unread, u8"未读", "Unread", u8"Не прочитано") \
+  X(message_read, u8"已读", "Read", u8"Прочитано") \
+  X(message_empty, u8"暂无公告", "No announcements", u8"Нет объявлений") \
+  X(message_select, u8"选择公告查看详情", "Select an announcement to read", u8"Выберите объявление") \
+  X(message_loading, u8"正在加载…", "Loading…", u8"Загрузка…") \
+  X(message_read_save_error, u8"无法保存本地阅读状态，请重新打开公告重试。", "Unable to save reading status locally. Open the announcement again to retry.", u8"Не удалось сохранить статус чтения. Откройте объявление снова.") \
+  X(message_close, u8"关闭", "Close", u8"Закрыть") \
+  X(message_delete, u8"删除", "Delete", u8"Удалить") \
+  X(message_delete_title, u8"删除公告", "Delete announcement", u8"Удалить объявление") \
+  X(message_delete_confirmation, u8"删除这条公告？", "Delete this announcement?", u8"Удалить это объявление?") \
+  X(message_delete_error, u8"无法删除这条公告，请重试。", "Unable to delete this announcement. Please try again.", u8"Не удалось удалить объявление. Повторите попытку.") \
+  X(console_cli_help, u8"Linux 无头运行选项：\n  --headless                  自动选择已有桌面并启用控制台\n  --headless-display DISPLAY  高级：指定已有显示会话\n  --headless-size WIDTHxHEIGHT 新建虚拟屏幕；默认1920x1080，偶数尺寸320..8192\n  --headless-session EXECUTABLE 启动桌面环境（startxfce4；none 仅启动裸屏幕）\n  --no-headless               禁用自动回退\n正常启动会自动选择已有桌面，无需填写显示编号。控制台输入 settings 管理设置。\n", "Linux headless options:\n  --headless                  Select an existing desktop and enable the console\n  --headless-display DISPLAY  Advanced: override desktop selection\n  --headless-size WIDTHxHEIGHT New virtual display; default 1920x1080, even 320..8192\n  --headless-session EXECUTABLE Start a desktop (startxfce4; none for a bare display)\n  --no-headless               Disable automatic fallback\nNormal startup selects your existing desktop automatically. Enter settings in the console to configure it.\n", u8"Параметры запуска без монитора:\n  --headless                  Выбрать рабочий стол и включить консоль\n  --headless-display DISPLAY  Дополнительно: указать сеанс дисплея\n  --headless-size WIDTHxHEIGHT Новый виртуальный экран; 1920x1080 по умолчанию, чётные размеры 320..8192\n  --headless-session EXECUTABLE Запустить рабочий стол (startxfce4; none — только экран)\n  --no-headless               Отключить автоматический резервный запуск\nРабочий стол выбирается автоматически. Команда settings открывает настройки консоли.\n") \
+  X(console_title, u8"CrossDesk 无头控制台", "CrossDesk headless console", u8"Консоль CrossDesk") \
+  X(console_log_file, u8"日志文件", "Log file", u8"Файл журнала") \
+  X(console_help, u8"命令: status 查看ID/密码/状态；settings 设置；password 修改密码；random 随机密码；help 帮助；quit 退出", "Commands: status, settings, password, random, help, quit", u8"Команды: status, settings, password, random, help, quit") \
+  X(console_status, u8"状态", "Status", u8"Состояние") \
+  X(console_online, u8"在线", "Online", u8"В сети") \
+  X(console_offline, u8"未连接服务器", "Disconnected from server", u8"Нет подключения к серверу") \
+  X(console_id, u8"设备 ID", "Device ID", u8"ID устройства") \
+  X(console_password, u8"连接密码", "Connection password", u8"Пароль подключения") \
+  X(console_waiting, u8"等待分配", "Waiting for assignment", u8"Ожидание назначения") \
+  X(console_password_hidden, u8"（仅在交互终端显示）", "(shown only in an interactive terminal)", u8"(виден только в интерактивном терминале)") \
+  X(console_cancelled, u8"已取消修改。", "Change cancelled.", u8"Изменение отменено.") \
+  X(console_password_invalid, u8"密码必须是6位英文字母或数字，未提交修改。", "Password must be 6 ASCII letters or digits; no change submitted.", u8"Пароль должен содержать 6 латинских букв или цифр. Изменение не отправлено.") \
+  X(console_password_offline, u8"尚未连接服务器，暂时无法修改密码。", "Connect to the server before changing the password.", u8"Для смены пароля подключитесь к серверу.") \
+  X(console_password_prompt, u8"输入新密码（6位英文字母或数字；输入 cancel 取消）:", "New password (6 ASCII letters or digits; cancel to abort):", u8"Новый пароль (6 латинских букв или цифр; cancel — отмена):") \
+  X(console_quitting, u8"正在退出 CrossDesk……", "Exiting CrossDesk...", u8"Выход из CrossDesk...") \
+  X(console_unknown_command, u8"未知命令，输入 help 查看帮助。", "Unknown command. Enter help for commands.", u8"Неизвестная команда. Введите help для справки.") \
+  X(console_line_too_long, u8"命令过长，已忽略。", "Command too long; ignored.", u8"Команда слишком длинная и проигнорирована.") \
+  X(console_random_failed, u8"无法生成随机密码，请重试。", "Unable to generate a random password; try again.", u8"Не удалось создать случайный пароль. Повторите попытку.") \
+  X(console_password_pending, u8"密码修改正在处理中，请等待服务器确认。", "Password change pending; wait for server confirmation.", u8"Смена пароля выполняется. Дождитесь подтверждения сервера.") \
+  X(console_password_stage_failed, u8"无法保存密码修改记录，未提交修改。请检查日志。", "Unable to save password recovery record; no change submitted. Check the log.", u8"Не удалось сохранить запись восстановления пароля. Изменение не отправлено. Проверьте журнал.") \
+  X(console_password_send_failed, u8"发送密码修改请求失败，请等待连接恢复后重试。", "Failed to submit password change; retry after reconnection.", u8"Не удалось отправить запрос смены пароля. Повторите после подключения.") \
+  X(console_password_submitted, u8"已提交密码修改，正在等待服务器确认……", "Password change submitted; waiting for server confirmation...", u8"Запрос смены пароля отправлен. Ожидание подтверждения...") \
+  X(console_password_uncertain, u8"密码修改结果尚未确认，正在重新连接服务器核实。", "Password change not yet confirmed; reconnecting to verify.", u8"Смена пароля не подтверждена. Повторное подключение для проверки.") \
+  X(console_password_rejected, u8"服务器未接受密码修改，原密码保持不变。详情见日志。", "Server rejected the password change; the original password remains. See the log.", u8"Сервер отклонил смену пароля. Старый пароль сохранён. См. журнал.") \
+  X(console_password_confirmed, u8"服务器已确认密码修改，正在重新连接。", "Server confirmed the password change; reconnecting.", u8"Сервер подтвердил смену пароля. Повторное подключение.") \
+  X(console_password_recovered, u8"重新连接确认：新密码已生效。", "Reconnection confirmed: the new password is active.", u8"Повторное подключение подтвердило новый пароль.") \
+  X(console_password_retained, u8"重新连接确认：继续使用原密码。", "Reconnection confirmed: the original password remains active.", u8"Повторное подключение подтвердило прежний пароль.") \
+  X(console_exited, u8"CrossDesk 已退出。", "CrossDesk exited.", u8"CrossDesk завершён.") \
+  X(console_stopped, u8"CrossDesk 已停止，退出码", "CrossDesk stopped; exit code", u8"CrossDesk остановлен; код выхода") \
+  X(console_settings_title, u8"设置（修改后立即保存）", "Settings (each change is saved immediately)", u8"Настройки (изменения сохраняются сразу)") \
+  X(console_settings_prompt, u8"输入编号或选项名称修改；back 返回。也可使用 settings set 名称 值。", "Enter an item number or key; back to return. Shortcut: settings set KEY VALUE.", u8"Введите номер или имя параметра; back — назад. Команда: settings set KEY VALUE.") \
+  X(console_settings_value, u8"输入新值（cancel 取消）", "Enter a new value (cancel to abort)", u8"Введите новое значение (cancel — отмена)") \
+  X(console_settings_unavailable, u8"设置尚未初始化，请稍后重试。", "Settings are not ready; try again shortly.", u8"Настройки ещё не готовы. Повторите позже.") \
+  X(console_settings_invalid, u8"无效的选项或值，未保存。请按菜单列出的格式输入。", "Invalid setting or value; not saved. Use the format shown in the menu.", u8"Неверный параметр или значение. Ничего не сохранено. Используйте указанный формат.") \
+  X(console_settings_save_failed, u8"保存设置失败，原设置保持不变。请检查日志。", "Failed to save settings; the previous value is retained. Check the log.", u8"Не удалось сохранить настройки. Прежнее значение сохранено. Проверьте журнал.") \
+  X(console_settings_busy, u8"有远程会话或密码修改正在进行，暂时不能更改连接设置。", "Connection settings cannot change during a remote session or password change.", u8"Нельзя менять параметры подключения во время удалённого сеанса или смены пароля.") \
+  X(console_settings_saved, u8"已保存并生效。", "Saved and applied.", u8"Сохранено и применено.") \
+  X(console_settings_unchanged, u8"设置未改变。", "Setting unchanged.", u8"Настройка не изменилась.") \
+  X(console_settings_reconnect, u8"已保存，正在重新连接服务器。", "Saved; reconnecting to the server.", u8"Сохранено. Повторное подключение к серверу.") \
+  X(console_settings_next_connection, u8"已保存，将用于后续连接。", "Saved; applies to subsequent connections.", u8"Сохранено. Будет применено к следующим подключениям.") \
+  X(console_settings_next_file, u8"已保存，将用于后续接收的文件。", "Saved; applies to subsequently received files.", u8"Сохранено. Будет применено к следующим получаемым файлам.") \
+  X(console_settings_autostart, u8"已保存，在下次图形桌面登录时生效。", "Saved; applies at the next graphical desktop login.", u8"Сохранено. Будет применено при следующем входе в графический сеанс.") \
+  X(console_settings_daemon, u8"已保存，普通模式重启后生效；无头控制台仍保持前台运行。", "Saved for the next normal-mode start; the headless console stays in the foreground.", u8"Сохранено для следующего запуска в обычном режиме. Консоль остаётся на переднем плане.") \
+  X(console_settings_hardware_unavailable, u8"当前构建不支持硬件编解码，未保存。", "Hardware codecs are unavailable in this build; not saved.", u8"Аппаратные кодеки недоступны в этой сборке. Не сохранено.") \
+  X(console_settings_server_required, u8"请先设置有效的服务器地址和端口，再启用自托管。", "Set a valid server host and port before enabling self-hosting.", u8"Укажите адрес и порт сервера перед включением собственного сервера.") \
+  X(console_settings_path_invalid, u8"请选择已存在且可写的绝对目录路径；default 使用默认目录。", "Use an existing writable absolute directory, or default for the default location.", u8"Укажите существующий доступный для записи абсолютный путь к каталогу или default.") \
+  X(console_settings_readonly, u8"该选项由系统或控制端管理，不可在此修改。", "This option is managed by the system or controller and is read-only here.", u8"Этот параметр управляется системой или клиентом и здесь недоступен для изменения.") \
+  X(console_setting_language, u8"语言", "Language", u8"Язык") \
+  X(console_setting_codec, u8"视频编码", "Video codec", u8"Видеокодек") \
+  X(console_setting_hardware, u8"硬件编解码", "Hardware codecs", u8"Аппаратные кодеки") \
+  X(console_setting_turn, u8"中继模式", "TURN relay mode", u8"Режим ретрансляции TURN") \
+  X(console_setting_self_hosted, u8"自托管", "Self-hosted server", u8"Собственный сервер") \
+  X(console_setting_host, u8"服务器地址", "Server host", u8"Адрес сервера") \
+  X(console_setting_port, u8"信令端口", "Signaling port", u8"Порт сигнализации") \
+  X(console_setting_privacy, u8"连接时自动开启隐私屏", "Privacy screen on connection", u8"Приватный экран при подключении") \
+  X(console_setting_files, u8"文件保存目录", "Received file directory", u8"Каталог получаемых файлов") \
+  X(console_setting_autostart, u8"登录桌面时自启", "Start at desktop login", u8"Запуск при входе в систему") \
+  X(console_setting_daemon, u8"守护进程（无头控制台中不生效）", "Daemon (inactive in headless console)", u8"Фоновый режим (не действует в консоли)") \
+  X(save_remote_previews, u8"保存远程画面预览:", "Save remote screen previews:", u8"Сохранять превью экрана:") \
+  X(unknown_platform, u8"未知平台", "Unknown platform", u8"Неизвестная платформа") \
+  X(privacy_screen, u8"隐私屏", "Privacy screen", u8"Приватный экран") \
+  X(privacy_enable, u8"开启隐私屏", "Enable privacy screen", u8"Включить приватный экран") \
+  X(privacy_disable, u8"关闭隐私屏", "Disable privacy screen", u8"Выключить приватный экран") \
+  X(privacy_on, u8"隐私屏：已开启", "Privacy screen: on", u8"Приватный экран: включён") \
+  X(privacy_off, u8"隐私屏：已关闭", "Privacy screen: off", u8"Приватный экран: выключен") \
+  X(privacy_unsupported, u8"隐私屏：不可用", "Privacy screen: unavailable", u8"Приватный экран: недоступен") \
   X(local_desktop, u8"本桌面", "Local Desktop", u8"Локальный рабочий стол")    \
   X(local_id, u8"本机ID", "Local ID", u8"Локальный ID")                        \
   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"Удаленный рабочий стол")                                                \
@@ -120,6 +201,16 @@ struct TranslationRow {
     u8"стола")                                                                 \
   X(settings, u8"设置", "Settings", u8"Настройки")                             \
   X(language, u8"语言:", "Language:", u8"Язык:")                               \
+  X(screen_capture_method, u8"采集方式:", "Capture Method:",                  \
+    u8"Способ захвата:")                                                      \
+  X(screen_capture_method_auto, u8"自动", "Auto", u8"Авто")                 \
+  X(video_settings, u8"画面设置", "Video settings", u8"Настройки видео") \
+  X(remote_update_title, u8"被控端版本过低", "Remote device needs an update", u8"Версия на удалённом устройстве устарела") \
+  X(remote_update, u8"请升级到最新版本。", "Please update to the latest version.", u8"Обновите её до последней версии.") \
+  X(remote_update_dismiss, u8"知道了", "Got it", u8"Понятно") \
+  X(video_settings_pending, u8"正在应用…", "Applying…", u8"Применение…") \
+  X(video_settings_failed, u8"调整失败，请重试。", "Could not apply settings. Try again.", u8"Не удалось применить настройки. Повторите попытку.") \
+  X(video_settings_unavailable, u8"连接建立后可调整，需被控端支持。", "Available when connected to a supported remote device.", u8"Доступно при подключении к поддерживаемому устройству.") \
   X(video_quality, u8"画面质量:", "Video Quality:", u8"Качество видео:")       \
   X(video_frame_rate, u8"画面采集帧率:",                                       \
     "Video Capture Frame Rate:", u8"Частота захвата видео:")                   \
@@ -140,7 +231,7 @@ struct TranslationRow {
     "Enable Hardware Video Codec:", u8"Использовать аппаратный кодек:")        \
   X(enable_turn, u8"启用中继服务:",                                            \
     "Enable TURN Service:", u8"Включить TURN-сервис:")                         \
-  X(enable_srtp, u8"启用SRTP:", "Enable SRTP:", u8"Включить SRTP:")            \
+  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",       \
@@ -149,8 +240,6 @@ struct TranslationRow {
     "Server Address:", u8"Адрес сервера:")                                     \
   X(self_hosted_server_port, u8"信令服务端口:",                                \
     "Signal Service Port:", u8"Порт сигнального сервиса:")                     \
-  X(self_hosted_server_coturn_server_port, u8"中继服务端口:",                  \
-    "Relay Service Port:", u8"Порт реле-сервиса:")                             \
   X(ok, u8"确认", "OK", u8"ОК")                                                \
   X(cancel, u8"取消", "Cancel", u8"Отмена")                                    \
   X(new_password, u8"请输入六位密码:",                                         \
@@ -184,8 +273,18 @@ struct TranslationRow {
   X(no_such_id, u8"无此ID", "No such ID", u8"ID не найден")                    \
   X(about, u8"关于", "About", u8"О программе")                                 \
   X(notification, u8"通知", "Notification", u8"Уведомление")                   \
+  X(new_version, u8"新版本", "New version", u8"Новая версия")                 \
   X(new_version_available, u8"新版本可用", "New Version Available",            \
     u8"Доступна новая версия")                                                 \
+  X(check_for_updates, u8"检查更新", "Check for updates",                     \
+    u8"Проверить обновления")                                                   \
+  X(checking_for_updates, u8"正在检查更新…", "Checking for updates…",         \
+    u8"Проверка обновлений…")                                                  \
+  X(up_to_date, u8"已是最新版本", "You're up to date",                         \
+    u8"Установлена последняя версия")                                          \
+  X(update_check_failed, u8"检查失败，请稍后重试",                             \
+    "Check failed. Please try again later.",                                    \
+    u8"Не удалось проверить обновления. Повторите позже.")                     \
   X(release_notes, u8"更新内容", "Release Notes", u8"Содержание обновления") \
   X(version, u8"版本", "Version", u8"Версия")                                  \
   X(release_date, u8"发布日期: ", "Release Date: ", u8"Дата релиза: ")         \
@@ -204,6 +303,8 @@ struct TranslationRow {
     "Confirm to delete this connection", u8"Удалить это подключение?")         \
   X(enable_autostart, u8"开机自启:", "Auto Start:", u8"Автозапуск:")           \
   X(enable_daemon, u8"启用守护进程:", "Enable Daemon:", u8"Включить демон:")   \
+  X(privacy_on_connect, u8"被连接时开启隐私屏:", "Privacy screen on connect:", \
+    u8"Приватность при подключении:")                                       \
   X(takes_effect_after_restart, u8"重启后生效", "Takes effect after restart",  \
     u8"Вступит в силу после перезапуска")                                      \
   X(select_file, u8"选择文件发送", "Select File to Send",                      \
@@ -222,9 +323,14 @@ struct TranslationRow {
     "File Transfer Save Path:", u8"Путь сохранения файлов:")                   \
   X(default_desktop, u8"桌面", "Desktop", u8"Рабочий стол")                    \
   X(resolution, u8"分辨率", "Res", u8"Разрешение")                             \
+  X(video_latency, u8"视频延时", "Video delay", u8"Задержка") \
+  X(connection_latency, u8"连接延时", "Connection RTT", u8"Задержка соединения") \
   X(connection_mode, u8"连接模式", "Mode", u8"Режим")                          \
   X(connection_mode_direct, u8"直连", "Direct", u8"Прямой")                    \
   X(connection_mode_relay, u8"中继", "Relay", u8"Релейный")                    \
+  X(transport_encryption, u8"加密传输", "Encryption", u8"Шифрование")         \
+  X(transport_encryption_enabled, u8"已开启", "Enabled", u8"Включено")         \
+  X(transport_encryption_disabled, u8"未开启", "Disabled", u8"Выключено")       \
   X(online, u8"在线", "Online", u8"Онлайн")                                    \
   X(offline, u8"离线", "Offline", u8"Офлайн")                                  \
   X(device_offline, u8"设备离线", "Device Offline", u8"Устройство офлайн")     \
@@ -237,8 +343,39 @@ struct TranslationRow {
   X(permission_required_message, u8"该应用需要授权以下权限:",                  \
     "The application requires the following permissions:",                     \
     u8"Для работы приложения требуются следующие разрешения:")                 \
+  X(wayland_notice_title, u8"Wayland 会话提示", "Wayland Session Notice",        \
+    u8"Уведомление о сеансе Wayland")                                          \
+  X(wayland_notice_subtitle, u8"检测到当前桌面会话使用 Wayland。",               \
+    "The current desktop session uses Wayland.",                              \
+    u8"Текущий сеанс рабочего стола использует Wayland.")                      \
+  X(wayland_permission_title, u8"每次共享均需本机授权",                        \
+    "Local approval required each time",                                      \
+    u8"Разрешение требуется каждый раз")                                      \
+  X(wayland_notice_message,                                                    \
+    u8"受 Wayland 安全机制限制，每次启动远程桌面共享时，"                      \
+    u8"均需在本机手动授权屏幕共享与远程控制，授权后方可正常使用。",             \
+    "Wayland security restrictions require you to authorize screen sharing "  \
+    "and remote control locally each time you start sharing this desktop. "   \
+    "Remote access is available only after authorization.",                    \
+    u8"Из-за ограничений безопасности Wayland при каждом запуске общего "       \
+    u8"доступа к рабочему столу необходимо вручную разрешать на этом "           \
+    u8"компьютере показ экрана и удалённое управление. Удалённый доступ "        \
+    u8"возможен только после разрешения.")                                     \
+  X(wayland_recommendation_title, u8"建议使用 X11（Xorg）",                      \
+    "X11 (Xorg) is recommended", u8"Рекомендуем X11 (Xorg)")                    \
+  X(wayland_recommendation_message,                                            \
+    u8"为便于持续使用远程桌面，建议注销当前桌面会话，"                        \
+    u8"在登录界面选择 X11（Xorg）会话后重新登录。",                            \
+    "For ongoing remote desktop access, we recommend logging out, selecting " \
+    "an X11 (Xorg) session on the login screen, and logging in again.",         \
+    u8"Для постоянного удалённого доступа рекомендуем завершить сеанс, "        \
+    u8"выбрать X11 (Xorg) на экране входа и войти снова.")                      \
+  X(wayland_notice_acknowledge, u8"我知道了", "Got it", u8"Понятно")            \
   X(show_main_window, u8"显示主界面", "Show Main Window",                    \
     u8"Показать главное окно")                                                \
+  X(privacy_screen_unlock_hint, u8"按下快捷键，解除隐私屏",                    \
+    "To turn off the privacy screen, press",                                 \
+    u8"Чтобы отключить приватный экран, нажмите")                             \
   X(exit_program, u8"退出", "Exit", u8"Выход")
 
 inline constexpr TranslationRow kTranslationRows[] = {

apps/desktop/src/gui/features/clipboard/clipboard_controller.cpp

@@ -1,5 +1,9 @@
 #include "features/clipboard/clipboard_controller.h"
 
+#include <SDL3/SDL_clipboard.h>
+#include <SDL3/SDL_error.h>
+#include <SDL3/SDL_events.h>
+
 #include <cstring>
 #include <shared_mutex>
 #include <utility>

apps/desktop/src/gui/features/clipboard/clipboard_controller.h

@@ -1,7 +1,11 @@
-#ifndef CROSSDESK_GUI_CLIPBOARD_CONTROLLER_H_
-#define CROSSDESK_GUI_CLIPBOARD_CONTROLLER_H_
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-25
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
 
-#include <SDL3/SDL.h>
+#ifndef _CLIPBOARD_CONTROLLER_H_
+#define _CLIPBOARD_CONTROLLER_H_
 
 #include <atomic>
 #include <cstddef>
@@ -42,4 +46,4 @@ private:
 
 } // namespace crossdesk
 
-#endif // CROSSDESK_GUI_CLIPBOARD_CONTROLLER_H_
+#endif // _CLIPBOARD_CONTROLLER_H_

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

@@ -1,14 +1,27 @@
 #include "features/devices/session_device_manager.h"
 
-#include <remote_action.h>
-
-#include <chrono>
-#include <cstdlib>
+#include <SDL3/SDL_audio.h>
+#include <SDL3/SDL_error.h>
+#include <SDL3/SDL_init.h>
 
 #include <display_stream_id.h>
+#include <remote_action.h>
+
+#include <algorithm>
+#include <chrono>
+#include <cstdlib>
+#include <utility>
+
+#include "device_controller_factory.h"
+#include "screen_capturer_factory.h"
 #include "platform.h"
 #include "rd_log.h"
 #include "runtime/gui_runtime.h"
+#include "speaker_capturer_factory.h"
+#ifdef _WIN32
+#include "platform/windows/screen_capturer/screen_capturer_win.h"
+#include "platform/windows/input/mouse/mouse_controller.h"
+#endif
 
 namespace crossdesk {
 namespace {
@@ -19,7 +32,23 @@ constexpr auto kFrameDeadlineTolerance = std::chrono::milliseconds(1);
 
 } // namespace
 
-SessionDeviceManager::SessionDeviceManager(GuiRuntime &owner) : owner_(owner) {}
+SessionDeviceManager::SessionDeviceManager(GuiRuntime &owner)
+    : owner_(owner),
+      speaker_capture_(
+          [] {
+            return std::unique_ptr<SpeakerCapturer>(
+                SpeakerCapturerFactory().Create());
+          },
+          [this](unsigned char *data, size_t size, const char *) {
+            if (!owner_.peer_) return;
+            MiniRtcAudioFrame frame{};
+            frame.data = reinterpret_cast<const char *>(data);
+            frame.size = size;
+            frame.captured_timestamp = GetSystemTimeMicros(owner_.peer_);
+            SendAudioFrame(owner_.peer_, &frame, owner_.audio_label_.c_str());
+          }) {}
+
+SessionDeviceManager::~SessionDeviceManager() { speaker_capture_.Shutdown(); }
 
 bool SessionDeviceManager::ShouldSendCapturedFrame(
     std::chrono::steady_clock::time_point now, int fps) {
@@ -38,10 +67,56 @@ bool SessionDeviceManager::ShouldSendCapturedFrame(
   return true;
 }
 
+void SessionDeviceManager::RecordCaptureCadence(
+    std::chrono::steady_clock::time_point now, int fps,
+    bool from_secure_desktop) {
+  std::lock_guard<std::mutex> lock(capture_metrics_mutex_);
+  if (capture_metrics_started_ == std::chrono::steady_clock::time_point{})
+    capture_metrics_started_ = now;
+  const auto elapsed_us = std::chrono::duration_cast<std::chrono::microseconds>(
+                              now - capture_metrics_started_)
+                              .count();
+  if (elapsed_us >= 2000000) {
+    if (capture_forwarded_) {
+      const char* source = capture_secure_callbacks_ == 0 ? "normal_desktop"
+                           : capture_secure_callbacks_ == capture_callbacks_
+                               ? "secure_desktop"
+                               : "mixed";
+      LOG_DEBUG(
+          "Capture delivery: source={} normal_callbacks={} secure_callbacks={} "
+          "target_fps={} input_fps={:.2f} "
+          "forwarded_fps={:.2f} callbacks={} rate_dropped={} "
+          "forwarded={} send_errors={} max_callback_gap_us={} "
+          "send_avg_us={} send_max_us={} window_ms={}",
+          source, capture_callbacks_ - capture_secure_callbacks_,
+          capture_secure_callbacks_, fps,
+          capture_callbacks_ * 1000000.0 / elapsed_us,
+          capture_forwarded_ * 1000000.0 / elapsed_us, capture_callbacks_,
+          capture_rate_drops_, capture_forwarded_, capture_send_errors_,
+          capture_max_gap_us_, capture_send_us_ / capture_forwarded_,
+          capture_max_send_us_, elapsed_us / 1000);
+    }
+    capture_metrics_started_ = now;
+    capture_callbacks_ = capture_rate_drops_ = capture_forwarded_ = 0;
+    capture_secure_callbacks_ = 0;
+    capture_send_errors_ = 0;
+    capture_max_gap_us_ = capture_send_us_ = capture_max_send_us_ = 0;
+  }
+  if (last_capture_callback_ != std::chrono::steady_clock::time_point{}) {
+    capture_max_gap_us_ =
+        std::max<int64_t>(capture_max_gap_us_,
+                          std::chrono::duration_cast<std::chrono::microseconds>(
+                              now - last_capture_callback_)
+                              .count());
+  }
+  last_capture_callback_ = std::max(last_capture_callback_, now);
+  ++capture_callbacks_;
+  if (from_secure_desktop) ++capture_secure_callbacks_;
+}
+
 void SessionDeviceManager::Initialize() {
   InitializeAudioOutput();
   screen_capturer_factory_ = new ScreenCapturerFactory();
-  speaker_capturer_factory_ = new SpeakerCapturerFactory();
   device_controller_factory_ = new DeviceControllerFactory();
   keyboard_capturer_ =
       static_cast<KeyboardCapturer *>(device_controller_factory_->Create(
@@ -59,15 +134,26 @@ int SessionDeviceManager::InitializeScreenCapturer() {
     screen_capturer_ =
         static_cast<ScreenCapturer *>(screen_capturer_factory_->Create());
   }
+  screen_capturer_->SetPrivacyController(&owner_.privacy_);
+#ifdef _WIN32
+  if (auto windows = dynamic_cast<ScreenCapturerWin*>(screen_capturer_)) {
+    windows->SetCaptureMethod(owner_.config_center_->GetScreenCaptureMethod());
+  }
+#endif
 
   last_frame_time_ = {};
   next_frame_deadline_ = {};
-  const int fps = owner_.config_center_->GetVideoFrameRate() ==
-                          ConfigCenter::VIDEO_FRAME_RATE::FPS_30
-                      ? 30
-                      : 60;
+  capture_metrics_started_ = last_capture_callback_ = {};
+  capture_callbacks_ = capture_rate_drops_ = capture_forwarded_ = 0;
+  capture_secure_callbacks_ = 0;
+  capture_send_errors_ = 0;
+  capture_max_gap_us_ = capture_send_us_ = capture_max_send_us_ = 0;
+  // Keep the shared source ready for either live rate. MiniRTC admits 30/60
+  // frames independently per viewer, so switching never restarts native
+  // capture.
+  const int fps = 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;
@@ -77,7 +163,15 @@ int SessionDeviceManager::InitializeScreenCapturer() {
                        const char *display_name,
                        const MiniRtcNativeVideoFrame *native_frame) {
         const auto now_time = std::chrono::steady_clock::now();
+        bool from_secure_desktop = false;
+#ifdef _WIN32
+        from_secure_desktop =
+            ScreenCapturerWin::CurrentFrameIsFromSecureDesktop();
+#endif
+        RecordCaptureCadence(now_time, fps, from_secure_desktop);
         if (!ShouldSendCapturedFrame(now_time, fps)) {
+          std::lock_guard<std::mutex> lock(capture_metrics_mutex_);
+          ++capture_rate_drops_;
           return;
         }
 
@@ -131,7 +225,7 @@ int SessionDeviceManager::InitializeScreenCapturer() {
                                     last_video_frame_stream_id_ != stream_id;
         if (resumed_after_gap || stream_changed) {
           if (RequestVideoKeyFrame(owner_.peer_, stream_id.c_str()) == 0) {
-            LOG_INFO("Request video key frame before sending captured frame, "
+            LOG_DEBUG("Request video key frame before sending captured frame, "
                      "stream='{}', gap_ms={}, stream_changed={}",
                      stream_id, duration_ms, stream_changed);
           }
@@ -144,9 +238,24 @@ int SessionDeviceManager::InitializeScreenCapturer() {
         frame.height = height;
         frame.captured_timestamp = GetSystemTimeMicros(owner_.peer_);
         frame.native_frame = native_frame;
+        const auto send_started = std::chrono::steady_clock::now();
+        uint64_t send_errors = 0;
         for (const std::string &remote_id : connected_remote_ids) {
-          SendVideoFrameToPeer(owner_.peer_, &frame, stream_id.c_str(),
-                               remote_id.data(), remote_id.size());
+          if (SendVideoFrameToPeer(owner_.peer_, &frame, stream_id.c_str(),
+                                   remote_id.data(), remote_id.size()) != 0)
+            ++send_errors;
+        }
+        const auto send_us =
+            std::chrono::duration_cast<std::chrono::microseconds>(
+                std::chrono::steady_clock::now() - send_started)
+                .count();
+        {
+          std::lock_guard<std::mutex> lock(capture_metrics_mutex_);
+          ++capture_forwarded_;
+          capture_send_errors_ += send_errors;
+          capture_send_us_ += send_us;
+          capture_max_send_us_ =
+              std::max<int64_t>(capture_max_send_us_, send_us);
         }
         last_video_frame_stream_id_ = stream_id;
         last_frame_time_ = now_time;
@@ -154,11 +263,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;
   }
 
@@ -169,6 +278,15 @@ int SessionDeviceManager::InitializeScreenCapturer() {
   return -1;
 }
 
+bool SessionDeviceManager::ShouldCaptureCursor() const {
+  std::shared_lock lock(owner_.connection_status_mutex_);
+  return std::any_of(owner_.connection_status_.begin(),
+                     owner_.connection_status_.end(), [](const auto& entry) {
+    return entry.second == ConnectionStatus::Connected &&
+           entry.first.find("web") != std::string::npos;
+  });
+}
+
 int SessionDeviceManager::StartScreenCapturer() {
 #ifdef __APPLE__
   if (!owner_.EnsureMacScreenRecordingPermission()) {
@@ -184,8 +302,11 @@ int SessionDeviceManager::StartScreenCapturer() {
     }
   }
 
-  LOG_INFO("Start screen capturer, show cursor: {}", owner_.show_cursor_);
-  const int ret = screen_capturer_->Start(owner_.show_cursor_);
+  // Clear before sampling, so a change arriving after the sample remains pending.
+  cursor_capture_dirty_.store(false, std::memory_order_relaxed);
+  const bool show_cursor = ShouldCaptureCursor();
+  LOG_INFO("Start screen capturer, show cursor: {}", show_cursor);
+  const int ret = screen_capturer_->Start(show_cursor);
   if (ret != 0) {
     LOG_ERROR("Start screen capturer failed: {}", ret);
   }
@@ -200,45 +321,46 @@ int SessionDeviceManager::StopScreenCapturer() {
   return 0;
 }
 
-int SessionDeviceManager::StartSpeakerCapturer() {
-  if (!speaker_capturer_) {
-    speaker_capturer_ =
-        static_cast<SpeakerCapturer *>(speaker_capturer_factory_->Create());
-    const int init_ret = speaker_capturer_->Init(
-        [this](unsigned char *data, size_t size, const char *audio_name) {
-          MiniRtcAudioFrame frame{};
-          frame.data = reinterpret_cast<const char *>(data);
-          frame.size = size;
-          frame.captured_timestamp = GetSystemTimeMicros(owner_.peer_);
-          SendAudioFrame(owner_.peer_, &frame, owner_.audio_label_.c_str());
-        });
+#ifdef _WIN32
+void SessionDeviceManager::ReleaseRemoteMouseButtons() {
+  if (auto mouse = dynamic_cast<PlatformMouseController*>(mouse_controller_))
+    mouse->ReleasePressedButtons();
+}
+#endif
 
-    if (init_ret != 0) {
-      speaker_capturer_->Destroy();
-      delete speaker_capturer_;
-      speaker_capturer_ = nullptr;
-    }
-  }
-
-  if (!speaker_capturer_) {
-    return -1;
-  }
-
-  const int ret = speaker_capturer_->Start();
-  if (ret != 0) {
-    LOG_ERROR("Start speaker capturer failed: {}", ret);
-    return ret;
-  }
-  owner_.start_speaker_capturer_ = true;
-  return 0;
+void SessionDeviceManager::StartSpeakerCapturer() {
+  speaker_capture_.SetEnabled(true);
 }
 
-int SessionDeviceManager::StopSpeakerCapturer() {
-  if (speaker_capturer_) {
-    speaker_capturer_->Stop();
-    owner_.start_speaker_capturer_ = false;
+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;
   }
-  return 0;
+  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() {
@@ -265,14 +387,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));
@@ -281,7 +398,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();
@@ -301,6 +418,7 @@ int SessionDeviceManager::StopMouseController() {
 }
 
 int SessionDeviceManager::StartKeyboardCapturer() {
+  ClearCapturedKeyboardInput();
   owner_.keyboard_capturer_uses_window_events_ = false;
 
 #ifdef __APPLE__
@@ -336,6 +454,7 @@ int SessionDeviceManager::StartKeyboardCapturer() {
       },
       this);
   if (hook_ret != 0) {
+    keyboard_capturer_->Unhook();
     owner_.keyboard_capturer_uses_window_events_ = true;
     LOG_WARN(
         "Start keyboard capturer failed, falling back to Slint keyboard events");
@@ -346,6 +465,9 @@ int SessionDeviceManager::StartKeyboardCapturer() {
 }
 
 int SessionDeviceManager::StopKeyboardCapturer() {
+  owner_.keyboard_capturer_is_started_ = false;
+  if (keyboard_capturer_) keyboard_capturer_->Unhook();
+  ClearCapturedKeyboardInput();
   if (owner_.keyboard_capturer_uses_window_events_) {
     owner_.keyboard_capturer_uses_window_events_ = false;
     LOG_INFO("Stop keyboard capturer with Slint keyboard backend");
@@ -353,8 +475,6 @@ int SessionDeviceManager::StopKeyboardCapturer() {
   }
 
   if (keyboard_capturer_) {
-    keyboard_capturer_->Unhook();
-    ClearCapturedKeyboardInput();
     LOG_INFO("Stop keyboard capturer");
   }
   return 0;
@@ -424,6 +544,15 @@ void SessionDeviceManager::PushAudio(const char *data, size_t size) {
 }
 
 void SessionDeviceManager::UpdateInteractions() {
+#ifdef _WIN32
+  if (owner_.screen_capturer_is_started_ &&
+      cursor_capture_dirty_.load(std::memory_order_relaxed)) {
+    if (auto* windows = dynamic_cast<ScreenCapturerWin*>(screen_capturer_)) {
+      cursor_capture_dirty_.store(false, std::memory_order_relaxed);
+      windows->SetCursorCapture(ShouldCaptureCursor());
+    }
+  }
+#endif
 #if defined(__linux__) && !defined(__APPLE__)
   const bool is_wayland_session = IsWaylandSession();
   const bool stop_wayland_mouse_before_screen =
@@ -448,16 +577,6 @@ void SessionDeviceManager::UpdateInteractions() {
     owner_.screen_capturer_is_started_ = false;
   }
 
-  if (owner_.start_speaker_capturer_ && !owner_.speaker_capturer_is_started_) {
-    if (StartSpeakerCapturer() == 0) {
-      owner_.speaker_capturer_is_started_ = true;
-    }
-  } else if (!owner_.start_speaker_capturer_ &&
-             owner_.speaker_capturer_is_started_) {
-    StopSpeakerCapturer();
-    owner_.speaker_capturer_is_started_ = false;
-  }
-
   if (owner_.start_mouse_controller_ && !owner_.mouse_controller_is_started_) {
     if (StartMouseController() == 0) {
       owner_.mouse_controller_is_started_ = true;
@@ -468,22 +587,33 @@ 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) {
       owner_.keyboard_capturer_is_started_ = true;
     }
     if (owner_.keyboard_capturer_is_started_) {
+      if (!owner_.keyboard_capturer_uses_window_events_ &&
+          (!keyboard_capturer_ || !keyboard_capturer_->IsHookActive())) {
+        StopKeyboardCapturer();
+        owner_.keyboard_.ForceReleasePressedKeys();
+        owner_.keyboard_capturer_uses_window_events_ = true;
+        owner_.keyboard_capturer_is_started_ = true;
+        LOG_WARN("Native keyboard capture stopped; using Slint keyboard events");
+      }
       DrainCapturedKeyboardInput();
       owner_.keyboard_.SendHeartbeat(false);
     }
@@ -515,6 +645,7 @@ void SessionDeviceManager::DrainCapturedKeyboardInput() {
     std::lock_guard<std::mutex> lock(captured_keyboard_inputs_mutex_);
     inputs.swap(captured_keyboard_inputs_);
   }
+  if (owner_.privacy_.Snapshot().input_blocked) return;
   for (const CapturedKeyboardInput &input : inputs) {
     owner_.keyboard_.SendKeyCommand(input.key_code, input.is_down,
                                     input.scan_code, input.extended);
@@ -541,21 +672,45 @@ 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_) {
     mouse_controller_->Destroy();
     delete mouse_controller_;
@@ -566,11 +721,6 @@ void SessionDeviceManager::DestroyDevices() {
     delete screen_capturer_;
     screen_capturer_ = nullptr;
   }
-  if (speaker_capturer_) {
-    speaker_capturer_->Destroy();
-    delete speaker_capturer_;
-    speaker_capturer_ = nullptr;
-  }
   if (keyboard_capturer_) {
     delete keyboard_capturer_;
     keyboard_capturer_ = nullptr;
@@ -580,8 +730,6 @@ void SessionDeviceManager::DestroyDevices() {
 void SessionDeviceManager::DestroyFactories() {
   delete screen_capturer_factory_;
   screen_capturer_factory_ = nullptr;
-  delete speaker_capturer_factory_;
-  speaker_capturer_factory_ = nullptr;
   delete device_controller_factory_;
   device_controller_factory_ = nullptr;
 }

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

@@ -1,8 +1,14 @@
-#ifndef CROSSDESK_GUI_SESSION_DEVICE_MANAGER_H_
-#define CROSSDESK_GUI_SESSION_DEVICE_MANAGER_H_
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-09
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
 
-#include <SDL3/SDL.h>
+#ifndef _SESSION_DEVICE_MANAGER_H_
+#define _SESSION_DEVICE_MANAGER_H_
 
+
+#include <atomic>
 #include <chrono>
 #include <cstddef>
 #include <cstdint>
@@ -14,14 +20,17 @@
 #include <remote_action.h>
 
 #include "device_controller.h"
-#include "device_controller_factory.h"
 #include "display_info.h"
-#include "screen_capturer_factory.h"
-#include "speaker_capturer_factory.h"
+#include "speaker_capture_controller.h"
+
+struct SDL_AudioStream;
 
 namespace crossdesk {
 
 class GuiRuntime;
+class DeviceControllerFactory;
+class ScreenCapturerFactory;
+class ScreenCapturer;
 
 // Owns media capture/playback and remote input devices for the active GUI
 // session. GuiRuntime supplies application intent; this class handles device
@@ -29,17 +38,28 @@ class GuiRuntime;
 class SessionDeviceManager {
 public:
   explicit SessionDeviceManager(GuiRuntime &owner);
+  ~SessionDeviceManager();
 
   void Initialize();
   void UpdateInteractions();
+  // Call after changing the controller map. UpdateInteractions consumes this
+  // notification on the UI thread before reading the map under its mutex.
+  void OnControllerConnectionsChanged() {
+    cursor_capture_dirty_.store(true, std::memory_order_relaxed);
+  }
   void DestroyDevices();
   void DestroyFactories();
 
   int InitializeScreenCapturer();
   int StartScreenCapturer();
   int StopScreenCapturer();
-  int StartSpeakerCapturer();
-  int StopSpeakerCapturer();
+#ifdef _WIN32
+  void ReleaseRemoteMouseButtons();
+#endif
+  // Requests are asynchronous; Stop drains/revokes audio delivery before
+  // returning so the connection peer can be destroyed safely.
+  void StartSpeakerCapturer();
+  void StopSpeakerCapturer();
   int StartMouseController();
   int StopMouseController();
   int StartKeyboardCapturer();
@@ -55,7 +75,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 {
@@ -71,26 +96,41 @@ private:
   void ClearCapturedKeyboardInput();
   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);
 
   GuiRuntime &owner_;
   SDL_AudioStream *output_stream_ = nullptr;
   ScreenCapturerFactory *screen_capturer_factory_ = nullptr;
   ScreenCapturer *screen_capturer_ = nullptr;
-  SpeakerCapturerFactory *speaker_capturer_factory_ = nullptr;
-  SpeakerCapturer *speaker_capturer_ = nullptr;
+  std::atomic<bool> cursor_capture_dirty_{true};
+  SpeakerCaptureController speaker_capture_;
   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_;
   std::mutex captured_keyboard_inputs_mutex_;
   std::chrono::steady_clock::time_point last_frame_time_{};
   std::chrono::steady_clock::time_point next_frame_deadline_{};
+  std::mutex capture_metrics_mutex_;
+  std::chrono::steady_clock::time_point capture_metrics_started_{};
+  std::chrono::steady_clock::time_point last_capture_callback_{};
+  uint64_t capture_callbacks_ = 0, capture_rate_drops_ = 0;
+  uint64_t capture_secure_callbacks_ = 0;
+  uint64_t capture_forwarded_ = 0, capture_send_errors_ = 0;
+  int64_t capture_max_gap_us_ = 0;
+  int64_t capture_send_us_ = 0, capture_max_send_us_ = 0;
   std::string last_video_frame_stream_id_;
   bool invalid_video_stream_id_logged_ = false;
 };
 
 } // namespace crossdesk
 
-#endif // CROSSDESK_GUI_SESSION_DEVICE_MANAGER_H_
+#endif

apps/desktop/src/gui/features/file_transfer/file_transfer_manager.cpp

@@ -298,7 +298,7 @@ void FileTransferManager::HandleAck(const char *data, size_t size) {
   uint32_t rate_bps = 0;
   if (props) {
     const uint32_t bitrate =
-        props->net_traffic_stats_.data_outbound_stats.bitrate;
+        props->net_traffic_stats_.DataOutboundBitrate();
     if (bitrate > 0 && state->file_sending_.load()) {
       rate_bps = static_cast<uint32_t>(bitrate * 0.99f);
       const uint32_t current_rate = state->file_send_rate_bps_.load();

apps/desktop/src/gui/features/file_transfer/file_transfer_manager.h

@@ -12,7 +12,7 @@
 #include <string>
 #include <unordered_map>
 
-#include "runtime/gui_state.h"
+#include "runtime/remote_session.h"
 
 namespace crossdesk {
 

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
@@ -213,6 +215,9 @@ int KeyboardController::SendKeyCommand(int key_code, bool is_down,
 bool KeyboardController::InjectRemoteKey(int key_code, bool is_down,
                                          uint32_t scan_code, bool extended) {
 #if _WIN32
+  if (owner_.privacy_.Engaged() && !IsWindowsPrivacyDesktopAvailable()) {
+    owner_.privacy_.Fail("Secure desktop or locked session; privacy screen will turn off");
+  }
   if (owner_.local_service_status_received_ &&
       IsSecureDesktopInteractionRequired(owner_.local_interactive_stage_)) {
     const std::string response = SendCrossDeskSecureDesktopKeyInput(
@@ -246,6 +251,7 @@ bool KeyboardController::InjectRemoteKey(int key_code, bool is_down,
     return true;
   }
 #endif
+  // Recheck after the desktop query; key-up cleanup remains allowed while paused.
   return owner_.devices_.SendKeyboardCommand(key_code, is_down, scan_code,
                                              extended);
 }
@@ -342,11 +348,50 @@ void KeyboardController::ReleaseRemotePressedKeys(const std::string& remote_id,
              keys_to_release.size(), remote_id, reason ? reason : "unknown");
   }
   for (const PressedKey& key : keys_to_release) {
-    InjectRemoteKey(key.key_code, false, key.scan_code, key.extended);
+    if (!InjectRemoteKey(key.key_code, false, key.scan_code, key.extended)) {
+#ifdef _WIN32
+      if (owner_.privacy_.Engaged()) {
+        std::lock_guard lock(remote_states_mutex_);
+        pending_privacy_releases_[key.key_code] = key;
+      }
+#endif
+    }
   }
 }
 
+void KeyboardController::ReleaseAllRemotePressedKeys(const char* reason) {
+  std::vector<std::string> remotes;
+  {
+    std::lock_guard lock(remote_states_mutex_);
+    for (const auto& [id, state] : remote_states_) remotes.push_back(id);
+  }
+  for (const auto& id : remotes) ReleaseRemotePressedKeys(id, reason);
+  CheckRemoteTimeouts();
+}
+
 void KeyboardController::CheckRemoteTimeouts() {
+#ifdef _WIN32
+  bool pending = false;
+  {
+    std::lock_guard lock(remote_states_mutex_);
+    pending = !pending_privacy_releases_.empty();
+  }
+  // A key-up rejected on the secure desktop is retained until the ordinary
+  // desktop returns. Never route cleanup through the security UI helper.
+  if (pending && IsWindowsPrivacyDesktopAvailable()) {
+    std::unordered_map<int, PressedKey> releases;
+    {
+      std::lock_guard lock(remote_states_mutex_);
+      releases.swap(pending_privacy_releases_);
+    }
+    for (const auto& [code, key] : releases) {
+      if (!owner_.devices_.SendKeyboardCommand(code, false, key.scan_code, key.extended)) {
+        std::lock_guard lock(remote_states_mutex_);
+        pending_privacy_releases_[code] = key;
+      }
+    }
+  }
+#endif
   const uint32_t now = static_cast<uint32_t>(SDL_GetTicks());
   std::vector<std::string> timed_out_remotes;
   {

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

@@ -30,6 +30,7 @@ public:
                         const RemoteAction &remote_action);
   void ReleaseRemotePressedKeys(const std::string &remote_id,
                                 const char *reason);
+  void ReleaseAllRemotePressedKeys(const char* reason);
   void CheckRemoteTimeouts();
 
 private:
@@ -58,6 +59,9 @@ private:
   uint32_t last_heartbeat_tick_ = 0;
   std::unordered_map<std::string, RemoteState> remote_states_;
   std::mutex remote_states_mutex_;
+#ifdef _WIN32
+  std::unordered_map<int, PressedKey> pending_privacy_releases_;
+#endif
 };
 
 } // namespace crossdesk

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

@@ -9,6 +9,7 @@
 #include <fstream>
 #include <functional>
 #include <memory>
+#include <nlohmann/json.hpp>
 #include <string>
 #include <thread>
 
@@ -297,18 +298,11 @@ int SettingsManager::Load() {
 
   owner_.language_button_value_ = localization::detail::ClampLanguageIndex(
       static_cast<int>(owner_.config_center_->GetLanguage()));
-  owner_.video_quality_button_value_ =
-      static_cast<int>(owner_.config_center_->GetVideoQuality());
-  owner_.video_frame_rate_button_value_ =
-      static_cast<int>(owner_.config_center_->GetVideoFrameRate());
-  owner_.video_adaptation_policy_button_value_ =
-      static_cast<int>(owner_.config_center_->GetVideoAdaptationPolicy());
   owner_.video_encode_format_button_value_ =
       static_cast<int>(owner_.config_center_->GetVideoEncodeFormat());
   owner_.enable_hardware_video_codec_ =
       owner_.config_center_->IsHardwareVideoCodec();
   owner_.enable_turn_ = owner_.config_center_->IsEnableTurn();
-  owner_.enable_srtp_ = owner_.config_center_->IsEnableSrtp();
   owner_.enable_self_hosted_ = owner_.config_center_->IsSelfHosted();
   owner_.enable_autostart_ = owner_.config_center_->IsEnableAutostart();
   owner_.enable_daemon_ = owner_.config_center_->IsEnableDaemon();
@@ -325,17 +319,11 @@ int SettingsManager::Load() {
   owner_.file_transfer_save_path_last_ = saved_path;
 
   owner_.language_button_value_last_ = owner_.language_button_value_;
-  owner_.video_quality_button_value_last_ = owner_.video_quality_button_value_;
-  owner_.video_frame_rate_button_value_last_ =
-      owner_.video_frame_rate_button_value_;
-  owner_.video_adaptation_policy_button_value_last_ =
-      owner_.video_adaptation_policy_button_value_;
   owner_.video_encode_format_button_value_last_ =
       owner_.video_encode_format_button_value_;
   owner_.enable_hardware_video_codec_last_ =
       owner_.enable_hardware_video_codec_;
   owner_.enable_turn_last_ = owner_.enable_turn_;
-  owner_.enable_srtp_last_ = owner_.enable_srtp_;
   owner_.enable_self_hosted_last_ = owner_.enable_self_hosted_;
   owner_.enable_autostart_last_ = owner_.enable_autostart_;
 
@@ -598,22 +586,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);
@@ -60,8 +58,9 @@ private:
   struct CacheV1 {
     char client_id_with_password[17];
     int language;
-    int video_quality;
-    int video_frame_rate;
+    // Reserved legacy slots: retain the on-disk cache layout.
+    int legacy_video_quality;
+    int legacy_video_frame_rate;
     int video_encode_format;
     bool enable_hardware_video_codec;
     bool enable_turn;
@@ -73,8 +72,9 @@ private:
   struct CacheV2 {
     char client_id_with_password[17];
     int language;
-    int video_quality;
-    int video_frame_rate;
+    // Reserved legacy slots: retain the on-disk cache layout.
+    int legacy_video_quality;
+    int legacy_video_frame_rate;
     int video_encode_format;
     bool enable_hardware_video_codec;
     bool enable_turn;

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

@@ -1,4 +1,5 @@
 #include "rendering/slint_video_presenter.h"
+#include "crossdesk_ui.h"
 
 #include <libyuv.h>
 #include <slint.h>
@@ -86,6 +87,7 @@ struct SlintVideoPresenter::Impl {
   VideoRenderSize gl_image_size;
   VideoRenderSize gl_pending_size;
   bool gl_pending_dirty = false;
+  VideoLatencyFrame gl_pending_timing;
 #endif
 
   SurfaceState CurrentState() const {
@@ -154,10 +156,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();
@@ -193,6 +193,7 @@ struct SlintVideoPresenter::Impl {
             glPixelStorei(GL_UNPACK_ALIGNMENT, previous_unpack_alignment);
             glBindTexture(GL_TEXTURE_2D, static_cast<GLuint>(previous_texture));
             gl_pending_dirty = false;
+            gl_pending_timing.MarkSubmitted();
             return;
           }
 
@@ -323,7 +324,7 @@ SlintVideoPresenter::PresentResult SlintVideoPresenter::Present(
       impl_->seeded_frame_sequence[frame.remote_id] != frame.sequence) {
     const auto submit_result = impl_->renderer.SubmitCachedNv12(
         frame.remote_id, frame.nv12->data(), frame.nv12->size(), frame.width,
-        frame.height);
+        frame.height, frame.timing);
     if (submit_result == VideoRenderer::SubmitResult::submitted ||
         submit_result == VideoRenderer::SubmitResult::dropped) {
       impl_->seeded_frame_sequence[frame.remote_id] = frame.sequence;
@@ -335,8 +336,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) {
@@ -442,6 +442,7 @@ SlintVideoPresenter::PresentResult SlintVideoPresenter::Present(
       impl_->gl_pending_frame.swap(impl_->gl_conversion_frame);
       impl_->gl_pending_size = {output_width, output_height};
       impl_->gl_pending_dirty = true;
+      impl_->gl_pending_timing = frame.timing;
     }
     const VideoRenderSize output_size{output_width, output_height};
     if (impl_->gl_image_size != output_size) {
@@ -471,6 +472,7 @@ SlintVideoPresenter::PresentResult SlintVideoPresenter::Present(
   }
 
   (*impl_->stream)->set_frame(slint::Image(std::move(pixels)));
+  frame.timing.MarkSubmitted();
   (*impl_->stream)->set_has_frame(true);
   (*impl_->stream)->set_receiving_text("");
   result.width = frame.width;

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

@@ -14,7 +14,15 @@
 #include <string>
 #include <vector>
 
-#include "crossdesk_ui.h"
+#include "rendering/video_latency.h"
+
+namespace slint {
+template <typename T> class ComponentHandle;
+}
+
+namespace crossdesk::ui {
+class StreamWindow;
+}
 
 namespace crossdesk {
 
@@ -28,7 +36,6 @@ public:
   struct SurfaceState {
     std::string selected_stream;
     bool fullscreen = false;
-    size_t tab_count = 0;
   };
 
   struct Frame {
@@ -37,6 +44,7 @@ public:
     int width = 0;
     int height = 0;
     uint64_t sequence = 0;
+    VideoLatencyFrame timing;
   };
 
   struct PresentResult {
@@ -78,4 +86,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/rendering/video_latency.h

@@ -0,0 +1,110 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-26
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _VIDEO_LATENCY_H_
+#define _VIDEO_LATENCY_H_
+
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <deque>
+#include <memory>
+#include <mutex>
+#include <optional>
+
+namespace crossdesk {
+
+class VideoLatencyStats;
+
+// Travels with the exact queued pixels, including native frames. Its clock is
+// translated once at the receive callback; rendering needs no live PeerPtr.
+struct VideoLatencyFrame {
+  using Clock = std::chrono::steady_clock;
+  std::shared_ptr<VideoLatencyStats> stats;
+  uint64_t id = 0;
+  Clock::time_point capture_time{};
+  void MarkPresented(Clock::time_point now = Clock::now()) const;
+  // Fallback for renderers which expose submission but no presentation time.
+  void MarkSubmitted(Clock::time_point now = Clock::now()) const;
+};
+
+class VideoLatencyStats
+    : public std::enable_shared_from_this<VideoLatencyStats> {
+ public:
+  using Clock = VideoLatencyFrame::Clock;
+  struct Snapshot {
+    double average_ms;
+    size_t samples;
+  };
+
+  VideoLatencyFrame Frame(uint64_t captured_us, int64_t local_now_us,
+                          Clock::time_point now = Clock::now()) {
+    if (captured_us == 0 || local_now_us <= 0 ||
+        captured_us > uint64_t(local_now_us) ||
+        uint64_t(local_now_us) - captured_us > 5'000'000)
+      return {};
+    std::lock_guard lock(mutex_);
+    return {shared_from_this(), ++issued_id_,
+            now - std::chrono::microseconds(local_now_us - captured_us)};
+  }
+
+  void Record(const VideoLatencyFrame& frame, Clock::time_point now) {
+    std::lock_guard lock(mutex_);
+    // Redraws, cached snapshots and late completions must not count twice.
+    if (frame.id <= last_id_) return;
+    last_id_ = frame.id;
+    const double ms =
+        std::chrono::duration<double, std::milli>(now - frame.capture_time)
+            .count();
+    if (ms < 0 || ms > 5000) return;
+    samples_.push_back({now, ms});
+    Prune(now);
+  }
+
+  std::optional<Snapshot> Get(Clock::time_point now = Clock::now()) {
+    std::lock_guard lock(mutex_);
+    Prune(now);
+    if (samples_.empty()) return std::nullopt;
+    double sum = 0;
+    for (const auto& sample : samples_) {
+      sum += sample.ms;
+    }
+    return Snapshot{sum / samples_.size(), samples_.size()};
+  }
+
+  void Reset() {
+    std::lock_guard lock(mutex_);
+    samples_.clear();
+    last_id_ = issued_id_;  // Invalidate frames still held by a renderer.
+  }
+
+ private:
+  void Prune(Clock::time_point now) {
+    while (!samples_.empty() &&
+           (now - samples_.front().time > std::chrono::seconds(1) ||
+            samples_.size() > 240))
+      samples_.pop_front();
+  }
+  struct Sample {
+    Clock::time_point time;
+    double ms;
+  };
+  std::mutex mutex_;
+  uint64_t issued_id_ = 0;
+  uint64_t last_id_ = 0;
+  std::deque<Sample> samples_;
+};
+
+inline void VideoLatencyFrame::MarkSubmitted(Clock::time_point now) const {
+  MarkPresented(now);
+}
+
+inline void VideoLatencyFrame::MarkPresented(Clock::time_point now) const {
+  if (stats) stats->Record(*this, now);
+}
+}  // namespace crossdesk
+
+#endif

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

@@ -0,0 +1,483 @@
+#include "runtime/announcement_inbox.h"
+
+#include <openssl/sha.h>
+
+#include <algorithm>
+#include <charconv>
+#include <fstream>
+#include <set>
+#include <system_error>
+
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+namespace crossdesk {
+namespace {
+using nlohmann::json;
+bool Integer(const json& object, const char* key, int64_t low, int64_t high) {
+  return object.contains(key) && object[key].is_number_integer() &&
+         object[key] >= low && object[key] <= high;
+}
+std::string ScopeFilename(const std::string& scope) {
+  unsigned char digest[SHA256_DIGEST_LENGTH];
+  SHA256(reinterpret_cast<const unsigned char*>(scope.data()), scope.size(),
+         digest);
+  std::string name;
+  constexpr char hex[] = "0123456789abcdef";
+  for (auto byte : digest) {
+    name += hex[byte >> 4];
+    name += hex[byte & 15];
+  }
+  return name + ".json";
+}
+}  // namespace
+
+AnnouncementInbox::Snapshot AnnouncementInbox::Get() const {
+  std::lock_guard<std::mutex> lock(mutex_);
+  return state_;
+}
+uint64_t AnnouncementInbox::Version() const {
+  std::lock_guard<std::mutex> lock(mutex_);
+  return state_.version;
+}
+void AnnouncementInbox::SetStorageDirectory(
+    const std::filesystem::path& directory) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  directory_ = directory;
+}
+void AnnouncementInbox::Configure(std::string host, int port,
+                                  const std::string& device_id) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  if (directory_.empty() || host.empty() || port <= 0 || device_id.empty())
+    return;
+  for (auto& ch : host)
+    if (ch >= 'A' && ch <= 'Z') ch += 'a' - 'A';
+  if (host.back() == '.') host.pop_back();
+  const auto scope = json::array({host, port, device_id}).dump();
+  if (scope_ == scope) return;
+  scope_ = scope;
+  read_file_ = directory_ / ScopeFilename(scope);
+  const auto version = state_.version + 1;
+  state_ = {};
+  state_.version = version;
+  catalog_.clear();
+  catalog_revision_ = -1;
+  page_ids_.clear();
+  page_bodies_.clear();
+  visible_limit_ = 20;
+  LoadLocalState();
+  BeginCatalog();
+}
+void AnnouncementInbox::Reset() {
+  std::lock_guard<std::mutex> lock(mutex_);
+  const auto version = state_.version + 1;
+  state_ = {};
+  state_.version = version;
+  scope_.clear();
+  read_file_.clear();
+  reads_.clear();
+  dismissed_.clear();
+  page_ids_.clear();
+  page_bodies_.clear();
+  visible_limit_ = 20;
+  catalog_.clear();
+  catalog_revision_ = -1;
+  connected_ = false;
+  BeginCatalog();
+}
+void AnnouncementInbox::BeginCatalog() {
+  pending_catalog_.clear();
+  pending_revision_ = -1;
+  pending_total_ = 0;
+  phase_ = Phase::Catalog;
+  request_id_.clear();
+  state_.loading = false;
+  refresh_ = connected_;
+  ++state_.version;
+}
+void AnnouncementInbox::SetConnected(bool connected) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  connected_ = connected;
+  BeginCatalog();
+}
+void AnnouncementInbox::Refresh() {
+  std::lock_guard<std::mutex> lock(mutex_);
+  BeginCatalog();
+}
+void AnnouncementInbox::LoadMore() {
+  std::lock_guard<std::mutex> lock(mutex_);
+  if (!connected_ || state_.loading || refresh_ || state_.failed ||
+      catalog_revision_ < 0 || visible_limit_ >= state_.total)
+    return;
+  visible_limit_ += (std::min)(20, state_.total - visible_limit_);
+  RebuildVisibleItems();
+  ++state_.version;
+}
+void AnnouncementInbox::UpdateReadingState() {
+  state_.total = 0;
+  state_.unread = 0;
+  for (const auto& [id, revision] : catalog_) {
+    if (IsDismissed(id, revision)) continue;
+    ++state_.total;
+    const auto read = reads_.find(id);
+    if (read == reads_.end() || read->second != revision) ++state_.unread;
+  }
+  for (auto& item : state_.items) {
+    const auto read = reads_.find(item["id"]);
+    item["read"] = read != reads_.end() && read->second == item["revision"];
+  }
+}
+bool AnnouncementInbox::Read(int64_t id, int64_t revision) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  for (const auto& item : state_.items) {
+    if (item["id"] != id || item["revision"] != revision) continue;
+    if (item["read"].get<bool>()) return true;
+    auto updated = reads_;
+    updated[id] = revision;
+    if (!SaveLocalState(updated, dismissed_)) {
+      state_.read_save_failed = true;
+      ++state_.version;
+      return false;
+    }
+    reads_ = std::move(updated);
+    state_.read_save_failed = false;
+    state_.delete_failed = false;
+    UpdateReadingState();
+    ++state_.version;
+    return true;
+  }
+  return false;
+}
+bool AnnouncementInbox::IsDismissed(int64_t id, int64_t revision) const {
+  const auto found = dismissed_.find(id);
+  return found != dismissed_.end() && found->second == revision;
+}
+
+bool AnnouncementInbox::Dismiss(int64_t id, int64_t revision) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  for (const auto& item : state_.items) {
+    if (item["id"] != id || item["revision"] != revision) continue;
+    auto updated = dismissed_;
+    updated[id] = revision;
+    if (!SaveLocalState(reads_, updated)) {
+      state_.delete_failed = true;
+      ++state_.version;
+      return false;
+    }
+    dismissed_ = std::move(updated);
+    state_.delete_failed = false;
+    state_.read_save_failed = false;
+    // An index refresh already in flight must finish before reusing its order.
+    if (phase_ == Phase::Catalog && (state_.loading || refresh_)) {
+      auto visible = json::array();
+      for (const auto& current : state_.items)
+        if (!IsDismissed(current["id"], current["revision"]))
+          visible.push_back(current);
+      state_.items = std::move(visible);
+      UpdateReadingState();
+    } else {
+      request_id_.clear();
+      state_.loading = false;
+      RebuildVisibleItems();
+    }
+    ++state_.version;
+    return true;
+  }
+  // The confirmation may refer to an announcement updated while it was open.
+  state_.delete_failed = true;
+  ++state_.version;
+  return false;
+}
+
+void AnnouncementInbox::RebuildVisibleItems() {
+  UpdateReadingState();
+  const int wanted = (std::min)(visible_limit_, state_.total);
+  auto visible = json::array();
+  std::set<int> retained_pages;
+  int position = 0;
+  phase_ = Phase::Page;
+  refresh_ = false;
+  for (int physical = 0;
+       wanted > 0 && physical < static_cast<int>(catalog_.size());
+       physical += 20) {
+    const auto ids = page_ids_.find(physical);
+    if (ids == page_ids_.end()) {
+      pending_page_offset_ = physical;
+      refresh_ = connected_;
+      break;
+    }
+    std::set<int64_t> page_selection;
+    for (auto id : ids->second) {
+      const auto entry = catalog_.find(id);
+      if (entry == catalog_.end() || IsDismissed(id, entry->second)) continue;
+      if (position < wanted) page_selection.insert(id);
+      ++position;
+    }
+    if (page_selection.empty()) {
+      page_bodies_.erase(physical);
+      continue;
+    }
+    retained_pages.insert(physical);
+    const auto bodies = page_bodies_.find(physical);
+    if (bodies == page_bodies_.end()) {
+      pending_page_offset_ = physical;
+      refresh_ = connected_;
+      break;
+    }
+    for (const auto& item : bodies->second)
+      if (page_selection.count(item["id"])) visible.push_back(item);
+    if (visible.size() == static_cast<size_t>(wanted)) break;
+  }
+  if (visible.size() == static_cast<size_t>(wanted)) {
+    for (auto it = page_bodies_.begin(); it != page_bodies_.end();)
+      if (!retained_pages.count(it->first))
+        it = page_bodies_.erase(it);
+      else
+        ++it;
+  }
+  // A failed body fetch must not erase announcements already received. Keep
+  // still-published, unchanged versions until the replacement batch arrives.
+  if (visible.size() < static_cast<size_t>(wanted)) {
+    std::set<int64_t> retained_ids;
+    for (const auto& item : visible) retained_ids.insert(item["id"].get<int64_t>());
+    for (const auto& item : state_.items) {
+      const int64_t id = item["id"];
+      const auto current = catalog_.find(id);
+      if (current == catalog_.end() || current->second != item["revision"] ||
+          IsDismissed(id, current->second) || !retained_ids.insert(id).second)
+        continue;
+      visible.push_back(item);
+      if (visible.size() == static_cast<size_t>(wanted)) break;
+    }
+  }
+  state_.items = std::move(visible);
+  state_.loaded = true;
+  UpdateReadingState();
+}
+
+void AnnouncementInbox::Fail() {
+  request_id_.clear();
+  refresh_ = false;
+  state_.loading = false;
+  state_.failed = true;
+  ++state_.version;
+}
+nlohmann::json AnnouncementInbox::TakePendingRequest(
+    std::chrono::steady_clock::time_point now) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  if (!connected_ || scope_.empty()) return nullptr;
+  if (state_.loading && now >= deadline_) Fail();
+  if (!refresh_) return nullptr;
+  refresh_ = false;
+  request_id_ = std::to_string(++serial_);
+  state_.loading = true;
+  state_.failed = false;
+  ++state_.version;
+  deadline_ = now + std::chrono::seconds(12);
+  return {{"type", "announcements_list"},
+          {"request_id", request_id_},
+          {"summary_only", phase_ == Phase::Catalog},
+          {"offset", phase_ == Phase::Catalog
+                         ? static_cast<int>(pending_catalog_.size())
+                         : pending_page_offset_}};
+}
+void AnnouncementInbox::Failed(const std::string& request_id) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  if (request_id == request_id_) Fail();
+}
+void AnnouncementInbox::Receive(const nlohmann::json& message) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  if (!message.is_object() || !message.contains("request_id") ||
+      message["request_id"] != request_id_ || request_id_.empty())
+    return;
+  if (message.contains("error")) {
+    Fail();
+    return;
+  }
+  const bool summary = phase_ == Phase::Catalog;
+  const int limit = summary ? 200 : 20;
+  if (!Integer(message, "offset", 0, INT32_MAX) ||
+      !Integer(message, "total", 0, INT32_MAX) ||
+      !Integer(message, "catalog_revision", 0, INT64_MAX) ||
+      !message.contains("summary_only") || message["summary_only"] != summary ||
+      !message.contains("items") || !message["items"].is_array() ||
+      message["items"].size() > static_cast<size_t>(limit)) {
+    Fail();
+    return;
+  }
+  const int offset = message["offset"], total = message["total"];
+  const int64_t revision = message["catalog_revision"];
+  if (offset > total ||
+      message["items"].size() !=
+          static_cast<size_t>((std::min)(limit, total - offset))) {
+    Fail();
+    return;
+  }
+  const auto expected_revision =
+      summary ? pending_revision_ : catalog_revision_;
+  if (expected_revision >= 0 && expected_revision != revision) {
+    BeginCatalog();
+    return;
+  }
+  for (const auto& item : message["items"]) {
+    if (!item.is_object() || !Integer(item, "id", 1, INT64_MAX) ||
+        !Integer(item, "revision", 1, INT64_MAX)) {
+      Fail();
+      return;
+    }
+    if (!summary) {
+      if (!Integer(item, "updated_at", 1, 32503680000LL)) {
+        Fail();
+        return;
+      }
+      for (const auto* key : {"title", "body"}) {
+        if (!item.contains(key) || !item[key].is_string() ||
+            item[key].get_ref<const std::string&>().size() >
+                (std::string(key) == "title" ? 240u : 8000u)) {
+          Fail();
+          return;
+        }
+      }
+      const auto found = catalog_.find(item["id"]);
+      if (found == catalog_.end() || found->second != item["revision"]) {
+        Fail();
+        return;
+      }
+    }
+  }
+  request_id_.clear();
+  state_.loading = false;
+  if (summary) {
+    if (pending_revision_ < 0) {
+      pending_revision_ = revision;
+      pending_total_ = total;
+    }
+    if (pending_total_ != total ||
+        offset != static_cast<int>(pending_catalog_.size())) {
+      Fail();
+      return;
+    }
+    for (const auto& item : message["items"]) {
+      if (!pending_catalog_.emplace(item["id"], item["revision"]).second) {
+        Fail();
+        return;
+      }
+    }
+    if (static_cast<int>(pending_catalog_.size()) < total) {
+      refresh_ = true;
+      ++state_.version;
+      return;
+    }
+    if (catalog_revision_ != revision) {
+      page_ids_.clear();
+      page_bodies_.clear();
+    }
+    catalog_ = std::move(pending_catalog_);
+    catalog_revision_ = revision;
+    // Prune expired records in memory; the next local action persists them.
+    for (auto* records : {&reads_, &dismissed_}) {
+      for (auto it = records->begin(); it != records->end();)
+        if (!catalog_.count(it->first))
+          it = records->erase(it);
+        else
+          ++it;
+    }
+  } else {
+    if (total != static_cast<int>(catalog_.size())) {
+      Fail();
+      return;
+    }
+    if (offset != pending_page_offset_) {
+      Fail();
+      return;
+    }
+    std::set<int64_t> unique;
+    std::vector<int64_t> ids;
+    for (const auto& item : message["items"]) {
+      const int64_t id = item["id"];
+      if (!unique.insert(id).second) {
+        Fail();
+        return;
+      }
+      ids.push_back(id);
+    }
+    page_ids_[offset] = std::move(ids);
+    page_bodies_[offset] = message["items"];
+  }
+  RebuildVisibleItems();
+  state_.failed = false;
+  ++state_.version;
+}
+
+void AnnouncementInbox::LoadLocalState() {
+  reads_.clear();
+  dismissed_.clear();
+  std::error_code ec;
+  const auto size = std::filesystem::file_size(read_file_, ec);
+  if (ec || size > 16 * 1024 * 1024) return;
+  std::ifstream input(read_file_, std::ios::binary);
+  const auto data = json::parse(input, nullptr, false);
+  if (!data.is_object() || !data.contains("scope") || data["scope"] != scope_ ||
+      !data.contains("version") ||
+      (data["version"] != 1 && data["version"] != 2) ||
+      !data.contains("reads") || !data["reads"].is_object())
+    return;
+  const auto load = [](const json& entries, Revisions& destination) {
+    if (!entries.is_object()) return;
+    for (const auto& entry : entries.items()) {
+      int64_t id = 0;
+      const auto parsed = std::from_chars(
+          entry.key().data(), entry.key().data() + entry.key().size(), id);
+      if (parsed.ec == std::errc{} &&
+          parsed.ptr == entry.key().data() + entry.key().size() && id > 0 &&
+          entry.value().is_number_integer() && entry.value() > 0 &&
+          entry.value() <= INT64_MAX)
+        destination[id] = entry.value();
+    }
+  };
+  load(data["reads"], reads_);
+  if (data.contains("dismissed")) load(data["dismissed"], dismissed_);
+}
+bool AnnouncementInbox::SaveLocalState(const Revisions& reads,
+                                       const Revisions& dismissed) const {
+  if (read_file_.empty()) return false;
+  std::error_code ec;
+  std::filesystem::create_directories(directory_, ec);
+  if (ec) return false;
+  const auto encode = [](const Revisions& records) {
+    auto entries = json::object();
+    for (const auto& [id, revision] : records)
+      entries[std::to_string(id)] = revision;
+    return entries;
+  };
+  const auto payload = json({{"version", 2},
+                             {"scope", scope_},
+                             {"reads", encode(reads)},
+                             {"dismissed", encode(dismissed)}})
+                           .dump();
+  auto temporary = read_file_;
+  temporary += ".tmp-" +
+               std::to_string(
+                   std::chrono::steady_clock::now().time_since_epoch().count());
+  {
+    std::ofstream output(temporary, std::ios::binary | std::ios::trunc);
+    output.write(payload.data(), static_cast<std::streamsize>(payload.size()));
+    output.close();
+    if (!output) {
+      std::filesystem::remove(temporary, ec);
+      return false;
+    }
+  }
+#ifdef _WIN32
+  const bool saved =
+      MoveFileExW(temporary.c_str(), read_file_.c_str(),
+                  MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH) != 0;
+#else
+  std::filesystem::rename(temporary, read_file_, ec);
+  const bool saved = !ec;
+#endif
+  if (!saved) std::filesystem::remove(temporary, ec);
+  return saved;
+}
+}  // namespace crossdesk

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

@@ -0,0 +1,78 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-29
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _ANNOUNCEMENT_INBOX_H_
+#define _ANNOUNCEMENT_INBOX_H_
+
+#include <chrono>
+#include <cstdint>
+#include <filesystem>
+#include <map>
+#include <mutex>
+#include <nlohmann/json.hpp>
+#include <string>
+#include <vector>
+
+namespace crossdesk {
+// Announcement data is shared; read and dismissed versions stay on this device.
+class AnnouncementInbox {
+ public:
+  struct Snapshot {
+    nlohmann::json items = nlohmann::json::array();
+    int total = 0, unread = 0;
+    bool loaded = false, loading = false, failed = false;
+    bool read_save_failed = false;
+    bool delete_failed = false;
+    uint64_t version = 0;
+  };
+  Snapshot Get() const;
+  uint64_t Version() const;
+  void SetStorageDirectory(const std::filesystem::path& directory);
+  // Called on the UI thread after login supplies the actual device ID.
+  void Configure(std::string host, int port, const std::string& device_id);
+  void Reset();
+  void SetConnected(bool connected);
+  void Refresh();
+  void LoadMore();
+  bool Read(int64_t id, int64_t revision);
+  bool Dismiss(int64_t id, int64_t revision);
+  nlohmann::json TakePendingRequest(std::chrono::steady_clock::time_point now =
+                                        std::chrono::steady_clock::now());
+  void Failed(const std::string& request_id);
+  void Receive(const nlohmann::json& message);
+
+ private:
+  using Revisions = std::map<int64_t, int64_t>;
+  enum class Phase { Catalog, Page };
+  void BeginCatalog();
+  void Fail();
+  void UpdateReadingState();
+  bool IsDismissed(int64_t id, int64_t revision) const;
+  void RebuildVisibleItems();
+  void LoadLocalState();
+  bool SaveLocalState(const Revisions& reads, const Revisions& dismissed) const;
+
+  mutable std::mutex mutex_;
+  Snapshot state_;
+  std::filesystem::path directory_, read_file_;
+  std::string scope_, request_id_;
+  Revisions reads_, dismissed_, catalog_, pending_catalog_;
+  // Keep bodies for the loaded list prefix. Lightweight page IDs let us skip
+  // locally deleted entries without sending deletion state upstream.
+  std::map<int, std::vector<int64_t>> page_ids_;
+  std::map<int, nlohmann::json> page_bodies_;
+  int pending_page_offset_ = 0;
+  int visible_limit_ = 20;
+  int64_t catalog_revision_ = -1, pending_revision_ = -1;
+  int pending_total_ = 0;
+  Phase phase_ = Phase::Catalog;
+  bool connected_ = false, refresh_ = false;
+  uint64_t serial_ = 0;
+  std::chrono::steady_clock::time_point deadline_{};
+};
+}  // namespace crossdesk
+
+#endif

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

@@ -0,0 +1,59 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-26
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _CONNECTION_LATENCY_H_
+#define _CONNECTION_LATENCY_H_
+
+#include <chrono>
+#include <cmath>
+#include <mutex>
+#include <optional>
+
+namespace crossdesk::gui_detail {
+
+// Presentation-only smoothing. The transport's raw RTT remains available for
+// recovery, congestion control and diagnostics. A missing one-second report
+// does not flicker, but a disconnected/stalled peer cannot leave a stale value.
+class ConnectionLatencyStats {
+ public:
+  using Clock = std::chrono::steady_clock;
+
+  void Update(double rtt_ms, Clock::time_point now = Clock::now()) {
+    if (!std::isfinite(rtt_ms) || rtt_ms < 0 || rtt_ms > 2000) return;
+    std::lock_guard lock(mutex_);
+    if (average_ms_ && now < updated_) return;
+    if (!Fresh(now)) {
+      average_ms_ = rtt_ms;
+    } else {
+      *average_ms_ += 0.25 * (rtt_ms - *average_ms_);
+    }
+    updated_ = now;
+  }
+
+  std::optional<double> Get(Clock::time_point now = Clock::now()) const {
+    std::lock_guard lock(mutex_);
+    return Fresh(now) ? average_ms_ : std::nullopt;
+  }
+
+  void Reset() {
+    std::lock_guard lock(mutex_);
+    average_ms_.reset();
+  }
+
+ private:
+  bool Fresh(Clock::time_point now) const {
+    // The UI may snapshot `now` just before the report thread updates us.
+    // A newer valid report must not cause a one-frame unavailable flicker.
+    return average_ms_ && now - updated_ < std::chrono::seconds(3);
+  }
+  mutable std::mutex mutex_;
+  std::optional<double> average_ms_;
+  Clock::time_point updated_{};
+};
+
+}  // namespace crossdesk::gui_detail
+
+#endif

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

@@ -25,6 +25,16 @@ constexpr auto kPresenceRefreshInterval = std::chrono::seconds(30);
 constexpr auto kPresenceRetryInterval = std::chrono::seconds(1);
 }  // namespace
 
+bool GuiRuntime::HasActiveSession() {
+  if (stream_window_inited_) return true;
+  std::shared_lock lock(connection_status_mutex_);
+  return std::any_of(connection_status_.begin(), connection_status_.end(),
+                     [](const auto& entry) {
+                       return entry.second == ConnectionStatus::Connecting ||
+                              entry.second == ConnectionStatus::Connected;
+                     });
+}
+
 void GuiRuntime::HandleConnectionStatusChange() {
   if (!signal_connected_ || !peer_) {
     return;
@@ -121,36 +131,41 @@ void GuiRuntime::HandlePresenceProbeTimeout() {
 void GuiRuntime::HandleServerControllerDisconnected(
     const std::string& remote_id, const char* reason) {
   keyboard_.ReleaseRemotePressedKeys(remote_id, reason);
+#ifdef _WIN32
+  devices_.ReleaseRemoteMouseButtons();
+#endif
   {
     std::lock_guard lock(remote_pointer_input_mutex_);
     last_remote_pointer_input_time_.erase(remote_id);
   }
 
   bool has_connected_controller = false;
-  bool has_web_controller = false;
   std::string remaining_controller_id;
   {
     std::unique_lock lock(connection_status_mutex_);
     connection_status_.erase(remote_id);
+    devices_.OnControllerConnectionsChanged();
     connection_host_names_.erase(remote_id);
+    privacy_sessions_.Disconnected(remote_id);
     for (const auto& [id, status] : connection_status_) {
       if (status != ConnectionStatus::Connected) {
         continue;
       }
       has_connected_controller = true;
-      has_web_controller =
-          has_web_controller || id.find("web") != std::string::npos;
       if (remaining_controller_id.empty()) {
         remaining_controller_id = id;
       }
     }
   }
-  show_cursor_ = has_web_controller;
   if (has_connected_controller) {
     remote_client_id_ = remaining_controller_id;
     return;
   }
 
+  LOG_INFO("Last remote controller disconnected; recovering privacy, reason={}",
+           reason ? reason : "unknown");
+  privacy_.Disconnected();
+
   need_to_create_server_window_.store(false, std::memory_order_release);
   need_to_destroy_server_window_.store(true, std::memory_order_release);
   is_server_mode_ = false;
@@ -168,14 +183,11 @@ void GuiRuntime::HandleServerControllerDisconnected(
 #else
   start_screen_capturer_ = false;
 #endif
-  start_speaker_capturer_ = false;
+  devices_.StopSpeakerCapturer();
   start_mouse_controller_ = false;
   start_keyboard_capturer_ = false;
   remote_client_id_.clear();
-  if (audio_capture_) {
-    devices_.StopSpeakerCapturer();
-    audio_capture_ = false;
-  }
+  audio_capture_ = false;
   devices_.ResetToInitialDisplay();
 }
 
@@ -224,7 +236,8 @@ void GuiRuntime::CloseRemoteSession(std::shared_ptr<RemoteSession> props) {
   std::shared_ptr<std::vector<unsigned char>> frame_snapshot;
   int video_width = 0;
   int video_height = 0;
-  {
+  const bool save_preview = config_center_->IsSaveRemotePreviews();
+  if (save_preview) {
     std::lock_guard<std::mutex> lock(props->video_frame_mutex_);
     frame_snapshot = props->front_frame_;
     video_width = props->video_width_;
@@ -237,7 +250,8 @@ void GuiRuntime::CloseRemoteSession(std::shared_ptr<RemoteSession> props) {
     }
   }
   auto* native_renderer = video_renderer_.get();
-  if ((!frame_snapshot || frame_snapshot->empty()) && native_renderer) {
+  if (save_preview && (!frame_snapshot || frame_snapshot->empty()) &&
+      native_renderer) {
     auto native_snapshot = std::make_shared<std::vector<unsigned char>>();
     if (native_renderer->CopyLatestNv12(props->remote_id_,
                                         native_snapshot.get(), &video_width,
@@ -257,9 +271,14 @@ void GuiRuntime::CloseRemoteSession(std::shared_ptr<RemoteSession> props) {
     std::unique_lock lock(remote_sessions_mutex_);
     peer = std::exchange(props->peer_, nullptr);
   }
+  HostPlatform platform;
+  {
+    std::lock_guard lock(props->remote_version_mutex_);
+    platform = props->recent_platform_;
+  }
   const auto queued_at = std::chrono::steady_clock::now();
   session_cleanup_tasks_[props->remote_id_] = session_cleanup_queue_.PostTask(
-      [props, peer, frame_snapshot, video_width, video_height,
+      [props, peer, frame_snapshot, video_width, video_height, platform,
        thumbnail = thumbnail_, queued_at]() mutable {
         if (peer) {
           LOG_INFO("[{}] Background leave connection [{}]", props->local_id_,
@@ -267,12 +286,16 @@ void GuiRuntime::CloseRemoteSession(std::shared_ptr<RemoteSession> props) {
           LeaveConnection(peer, props->remote_id_.c_str());
           DestroyPeer(&peer);
         }
-        if (thumbnail && frame_snapshot && !frame_snapshot->empty() &&
-            video_width > 0 && video_height > 0) {
-          thumbnail->SaveToThumbnail(
-              reinterpret_cast<char*>(frame_snapshot->data()), video_width,
-              video_height, props->remote_id_, props->remote_host_name_,
-              props->remember_password_ ? props->remote_password_ : "");
+        if (thumbnail && props->was_connected_) {
+          const char* nv12 = frame_snapshot && !frame_snapshot->empty()
+              ? reinterpret_cast<const char*>(frame_snapshot->data()) : nullptr;
+          if (thumbnail->SaveToThumbnail(
+                  nv12, video_width, video_height, props->remote_id_,
+                  props->remote_host_name_,
+                  props->remember_password_ ? props->remote_password_ : "",
+                  platform) != 0) {
+            LOG_ERROR("[{}] Failed to save recent connection", props->remote_id_);
+          }
         }
         const auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
             std::chrono::steady_clock::now() - queued_at).count();
@@ -289,8 +312,12 @@ void GuiRuntime::CloseServerController(const std::string& remote_id) {
 }
 
 void GuiRuntime::CloseConnectionPeer() {
-  if (!peer_) return;
+  if (!peer_) {
+    announcements_.Reset();
+    return;
+  }
   peer_events_->Deactivate();
+  announcements_.Reset();
   std::vector<std::string> controllers;
   {
     std::shared_lock lock(connection_status_mutex_);
@@ -405,8 +432,11 @@ void GuiRuntime::WaitForSessionCleanup() {
 
 void GuiRuntime::ResetRemoteSessionResources(
     std::shared_ptr<RemoteSession> props) {
+  props->net_traffic_stats_.Reset();
   {
     std::lock_guard<std::mutex> lock(props->video_frame_mutex_);
+    props->video_latency_->Reset();
+    props->video_frame_timing_ = {};
     props->front_frame_.reset();
     props->back_frame_.reset();
     props->thumbnail_frame_.reset();
@@ -423,6 +453,7 @@ void GuiRuntime::ResetRemoteSessionResources(
     std::lock_guard<std::mutex> lock(props->remote_cursor_state_mutex_);
     props->remote_cursor_state_ = {};
     props->remote_cursor_state_received_ = false;
+    props->cursor_presentation_ = {};
   }
 }
 
@@ -464,7 +495,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;
@@ -483,13 +549,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;
 
@@ -505,7 +564,7 @@ int GuiRuntime::ConnectTo(const std::string& remote_id, const char* password,
         }
         AddAudioStream(props->peer_, props->audio_label_.c_str());
         AddDataStream(props->peer_, props->data_label_.c_str(), false);
-        AddDataStream(props->peer_, props->mouse_label_.c_str(), false);
+        AddDataStream(props->peer_, props->mouse_label_.c_str(), true);
         AddDataStream(props->peer_, props->keyboard_label_.c_str(), true);
         AddDataStream(props->peer_, props->control_data_label_.c_str(), true);
         AddDataStream(props->peer_, props->file_label_.c_str(), true);

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

@@ -0,0 +1,77 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-16
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _CURSOR_PRESENTATION_H_
+#define _CURSOR_PRESENTATION_H_
+
+#include <remote_action.h>
+
+#include <cstdint>
+#include <optional>
+
+namespace crossdesk {
+
+// All times use one monotonic millisecond clock. The owning session's cursor
+// mutex protects this policy from the transport and UI threads.
+class CursorPresentation {
+ public:
+  static constexpr uint64_t kStateTimeoutMs = 1500;  // Three 500ms heartbeats.
+  static constexpr uint64_t kInputActivityMs = 1500;
+
+  void Observe(const CursorState& state, uint64_t now) {
+    if (state.render_mode == CursorRenderMode::unknown) {
+      // Repeated unavailable samples must not extend the recovery deadline.
+      if (!sample_unavailable_) stale_at_ = now + kStateTimeoutMs;
+      sample_unavailable_ = true;
+      return;
+    }
+    sample_unavailable_ = false;
+    stale_at_ = now + kStateTimeoutMs;
+    const bool separate =
+        state.render_mode == CursorRenderMode::separate ||
+        (state.render_mode == CursorRenderMode::legacy && state.visible);
+    // Old senders cannot distinguish embedded from hidden. Only explicit
+    // metadata from a new sender can establish the no-device compatibility
+    // case.
+    no_device_ = state.render_mode == CursorRenderMode::hidden &&
+                 state.hidden_reason == CursorHiddenReason::no_pointing_device;
+    held_shape_ = separate ? state.shape : RemoteCursorShape::none;
+    if (held_shape_ != RemoteCursorShape::none) {
+      last_visible_shape_ = held_shape_;
+    }
+    if (!no_device_) fallback_engaged_ = false;
+  }
+
+  void NoteInput(uint64_t now) { last_input_ = now; }
+
+  RemoteCursorShape Resolve(uint64_t now) {
+    if (!stale_at_) return RemoteCursorShape::default_cursor;
+
+    const bool recent_input =
+        last_input_ && now - *last_input_ < kInputActivityMs;
+    const bool can_recover =
+        now >= *stale_at_ || (!sample_unavailable_ && no_device_);
+    if (can_recover && recent_input) {
+      fallback_engaged_ = true;
+    }
+    // Once needed, retain the locator while idle until a good non-compatibility
+    // sample arrives. Otherwise it would blink off whenever input pauses.
+    return fallback_engaged_ ? last_visible_shape_ : held_shape_;
+  }
+
+ private:
+  bool sample_unavailable_ = false;
+  bool no_device_ = false;
+  bool fallback_engaged_ = false;
+  std::optional<uint64_t> stale_at_;
+  std::optional<uint64_t> last_input_;
+  RemoteCursorShape held_shape_ = RemoteCursorShape::default_cursor;
+  RemoteCursorShape last_visible_shape_ = RemoteCursorShape::default_cursor;
+};
+
+}  // namespace crossdesk
+
+#endif

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

@@ -6,39 +6,17 @@
 
 #include <windows.h>
 
+#include "platform/windows/input/windows_cursor_state.h"
+#include "platform/windows/screen_capturer/captured_cursor_state.h"
+#include "platform/windows/screen_capturer/dxgi_cursor_state.h"
+#include "platform/windows/screen_capturer/secure_desktop_cursor_state.h"
 #include "runtime/cursor_position.h"
 
 namespace crossdesk {
-namespace {
 
-bool IsSystemCursor(HCURSOR cursor, LPCWSTR resource) {
-  return cursor != nullptr && cursor == LoadCursorW(nullptr, resource);
-}
-
-RemoteCursorShape ShapeFromWindowsCursor(HCURSOR cursor) {
-  if (IsSystemCursor(cursor, IDC_HELP)) return RemoteCursorShape::help;
-  if (IsSystemCursor(cursor, IDC_HAND)) return RemoteCursorShape::pointer;
-  if (IsSystemCursor(cursor, IDC_APPSTARTING))
-    return RemoteCursorShape::progress;
-  if (IsSystemCursor(cursor, IDC_WAIT)) return RemoteCursorShape::wait;
-  if (IsSystemCursor(cursor, IDC_CROSS)) return RemoteCursorShape::crosshair;
-  if (IsSystemCursor(cursor, IDC_IBEAM)) return RemoteCursorShape::text;
-  if (IsSystemCursor(cursor, IDC_NO))
-    return RemoteCursorShape::not_allowed;
-  if (IsSystemCursor(cursor, IDC_SIZEALL)) return RemoteCursorShape::move;
-  if (IsSystemCursor(cursor, IDC_SIZEWE)) return RemoteCursorShape::ew_resize;
-  if (IsSystemCursor(cursor, IDC_SIZENS)) return RemoteCursorShape::ns_resize;
-  if (IsSystemCursor(cursor, IDC_SIZENESW))
-    return RemoteCursorShape::nesw_resize;
-  if (IsSystemCursor(cursor, IDC_SIZENWSE))
-    return RemoteCursorShape::nwse_resize;
-  if (IsSystemCursor(cursor, IDC_UPARROW)) return RemoteCursorShape::n_resize;
-  return RemoteCursorShape::default_cursor;
-}
-
-}  // namespace
-
-struct CursorStateProvider::Impl {};
+struct CursorStateProvider::Impl {
+  WindowsCursorState cursor;
+};
 
 CursorStateProvider::CursorStateProvider() : impl_(std::make_unique<Impl>()) {}
 CursorStateProvider::~CursorStateProvider() = default;
@@ -47,16 +25,39 @@ bool CursorStateProvider::Sample(const std::vector<DisplayInfo>& displays,
                                  int preferred_display, CursorState* state) {
   if (!state) return false;
 
+  SecureDesktopCursorSnapshot secure_cursor{};
+  if (SharedSecureDesktopCursorState().Get(&secure_cursor)) {
+    if (!secure_cursor.valid) {
+      state->hidden_reason = CursorHiddenReason::secure_desktop_pending;
+      return false;
+    }
+    state->seq = 0;
+    NormalizeCursorPosition(secure_cursor.x, secure_cursor.y, displays,
+                            preferred_display, state);
+    state->visible = secure_cursor.visible != 0;
+    state->render_mode = static_cast<CursorRenderMode>(secure_cursor.render_mode);
+    state->hidden_reason =
+        static_cast<CursorHiddenReason>(secure_cursor.hidden_reason);
+    state->shape = state->visible
+                       ? static_cast<RemoteCursorShape>(secure_cursor.shape)
+                       : RemoteCursorShape::none;
+    return true;
+  }
+
   CURSORINFO info{};
   info.cbSize = sizeof(info);
   if (!GetCursorInfo(&info)) return false;
 
   state->seq = 0;
-  state->visible = (info.flags & CURSOR_SHOWING) != 0;
-  state->shape = state->visible ? ShapeFromWindowsCursor(info.hCursor)
-                                : RemoteCursorShape::none;
   NormalizeCursorPosition(info.ptScreenPos.x, info.ptScreenPos.y, displays,
                           preferred_display, state);
+  void* cursor_monitor = state->position_valid
+                             ? displays[state->display_id].handle
+                             : nullptr;
+  const bool embedded = SharedCapturedCursorState().IsEmbedded(cursor_monitor) ||
+      ((info.flags & CURSOR_SHOWING) != 0 &&
+       !SharedDxgiCursorState().ShouldDrawCursor(true, cursor_monitor));
+  impl_->cursor.Sample(info, embedded, state);
   return true;
 }
 

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

@@ -1,5 +1,7 @@
 #include "runtime/gui_runtime.h"
 
+#include <SDL3/SDL_timer.h>
+
 #include <algorithm>
 #include <chrono>
 #include <cstring>
@@ -14,6 +16,9 @@
 #include "localization.h"
 #include "platform/video_renderer.h"
 #include "rd_log.h"
+#ifdef __linux__
+#include "platform/linux/headless/headless_console.h"
+#endif
 
 namespace crossdesk {
 
@@ -34,12 +39,10 @@ int GuiRuntime::CreateConnectionPeer() {
 
   std::string signal_server_ip;
   int signal_server_port;
-  int coturn_server_port;
 
   if (config_center_->IsSelfHosted()) {
     signal_server_ip = config_center_->GetSignalServerHost();
     signal_server_port = config_center_->GetSignalServerPort();
-    coturn_server_port = config_center_->GetCoturnServerPort();
 
     std::string current_self_hosted_ip = config_center_->GetSignalServerHost();
     const bool use_cached_id = settings_.LoadCachedSelfHostedIdentity();
@@ -64,7 +67,6 @@ int GuiRuntime::CreateConnectionPeer() {
   } else {
     signal_server_ip = config_center_->GetDefaultServerHost();
     signal_server_port = config_center_->GetDefaultSignalServerPort();
-    coturn_server_port = config_center_->GetDefaultCoturnServerPort();
     settings_.ActivateCachedPublicIdentity();
     params_.user_id = client_id_with_password_;
   }
@@ -95,6 +97,11 @@ int GuiRuntime::CreateConnectionPeer() {
 
   const char *active_identity =
       self_hosted ? self_hosted_user_id_ : client_id_with_password_;
+#ifdef __linux__
+  // Publish the committed identity; an unconfirmed recovery credential must
+  // not be advertised as the current connection password.
+  HeadlessConsole::Instance().SetIdentity(active_identity);
+#endif
   const std::string login_identity =
       try_pending_identity ? pending_identity : std::string(active_identity);
   std::memset(connection_login_identity_, 0,
@@ -115,34 +122,11 @@ int GuiRuntime::CreateConnectionPeer() {
   } else {
     signal_server_port_self_[0] = '\0';
   }
-  int coturn_port = config_center_->GetCoturnServerPort();
-  if (coturn_port > 0) {
-    strncpy(coturn_server_port_self_, std::to_string(coturn_port).c_str(),
-            sizeof(coturn_server_port_self_) - 1);
-    coturn_server_port_self_[sizeof(coturn_server_port_self_) - 1] = '\0';
-  } else {
-    coturn_server_port_self_[0] = '\0';
-  }
-
   // peer config
   strncpy((char *)params_.signal_server_ip, signal_server_ip.c_str(),
           sizeof(params_.signal_server_ip) - 1);
   params_.signal_server_ip[sizeof(params_.signal_server_ip) - 1] = '\0';
   params_.signal_server_port = signal_server_port;
-  strncpy((char *)params_.stun_server_ip, signal_server_ip.c_str(),
-          sizeof(params_.stun_server_ip) - 1);
-  params_.stun_server_ip[sizeof(params_.stun_server_ip) - 1] = '\0';
-  params_.stun_server_port = coturn_server_port;
-  strncpy((char *)params_.turn_server_ip, signal_server_ip.c_str(),
-          sizeof(params_.turn_server_ip) - 1);
-  params_.turn_server_ip[sizeof(params_.turn_server_ip) - 1] = '\0';
-  params_.turn_server_port = coturn_server_port;
-  // TURN credentials are issued by the signaling server after login. Keep the
-  // initial values empty so a reusable static password is never embedded in
-  // the client binary.
-  params_.turn_server_username[0] = '\0';
-  params_.turn_server_password[0] = '\0';
-
   strncpy(params_.log_path, dll_log_path_.c_str(),
           sizeof(params_.log_path) - 1);
   params_.log_path[sizeof(params_.log_path) - 1] = '\0';
@@ -162,28 +146,12 @@ int GuiRuntime::CreateConnectionPeer() {
   params_.turn_mode = static_cast<TurnMode>(config_center_->GetTurnMode());
   params_.enable_srtp = config_center_->IsEnableSrtp();
   params_.video_content_type = VideoContentType::ScreenContent;
-  params_.video_quality =
-      static_cast<VideoQuality>(config_center_->GetVideoQuality());
-  params_.video_frame_rate =
-      config_center_->GetVideoFrameRate() ==
-              ConfigCenter::VIDEO_FRAME_RATE::FPS_30
-          ? 30
-          : 60;
-  switch (config_center_->GetVideoAdaptationPolicy()) {
-    case ConfigCenter::VIDEO_ADAPTATION_POLICY::FRAME_RATE_PRIORITY:
-      params_.video_degradation_preference =
-          VideoDegradationPreference::MaintainFrameRate;
-      break;
-    case ConfigCenter::VIDEO_ADAPTATION_POLICY::BALANCED:
-      params_.video_degradation_preference =
-          VideoDegradationPreference::Balanced;
-      break;
-    case ConfigCenter::VIDEO_ADAPTATION_POLICY::QUALITY_PRIORITY:
-    default:
-      params_.video_degradation_preference =
-          VideoDegradationPreference::MaintainResolution;
-      break;
-  }
+  // Bootstrap outgoing media with fixed defaults. Live overrides come only
+  // from the authorized controller and apply to its connection on this host.
+  params_.video_quality = VideoQuality::QualityHigh;
+  params_.video_frame_rate = 60;
+  params_.video_degradation_preference =
+      VideoDegradationPreference::MaintainResolution;
   params_.on_receive_video_buffer = nullptr;
   params_.on_receive_audio_buffer = PeerEventHandler::OnReceiveAudioBuffer;
   params_.on_receive_data_buffer = PeerEventHandler::OnReceiveDataBuffer;
@@ -225,7 +193,7 @@ int GuiRuntime::CreateConnectionPeer() {
 
     AddAudioStream(peer_, audio_label_.c_str());
     AddDataStream(peer_, data_label_.c_str(), false);
-    AddDataStream(peer_, mouse_label_.c_str(), false);
+    AddDataStream(peer_, mouse_label_.c_str(), true);
     AddDataStream(peer_, keyboard_label_.c_str(), true);
     AddDataStream(peer_, control_data_label_.c_str(), true);
     AddDataStream(peer_, file_label_.c_str(), true);
@@ -237,19 +205,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

@@ -8,6 +8,8 @@
 #define _GUI_RUNTIME_H_
 
 #include <atomic>
+#include <cstdint>
+#include <deque>
 #include <memory>
 #include <string>
 
@@ -16,15 +18,18 @@
 #include "features/file_transfer/file_transfer_manager.h"
 #include "features/input/keyboard_controller.h"
 #include "features/settings/settings_manager.h"
+#include "privacy_controller.h"
 #include "runtime/gui_state.h"
+#include "runtime/announcement_inbox.h"
 #include "runtime/peer_event_handler.h"
+#include "runtime/privacy_session_policy.h"
 
 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;
@@ -41,8 +46,8 @@ class GuiRuntime : protected gui_detail::GuiState {
   GuiRuntime();
   ~GuiRuntime();
 
-  static void SdlCaptureAudioIn(void* userdata, Uint8* stream, int len);
-  static void SdlCaptureAudioOut(void* userdata, Uint8* stream, int len);
+  static void SdlCaptureAudioIn(void* userdata, uint8_t* stream, int len);
+  static void SdlCaptureAudioOut(void* userdata, uint8_t* stream, int len);
 
   int CreateConnectionPeer();
   int ConnectTo(const std::string& remote_id, const char* password,
@@ -50,14 +55,21 @@ 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();
   void HandlePresenceProbeTimeout();
+  bool HasActiveSession();
   void HandleServerControllerDisconnected(const std::string& remote_id,
                                           const char* reason);
   void HandleWindowsServiceIntegration();
+  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);
   void CloseAllRemoteSessions();
@@ -87,6 +99,13 @@ class GuiRuntime : protected gui_detail::GuiState {
   bool EnsureMacAccessibilityPermission();
 #endif
 
+  PrivacyController privacy_;
+  AnnouncementInbox announcements_;
+  PrivacySessionPolicy privacy_sessions_;
+  std::mutex privacy_commands_mutex_;
+  std::deque<std::pair<std::string, PrivacyCommand>> privacy_commands_;
+  uint32_t last_privacy_revision_ = 0;
+  uint64_t last_privacy_status_tick_ = 0;
   ClipboardController clipboard_;
   SessionDeviceManager devices_;
   FileTransferManager transfers_;

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

@@ -0,0 +1,122 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-26
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _NET_TRAFFIC_STATS_CACHE_H_
+#define _NET_TRAFFIC_STATS_CACHE_H_
+
+#include <atomic>
+
+#include "minirtc.h"
+#include "runtime/connection_latency.h"
+
+namespace crossdesk::gui_detail {
+
+// Fields are independent observations and may come from different reports.
+// Relaxed accesses keep each field safe without publishing any other state.
+class NetTrafficStatsCache {
+  static_assert(std::atomic<uint32_t>::is_always_lock_free &&
+                    std::atomic<float>::is_always_lock_free &&
+                    std::atomic<double>::is_always_lock_free &&
+                    std::atomic<bool>::is_always_lock_free,
+                "Network statistics require lock-free scalar atomics");
+
+ public:
+  void Store(const MiniRtcNetTrafficStats& stats) {
+    video_inbound_stats_.Store(stats.video_inbound_stats);
+    video_outbound_stats_.Store(stats.video_outbound_stats);
+    audio_inbound_stats_.Store(stats.audio_inbound_stats);
+    audio_outbound_stats_.Store(stats.audio_outbound_stats);
+    data_inbound_stats_.Store(stats.data_inbound_stats);
+    data_outbound_stats_.Store(stats.data_outbound_stats);
+    total_inbound_stats_.Store(stats.total_inbound_stats);
+    total_outbound_stats_.Store(stats.total_outbound_stats);
+    srtp_active_.store(stats.srtp_active, std::memory_order_relaxed);
+    rtt_ms_.store(stats.rtt_ms, std::memory_order_relaxed);
+    connection_latency_.Update(stats.rtt_ms);
+  }
+
+  MiniRtcNetTrafficStats Load() const {
+    MiniRtcNetTrafficStats stats{};
+    stats.video_inbound_stats = video_inbound_stats_.Load();
+    stats.video_outbound_stats = video_outbound_stats_.Load();
+    stats.audio_inbound_stats = audio_inbound_stats_.Load();
+    stats.audio_outbound_stats = audio_outbound_stats_.Load();
+    stats.data_inbound_stats = data_inbound_stats_.Load();
+    stats.data_outbound_stats = data_outbound_stats_.Load();
+    stats.total_inbound_stats = total_inbound_stats_.Load();
+    stats.total_outbound_stats = total_outbound_stats_.Load();
+    stats.srtp_active = srtp_active_.load(std::memory_order_relaxed);
+    stats.rtt_ms = rtt_ms_.load(std::memory_order_relaxed);
+    return stats;
+  }
+
+  uint32_t DataOutboundBitrate() const {
+    return data_outbound_stats_.bitrate.load(std::memory_order_relaxed);
+  }
+
+  std::optional<double> SmoothedRttMs(
+      ConnectionLatencyStats::Clock::time_point now =
+          ConnectionLatencyStats::Clock::now()) const {
+    return connection_latency_.Get(now);
+  }
+
+  void ResetLatency() { connection_latency_.Reset(); }
+
+  void Reset() {
+    Store(MiniRtcNetTrafficStats{});
+    ResetLatency();
+  }
+
+ private:
+  struct InboundStats {
+    void Store(const MiniRtcInboundStats& stats) {
+      bitrate.store(stats.bitrate, std::memory_order_relaxed);
+      rtp_packet_count.store(stats.rtp_packet_count, std::memory_order_relaxed);
+      loss_rate.store(stats.loss_rate, std::memory_order_relaxed);
+    }
+
+    MiniRtcInboundStats Load() const {
+      return {bitrate.load(std::memory_order_relaxed),
+              rtp_packet_count.load(std::memory_order_relaxed),
+              loss_rate.load(std::memory_order_relaxed)};
+    }
+
+    std::atomic<uint32_t> bitrate{0};
+    std::atomic<uint32_t> rtp_packet_count{0};
+    std::atomic<float> loss_rate{0};
+  };
+
+  struct OutboundStats {
+    void Store(const MiniRtcOutboundStats& stats) {
+      bitrate.store(stats.bitrate, std::memory_order_relaxed);
+      rtp_packet_count.store(stats.rtp_packet_count, std::memory_order_relaxed);
+    }
+
+    MiniRtcOutboundStats Load() const {
+      return {bitrate.load(std::memory_order_relaxed),
+              rtp_packet_count.load(std::memory_order_relaxed)};
+    }
+
+    std::atomic<uint32_t> bitrate{0};
+    std::atomic<uint32_t> rtp_packet_count{0};
+  };
+
+  InboundStats video_inbound_stats_;
+  OutboundStats video_outbound_stats_;
+  InboundStats audio_inbound_stats_;
+  OutboundStats audio_outbound_stats_;
+  InboundStats data_inbound_stats_;
+  OutboundStats data_outbound_stats_;
+  InboundStats total_inbound_stats_;
+  OutboundStats total_outbound_stats_;
+  std::atomic<bool> srtp_active_{false};
+  std::atomic<double> rtt_ms_{-1};
+  ConnectionLatencyStats connection_latency_;
+};
+
+}  // namespace crossdesk::gui_detail
+
+#endif

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

@@ -1,6 +1,10 @@
+#include <SDL3/SDL_timer.h>
+
 #include "runtime/peer_event_handler.h"
 
+#include <app_version.h>
 #include <remote_action.h>
+#include <nlohmann/json.hpp>
 
 #include <algorithm>
 #include <chrono>
@@ -20,7 +24,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"
@@ -147,6 +150,87 @@ void PeerEventHandler::OnReceiveDataBuffer(
   }
 
   std::string remote_id(user_id, user_id_size);
+  if (remote_action.type == ControlType::video_settings_status) {
+    if (auto props = runtime->FindRemoteSession(remote_id)) {
+      if (source_id != props->control_data_label_) return;
+      std::lock_guard lock(props->video_settings_mutex_);
+      if (!props->video_settings_supported_) return;
+      if (remote_action.vs.accepted &&
+          static_cast<int32_t>(remote_action.vs.request_id -
+                               props->applied_video_settings_.request_id) >= 0) {
+        props->applied_video_settings_ = remote_action.vs;
+      }
+      if (remote_action.vs.request_id != props->video_settings_.request_id) return;
+      props->video_settings_pending_ = false;
+      props->video_settings_failed_ = !remote_action.vs.accepted;
+      if (remote_action.vs.accepted) {
+        props->video_settings_ = remote_action.vs;
+        props->applied_video_settings_ = remote_action.vs;
+      } else {
+        const auto request_id = props->video_settings_.request_id;
+        props->video_settings_ = props->applied_video_settings_;
+        props->video_settings_.request_id = request_id;
+      }
+    }
+    return;
+  }
+  if (remote_action.type == ControlType::video_settings) {
+    if (source_id != runtime->control_data_label_ ||
+        !runtime->IsAuthorizedController(remote_id))
+      return;
+    const auto& settings = remote_action.vs;
+    remote_action.vs.accepted =
+        UpdateVideoSettings(
+            runtime->peer_, remote_id.data(), remote_id.size(),
+            static_cast<VideoQuality>(settings.quality), settings.frame_rate,
+            static_cast<VideoDegradationPreference>(settings.preference)) == 0;
+    remote_action.type = ControlType::video_settings_status;
+    const auto message = remote_action.to_json();
+    SendReliableDataFrameToPeer(runtime->peer_, message.data(), message.size(),
+                                runtime->control_data_label_.c_str(),
+                                remote_id.data(), remote_id.size());
+    return;
+  }
+  if (remote_action.type == ControlType::privacy_status) {
+    if (auto props = runtime->FindRemoteSession(remote_id)) {
+      if (source_id != props->control_data_label_) return;
+      std::lock_guard lock(props->privacy_status_mutex_);
+      if (!props->privacy_status_received_ ||
+          static_cast<int32_t>(remote_action.ps.revision - props->privacy_status_.revision) >= 0) {
+        props->privacy_status_ = remote_action.ps;
+        props->privacy_status_received_ = true;
+        props->privacy_status_tick_ = SDL_GetTicks();
+        if (static_cast<int32_t>(remote_action.ps.revision - props->privacy_request_revision_) > 0 &&
+            remote_action.ps.state != PrivacyState::starting &&
+            remote_action.ps.state != PrivacyState::stopping)
+          props->privacy_command_pending_ = false;
+      }
+    }
+    return;
+  }
+  if (remote_action.type == ControlType::privacy_command) {
+    if (source_id == runtime->control_data_label_)
+      runtime->QueuePrivacyCommand(remote_id, remote_action.pc);
+    return;
+  }
+  const bool operates_host = remote_action.type == ControlType::mouse ||
+      remote_action.type == ControlType::keyboard || remote_action.type == ControlType::keyboard_state ||
+      remote_action.type == ControlType::service_command || remote_action.type == ControlType::display_id ||
+      remote_action.type == ControlType::audio_capture;
+  if (operates_host) {
+    if (!runtime->IsAuthorizedController(remote_id)) return;
+#ifdef _WIN32
+    // KeyboardController checks the desktop immediately before each native
+    // key injection, including state reconciliation and cleanup. Avoid a
+    // second synchronous session query for every received keyboard packet.
+    const bool keyboard_input = remote_action.type == ControlType::keyboard ||
+                                remote_action.type == ControlType::keyboard_state;
+    if (!keyboard_input && runtime->privacy_.Engaged() &&
+        !IsWindowsPrivacyDesktopAvailable()) {
+      runtime->privacy_.Fail("Secure desktop or lock screen; privacy screen will turn off");
+    }
+#endif
+  }
   if (remote_action.type == ControlType::service_status) {
     if (auto props = runtime->FindRemoteSession(remote_id)) {
       runtime->ApplyRemoteServiceStatus(*props, remote_action.ss);
@@ -155,6 +239,9 @@ void PeerEventHandler::OnReceiveDataBuffer(
   }
 
   if (remote_action.type == ControlType::service_command) {
+    if (runtime->privacy_.Engaged()) {
+      runtime->privacy_.Fail("Security shortcut requested; privacy screen will turn off");
+    }
 #if _WIN32
     if (remote_action.c.flag == ServiceCommandFlag::send_sas) {
       runtime->pending_windows_service_sas_.store(true,
@@ -191,7 +278,11 @@ void PeerEventHandler::OnReceiveDataBuffer(
       const bool changed =
           !props->remote_cursor_state_received_ ||
           props->remote_cursor_state_.visible != remote_action.cs.visible ||
-          props->remote_cursor_state_.shape != remote_action.cs.shape;
+          props->remote_cursor_state_.shape != remote_action.cs.shape ||
+          props->remote_cursor_state_.render_mode !=
+              remote_action.cs.render_mode ||
+          props->remote_cursor_state_.hidden_reason !=
+              remote_action.cs.hidden_reason;
       CursorState merged = remote_action.cs;
       if (!remote_action.cs.position_update &&
           props->remote_cursor_state_received_) {
@@ -202,10 +293,14 @@ void PeerEventHandler::OnReceiveDataBuffer(
       }
       props->remote_cursor_state_ = merged;
       props->remote_cursor_state_received_ = true;
+      props->cursor_presentation_.Observe(merged, SDL_GetTicks());
       if (changed) {
-        LOG_INFO("Received cursor state: seq={}, visible={}, shape={}",
+        LOG_DEBUG("Received cursor state: seq={}, visible={}, shape={}, "
+                 "mode={}, reason={}",
                  remote_action.cs.seq, remote_action.cs.visible,
-                 static_cast<int>(remote_action.cs.shape));
+                 static_cast<int>(remote_action.cs.shape),
+                 static_cast<int>(remote_action.cs.render_mode),
+                 static_cast<int>(remote_action.cs.hidden_reason));
       }
     }
     return;
@@ -224,6 +319,33 @@ void PeerEventHandler::OnReceiveDataBuffer(
     }
 
     if (is_client_mode) {
+      if (props && source_id == props->control_data_label_) {
+        std::lock_guard lock(props->remote_version_mutex_);
+        props->remote_host_info_received_ = true;
+        props->remote_platform_ = remote_action.i.platform;
+        props->recent_platform_ = remote_action.i.platform;
+        props->remote_app_version_ = IsValidAppVersion(remote_action.i.app_version)
+                                        ? remote_action.i.app_version : "";
+      }
+      // Negotiate live settings only on the reliable control stream. Old
+      // hosts omit this capability and retain their existing video behavior.
+      if (props && source_id == props->control_data_label_) {
+        std::lock_guard lock(props->video_settings_mutex_);
+        const bool first_advertisement = !props->video_settings_supported_;
+        props->video_settings_supported_ =
+            remote_action.i.supports_video_settings;
+        if (first_advertisement && props->video_settings_supported_) {
+          RemoteAction settings{};
+          settings.type = ControlType::video_settings;
+          ++props->video_settings_.request_id;
+          props->video_settings_pending_ = true;
+          props->video_settings_request_tick_ = SDL_GetTicks();
+          settings.vs = props->video_settings_;
+          const auto message = settings.to_json();
+          SendReliableDataFrame(props->peer_, message.data(), message.size(),
+                                props->control_data_label_.c_str());
+        }
+      }
       // client mode
       if (props && props->remote_host_name_.empty()) {
         props->remote_host_name_ = std::string(remote_action.i.host_name,
@@ -237,7 +359,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,
@@ -247,7 +369,11 @@ void PeerEventHandler::OnReceiveDataBuffer(
         runtime->connection_host_names_[remote_id] = host_name;
       }
       LOG_INFO("Remote hostname: [{}]", host_name);
-      remote_action_codec::Free(remote_action);
+      if (source_id == runtime->control_data_label_) {
+        runtime->SetControllerPrivacySupport(
+            remote_id, remote_action.i.supports_privacy_screen);
+      }
+      FreeRemoteAction(remote_action);
     }
   } else {
     // remote
@@ -298,9 +424,9 @@ void PeerEventHandler::OnReceiveDataBuffer(
       runtime->devices_.SendMouseCommand(remote_action,
                                         runtime->selected_display_);
     } else if (remote_action.type == ControlType::audio_capture) {
-      if (remote_action.a && !runtime->start_speaker_capturer_)
+      if (remote_action.a)
         runtime->devices_.StartSpeakerCapturer();
-      else if (!remote_action.a && runtime->start_speaker_capturer_)
+      else
         runtime->devices_.StopSpeakerCapturer();
     } else if (remote_action.type == ControlType::keyboard) {
       runtime->keyboard_.ApplyRemoteEvent(remote_id, remote_action);

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

@@ -1,6 +1,7 @@
 #include "runtime/peer_event_handler.h"
 
 #include <remote_action.h>
+#include <nlohmann/json.hpp>
 
 #include <algorithm>
 #include <chrono>
@@ -21,7 +22,9 @@
 #include "platform/video_renderer.h"
 #include "rd_log.h"
 #include "runtime/gui_runtime.h"
-#include "runtime/remote_action_codec.h"
+#ifdef __linux__
+#include "platform/linux/headless/headless_console.h"
+#endif
 
 #if _WIN32
 #include "interactive_state.h"
@@ -29,6 +32,19 @@
 #endif
 
 namespace crossdesk {
+namespace {
+
+#if defined(_WIN32)
+constexpr HostPlatform kClientPlatform = HostPlatform::Windows;
+#elif defined(__APPLE__)
+constexpr HostPlatform kClientPlatform = HostPlatform::MacOS;
+#elif defined(__linux__)
+constexpr HostPlatform kClientPlatform = HostPlatform::Linux;
+#else
+constexpr HostPlatform kClientPlatform = HostPlatform::Unknown;
+#endif
+
+}  // namespace
 
 void PeerEventHandler::SendClientInfo(PeerPtr* peer,
                                       const std::string& client_id) {
@@ -36,19 +52,9 @@ void PeerEventHandler::SendClientInfo(PeerPtr* peer,
     return;
   }
 
-#if defined(_WIN32)
-  constexpr const char* kClientPlatform = "windows";
-#elif defined(__APPLE__)
-  constexpr const char* kClientPlatform = "macos";
-#elif defined(__linux__)
-  constexpr const char* kClientPlatform = "linux";
-#else
-  constexpr const char* kClientPlatform = "unknown";
-#endif
-
   const nlohmann::json message = {{"type", "client_info"},
                                   {"version", CROSSDESK_VERSION},
-                                  {"platform", kClientPlatform}};
+                                  {"platform", HostPlatformName(kClientPlatform)}};
   const std::string payload = message.dump();
   if (SendSignalMessage(peer, payload.data(), payload.size()) != 0) {
     LOG_WARN("[{}] failed to report client information", client_id);
@@ -73,7 +79,11 @@ void PeerEventHandler::OnSignalMessage(const char* message, size_t size,
     return;
   }
   std::string type = j["type"].get<std::string>();
-  if (type == "presence") {
+  if (type == "announcements_changed") {
+    runtime->announcements_.Refresh();
+  } else if (type == "announcements") {
+    runtime->announcements_.Receive(j);
+  } else if (type == "presence") {
     if (j.contains("devices") && j["devices"].is_array()) {
       for (auto& dev : j["devices"]) {
         if (!dev.is_object()) {
@@ -166,6 +176,7 @@ void PeerEventHandler::OnSignalStatus(SignalStatus status, const char* user_id,
 
   std::string client_id(user_id, user_id_size);
   if (client_id == runtime->client_id_) {
+    runtime->announcements_.SetConnected(status == SignalStatus::SignalConnected);
     runtime->signal_status_ = status;
     runtime->device_presence_cache_.SetSignalConnected(
         status == SignalStatus::SignalConnected);
@@ -262,59 +273,34 @@ void PeerEventHandler::OnConnectionStatus(ConnectionStatus status,
           std::lock_guard lock(props->remote_cursor_state_mutex_);
           props->remote_cursor_state_ = {};
           props->remote_cursor_state_received_ = false;
+          props->cursor_presentation_ = {};
         }
         {
-          RemoteAction remote_action;
-          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, CROSSDESK_VERSION,
+              kClientPlatform);
+          remote_action.i.supports_video_settings = 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_) {
           runtime->need_to_create_stream_window_ = true;
         }
         props->connection_established_ = true;
+        props->was_connected_ = true;
         runtime->start_keyboard_capturer_ = true;
         break;
       }
@@ -324,12 +310,27 @@ void PeerEventHandler::OnConnectionStatus(ConnectionStatus status,
         runtime->keyboard_.ReleaseRemotePressedKeys(remote_id,
                                                     "connection_closed");
         props->connection_established_ = false;
+        {
+          std::lock_guard lock(props->remote_version_mutex_);
+          props->remote_host_info_received_ = false;
+          props->remote_app_version_.clear();
+          props->remote_platform_ = HostPlatform::Unknown;
+          props->remote_update_dismissed_ = false;
+        }
+        props->net_traffic_stats_.Reset();
         props->enable_mouse_control_ = false;
         runtime->ResetRemoteServiceStatus(*props);
+        {
+          std::lock_guard lock(props->video_settings_mutex_);
+          props->video_settings_supported_ = false;
+          props->video_settings_pending_ = false;
+          props->video_settings_failed_ = false;
+        }
         {
           std::lock_guard lock(props->remote_cursor_state_mutex_);
           props->remote_cursor_state_ = {};
           props->remote_cursor_state_received_ = false;
+          props->cursor_presentation_ = {};
         }
 
         std::shared_ptr<std::vector<unsigned char>> native_snapshot;
@@ -341,7 +342,8 @@ void PeerEventHandler::OnConnectionStatus(ConnectionStatus status,
           needs_native_snapshot =
               !props->thumbnail_frame_ || props->thumbnail_frame_->empty();
         }
-        if (needs_native_snapshot) {
+        if (needs_native_snapshot &&
+            runtime->config_center_->IsSaveRemotePreviews()) {
           auto* native_renderer = runtime->video_renderer_.get();
           auto snapshot = std::make_shared<std::vector<unsigned char>>();
           if (native_renderer &&
@@ -353,6 +355,8 @@ void PeerEventHandler::OnConnectionStatus(ConnectionStatus status,
         }
         {
           std::lock_guard<std::mutex> lock(props->video_frame_mutex_);
+          props->video_latency_->Reset();
+          props->video_frame_timing_ = {};
           props->front_frame_.reset();
           props->back_frame_.reset();
           if (native_snapshot &&
@@ -380,21 +384,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:
@@ -405,7 +394,15 @@ void PeerEventHandler::OnConnectionStatus(ConnectionStatus status,
     runtime->show_connection_status_window_ = true;
     {
       std::unique_lock lock(runtime->connection_status_mutex_);
+      if (status == ConnectionStatus::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());
+        runtime->ApplyPrivacyAdmission(automatic_enable);
+      }
       runtime->connection_status_[remote_id] = status;
+      runtime->devices_.OnControllerConnectionsChanged();
     }
 
     switch (status) {
@@ -414,52 +411,24 @@ void PeerEventHandler::OnConnectionStatus(ConnectionStatus status,
         runtime->last_windows_service_status_tick_ = 0;
 #endif
         {
-          RemoteAction remote_action;
-          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, CROSSDESK_VERSION,
+              kClientPlatform);
+          remote_action.i.supports_video_settings = 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(
@@ -468,19 +437,9 @@ void PeerEventHandler::OnConnectionStatus(ConnectionStatus status,
                                                      std::memory_order_release);
         runtime->is_server_mode_ = true;
         runtime->start_screen_capturer_ = true;
-        runtime->start_speaker_capturer_ = true;
+        runtime->devices_.StartSpeakerCapturer();
         runtime->remote_client_id_ = remote_id;
         runtime->start_mouse_controller_ = true;
-        {
-          std::shared_lock lock(runtime->connection_status_mutex_);
-          if (std::all_of(runtime->connection_status_.begin(),
-                          runtime->connection_status_.end(),
-                          [](const auto& kv) {
-                            return kv.first.find("web") != std::string::npos;
-                          })) {
-            runtime->show_cursor_ = true;
-          }
-        }
 
         break;
       }
@@ -562,12 +521,16 @@ void PeerEventHandler::OnNetStatusReport(
       LOG_INFO("Use client id [{}] and save id into cache file", id);
       runtime->settings_.Save();
     }
+#ifdef __linux__
+    HeadlessConsole::Instance().SetIdentity(id + "@" + password);
+#endif
   }
 
   std::string remote_id(user_id, user_id_size);
   auto props = runtime->FindRemoteSession(remote_id);
   if (!props) return;
   if (props->traversal_mode_ != mode) {
+    props->net_traffic_stats_.ResetLatency();
     props->traversal_mode_ = mode;
     LOG_INFO("Net mode: [{}]", int(props->traversal_mode_));
   }
@@ -578,7 +541,7 @@ void PeerEventHandler::OnNetStatusReport(
 
   // only display client side net status if connected to itself
   if (!(runtime->peer_reserved_ && !strstr(client_id, "C-"))) {
-    props->net_traffic_stats_ = *net_traffic_stats;
+    props->net_traffic_stats_.Store(*net_traffic_stats);
   }
 }
 }  // namespace crossdesk

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

@@ -36,7 +36,7 @@ void PeerEventHandler::OnReceiveVideoBuffer(
   auto callback = handler->EnterCallback();
   if (!callback) return;
   GuiRuntime* runtime = handler ? &handler->owner_ : nullptr;
-  if (!runtime) {
+  if (!runtime || !video_frame) {
     return;
   }
 
@@ -45,19 +45,43 @@ void PeerEventHandler::OnReceiveVideoBuffer(
   if (!props) return;
 
   if (props->connection_established_) {
+    const auto timing_now = VideoLatencyFrame::Clock::now();
+    const auto timing = props->video_latency_->Frame(
+        video_frame->captured_timestamp, GetSystemTimeMicros(props->peer_),
+        timing_now);
     bool background_snapshot_only = false;
     auto* native_renderer = runtime->video_renderer_.get();
     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, timing);
+        // 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), timing);
+          }
+        }
       } else
       {
         submit_result = native_renderer->SubmitNv12(
             remote_id, reinterpret_cast<const uint8_t*>(video_frame->data),
-            video_frame->size, video_frame->width, video_frame->height);
+            video_frame->size, video_frame->width, video_frame->height, timing);
       }
       if (submit_result == VideoRenderer::SubmitResult::submitted) {
         std::lock_guard<std::mutex> lock(props->video_frame_mutex_);
@@ -151,6 +175,7 @@ void PeerEventHandler::OnReceiveVideoBuffer(
       props->video_size_ = frame_size;
 
       props->front_frame_.swap(props->back_frame_);
+      props->video_frame_timing_ = timing;
       props->thumbnail_frame_ = props->front_frame_;
       props->thumbnail_width_ = video_frame->width;
       props->thumbnail_height_ = video_frame->height;

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

@@ -0,0 +1,53 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-12
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _PRIVACY_CONTROL_STATE_H_
+#define _PRIVACY_CONTROL_STATE_H_
+
+#include <cstdint>
+
+#include "remote_action.h"
+
+namespace crossdesk {
+
+struct PrivacyControlState {
+  bool active = false;
+  bool enabled = false;
+  bool off = false;
+  bool unsupported = false;
+  bool can_toggle = false;
+};
+
+// Use the same host-confirmed state for presentation and command admission.
+// Missing confirmation or a failure makes only this toolbar control unavailable.
+inline PrivacyControlState GetPrivacyControlState(
+    const PrivacyStatus& status, bool received, bool command_pending,
+    uint64_t status_age_ms, uint64_t command_age_ms) {
+  PrivacyControlState result;
+  const bool timeout = command_pending && command_age_ms > 15000;
+  result.unsupported = timeout ||
+      (received && (status_age_ms > 5000 || !status.supported ||
+                    status.state == PrivacyState::failed));
+  if (result.unsupported) return result;
+
+  result.active = status.overlay_active || status.remote_paused ||
+                  status.state == PrivacyState::on ||
+                  status.state == PrivacyState::starting ||
+                  status.state == PrivacyState::stopping ||
+                  status.state == PrivacyState::failed;
+  // A command in flight only gates repeated clicks; it adds no display state.
+  result.enabled = received &&
+                   status.state == PrivacyState::on && status.overlay_active &&
+                   !status.remote_paused;
+  result.off = received &&
+               status.state == PrivacyState::off && !result.active;
+  result.can_toggle = !command_pending && (result.active || received);
+  return result;
+}
+
+}  // namespace crossdesk
+
+#endif

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

@@ -0,0 +1,133 @@
+#include <SDL3/SDL_timer.h>
+
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-11
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#include <cstring>
+#include <shared_mutex>
+
+#include "rd_log.h"
+#include "runtime/gui_runtime.h"
+
+namespace crossdesk {
+
+bool GuiRuntime::IsAuthorizedController(const std::string& remote_id) {
+  // Connections appear here only after the existing password/signalling/RTC
+  // admission path. Outgoing/viewer sessions live in remote_sessions_ instead.
+  std::shared_lock lock(connection_status_mutex_);
+  const auto found = connection_status_.find(remote_id);
+  return found != connection_status_.end() &&
+         found->second == ConnectionStatus::Connected;
+}
+
+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()) 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) {
+    privacy_.EnableOnConnection();
+  }
+}
+
+void GuiRuntime::QueuePrivacyCommand(const std::string& remote_id,
+                                     const PrivacyCommand& command) {
+  std::shared_lock session_lock(connection_status_mutex_);
+  const auto found = connection_status_.find(remote_id);
+  if (found == connection_status_.end() ||
+      found->second != ConnectionStatus::Connected ||
+      !privacy_sessions_.Supports(remote_id)) return;
+  std::lock_guard lock(privacy_commands_mutex_);
+  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() {
+  std::deque<std::pair<std::string, PrivacyCommand>> commands;
+  {
+    std::lock_guard lock(privacy_commands_mutex_);
+    commands.swap(privacy_commands_);
+  }
+  for (const auto& [remote_id, command] : commands) {
+    // Keep admission and activation under the connection lock so an unknown
+    // controller cannot join between the capability check and enabling.
+    std::shared_lock lock(connection_status_mutex_);
+    const auto found = connection_status_.find(remote_id);
+    if (found == connection_status_.end() ||
+        found->second != ConnectionStatus::Connected ||
+        !privacy_sessions_.Supports(remote_id)) continue;
+    if (command.flag == PrivacyCommandFlag::enable) {
+      if (privacy_sessions_.CanEnable())
+        privacy_.Enable(command.block_local_input);
+    } else if (command.flag == PrivacyCommandFlag::disable) {
+      privacy_.Disable();
+    }
+    last_privacy_status_tick_ = 0;
+  }
+  PrivacyStatus status{};
+  const uint64_t now = SDL_GetTicks();
+  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))
+        controllers.push_back(id);
+    if (!privacy_sessions_.CanEnable()) {
+      status.state = PrivacyState::unsupported;
+      status.supported = false;
+      status.input_block_supported = false;
+      std::strcpy(status.reason,
+                  "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;
+  const auto message = action.to_json();
+  bool sent = true;
+  for (const auto& id : controllers) {
+    const int result = SendReliableDataFrameToPeer(
+        peer_, message.data(), message.size(), control_data_label_.c_str(),
+        id.data(), id.size());
+    if (result != 0) {
+      sent = false;
+      LOG_WARN("Privacy status send failed, peer={}, ret={}", id, result);
+    }
+  }
+  if (sent) {
+    last_privacy_revision_ = status.revision;
+    last_privacy_status_tick_ = now;
+  }
+}
+
+}  // namespace crossdesk

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

@@ -0,0 +1,80 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-15
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _PRIVACY_SESSION_POLICY_H_
+#define _PRIVACY_SESSION_POLICY_H_
+
+#include <algorithm>
+#include <string>
+#include <unordered_map>
+
+namespace crossdesk {
+
+// Guarded by GuiRuntime's connection_status_mutex_. Privacy covers the local
+// displays, so every connected controller must explicitly support its controls.
+class PrivacySessionPolicy {
+ public:
+  // 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 &&
+        !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();
+  }
+
+  // Consume automatic activation once, on the first controller's host info.
+  // Repeated metadata or a later join must not undo an explicit privacy exit.
+  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 && !IsWebController(remote_id);
+    if (automatic_controller_ != remote_id) return false;
+    automatic_controller_.clear();
+    return CanEnable();
+  }
+
+  bool Supports(const std::string& remote_id) const {
+    const auto entry = controllers_.find(remote_id);
+    return entry != controllers_.end() && entry->second;
+  }
+
+  bool CanEnable() const {
+    return !controllers_.empty() &&
+           std::all_of(controllers_.begin(), controllers_.end(),
+                       [](const auto& entry) { return entry.second; });
+  }
+
+ private:
+  std::unordered_map<std::string, bool> controllers_;
+  std::unordered_map<std::string, bool> early_support_;
+  std::string automatic_controller_;
+};
+
+}  // namespace crossdesk
+
+#endif

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

@@ -1,119 +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) {
-    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

@@ -22,7 +22,10 @@
 #include <remote_action.h>
 #include <stream_names.h>
 #include "display_info.h"
+#include "cursor_presentation.h"
 #include "minirtc.h"
+#include "rendering/video_latency.h"
+#include "runtime/net_traffic_stats_cache.h"
 
 namespace crossdesk { class PeerEventHandler; }
 
@@ -38,7 +41,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 {
@@ -85,6 +87,7 @@ struct RemoteSession {
   bool signal_connected_ = false;
   SignalStatus signal_status_ = SignalStatus::SignalClosed;
   bool connection_established_ = false;
+  std::atomic<bool> was_connected_{false};
   bool rejoin_ = false;
   bool net_traffic_stats_button_pressed_ = false;
   bool enable_mouse_control_ = true;
@@ -92,31 +95,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_;
@@ -130,33 +114,42 @@ 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;
+  VideoLatencyFrame video_frame_timing_;
+  std::shared_ptr<VideoLatencyStats> video_latency_ =
+      std::make_shared<VideoLatencyStats>();
   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_;
+  // Host metadata and dismissal state belong to this connection and are
+  // protected by remote_version_mutex_.
+  std::mutex remote_version_mutex_;
+  bool remote_host_info_received_ = false;
+  std::string remote_app_version_;
+  HostPlatform remote_platform_ = HostPlatform::Unknown;
+  // Retain history metadata after disconnect resets the live capabilities.
+  HostPlatform recent_platform_ = HostPlatform::Unknown;
+  bool remote_update_dismissed_ = false;
   bool remote_service_status_received_ = false;
+  std::mutex video_settings_mutex_;
+  // Requested and confirmed settings for this remote session only.
+  VideoSettings video_settings_{2, 60, 1};
+  bool video_settings_supported_ = false;
+  VideoSettings applied_video_settings_{2, 60, 1, 0, false};
+  bool video_settings_pending_ = false;
+  bool video_settings_failed_ = false;
+  uint64_t video_settings_request_tick_ = 0;
+  std::mutex privacy_status_mutex_;
+  PrivacyStatus privacy_status_{};
+  bool privacy_status_received_ = false;
+  bool privacy_command_pending_ = false;
+  uint64_t privacy_command_tick_ = 0;
+  uint32_t privacy_request_revision_ = 0;
+  uint64_t privacy_status_tick_ = 0;
   bool remote_service_available_ = false;
   std::string remote_interactive_stage_;
   std::vector<DisplayInfo> display_info_list_;
@@ -166,13 +159,16 @@ struct RemoteSession {
   std::mutex remote_cursor_state_mutex_;
   CursorState remote_cursor_state_{};
   bool remote_cursor_state_received_ = false;
+  CursorPresentation cursor_presentation_;
   // Shared by minirtc callbacks, Slint rendering and SDL audio callbacks.
   std::atomic<ConnectionStatus> connection_status_ = ConnectionStatus::Closed;
   TraversalMode traversal_mode_ = TraversalMode::UnknownMode;
   int fps_ = 0;
   int frame_count_ = 0;
   std::chrono::steady_clock::time_point last_time_;
-  MiniRtcNetTrafficStats net_traffic_stats_{};
+  // UI-thread snapshot refreshed with FPS once per second.
+  std::optional<VideoLatencyStats::Snapshot> video_latency_snapshot_;
+  NetTrafficStatsCache net_traffic_stats_;
 
   using QueuedFile = FileTransferState::QueuedFile;
   using FileTransferStatus = FileTransferState::FileTransferStatus;
@@ -184,4 +180,4 @@ using RemoteSessionPtr = std::shared_ptr<RemoteSession>;
 
 }  // namespace crossdesk::gui_detail
 
-#endif
+#endif

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,32 +122,22 @@ 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] = "";
   char self_hosted_user_id_[17] = "";
   char connection_login_identity_[17] = "";
   int language_button_value_ = 0;
-  int video_quality_button_value_ = 2;
-  int video_frame_rate_button_value_ = 1;
-  int video_adaptation_policy_button_value_ = 1;
   int video_encode_format_button_value_ = 0;
   bool enable_hardware_video_codec_ = true;
   bool enable_turn_ = true;
-  bool enable_srtp_ = false;
   char signal_server_ip_[256] = "api.crossdesk.cn";
   char signal_server_port_[6] = "9099";
-  char coturn_server_port_[6] = "3478";
   bool enable_self_hosted_ = false;
   int language_button_value_last_ = 0;
-  int video_quality_button_value_last_ = 0;
-  int video_frame_rate_button_value_last_ = 0;
-  int video_adaptation_policy_button_value_last_ = 1;
   int video_encode_format_button_value_last_ = 0;
   bool enable_hardware_video_codec_last_ = false;
   bool enable_turn_last_ = true;
-  bool enable_srtp_last_ = false;
   bool enable_self_hosted_last_ = false;
   bool enable_autostart_ = false;
   bool enable_autostart_last_ = false;
@@ -158,9 +147,6 @@ struct UserSettingsState {
   std::string file_transfer_save_path_last_;
   char signal_server_ip_self_[256] = "";
   char signal_server_port_self_[6] = "";
-  char coturn_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;
 };
@@ -208,7 +194,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/announcement_text.h

@@ -0,0 +1,161 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2026-09-29
+ * Copyright (c) 2026 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _ANNOUNCEMENT_TEXT_H_
+#define _ANNOUNCEMENT_TEXT_H_
+
+#include <slint.h>
+
+#include <algorithm>
+#include <cctype>
+#include <string>
+#include <string_view>
+
+namespace crossdesk::announcement_text {
+
+inline size_t WebSchemeLength(std::string_view url) {
+  for (const std::string_view prefix : {"https://", "http://"}) {
+    if (url.size() >= prefix.size() &&
+        std::equal(prefix.begin(), prefix.end(), url.begin(),
+                   [](char expected, unsigned char actual) {
+                     return expected == std::tolower(actual);
+                   })) {
+      return prefix.size();
+    }
+  }
+  return 0;
+}
+
+inline bool IsWebUrl(std::string_view url) {
+  const size_t scheme = WebSchemeLength(url);
+  if (!scheme || url.size() == scheme ||
+      std::any_of(url.begin(), url.end(), [](unsigned char ch) {
+        return ch <= 0x20 || ch == 0x7f || ch == '\\' || ch == '<' ||
+               ch == '>' || ch == '"';
+      })) {
+    return false;
+  }
+  const auto authority =
+      url.substr(scheme, url.find_first_of("/?#", scheme) - scheme);
+  return !authority.empty() && authority.back() != '@';
+}
+
+namespace detail {
+
+inline size_t UrlEnd(std::string_view text, size_t start) {
+  // Do not include surrounding prose punctuation in a bare URL. Balanced
+  // parentheses and IPv6 brackets are part of the address when present.
+  const std::string_view punctuation =
+      reinterpret_cast<const char*>(u8"，。；：！？、（）【】《》「」『』“”‘’");
+  int parentheses = 0, brackets = 0;
+  size_t end = start;
+  for (; end < text.size(); ++end) {
+    const unsigned char ch = text[end];
+    if (ch <= 0x20 || ch == 0x7f ||
+        std::string_view("<>\"'`\\{}").find(ch) != std::string_view::npos ||
+        (ch >= 0xe0 && end + 3 <= text.size() &&
+         punctuation.find(text.substr(end, 3)) != std::string_view::npos)) {
+      break;
+    }
+    if (ch == '(') ++parentheses;
+    if (ch == ')' && parentheses-- == 0) break;
+    if (ch == '[') ++brackets;
+    if (ch == ']' && brackets-- == 0) break;
+  }
+  return end;
+}
+
+inline void AppendLiteral(std::string& output, std::string_view text) {
+  for (const unsigned char ch : text) {
+    // Entity-encode spaces so leading indentation is not parsed as code.
+    if (ch == ' ') {
+      output += "&#32;";
+    } else if (ch == '\t') {
+      output += "&#9;";
+    } else {
+      if (ch < 0x80 && std::ispunct(ch)) output += '\\';
+      output += static_cast<char>(ch);
+    }
+  }
+}
+
+inline void AppendLink(std::string& output, std::string_view label,
+                       std::string_view url) {
+  output += '[';
+  AppendLiteral(output, label);
+  output += "](<";
+  for (const char ch : url) {
+    // Markdown decodes entities in link destinations; keep query strings exact.
+    if (ch == '&')
+      output += "&amp;";
+    else
+      output += ch;
+  }
+  output += ">)";
+}
+
+}  // namespace detail
+
+inline slint::StyledText Format(std::string_view body) {
+  std::string markdown;
+  markdown.reserve(body.size());
+  bool has_link = false;
+  for (size_t pos = 0; pos < body.size();) {
+    if (body[pos] == '[') {
+      const size_t label_end = body.find("](", pos + 1);
+      if (label_end != std::string_view::npos && label_end > pos + 1 &&
+          body.substr(pos + 1, label_end - pos - 1).find_first_of("[]\r\n") ==
+              std::string_view::npos &&
+          WebSchemeLength(body.substr(label_end + 2))) {
+        const size_t end = detail::UrlEnd(body, label_end + 2);
+        const auto url = body.substr(label_end + 2, end - label_end - 2);
+        if (end < body.size() && body[end] == ')' && IsWebUrl(url)) {
+          detail::AppendLink(markdown,
+                             body.substr(pos + 1, label_end - pos - 1), url);
+          pos = end + 1;
+          has_link = true;
+          continue;
+        }
+      }
+    }
+    if (WebSchemeLength(body.substr(pos))) {
+      size_t end = detail::UrlEnd(body, pos);
+      while (end > pos && std::string_view(".,;:!?").find(body[end - 1]) !=
+                              std::string_view::npos) {
+        --end;
+      }
+      const auto url = body.substr(pos, end - pos);
+      if (IsWebUrl(url)) {
+        detail::AppendLink(markdown, url, url);
+        pos = end;
+        has_link = true;
+        continue;
+      }
+    }
+    if (body[pos] == '\r' && pos + 1 < body.size() && body[pos + 1] == '\n') {
+      ++pos;
+      continue;
+    }
+    if (body[pos] == '\n') {
+      // Preserve empty lines instead of letting Markdown collapse them.
+      if (markdown.empty() || markdown.back() == '\n') markdown += "&#32;";
+      markdown += '\n';
+    } else {
+      detail::AppendLiteral(markdown, body.substr(pos, 1));
+    }
+    ++pos;
+  }
+  if (has_link) {
+    if (markdown.back() == '\n') markdown += "&#32;";
+    if (const auto styled = slint::StyledText::from_markdown(markdown))
+      return *styled;
+  }
+  return slint::StyledText::from_plain_text(body);
+}
+
+}  // namespace crossdesk::announcement_text
+
+#endif

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

@@ -41,10 +41,12 @@ 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}";
     out property <string> trash-can: "\u{f2ed}";
+    out property <string> user-secret: "\u{f21b}";
     out property <string> volume-high: "\u{f028}";
     out property <string> volume-xmark: "\u{f6a9}";
     out property <string> xmark: "\u{f00d}";
@@ -53,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;
@@ -68,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;
@@ -89,6 +93,7 @@ export component IconButton inherits Rectangle {
     }
 
     touch := TouchArea {
+        enabled: root.enabled;
         clicked => { root.clicked(); }
     }
 
@@ -334,6 +339,7 @@ export component MiniToggleSwitch inherits Rectangle {
 
 export component CompactButton inherits Rectangle {
     in property <string> text;
+    in property <length> text-size: ImGuiFontStyle.body;
     in property <bool> primary: false;
     in property <bool> enabled: true;
     callback clicked;
@@ -350,7 +356,7 @@ export component CompactButton inherits Rectangle {
     Text {
         text: root.text;
         color: root.enabled ? #24272d : #8e9298;
-        font-size: ImGuiFontStyle.body;
+        font-size: root.text-size;
         overflow: elide;
         horizontal-alignment: center;
         vertical-alignment: center;
@@ -360,6 +366,7 @@ export component CompactButton inherits Rectangle {
 
 export component PrimaryButton inherits Rectangle {
     in property <string> text;
+    in property <length> text-size: ImGuiFontStyle.body;
     in property <bool> enabled: true;
     callback clicked;
 
@@ -374,7 +381,7 @@ export component PrimaryButton inherits Rectangle {
     Text {
         text: root.text;
         color: white;
-        font-size: ImGuiFontStyle.body;
+        font-size: root.text-size;
         horizontal-alignment: center;
         vertical-alignment: center;
     }

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

@@ -1,5 +1,6 @@
 // Single AOT entry point. Generating one header for the entire UI avoids
 // duplicate imported-component definitions when C++ uses all three windows.
-export { MainWindow, RecentConnection, UiStrings } from "main_window.slint";
+export { AnnouncementItem, MessageStrings } from "message_panel.slint";
+export { MainWindow, RecentConnection, UpdateCheckStatus, UiStrings } from "main_window.slint";
 export { StreamWindow, StreamTab, FileTransferEntry, NetworkStatsRow, StreamStrings } from "stream_window.slint";
 export { ServerWindow, ControllerEntry } from "server_window.slint";

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

@@ -0,0 +1,249 @@
+import { ScrollView } from "std-widgets.slint";
+import { CompactButton, DialogSurface, IconButton, FontAwesomeIcons, ImGuiFontStyle } from "common.slint";
+
+export struct AnnouncementItem {
+    id: string,
+    revision: string,
+    title: string,
+    date: string,
+    read: bool,
+}
+
+export global MessageStrings {
+    in-out property <string> messages: "Messages";
+    in-out property <string> unread: "Unread";
+    in-out property <string> read: "Read";
+    in-out property <string> empty: "No announcements";
+    in-out property <string> select-message: "Select an announcement to read";
+    in-out property <string> loading: "Loading…";
+    in-out property <string> read-save-error: "Unable to save reading status locally. Open the announcement again to retry.";
+    in-out property <string> close: "Close";
+    in-out property <string> delete-message: "Delete";
+    in-out property <string> delete-title: "Delete announcement";
+    in-out property <string> delete-confirmation: "Delete this announcement?";
+    in-out property <string> delete-error: "Unable to delete this announcement. Please try again.";
+    in-out property <string> cancel: "Cancel";
+}
+
+export component MessagePanel inherits DialogSurface {
+    in property <[AnnouncementItem]> items;
+    in property <int> unread-count;
+    in property <int> total;
+    in property <bool> loading;
+    in property <bool> failed;
+    in property <bool> read-save-failed;
+    in property <bool> delete-failed;
+    in property <bool> loaded;
+    in property <bool> connected;
+    in property <string> selected-id;
+    in property <string> selected-title;
+    in property <styled-text> selected-body;
+    in property <string> selected-date;
+    in property <bool> selected-read;
+    callback open-message(string, string);
+    callback open-link(string);
+    callback delete-message(string, string);
+    callback load-more;
+    callback close;
+    private property <string> notice-text: root.delete-failed ? MessageStrings.delete-error
+        : root.read-save-failed ? MessageStrings.read-save-error : "";
+    private property <length> content-top: title-bar.height + (root.notice-text == "" ? 14px : 50px);
+    private property <color> separator-color: #e6e8eb;
+    private property <string> pending-delete-id;
+    private property <string> pending-delete-revision;
+    function request-delete(id: string, revision: string) {
+        root.pending-delete-id = id;
+        root.pending-delete-revision = revision;
+        confirmation-keys.focus();
+    }
+    confirmation-keys := FocusScope {
+        width: 0px; height: 0px;
+        key-pressed(event) => {
+            if event.text == Key.Escape {
+                if root.pending-delete-id != "" { root.pending-delete-id = ""; }
+                else { root.close(); }
+                return accept;
+            }
+            return reject;
+        }
+    }
+    background: white;
+    border-radius: 7px;
+    TouchArea { }
+    title-bar := Rectangle {
+        x: 0px; y: 0px; width: parent.width; height: 21px;
+        background: #d3d3d3; border-radius: 7px;
+        Rectangle { y: parent.height - 7px; height: 7px; background: #d3d3d3; }
+        message-heading := Text {
+            x: 6px; width: parent.width - 100px; height: parent.height;
+            text: MessageStrings.messages;
+            font-size: ImGuiFontStyle.base; font-weight: 600; color: #202124;
+            vertical-alignment: center; overflow: elide;
+        }
+        if root.unread-count > 0: Rectangle {
+            x: message-heading.x + message-heading.preferred-width + 8px;
+            y: (parent.height - self.height) / 2; height: 16px;
+            width: max(16px, unread-count-label.preferred-width + 8px);
+            border-radius: 8px; background: #eaf2ff;
+            accessible-role: text;
+            accessible-label: MessageStrings.unread + " " + root.unread-count;
+            unread-count-label := Text {
+                text: "" + root.unread-count; color: #2563eb;
+                font-size: ImGuiFontStyle.small; font-weight: 600;
+                horizontal-alignment: center; vertical-alignment: center;
+                accessible-role: none;
+            }
+        }
+        if root.loading: Text {
+            x: parent.width - 150px; width: 110px; height: parent.height;
+            text: MessageStrings.loading; color: #61656c; font-size: ImGuiFontStyle.small;
+            horizontal-alignment: right; vertical-alignment: center;
+        }
+        IconButton {
+            x: parent.width - 25px; y: 2px; width: 19px; height: parent.height - 4px;
+            border-radius: 3px;
+            icon: FontAwesomeIcons.xmark; icon-size: ImGuiFontStyle.base;
+            icon-color: #202124;
+            hover-background: #bfc2c7; pressed-background: #b2b2b2;
+            accessible-role: button;
+            accessible-label: MessageStrings.close;
+            accessible-action-default => { root.close(); }
+            clicked => { root.close(); }
+        }
+    }
+    if root.notice-text != "": Rectangle {
+        x: 16px; y: title-bar.height + 10px; width: parent.width - 32px; height: 28px;
+        border-radius: 4px;
+        background: #fef2f2;
+        Text {
+            x: 8px; width: parent.width - 16px; height: parent.height;
+            text: root.notice-text; font-size: ImGuiFontStyle.body; overflow: elide;
+            color: #b3261e;
+            vertical-alignment: center;
+        }
+    }
+    announcement-list := Rectangle {
+        x: 16px; y: root.content-top; width: 168px; height: parent.height - self.y - 16px;
+        announcements-scroll := ScrollView {
+            width: parent.width; height: parent.height;
+            VerticalLayout {
+                width: announcements-scroll.width; spacing: 0px; padding: 0px;
+                padding-right: 8px;
+                alignment: start;
+                for item[index] in root.items: Rectangle {
+                    height: 54px;
+                    background: root.selected-id == item.id ? #eaf2ff : entry-touch.has-hover ? #f0f1f2 : transparent;
+                    border-radius: 4px;
+                    Text { x: 8px; y: 6px; width: parent.width - 32px; height: 18px; text: item.title; overflow: elide; font-size: ImGuiFontStyle.base; font-weight: item.read ? 400 : 600; color: #202124; vertical-alignment: center; }
+                    if !item.read: Rectangle {
+                        x: parent.width - 17px; y: 13px; width: 5px; height: 5px;
+                        border-radius: 2.5px; background: #2563eb;
+                        accessible-role: none;
+                    }
+                    Text { x: 8px; y: 28px; width: parent.width - 36px; height: 16px; text: item.date; color: #61656c; font-size: ImGuiFontStyle.small; overflow: elide; vertical-alignment: center; }
+                    accessible-role: button;
+                    accessible-label: item.title + " " + (item.read ? MessageStrings.read : MessageStrings.unread);
+                    accessible-action-default => { root.open-message(item.id, item.revision); }
+                    entry-touch := TouchArea { mouse-cursor: pointer; clicked => { root.open-message(item.id, item.revision); } }
+                    IconButton {
+                        x: parent.width - 24px; y: 26px; width: 20px; height: 20px;
+                        icon: FontAwesomeIcons.xmark; icon-size: ImGuiFontStyle.small;
+                        icon-color: #61656c; danger: true;
+                        accessible-role: button;
+                        accessible-label: MessageStrings.delete-message + " " + item.title;
+                        accessible-action-default => { root.request-delete(item.id, item.revision); }
+                        clicked => { root.request-delete(item.id, item.revision); }
+                    }
+                    if index < root.items.length - 1: Rectangle {
+                        x: 8px; y: parent.height - 1px;
+                        width: parent.width - 16px; height: 1px;
+                        background: root.separator-color;
+                        accessible-role: none;
+                    }
+                }
+            }
+        }
+    }
+    if root.items.length == 0 && root.total == 0 && root.loaded && root.connected && !root.loading && !root.failed: Text {
+        x: 16px; y: root.content-top; width: parent.width - 32px; height: announcement-list.height;
+        text: MessageStrings.empty; wrap: word-wrap;
+        color: #61656c; font-size: ImGuiFontStyle.body;
+        horizontal-alignment: center; vertical-alignment: center;
+    }
+    content-divider := Rectangle {
+        x: announcement-list.x + announcement-list.width + 12px;
+        y: root.content-top; width: 1px; height: announcement-list.height;
+        background: root.separator-color;
+        visible: root.items.length > 0 || root.selected-id != "";
+        accessible-role: none;
+    }
+    announcement-details := Rectangle {
+        x: content-divider.x + content-divider.width + 12px;
+        y: root.content-top; width: parent.width - self.x - 16px; height: announcement-list.height;
+        if root.selected-id == "" && root.items.length > 0: Text { x: 8px; width: parent.width - 16px; text: MessageStrings.select-message; color: #61656c; font-size: ImGuiFontStyle.body; wrap: word-wrap; horizontal-alignment: center; vertical-alignment: center; }
+        if root.selected-id != "": details-scroll := ScrollView {
+            width: parent.width; height: parent.height;
+            VerticalLayout {
+                width: details-scroll.width; padding: 8px; padding-top: 6px; padding-right: 16px;
+                spacing: 12px; alignment: start;
+                VerticalLayout {
+                    vertical-stretch: 0; spacing: 4px;
+                    Text { vertical-stretch: 0; min-height: 18px; text: root.selected-title; wrap: word-wrap; font-size: ImGuiFontStyle.base; font-weight: 600; color: #202124; vertical-alignment: center; }
+                    Text { vertical-stretch: 0; min-height: 16px; text: root.selected-date; accessible-label: root.selected-date + " · " + (root.selected-read ? MessageStrings.read : MessageStrings.unread); color: #61656c; font-size: ImGuiFontStyle.small; wrap: word-wrap; vertical-alignment: center; }
+                }
+                Rectangle { height: 1px; background: root.separator-color; }
+                StyledText {
+                    vertical-stretch: 0;
+                    text: root.selected-body;
+                    default-color: #202124; default-font-size: ImGuiFontStyle.body;
+                    link-color: #2563eb;
+                    link-clicked(url) => { root.open-link(url); }
+                }
+            }
+        }
+    }
+    Timer {
+        interval: 100ms;
+        running: root.connected && !root.loading && !root.failed
+            && root.pending-delete-id == "" && root.items.length > 0
+            && root.items.length < root.total && announcements-scroll.viewport-height > 0px
+            && announcements-scroll.viewport-height + announcements-scroll.viewport-y <= announcements-scroll.height + 80px;
+        triggered => { root.load-more(); }
+    }
+    if root.pending-delete-id != "": Rectangle {
+        background: #00000042; border-radius: root.border-radius; z: 30;
+        TouchArea { clicked => { confirmation-keys.focus(); } }
+        DialogSurface {
+            x: (parent.width - self.width) / 2;
+            y: (parent.height - self.height) / 2;
+            width: 230px; height: confirmation-content.preferred-height;
+            border-radius: root.border-radius;
+            TouchArea { clicked => { confirmation-keys.focus(); } }
+            confirmation-content := VerticalLayout {
+                padding: 16px;
+                padding-top: 26px;
+                padding-bottom: 26px;
+                spacing: 20px;
+                Text { text: MessageStrings.delete-confirmation; font-size: ImGuiFontStyle.base; color: #202124; wrap: word-wrap; horizontal-alignment: center; }
+                HorizontalLayout {
+                    alignment: center; spacing: 8px;
+                    cancel-delete-button := CompactButton {
+                        width: 72px; text: MessageStrings.cancel;
+                        accessible-role: button; accessible-label: MessageStrings.cancel;
+                        accessible-action-default => { cancel-delete-button.clicked(); }
+                        clicked => { root.pending-delete-id = ""; }
+                    }
+                    confirm-delete-button := CompactButton {
+                        width: 72px; text: MessageStrings.delete-message; primary: true;
+                        accessible-role: button; accessible-label: MessageStrings.delete-title;
+                        accessible-action-default => { confirm-delete-button.clicked(); }
+                        clicked => {
+                            root.delete-message(root.pending-delete-id, root.pending-delete-revision);
+                            root.pending-delete-id = "";
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

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

@@ -1,5 +1,5 @@
 import { ComboBox, ScrollView } from "std-widgets.slint";
-import { FontAwesomeIcons, IconButton, PrimaryButton, ImGuiLineStyle, ImGuiFontStyle } from "common.slint";
+import { FontAwesomeIcons, IconButton, PrimaryButton, DialogSurface, ImGuiLineStyle, ImGuiFontStyle } from "common.slint";
 
 export struct StreamTab {
     remote-id: string,
@@ -23,8 +23,25 @@ export struct NetworkStatsRow {
 }
 
 export global StreamStrings {
+    in-out property <string> remote-update-title: "Remote device needs an update";
+    in-out property <string> remote-update: "Please update to the latest version.";
+    in-out property <string> remote-update-dismiss: "Got it";
+    in-out property <string> video-settings: "Video settings";
+    in-out property <string> video-settings-unavailable: "The remote device does not support live video settings";
+    in-out property <string> video-quality: "Video quality";
+    in-out property <string> frame-rate: "Capture frame rate";
+    in-out property <string> adaptation-policy: "Video preference";
+    in-out property <string> quality-low: "Low";
+    in-out property <string> quality-medium: "Medium";
+    in-out property <string> quality-high: "High";
+    in-out property <string> priority-frame-rate: "Frame rate";
+    in-out property <string> priority-quality: "Quality";
+    in-out property <string> priority-balanced: "Balanced";
+
     in-out property <string> select-display: "Select Display";
     in-out property <string> send-shortcut: "Send Shortcut";
+    in-out property <string> privacy-enable: "Enable privacy screen";
+    in-out property <string> privacy-disable: "Turn privacy off / recover";
     in-out property <string> control-mouse: "Control Mouse";
     in-out property <string> release-mouse: "Release Mouse";
     in-out property <string> audio: "Audio Capture";
@@ -42,7 +59,17 @@ export global StreamStrings {
     in-out property <string> stats-out: "Out";
     in-out property <string> stats-loss-rate: "Loss Rate";
     in-out property <string> stats-resolution: "Res";
+    in-out property <string> stats-video-latency: "Video delay";
+    in-out property <string> stats-connection-latency: "Connection RTT";
     in-out property <string> stats-connection-mode: "Mode";
+    in-out property <string> stats-encryption: "Encryption";
+    in-out property <string> stats-encryption-enabled: "Enabled";
+    in-out property <string> stats-encryption-disabled: "Disabled";
+}
+
+struct ControlBarTooltip {
+    text: string,
+    anchor-x: length,
 }
 
 // The legacy ImGui control bar uses 24px buttons with Font Awesome rendered
@@ -54,19 +81,27 @@ component ControlBarButton inherits Rectangle {
     in property <string> tooltip: "";
     in property <bool> selected: false;
     in property <bool> slashed: false;
+    in property <bool> action-enabled: true;
+    // Capability and temporary command availability have different visuals.
+    in property <bool> muted: false;
     in property <length> icon-size: 16px;
+    out property <bool> has-hover: touch.has-hover;
+    out property <ControlBarTooltip> tooltip-info: {
+        text: root.visible && touch.has-hover && !touch.pressed ? root.tooltip : "",
+        anchor-x: root.x + root.width / 2,
+    };
     callback clicked;
 
     width: 24px;
     height: 24px;
-    background: touch.pressed ? #0f87fa
+    background: root.muted ? #eef0f3 : touch.pressed && root.action-enabled ? #0f87fa
                               : touch.has-hover ? #4296fa
                                                 : root.selected ? #4296fa : #4296fa66;
     border-radius: 3px;
 
     Text {
         text: root.icon;
-        color: #24272d;
+        color: root.muted ? #8a8f96 : #24272d;
         font-family: "Font Awesome 6 Free";
         font-weight: 900;
         font-size: root.icon-size;
@@ -85,27 +120,55 @@ component ControlBarButton inherits Rectangle {
         font-size: 11px;
     }
 
-    // Match the two offset diagonal strokes used by the ImGui mouse/audio
-    // disabled state instead of covering the glyph with a full-width slash.
-    if root.slashed: Rectangle {
-        x: 11px;
-        y: 0px;
-        width: 2px;
-        height: 24px;
-        background: black;
-        transform-rotation: -45deg;
+    // Draw the two offset disabled-state strokes as paths. Rotated rectangles
+    // stay vertical in the software renderer used for fallback and UI capture.
+    if root.slashed: Path {
+        width: 24px; height: 24px;
+        viewbox-width: 24; viewbox-height: 24;
+        commands: "M 3.5 3.5 L 20.5 20.5";
+        stroke: black;
+        stroke-width: 2px;
     }
-    if root.slashed: Rectangle {
-        x: 9.5px;
-        y: 1.5px;
-        width: 2px;
-        height: 24px;
-        background: touch.has-hover ? #4296fa : #b3d5fd;
-        transform-rotation: -45deg;
+    if root.slashed: Path {
+        width: 24px; height: 24px;
+        viewbox-width: 24; viewbox-height: 24;
+        commands: "M 2 5 L 19 22";
+        stroke: touch.has-hover ? #4296fa : #b3d5fd;
+        stroke-width: 2px;
     }
 
     touch := TouchArea {
-        clicked => { root.clicked(); }
+        // Keep disabled controls hit-testable so clicks cannot reach the peer.
+        clicked => { if root.action-enabled { root.clicked(); } }
+    }
+}
+
+component VideoSettingRow inherits VerticalLayout {
+    in property <string> label;
+    in property <[string]> options;
+    in property <int> selected;
+    in property <bool> enabled;
+    callback choose(int);
+    callback pressed;
+    spacing: 4px;
+    Text { text: root.label; color: #5c626c; font-size: 11px; height: 18px; }
+    HorizontalLayout {
+        spacing: 4px;
+        for option[index] in root.options: Rectangle {
+            height: 27px;
+            background: !root.enabled ? #f1f1f1 : root.selected == index ? #d7eaff
+                : option-touch.has-hover ? #eaf3ff : #f5f6f8;
+            border-radius: 4px;
+            border-width: 1px;
+            border-color: root.enabled && root.selected == index ? #4296fa : #dce0e6;
+            Text { text: option; color: root.enabled ? #30343b : #8b8f95;
+                font-size: 11px; horizontal-alignment: center; vertical-alignment: center; }
+            option-touch := TouchArea {
+                pointer-event(event) => { if event.kind == PointerEventKind.down { root.pressed(); } }
+                clicked => { if root.enabled { root.choose(index); } }
+                scroll-event(event) => { accept }
+            }
+        }
     }
 }
 
@@ -123,6 +186,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;
@@ -131,20 +199,36 @@ export component StreamWindow inherits Window {
     in property <bool> has-frame: false;
     in property <string> status-text: "";
     in property <string> receiving-text: "";
+    in property <bool> remote-update-visible: false;
+    callback dismiss-remote-update;
     in property <[string]> displays;
     in-out property <int> selected-display: 0;
     in property <bool> mouse-control-enabled: true;
+    in property <bool> privacy-can-toggle: false;
+    in property <bool> privacy-active: false;
+    in property <bool> privacy-off: false;
+    in property <bool> privacy-unsupported: false;
+    // Privacy feedback stays on its toolbar button and hover tooltip.
+    in property <string> privacy-status-text: "Privacy screen";
     // Numeric values mirror crossdesk::RemoteCursorShape and Slint's MouseCursor.
     in property <bool> remote-cursor-active: false;
     in property <int> remote-cursor-shape: 0;
     in property <bool> audio-enabled: true;
-    in property <bool> srtp-enabled: false;
+    in property <bool> video-settings-enabled: false;
+    in property <string> video-settings-feedback: "";
+    in-out property <int> video-quality-index: 2;
+    in-out property <int> frame-rate-index: 1;
+    in-out property <int> adaptation-policy-index: 1;
+    callback change-video-settings(int, int, int);
     in property <bool> fullscreen-enabled: false;
     in property <bool> stats-visible: false;
     in property <[NetworkStatsRow]> stats-rows;
     in property <string> stats-fps: "0";
     in property <string> stats-resolution: "";
+    in property <string> stats-video-latency: "—";
+    in property <string> stats-connection-latency: "—";
     in property <string> stats-connection-mode: "";
+    in property <bool> stats-encryption-enabled: false;
     in property <bool> file-transfer-visible: false;
     in property <[FileTransferEntry]> file-transfers;
 
@@ -154,6 +238,7 @@ export component StreamWindow inherits Window {
     callback switch-display(int);
     callback send-shortcut(string);
     callback toggle-mouse-control;
+    callback toggle-privacy;
     callback toggle-audio;
     callback select-file;
     callback close-file-transfer;
@@ -172,10 +257,54 @@ export component StreamWindow inherits Window {
     callback keyboard-focus-changed(bool);
 
     private property <bool> control-expanded: true;
+    private property <length> control-toolbar-height: 38px;
+    private property <length> control-button-step: 32px;
+    private property <length> stats-row-height: 18px;
+    private property <length> stats-header-height: 18px;
+    private property <length> stats-content-height:
+        root.stats-header-height + root.stats-rows.length * root.stats-row-height + 65px;
     private property <bool> display-menu-open: false;
     private property <bool> display-menu-animation-enabled: false;
     private property <float> display-menu-progress: 0.0;
     private property <bool> shortcut-menu-open: false;
+    in-out property <bool> video-menu-open: false;
+    private property <length> video-menu-width: min(320px, video.width - 8px);
+    private property <length> video-menu-height: root.video-settings-enabled && root.video-settings-feedback == "" ? 182px : 220px;
+    private property <length> video-menu-x: min(max(4px, control.x + video-button.x), video.width - root.video-menu-width - 4px);
+    private property <length> video-menu-y: control.y + root.control-toolbar-height + root.video-menu-height <= video.height
+        ? control.y + root.control-toolbar-height - 1px : max(0px, control.y - root.video-menu-height);
+    changed selected-tab => { root.video-menu-open = false; }
+    changed control-expanded => { if !root.control-expanded { root.video-menu-open = false; } }
+    changed window-active => { if !root.window-active { root.video-menu-open = false; } }
+    changed remote-update-visible => {
+        if root.remote-update-visible {
+            root.video-menu-open = false;
+            root.display-menu-open = false;
+            root.shortcut-menu-open = false;
+        }
+        input-focus.focus();
+        root.keyboard-focus-changed(!root.remote-update-visible);
+    }
+    private property <bool> control-tooltip-visible: false;
+    private property <ControlBarTooltip> hovered-control: {
+        if root.window-active && !root.control-dragging
+            && !root.display-menu-open && !root.shortcut-menu-open && !root.video-menu-open {
+            if collapse-button.has-hover { return collapse-button.tooltip-info; }
+            if root.control-expanded {
+                if display-button.has-hover { return display-button.tooltip-info; }
+                if shortcut-button.has-hover { return shortcut-button.tooltip-info; }
+                if mouse-button.has-hover { return mouse-button.tooltip-info; }
+                if privacy-button.has-hover { return privacy-button.tooltip-info; }
+                if video-button.has-hover { return video-button.tooltip-info; }
+                if audio-button.has-hover { return audio-button.tooltip-info; }
+                if file-button.has-hover { return file-button.tooltip-info; }
+                if stats-button.has-hover { return stats-button.tooltip-info; }
+                if fullscreen-button.has-hover { return fullscreen-button.tooltip-info; }
+                if close-button.has-hover { return close-button.tooltip-info; }
+            }
+        }
+        return { text: "", anchor-x: 0px };
+    }
     // A popup can remove itself from the scene in its clicked callback before
     // the video input layer observes the same pointer release. Remember that
     // the press belonged to local UI so that release cannot reach the peer.
@@ -215,27 +344,45 @@ export component StreamWindow inherits Window {
         }
     }
 
+    changed hovered-control => {
+        root.control-tooltip-visible = false;
+        control-tooltip-timer.running = root.hovered-control.text != "";
+        if root.hovered-control.text != "" { control-tooltip-timer.restart(); }
+    }
+    control-tooltip-timer := Timer {
+        interval: 450ms;
+        running: false;
+        triggered => {
+            self.running = false;
+            root.control-tooltip-visible = true;
+        }
+    }
+
     is-local-control-area(pointer-x, pointer-y) => {
+        if root.remote-update-visible { return true; }
         let over-control = pointer-x >= control.x
             && pointer-x <= control.x + control.width
             && 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
             && pointer-x <= display-menu-x + 180px
             && pointer-y >= display-menu-y
             && pointer-y <= display-menu-y + display-menu-height;
-        let shortcut-menu-x = control.x + (root.control-docked-left ? 41px : 74px);
+        let shortcut-menu-x = control.x + shortcut-button.x;
         let shortcut-menu-y = control.y + 40px;
         let over-shortcut-menu = root.shortcut-menu-open
             && pointer-x >= shortcut-menu-x
-            && pointer-x <= shortcut-menu-x + 150px
+            && pointer-x <= shortcut-menu-x + 180px
             && pointer-y >= shortcut-menu-y
             && pointer-y <= shortcut-menu-y + 68px;
-        return over-control || over-display-menu || over-shortcut-menu;
+        let over-video-menu = root.video-menu-open
+            && pointer-x >= root.video-menu-x && pointer-x <= root.video-menu-x + root.video-menu-width
+            && pointer-y >= root.video-menu-y && pointer-y <= root.video-menu-y + root.video-menu-height;
+        return over-control || over-display-menu || over-shortcut-menu || over-video-menu;
     }
 
     begin-control-drag(press-x, press-y) => {
@@ -254,6 +401,7 @@ export component StreamWindow inherits Window {
         root.display-menu-progress = 0.0;
         root.display-menu-open = false;
         root.shortcut-menu-open = false;
+        root.video-menu-open = false;
         root.control-dragging = true;
     }
     move-control-drag(pointer-x, pointer-y) => {
@@ -450,20 +598,8 @@ export component StreamWindow inherits Window {
                         width: parent.width - 27px;
                         height: parent.height;
                         background: transparent;
-                        if root.srtp-enabled: Text {
-                            x: 0px;
-                            width: 12px;
-                            height: parent.height;
-                            text: FontAwesomeIcons.shield-halved;
-                            color: #30343b;
-                            font-family: "Font Awesome 6 Free";
-                            font-weight: 900;
-                            font-size: ImGuiFontStyle.base;
-                            horizontal-alignment: center;
-                            vertical-alignment: center;
-                        }
                         Text {
-                            x: root.srtp-enabled ? 16px : 0px;
+                            x: 0px;
                             width: parent.width - self.x;
                             height: parent.height;
                             text: tab.title;
@@ -534,9 +670,11 @@ export component StreamWindow inherits Window {
 
             drop-zone := DropArea {
                 can-drop(event) => {
-                    return root.can-drop-file(event.data) ? DragAction.copy : DragAction.none;
+                    return !root.remote-update-visible && root.can-drop-file(event.data)
+                        ? DragAction.copy : DragAction.none;
                 }
                 dropped(event) => {
+                    if root.remote-update-visible { return DragAction.none; }
                     root.file-dropped(event.data);
                     return DragAction.copy;
                 }
@@ -547,11 +685,20 @@ export component StreamWindow inherits Window {
                 focus-gained => { root.keyboard-focus-changed(true); }
                 focus-lost => { root.keyboard-focus-changed(false); }
                 key-pressed(event) => {
-                    root.key-input(event.text, true, event.modifiers.control, event.modifiers.alt, event.modifiers.shift, event.modifiers.meta);
+                    if !root.remote-update-visible {
+                        root.key-input(event.text, true, event.modifiers.control, event.modifiers.alt, event.modifiers.shift, event.modifiers.meta);
+                    }
                     accept
                 }
                 key-released(event) => {
-                    root.key-input(event.text, false, event.modifiers.control, event.modifiers.alt, event.modifiers.shift, event.modifiers.meta);
+                    if root.remote-update-visible {
+                        // Dismiss on release so the same key cannot reach the peer.
+                        if event.text == Key.Escape || event.text == Key.Return {
+                            root.dismiss-remote-update();
+                        }
+                    } else {
+                        root.key-input(event.text, false, event.modifiers.control, event.modifiers.alt, event.modifiers.shift, event.modifiers.meta);
+                    }
                     accept
                 }
                 pointer := TouchArea {
@@ -602,7 +749,12 @@ export component StreamWindow inherits Window {
                             root.suppress-next-remote-pointer-release = false;
                             input-focus.focus();
                         }
-                        if event.kind == PointerEventKind.down
+                        // A gesture started before the modal appeared keeps
+                        // pointer capture. Let its release reach the peer.
+                        if root.remote-update-visible && !root.control-dragging
+                            && event.kind == PointerEventKind.up {
+                            root.pointer-input(event.button, event.kind, self.mouse-x, self.mouse-y);
+                        } else if event.kind == PointerEventKind.down
                             && event.button == PointerEventButton.left
                             && over-control {
                             root.begin-control-drag(self.mouse-x, self.mouse-y);
@@ -639,8 +791,10 @@ export component StreamWindow inherits Window {
             control := Rectangle {
                 x: root.control-dragging ? root.control-drag-x : root.control-docked-left ? 0px : parent.width - self.width;
                 y: min(max(0px, root.control-pos-y), parent.height - self.height);
-                width: root.control-expanded ? min(300px, parent.width) : 20px;
-                height: root.stats-visible && root.control-expanded ? min(180px, parent.height) : 38px;
+                width: root.control-expanded ? min(76px + 9 * root.control-button-step, parent.width) : 20px;
+                height: root.stats-visible && root.control-expanded
+                    ? min(root.control-toolbar-height + root.stats-content-height + 8px, parent.height)
+                    : root.control-toolbar-height;
                 background: white;
                 border-width: 1px;
                 border-color: ImGuiLineStyle.border;
@@ -657,7 +811,8 @@ export component StreamWindow inherits Window {
                     background: ImGuiLineStyle.control-separator;
                 }
 
-                if root.control-expanded: display-button := ControlBarButton {
+                display-button := ControlBarButton {
+                    visible: root.control-expanded;
                     x: root.control-docked-left ? 9px : 42px; y: 7px;
                     icon: FontAwesomeIcons.display;
                     badge: root.selected-display + 1;
@@ -668,13 +823,15 @@ export component StreamWindow inherits Window {
                         root.display-menu-progress = 0.0;
                         root.display-menu-open = !root.display-menu-open;
                         root.shortcut-menu-open = false;
+                        root.video-menu-open = false;
                         if root.display-menu-open {
                             display-menu-open-timer.running = true;
                         }
                     }
                 }
-                if root.control-expanded: shortcut-button := ControlBarButton {
-                    x: root.control-docked-left ? 41px : 74px; y: 7px;
+                shortcut-button := ControlBarButton {
+                    visible: root.control-expanded;
+                    x: (root.control-docked-left ? 9px : 42px) + root.control-button-step; y: 7px;
                     icon: FontAwesomeIcons.keyboard; tooltip: StreamStrings.send-shortcut;
                     clicked => {
                         display-menu-open-timer.running = false;
@@ -682,49 +839,67 @@ export component StreamWindow inherits Window {
                         root.display-menu-progress = 0.0;
                         root.shortcut-menu-open = !root.shortcut-menu-open;
                         root.display-menu-open = false;
+                        root.video-menu-open = false;
                     }
                 }
-                if root.control-expanded: mouse-button := ControlBarButton {
-                    x: root.control-docked-left ? 73px : 106px; y: 7px;
+                mouse-button := ControlBarButton {
+                    visible: root.control-expanded;
+                    x: (root.control-docked-left ? 9px : 42px) + 2 * root.control-button-step; y: 7px;
                     icon: FontAwesomeIcons.computer-mouse; slashed: !root.mouse-control-enabled;
                     tooltip: root.mouse-control-enabled ? StreamStrings.release-mouse : StreamStrings.control-mouse;
                     clicked => { root.toggle-mouse-control(); }
                 }
-                if root.control-expanded: audio-button := ControlBarButton {
-                    x: root.control-docked-left ? 105px : 138px; y: 7px;
+                audio-button := ControlBarButton {
+                    visible: root.control-expanded;
+                    x: (root.control-docked-left ? 9px : 42px) + 4 * root.control-button-step; y: 7px;
                     icon: FontAwesomeIcons.volume-high; slashed: !root.audio-enabled;
                     tooltip: root.audio-enabled ? StreamStrings.mute : StreamStrings.audio;
                     clicked => { root.toggle-audio(); }
                 }
-                if root.control-expanded: file-button := ControlBarButton {
-                    x: root.control-docked-left ? 137px : 170px; y: 7px;
+                file-button := ControlBarButton {
+                    visible: root.control-expanded;
+                    x: (root.control-docked-left ? 9px : 42px) + 5 * root.control-button-step; y: 7px;
                     icon: FontAwesomeIcons.folder-open; tooltip: StreamStrings.select-file;
                     clicked => { root.select-file(); }
                 }
-                if root.control-expanded: stats-button := ControlBarButton {
-                    x: root.control-docked-left ? 169px : 202px; y: 7px;
+                video-button := ControlBarButton {
+                    visible: root.control-expanded;
+                    x: (root.control-docked-left ? 9px : 42px) + 6 * root.control-button-step; y: 7px;
+                    icon: "\u{f1de}"; selected: root.video-menu-open;
+                    tooltip: StreamStrings.video-settings;
+                    clicked => {
+                        root.video-menu-open = !root.video-menu-open;
+                        root.display-menu-open = false;
+                        root.shortcut-menu-open = false;
+                    }
+                }
+                stats-button := ControlBarButton {
+                    visible: root.control-expanded;
+                    x: (root.control-docked-left ? 9px : 42px) + 7 * root.control-button-step; y: 7px;
                     icon: FontAwesomeIcons.signal; selected: root.stats-visible;
                     tooltip: root.stats-visible ? StreamStrings.hide-stats : StreamStrings.show-stats;
                     clicked => { root.toggle-stats(); }
                 }
-                if root.control-expanded: fullscreen-button := ControlBarButton {
-                    x: root.control-docked-left ? 201px : 234px; y: 7px;
+                fullscreen-button := ControlBarButton {
+                    visible: root.control-expanded;
+                    x: (root.control-docked-left ? 9px : 42px) + 8 * root.control-button-step; y: 7px;
                     icon: root.fullscreen-enabled ? FontAwesomeIcons.compress : FontAwesomeIcons.expand;
                     tooltip: root.fullscreen-enabled ? StreamStrings.exit-fullscreen : StreamStrings.fullscreen;
                     clicked => { root.toggle-fullscreen(); }
                 }
-                if root.control-expanded: close-button := ControlBarButton {
-                    x: root.control-docked-left ? 233px : 266px; y: 7px;
+                close-button := ControlBarButton {
+                    visible: root.control-expanded;
+                    x: (root.control-docked-left ? 9px : 42px) + 9 * root.control-button-step; y: 7px;
                     icon: FontAwesomeIcons.xmark; tooltip: StreamStrings.disconnect;
                     clicked => { root.disconnect(); }
                 }
 
                 if root.control-expanded && root.control-docked-left: Rectangle {
-                    x: 267px; y: 12px; width: 2px; height: 15px;
+                    x: parent.width - 33px; y: 12px; width: 2px; height: 15px;
                     background: ImGuiLineStyle.control-separator;
                 }
                 collapse-button := ControlBarButton {
-                    x: root.control-expanded ? (root.control-docked-left ? 275px : 10px) : 2px;
+                    x: root.control-expanded ? (root.control-docked-left ? parent.width - 25px : 10px) : 2px;
                     y: 7px;
                     width: 15px;
                     icon: root.control-expanded
@@ -734,76 +909,134 @@ export component StreamWindow inherits Window {
                     clicked => { root.control-expanded = !root.control-expanded; }
                 }
 
+                privacy-button := ControlBarButton {
+                    visible: root.control-expanded;
+                    x: (root.control-docked-left ? 9px : 42px) + 3 * root.control-button-step; y: 7px;
+                    icon: FontAwesomeIcons.user-secret;
+                    slashed: root.privacy-off && !root.privacy-unsupported;
+                    muted: root.privacy-unsupported;
+                    action-enabled: root.privacy-can-toggle;
+                    tooltip: root.privacy-status-text
+                        + (root.privacy-can-toggle ? "\n" + (root.privacy-active
+                            ? StreamStrings.privacy-disable : StreamStrings.privacy-enable) : "");
+                    clicked => { root.toggle-privacy(); }
+                }
+
                 if root.stats-visible && root.control-expanded: stats-table := Rectangle {
-                    x: 14px;
-                    y: 38px;
-                    width: parent.width - 28px;
-                    height: 128px;
+                    x: 8px;
+                    y: root.control-toolbar-height + 2px;
+                    width: parent.width - 16px;
+                    height: root.stats-content-height;
                     background: transparent;
-                    private property <length> row-height: 16px;
-                    private property <length> label-column-width: 60px;
-                    private property <length> loss-column-width: 66px;
+                    private property <length> row-height: root.stats-row-height;
+                    private property <length> label-column-width: 50px;
+                    private property <length> loss-column-width:
+                        max((self.width - self.label-column-width) / 3,
+                            stats-loss-label.preferred-width + 8px);
                     private property <length> value-column-width:
                         (self.width - self.label-column-width - self.loss-column-width) / 2;
+                    private property <length> details-right-width:
+                        right-label-width-probe.preferred-width + 6px
+                            + max(resolution-width-probe.preferred-width,
+                                connection-latency-width-probe.preferred-width,
+                                encryption-width-probe.preferred-width
+                                    + (root.stats-encryption-enabled ? 14px : 0px));
+                    private property <length> details-right-x:
+                        min(self.width / 2, self.width - self.details-right-width - 6px);
 
-                    Rectangle {
-                        y: 0px;
-                        height: 1px;
-                        background: ImGuiLineStyle.border;
+                    left-label-width-probe := Text {
+                        visible: false;
+                        text: "FPS\n" + StreamStrings.stats-video-latency
+                            + "\n" + StreamStrings.stats-connection-mode;
+                        font-size: ImGuiFontStyle.small;
+                    }
+                    right-label-width-probe := Text {
+                        visible: false;
+                        text: StreamStrings.stats-resolution + "\n" + StreamStrings.stats-connection-latency
+                            + "\n" + StreamStrings.stats-encryption;
+                        font-size: ImGuiFontStyle.small;
+                    }
+                    resolution-width-probe := Text {
+                        visible: false;
+                        text: root.stats-resolution;
+                        font-size: ImGuiFontStyle.body;
+                        font-weight: 600;
+                    }
+                    connection-latency-width-probe := Text {
+                        visible: false;
+                        text: root.stats-connection-latency;
+                        font-size: ImGuiFontStyle.body;
+                        font-weight: 600;
+                    }
+                    encryption-width-probe := Text {
+                        visible: false;
+                        text: root.stats-encryption-enabled
+                            ? StreamStrings.stats-encryption-enabled : StreamStrings.stats-encryption-disabled;
+                        font-size: ImGuiFontStyle.body;
+                        font-weight: 600;
                     }
 
                     Rectangle {
+                        x: 0px;
                         y: 0px;
-                        height: stats-table.row-height;
+                        width: parent.width;
+                        height: root.stats-header-height;
+                        background: #f3f5f8;
+                        border-radius: 4px;
                         Text {
                             x: stats-table.label-column-width + 4px;
                             width: stats-table.value-column-width - 8px;
                             text: StreamStrings.stats-in;
-                            color: #30343b;
+                            color: #667085;
                             font-size: ImGuiFontStyle.small;
+                            horizontal-alignment: right;
                             vertical-alignment: center;
                         }
                         Text {
                             x: stats-table.label-column-width + stats-table.value-column-width + 4px;
                             width: stats-table.value-column-width - 8px;
                             text: StreamStrings.stats-out;
-                            color: #30343b;
+                            color: #667085;
                             font-size: ImGuiFontStyle.small;
+                            horizontal-alignment: right;
                             vertical-alignment: center;
                         }
-                        Text {
+                        stats-loss-label := Text {
                             x: stats-table.label-column-width + stats-table.value-column-width * 2 + 4px;
                             width: stats-table.loss-column-width - 8px;
                             text: StreamStrings.stats-loss-rate;
-                            color: #30343b;
+                            color: #667085;
                             font-size: ImGuiFontStyle.small;
+                            horizontal-alignment: right;
                             vertical-alignment: center;
                             overflow: elide;
                         }
-                        Rectangle {
-                            y: parent.height - 1px;
-                            height: 1px;
-                            background: ImGuiLineStyle.border;
-                        }
                     }
 
                     for row[index] in root.stats-rows: Rectangle {
-                        y: (index + 1) * stats-table.row-height;
+                        x: 0px;
+                        y: root.stats-header-height + index * stats-table.row-height;
+                        width: parent.width;
                         height: stats-table.row-height;
+                        background: index == root.stats-rows.length - 1 ? #edf3fc : transparent;
+                        border-radius: 4px;
                         Text {
                             x: 4px;
                             width: stats-table.label-column-width - 8px;
                             text: row.label;
-                            color: #30343b;
-                            font-size: ImGuiFontStyle.small;
+                            color: #475467;
+                            font-size: ImGuiFontStyle.body;
+                            font-weight: index == root.stats-rows.length - 1 ? 600 : 400;
                             vertical-alignment: center;
                         }
                         Text {
                             x: stats-table.label-column-width + 4px;
                             width: stats-table.value-column-width - 8px;
                             text: row.inbound;
-                            color: #30343b;
-                            font-size: ImGuiFontStyle.small;
+                            color: #253247;
+                            font-size: ImGuiFontStyle.body;
+                            font-weight: index == root.stats-rows.length - 1 ? 600 : 400;
+                            horizontal-alignment: right;
                             vertical-alignment: center;
                             overflow: elide;
                         }
@@ -811,8 +1044,10 @@ export component StreamWindow inherits Window {
                             x: stats-table.label-column-width + stats-table.value-column-width + 4px;
                             width: stats-table.value-column-width - 8px;
                             text: row.outbound;
-                            color: #30343b;
-                            font-size: ImGuiFontStyle.small;
+                            color: #253247;
+                            font-size: ImGuiFontStyle.body;
+                            font-weight: index == root.stats-rows.length - 1 ? 600 : 400;
+                            horizontal-alignment: right;
                             vertical-alignment: center;
                             overflow: elide;
                         }
@@ -820,51 +1055,133 @@ export component StreamWindow inherits Window {
                             x: stats-table.label-column-width + stats-table.value-column-width * 2 + 4px;
                             width: stats-table.loss-column-width - 8px;
                             text: row.loss-rate;
-                            color: #30343b;
-                            font-size: ImGuiFontStyle.small;
+                            color: #475467;
+                            font-size: ImGuiFontStyle.body;
+                            font-weight: index == root.stats-rows.length - 1 ? 600 : 400;
+                            horizontal-alignment: right;
                             vertical-alignment: center;
                             overflow: elide;
                         }
-                        Rectangle {
+                        if index < root.stats-rows.length - 2: Rectangle {
+                            x: 4px;
                             y: parent.height - 1px;
+                            width: parent.width - 8px;
                             height: 1px;
-                            background: ImGuiLineStyle.border;
+                            background: #edf0f4;
                         }
                     }
 
                     for metric[index] in [
-                        { label: "FPS:", value: root.stats-fps },
-                        { label: StreamStrings.stats-resolution + ":", value: root.stats-resolution },
-                        { label: StreamStrings.stats-connection-mode + ":", value: root.stats-connection-mode },
+                        { label: "FPS", value: root.stats-fps },
+                        { label: StreamStrings.stats-resolution, value: root.stats-resolution },
+                        { label: StreamStrings.stats-video-latency, value: root.stats-video-latency },
+                        { label: StreamStrings.stats-connection-latency, value: root.stats-connection-latency },
+                        { label: StreamStrings.stats-connection-mode, value: root.stats-connection-mode },
+                        { label: StreamStrings.stats-encryption, value: root.stats-encryption-enabled
+                            ? StreamStrings.stats-encryption-enabled : StreamStrings.stats-encryption-disabled },
                     ]: Rectangle {
-                        y: (index + 5) * stats-table.row-height;
-                        height: stats-table.row-height;
-                        Text {
-                            x: 4px;
-                            width: stats-table.label-column-width - 8px;
+                        private property <length> encryption-icon-width:
+                            index == 5 && root.stats-encryption-enabled ? 14px : 0px;
+                        x: mod(index, 2) == 1 ? stats-table.details-right-x : 6px;
+                        y: root.stats-header-height + root.stats-rows.length * stats-table.row-height
+                            + 2px + floor(index / 2) * 21px;
+                        width: mod(index, 2) == 1 ? stats-table.details-right-width
+                            : stats-table.details-right-x - 14px;
+                        height: 21px;
+                        metric-label := Text {
+                            x: 0px;
+                            y: 0px;
+                            width: mod(index, 2) == 1 ? right-label-width-probe.preferred-width
+                                : left-label-width-probe.preferred-width;
+                            height: parent.height;
                             text: metric.label;
-                            color: #30343b;
+                            color: #667085;
                             font-size: ImGuiFontStyle.small;
                             vertical-alignment: center;
                         }
-                        Text {
-                            x: stats-table.label-column-width + 4px;
-                            width: stats-table.value-column-width - 8px;
+                        metric-value := Text {
+                            x: metric-label.width + 6px;
+                            y: 0px;
+                            height: parent.height;
+                            width: parent.width - self.x - parent.encryption-icon-width;
                             text: metric.value;
-                            color: #30343b;
-                            font-size: ImGuiFontStyle.small;
+                            color: index == 5 && root.stats-encryption-enabled ? #18794e : #253247;
+                            font-size: ImGuiFontStyle.body;
+                            font-weight: 600;
+                            horizontal-alignment: left;
                             vertical-alignment: center;
                             overflow: elide;
                         }
-                        Rectangle {
-                            y: parent.height - 1px;
-                            height: 1px;
-                            background: ImGuiLineStyle.border;
+                        if index == 5 && root.stats-encryption-enabled: Text {
+                            x: metric-value.x + min(metric-value.preferred-width, metric-value.width) + 4px;
+                            y: metric-value.y + (metric-value.height - self.height) / 2;
+                            width: 10px;
+                            height: 12px;
+                            text: FontAwesomeIcons.shield-halved;
+                            font-family: "Font Awesome 6 Free";
+                            font-weight: 900;
+                            font-size: 10px;
+                            color: #238653;
+                            horizontal-alignment: center;
+                            vertical-alignment: center;
                         }
                     }
                 }
             }
 
+            // While the menu is open, outside gestures dismiss it locally.
+            // Keep the backdrop through pointer-up; otherwise Slint's implicit
+            // pointer move or release can reach the remote input surface.
+            if root.video-menu-open: Rectangle {
+                width: parent.width; height: parent.height; z: 9;
+                TouchArea {
+                    pointer-event(event) => {
+                        if event.kind == PointerEventKind.down {
+                            root.suppress-next-remote-pointer-release = true;
+                        }
+                    }
+                    clicked => { root.video-menu-open = false; }
+                    scroll-event(event) => { accept }
+                }
+            }
+            if root.video-menu-open: Rectangle {
+                x: root.video-menu-x; y: root.video-menu-y;
+                width: root.video-menu-width; height: root.video-menu-height;
+                background: white; border-width: 1px; border-color: ImGuiLineStyle.border;
+                border-radius: 5px; z: 11;
+                TouchArea {
+                    pointer-event(event) => { if event.kind == PointerEventKind.down { root.suppress-next-remote-pointer-release = true; } }
+                    scroll-event(event) => { accept }
+                }
+                VerticalLayout {
+                    padding: 10px; spacing: 8px;
+                    VideoSettingRow {
+                        label: StreamStrings.video-quality;
+                        options: [StreamStrings.quality-low, StreamStrings.quality-medium, StreamStrings.quality-high];
+                        selected: root.video-quality-index; enabled: root.video-settings-enabled;
+                        pressed => { root.suppress-next-remote-pointer-release = true; }
+                        choose(index) => { root.change-video-settings(index, root.frame-rate-index, root.adaptation-policy-index); }
+                    }
+                    VideoSettingRow {
+                        label: StreamStrings.frame-rate; options: ["30 fps", "60 fps"];
+                        selected: root.frame-rate-index; enabled: root.video-settings-enabled;
+                        pressed => { root.suppress-next-remote-pointer-release = true; }
+                        choose(index) => { root.change-video-settings(root.video-quality-index, index, root.adaptation-policy-index); }
+                    }
+                    VideoSettingRow {
+                        label: StreamStrings.adaptation-policy;
+                        options: [StreamStrings.priority-frame-rate, StreamStrings.priority-quality, StreamStrings.priority-balanced];
+                        selected: root.adaptation-policy-index; enabled: root.video-settings-enabled;
+                        pressed => { root.suppress-next-remote-pointer-release = true; }
+                        choose(index) => { root.change-video-settings(root.video-quality-index, root.frame-rate-index, index); }
+                    }
+                    if !root.video-settings-enabled || root.video-settings-feedback != "": Text {
+                        text: root.video-settings-enabled ? root.video-settings-feedback : StreamStrings.video-settings-unavailable; wrap: word-wrap;
+                        color: #8b8f95; font-size: 11px;
+                    }
+                }
+            }
+
             if root.display-menu-open: display-menu := Rectangle {
                 private property <length> expanded-height: min(180px, root.displays.length * 30px + 8px);
                 private property <int> hovered-index:
@@ -872,9 +1189,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;
@@ -943,7 +1260,7 @@ export component StreamWindow inherits Window {
             }
 
             if root.shortcut-menu-open: Rectangle {
-                x: control.x + (root.control-docked-left ? 41px : 74px); y: control.y + 40px; width: 150px; height: 68px;
+                x: control.x + shortcut-button.x; y: control.y + 40px; width: 180px; height: 68px;
                 background: white; border-width: 1px; border-color: ImGuiLineStyle.border; border-radius: 5px; z: 11;
                 VerticalLayout {
                     padding: 4px; spacing: 1px;
@@ -962,6 +1279,104 @@ export component StreamWindow inherits Window {
                 }
             }
 
+            // Measure unwrapped text so short hints stay compact. Render outside
+            // the clipped control bar, capping longer hints before wrapping.
+            control-tooltip-width-probe := Text {
+                visible: false;
+                text: root.hovered-control.text;
+                font-size: ImGuiFontStyle.body;
+            }
+            if root.hovered-control.text != "" && root.control-tooltip-visible: Rectangle {
+                width: min(240px, video.width - 8px,
+                    control-tooltip-width-probe.preferred-width + 16px);
+                x: min(max(4px, control.x + root.hovered-control.anchor-x - self.width / 2),
+                    video.width - self.width - 4px);
+                height: control-tip.preferred-height + 12px;
+                // Anchor to the button row so expanded stats stay beneath the tooltip.
+                y: control.y + root.control-toolbar-height + self.height + 8px <= video.height
+                    ? control.y + root.control-toolbar-height + 4px : max(4px, control.y - self.height - 4px);
+                background: #30343bf5; border-radius: 5px; z: 12;
+                control-tip := Text {
+                    x: 8px; y: 6px; width: parent.width - 16px;
+                    text: root.hovered-control.text;
+                    color: white; font-size: ImGuiFontStyle.body; wrap: word-wrap;
+                }
+            }
+
+            if root.remote-update-visible: Rectangle {
+                width: parent.width; height: parent.height;
+                background: #0c162c52;
+                z: 13;
+                TouchArea {
+                    mouse-cursor: default;
+                    scroll-event(event) => { accept }
+                }
+            }
+            remote-update-banner := DialogSurface {
+                visible: root.remote-update-visible;
+                x: (parent.width - self.width) / 2;
+                y: min(max(64px, parent.height * 0.18), max(16px, parent.height - self.height - 16px));
+                width: min(520px, parent.width - 48px);
+                height: max(208px, remote-update-message.y + remote-update-message.height + 92px);
+                border-color: #e5e9f0;
+                border-radius: 14px;
+                drop-shadow-color: #07142b30;
+                drop-shadow-blur: 32px;
+                drop-shadow-offset-y: 12px;
+                z: 14;
+                TouchArea {
+                    mouse-cursor: default;
+                    pointer-event(event) => {
+                        if event.kind == PointerEventKind.down {
+                            root.suppress-next-remote-pointer-release = true;
+                        }
+                    }
+                    scroll-event(event) => { accept }
+                }
+                Rectangle {
+                    x: 32px; y: 32px; width: 48px; height: 48px;
+                    background: #edf4ff; border-radius: 12px;
+                    Path {
+                        x: 12px; y: 12px; width: 24px; height: 24px;
+                        viewbox-width: 24; viewbox-height: 24;
+                        commands: "M 12 16 L 12 3 M 6.5 8.5 L 12 3 L 17.5 8.5 M 4 15 L 4 20 Q 4 21 5 21 L 19 21 Q 20 21 20 20 L 20 15";
+                        fill: transparent;
+                        stroke: #2463c7; stroke-width: 1.8px;
+                    }
+                }
+                remote-update-title := Text {
+                    x: 100px; y: 34px; width: parent.width - 144px;
+                    height: max(28px, self.preferred-height);
+                    text: StreamStrings.remote-update-title;
+                    color: #1b2433; font-size: 20px; font-weight: 600;
+                    wrap: word-wrap;
+                }
+                remote-update-message := Text {
+                    x: remote-update-title.x;
+                    y: remote-update-title.y + remote-update-title.height + 8px;
+                    width: remote-update-title.width;
+                    height: max(22px, self.preferred-height);
+                    text: StreamStrings.remote-update;
+                    color: #667085; font-size: 15px;
+                    wrap: word-wrap;
+                }
+                IconButton {
+                    x: parent.width - 44px; y: 12px; width: 32px; height: 32px;
+                    icon: FontAwesomeIcons.xmark; icon-size: 14px;
+                    icon-color: #8a93a3;
+                    hover-background: #f2f4f7;
+                    clicked => { root.dismiss-remote-update(); }
+                }
+                PrimaryButton {
+                    x: parent.width - 136px; y: parent.height - 68px;
+                    width: 104px; height: 36px;
+                    border-radius: 7px;
+                    text: StreamStrings.remote-update-dismiss;
+                    text-size: 14px;
+                    clicked => { root.dismiss-remote-update(); }
+                }
+            }
+
             // Transfer progress overlay at bottom-left.
             if root.file-transfer-visible: Rectangle {
                 x: 18px; y: parent.height - min(210px, parent.height * 0.35); width: min(430px, parent.width * 0.6); height: min(190px, parent.height * 0.32);

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

@@ -26,6 +26,21 @@ inline int ApplyMainWindowStrings(
   const int language =
       localization::detail::ClampLanguageIndex(language_index);
   auto& strings = window->global<ui::UiStrings>();
+  auto& messages = window->global<ui::MessageStrings>();
+  messages.set_messages(Text(localization::messages[language]));
+  messages.set_unread(Text(localization::message_unread[language]));
+  messages.set_read(Text(localization::message_read[language]));
+  messages.set_empty(Text(localization::message_empty[language]));
+  messages.set_select_message(Text(localization::message_select[language]));
+  messages.set_loading(Text(localization::message_loading[language]));
+  messages.set_read_save_error(Text(localization::message_read_save_error[language]));
+  messages.set_close(Text(localization::message_close[language]));
+  messages.set_delete_message(Text(localization::message_delete[language]));
+  messages.set_delete_title(Text(localization::message_delete_title[language]));
+  messages.set_delete_confirmation(Text(localization::message_delete_confirmation[language]));
+  messages.set_delete_error(Text(localization::message_delete_error[language]));
+  messages.set_cancel(Text(localization::cancel[language]));
+
   strings.set_local_desktop(Text(localization::local_desktop[language]));
   strings.set_remote_desktop(Text(localization::remote_desktop[language]));
   strings.set_recent_connections(
@@ -36,6 +51,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]));
@@ -52,25 +68,21 @@ inline int ApplyMainWindowStrings(
   strings.set_confirm_delete(
       Text(localization::confirm_delete_connection[language]));
   strings.set_language(Text(localization::language[language]));
-  strings.set_video_quality(Text(localization::video_quality[language]));
-  strings.set_frame_rate(Text(localization::video_frame_rate[language]));
-  strings.set_adaptation_policy(
-      Text(localization::video_adaptation_policy[language]));
-  strings.set_priority_frame_rate(
-      Text(localization::video_priority_frame_rate[language]));
-  strings.set_priority_quality(
-      Text(localization::video_priority_quality[language]));
-  strings.set_priority_balanced(
-      Text(localization::video_priority_balanced[language]));
+  strings.set_capture_method(Text(localization::screen_capture_method[language]));
+  strings.set_capture_method_auto(
+      Text(localization::screen_capture_method_auto[language]));
   strings.set_codec(Text(localization::video_encode_format[language]));
   strings.set_hardware_codec(
       Text(localization::enable_hardware_video_codec[language]));
   strings.set_turn_relay(Text(localization::enable_turn[language]));
-  strings.set_srtp(Text(localization::enable_srtp[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]));
   strings.set_daemon(Text(localization::enable_daemon[language]));
+  strings.set_save_remote_previews(Text(localization::save_remote_previews[language]));
+  strings.set_unknown_platform(Text(localization::unknown_platform[language]));
+  strings.set_privacy_on_connect(Text(localization::privacy_on_connect[language]));
   strings.set_file_save_path(
       Text(localization::file_transfer_save_path[language]));
   strings.set_default_desktop(Text(localization::default_desktop[language]));
@@ -78,8 +90,6 @@ inline int ApplyMainWindowStrings(
       Text(localization::self_hosted_server_address[language]));
   strings.set_server_port(
       Text(localization::self_hosted_server_port[language]));
-  strings.set_coturn_port(
-      Text(localization::self_hosted_server_coturn_server_port[language]));
   strings.set_version(Text(localization::version[language]));
   strings.set_signal_connected(Text(localization::signal_connected[language]));
   strings.set_signal_disconnected(
@@ -87,6 +97,13 @@ inline int ApplyMainWindowStrings(
   strings.set_tls_error(Text(localization::signal_tls_cert_error[language]));
   strings.set_update_available(
       Text(localization::new_version_available[language]));
+  strings.set_new_version(Text(localization::new_version[language]));
+  strings.set_check_for_updates(Text(localization::check_for_updates[language]));
+  strings.set_checking_for_updates(
+      Text(localization::checking_for_updates[language]));
+  strings.set_up_to_date(Text(localization::up_to_date[language]));
+  strings.set_update_check_failed(
+      Text(localization::update_check_failed[language]));
   strings.set_release_notes(Text(localization::release_notes[language]));
   strings.set_download(Text(localization::update[language]));
   strings.set_input_password(Text(localization::input_password[language]));
@@ -103,6 +120,20 @@ inline int ApplyMainWindowStrings(
       Text(localization::screen_recording_permission[language]));
   strings.set_accessibility_permission(
       Text(localization::accessibility_permission[language]));
+  strings.set_wayland_notice_title(
+      Text(localization::wayland_notice_title[language]));
+  strings.set_wayland_notice_subtitle(
+      Text(localization::wayland_notice_subtitle[language]));
+  strings.set_wayland_permission_title(
+      Text(localization::wayland_permission_title[language]));
+  strings.set_wayland_notice_message(
+      Text(localization::wayland_notice_message[language]));
+  strings.set_wayland_recommendation_title(
+      Text(localization::wayland_recommendation_title[language]));
+  strings.set_wayland_recommendation_message(
+      Text(localization::wayland_recommendation_message[language]));
+  strings.set_wayland_notice_acknowledge(
+      Text(localization::wayland_notice_acknowledge[language]));
   strings.set_service_setup_title(
       Text(localization::windows_service_setup_title[language]));
   strings.set_service_setup_message(
@@ -118,10 +149,6 @@ inline int ApplyMainWindowStrings(
   strings.set_notification(Text(localization::notification[language]));
   strings.set_service_suppressed_message(
       Text(localization::windows_service_prompt_suppressed_message[language]));
-  strings.set_quality_low(Text(localization::video_quality_low[language]));
-  strings.set_quality_medium(
-      Text(localization::video_quality_medium[language]));
-  strings.set_quality_high(Text(localization::video_quality_high[language]));
   strings.set_codec_h264(Text(localization::h264[language]));
   strings.set_codec_av1(Text(localization::av1[language]));
   strings.set_self_hosted_settings(
@@ -138,10 +165,32 @@ inline int ApplyStreamWindowStrings(
   const int language =
       localization::detail::ClampLanguageIndex(language_index);
   auto& strings = window->template global<ui::StreamStrings>();
+  strings.set_remote_update_title(Text(localization::remote_update_title[language]));
+  strings.set_remote_update(Text(localization::remote_update[language]));
+  strings.set_remote_update_dismiss(Text(localization::remote_update_dismiss[language]));
   strings.set_select_display(Text(localization::select_display[language]));
   strings.set_send_shortcut(Text(localization::send_shortcut[language]));
+  strings.set_privacy_enable(Text(localization::privacy_enable[language]));
+  strings.set_privacy_disable(Text(localization::privacy_disable[language]));
   strings.set_control_mouse(Text(localization::control_mouse[language]));
   strings.set_release_mouse(Text(localization::release_mouse[language]));
+  strings.set_video_settings(Text(localization::video_settings[language]));
+  strings.set_video_settings_unavailable(
+      Text(localization::video_settings_unavailable[language]));
+  strings.set_video_quality(Text(localization::video_quality[language]));
+  strings.set_frame_rate(Text(localization::video_frame_rate[language]));
+  strings.set_adaptation_policy(
+      Text(localization::video_adaptation_policy[language]));
+  strings.set_quality_low(Text(localization::video_quality_low[language]));
+  strings.set_quality_medium(
+      Text(localization::video_quality_medium[language]));
+  strings.set_quality_high(Text(localization::video_quality_high[language]));
+  strings.set_priority_frame_rate(
+      Text(localization::video_priority_frame_rate[language]));
+  strings.set_priority_quality(
+      Text(localization::video_priority_quality[language]));
+  strings.set_priority_balanced(
+      Text(localization::video_priority_balanced[language]));
   strings.set_audio(Text(localization::audio_capture[language]));
   strings.set_mute(Text(localization::mute[language]));
   strings.set_select_file(Text(localization::select_file[language]));
@@ -161,12 +210,20 @@ inline int ApplyStreamWindowStrings(
   strings.set_stats_out(Text(localization::out[language]));
   strings.set_stats_loss_rate(Text(localization::loss_rate[language]));
   strings.set_stats_resolution(Text(localization::resolution[language]));
+  strings.set_stats_video_latency(Text(localization::video_latency[language]));
+  strings.set_stats_connection_latency(Text(localization::connection_latency[language]));
   strings.set_stats_connection_mode(
       Text(localization::connection_mode[language]));
+  strings.set_stats_encryption(
+      Text(localization::transport_encryption[language]));
+  strings.set_stats_encryption_enabled(
+      Text(localization::transport_encryption_enabled[language]));
+  strings.set_stats_encryption_disabled(
+      Text(localization::transport_encryption_disabled[language]));
   return language;
 }
 
 }  // namespace crossdesk::ui_localization
 
 
-#endif
+#endif

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,670 +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);
-        ImGui::AlignTextToFramePadding();
-        ImGui::Text(
-            "%s",
-            localization::enable_srtp[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_srtp", &enable_srtp_);
-      }
-
-      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_;
-
-        // SRTP
-        if (enable_srtp_) {
-          config_center_->SetSrtp(true);
-        } else {
-          config_center_->SetSrtp(false);
-        }
-        enable_srtp_last_ = enable_srtp_;
-
-        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,197 +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.35f));
-      } 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.35f));
-      }
-
-      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_));
-      }
-
-      ImGui::Separator();
-
-      {
-        ImGui::AlignTextToFramePadding();
-        ImGui::Text("%s", localization::self_hosted_server_coturn_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("##coturn_server_port_self_", coturn_server_port_self_,
-                         IM_ARRAYSIZE(coturn_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_));
-        config_center_->SetCoturnServerPort(atoi(coturn_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';
-        strncpy(coturn_server_port_, coturn_server_port_self_,
-                sizeof(coturn_server_port_) - 1);
-        coturn_server_port_[sizeof(coturn_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';
-        }
-        int coturn_port = config_center_->GetCoturnServerPort();
-        if (coturn_port > 0) {
-          strncpy(coturn_server_port_self_, std::to_string(coturn_port).c_str(),
-                  sizeof(coturn_server_port_self_) - 1);
-          coturn_server_port_self_[sizeof(coturn_server_port_self_) - 1] = '\0';
-        } else {
-          coturn_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,311 +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;
-        }
-
-        std::string tab_label =
-            enable_srtp_
-                ? std::string(ICON_FA_SHIELD_HALVED) + " " + props->remote_id_
-                : 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/log/rd_log.cpp

@@ -1,63 +1,73 @@
 #include "rd_log.h"
 
-#include <atomic>
 #include <filesystem>
+#include <mutex>
+#include <vector>
+
+#include "spdlog/sinks/rotating_file_sink.h"
+#include "spdlog/sinks/stdout_color_sinks.h"
 
 namespace crossdesk {
 
 namespace {
 
 std::string g_log_dir = "logs";
+std::string g_logger_name = LOGGER_NAME;
 std::once_flag g_logger_once_flag;
+std::mutex g_logger_mutex;
 std::shared_ptr<spdlog::logger> g_logger;
-std::atomic<bool> g_logger_created{false};
+
+std::string NormalizeLogDirectory(const std::string& log_dir) {
+  const std::filesystem::path path = log_dir.empty() ? "logs" : log_dir;
+  std::error_code ec;
+  const auto absolute = std::filesystem::absolute(path, ec);
+  return (ec ? path : absolute).lexically_normal().string();
+}
 
 }  // namespace
 
-void InitLogger(const std::string& log_dir) {
-  if (g_logger_created.load()) {
-    LOG_WARN(
-        "InitLogger called after logger initialized. Ignoring log_dir: {}, "
-        "using previous log_dir: {}",
-        log_dir, g_log_dir);
+void InitLogger(const std::string& log_dir, const std::string& logger_name) {
+  const auto directory = NormalizeLogDirectory(log_dir);
+  std::lock_guard<std::mutex> lock(g_logger_mutex);
+  if (g_logger) {
+    if (directory != g_log_dir || logger_name != g_logger_name) {
+      g_logger->warn(
+          "InitLogger called after logger initialized. Keeping logger {} in {}",
+          g_logger_name, g_log_dir);
+    }
     return;
   }
 
-  g_log_dir = log_dir;
+  g_log_dir = directory;
+  g_logger_name = logger_name;
 }
 
 std::shared_ptr<spdlog::logger> get_logger() {
   std::call_once(g_logger_once_flag, []() {
-    g_logger_created.store(true);
+    std::lock_guard<std::mutex> lock(g_logger_mutex);
+    g_log_dir = NormalizeLogDirectory(g_log_dir);
 
     std::error_code ec;
     std::filesystem::create_directories(g_log_dir, ec);
 
-    auto now = std::chrono::system_clock::now() + std::chrono::hours(8);
-    auto now_time = std::chrono::system_clock::to_time_t(now);
-
-    std::tm tm_info;
-#ifdef _WIN32
-    gmtime_s(&tm_info, &now_time);
-#else
-    gmtime_r(&now_time, &tm_info);
-#endif
-
-    std::stringstream ss;
-    ss << LOGGER_NAME;
-    ss << std::put_time(&tm_info, "-%Y%m%d-%H%M%S.log");
-
-    std::string filename = g_log_dir + "/" + ss.str();
+    // Reuse the same rotation set across restarts. Timestamped base names
+    // give each launch its own backups and let the directory grow forever.
+    auto file_sink = std::make_shared<spdlog::sinks::rotating_file_sink_mt>(
+        g_log_dir + "/" + g_logger_name + ".log", 5 * 1024 * 1024, 3);
 
     std::vector<spdlog::sink_ptr> sinks;
     sinks.push_back(std::make_shared<spdlog::sinks::stdout_color_sink_mt>());
-    sinks.push_back(std::make_shared<spdlog::sinks::rotating_file_sink_mt>(
-        filename, 5 * 1024 * 1024, 3));
+    sinks.push_back(file_sink);
 
-    g_logger = std::make_shared<spdlog::logger>(LOGGER_NAME, sinks.begin(),
-                                                sinks.end());
-    g_logger->flush_on(spdlog::level::info);
-    spdlog::register_logger(g_logger);
+    auto logger = std::make_shared<spdlog::logger>(g_logger_name, sinks.begin(),
+                                                   sinks.end());
+    logger->set_level(SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_DEBUG
+                          ? spdlog::level::debug
+                          : spdlog::level::info);
+    logger->flush_on(spdlog::level::info);
+    spdlog::register_logger(logger);
+    logger->info("Logger initialized: path={}", file_sink->filename());
+    g_logger = std::move(logger);
   });
 
   return g_logger;

apps/desktop/src/log/rd_log.h

@@ -7,35 +7,29 @@
 #ifndef _RD_LOG_H_
 #define _RD_LOG_H_
 
-#include <chrono>
-#include <iomanip>
-#include <iostream>
 #include <memory>
-#include <mutex>
-#include <sstream>
 #include <string>
-#include <vector>
-
-#include "spdlog/common.h"
-#include "spdlog/logger.h"
-#include "spdlog/sinks/base_sink.h"
-#include "spdlog/sinks/rotating_file_sink.h"
-#include "spdlog/sinks/stdout_color_sinks.h"
-#include "spdlog/spdlog.h"
 
+#ifndef SPDLOG_ACTIVE_LEVEL
 #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO
+#endif
+
+#include "spdlog/spdlog.h"
 
 namespace crossdesk {
 
 constexpr auto LOGGER_NAME = "crossdesk";
 
-void InitLogger(const std::string& log_dir);
+void InitLogger(const std::string& log_dir,
+                const std::string& logger_name = LOGGER_NAME);
 
 std::shared_ptr<spdlog::logger> get_logger();
 
+#define LOG_TRACE(...) SPDLOG_LOGGER_TRACE(get_logger(), __VA_ARGS__)
+#define LOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(get_logger(), __VA_ARGS__)
 #define LOG_INFO(...) SPDLOG_LOGGER_INFO(get_logger(), __VA_ARGS__)
 #define LOG_WARN(...) SPDLOG_LOGGER_WARN(get_logger(), __VA_ARGS__)
 #define LOG_ERROR(...) SPDLOG_LOGGER_ERROR(get_logger(), __VA_ARGS__)
 #define LOG_FATAL(...) SPDLOG_LOGGER_CRITICAL(get_logger(), __VA_ARGS__)
 }  // namespace crossdesk
-#endif
+#endif

apps/desktop/src/platform/common/gui/opengl_video_renderer.cpp

@@ -59,6 +59,7 @@ struct FrameSlot {
   int height = 0;
   std::string remote_id;
   uint64_t sequence = 0;
+  VideoLatencyFrame timing;
   SlotUse use = SlotUse::available;
   bool valid = false;
 };
@@ -122,6 +123,11 @@ struct OpenGlFunctions {
   PFNGLUNIFORM4FPROC uniform_4f = nullptr;
   PFNGLUSEPROGRAMPROC use_program = nullptr;
   PFNGLVERTEXATTRIBPOINTERPROC vertex_attrib_pointer = nullptr;
+  PFNGLGENFRAMEBUFFERSPROC gen_framebuffers = nullptr;
+  PFNGLDELETEFRAMEBUFFERSPROC delete_framebuffers = nullptr;
+  PFNGLBINDFRAMEBUFFERPROC bind_framebuffer = nullptr;
+  PFNGLFRAMEBUFFERTEXTURE2DPROC framebuffer_texture_2d = nullptr;
+  PFNGLCHECKFRAMEBUFFERSTATUSPROC check_framebuffer_status = nullptr;
 #if CROSSDESK_OPENGL_CUDA_INTEROP
   PFNGLFENCESYNCPROC fence_sync = nullptr;
   PFNGLCLIENTWAITSYNCPROC client_wait_sync = nullptr;
@@ -163,6 +169,15 @@ struct OpenGlFunctions {
            LoadOpenGlFunction(&vertex_attrib_pointer, "glVertexAttribPointer");
   }
 
+  bool LoadFramebufferFunctions() {
+    return LoadOpenGlFunction(&gen_framebuffers, "glGenFramebuffers") &&
+           LoadOpenGlFunction(&delete_framebuffers, "glDeleteFramebuffers") &&
+           LoadOpenGlFunction(&bind_framebuffer, "glBindFramebuffer") &&
+           LoadOpenGlFunction(&framebuffer_texture_2d, "glFramebufferTexture2D") &&
+           LoadOpenGlFunction(&check_framebuffer_status,
+                              "glCheckFramebufferStatus");
+  }
+
 #if CROSSDESK_OPENGL_CUDA_INTEROP
   bool LoadSyncFunctions() {
     return LoadOpenGlFunction(&fence_sync, "glFenceSync") &&
@@ -287,6 +302,17 @@ struct OpenGlVideoRenderer::Impl {
   GLint video_rect_location = -1;
   GLint corner_radius_location = -1;
   GLint video_enabled_location = -1;
+  GLint source_size_location = -1;
+  GLint filter_direction_location = -1;
+  GLint packed_video_location = -1;
+  GLuint scale_framebuffer = 0;
+  std::array<GLuint, 2> scale_textures{};
+  std::array<std::pair<int, int>, 2> scale_sizes{};
+  uint64_t scaled_sequence = 0;
+  bool scaling_available = false;
+  GLenum framebuffer_target = GL_FRAMEBUFFER;
+  GLenum framebuffer_binding = GL_FRAMEBUFFER_BINDING;
+  std::array<int, 4> logged_render_size{};
   int texture_width = 0;
   int texture_height = 0;
   int cpu_texture_width = 0;
@@ -295,6 +321,7 @@ struct OpenGlVideoRenderer::Impl {
   bool unpack_subimage_available = false;
   std::string uploaded_stream;
   uint64_t uploaded_sequence = 0;
+  VideoLatencyFrame uploaded_timing;
 
 #if CROSSDESK_OPENGL_CUDA_INTEROP
   enum class CudaUploadResult {
@@ -504,6 +531,116 @@ struct OpenGlVideoRenderer::Impl {
   }
 #endif
 
+  // The vertex buffer and program are shared with the final underlay draw.
+  void DrawVideo(GLuint y, GLuint uv, int source_width, int source_height,
+                 int target_width, int target_height, int video_x, int video_y,
+                 int video_width, int video_height, int corner_radius,
+                 bool enabled, bool packed, float filter_x = 0.0f,
+                 float filter_y = 0.0f) {
+    gl.active_texture(GL_TEXTURE0);
+    glBindTexture(GL_TEXTURE_2D, y);
+    gl.active_texture(GL_TEXTURE1);
+    glBindTexture(GL_TEXTURE_2D, uv);
+    gl.uniform_2f(source_size_location, static_cast<GLfloat>(source_width),
+                  static_cast<GLfloat>(source_height));
+    gl.uniform_2f(target_size_location, static_cast<GLfloat>(target_width),
+                  static_cast<GLfloat>(target_height));
+    gl.uniform_4f(video_rect_location, static_cast<GLfloat>(video_x),
+                  static_cast<GLfloat>(video_y), static_cast<GLfloat>(video_width),
+                  static_cast<GLfloat>(video_height));
+    gl.uniform_1f(corner_radius_location, static_cast<GLfloat>(corner_radius));
+    gl.uniform_1f(video_enabled_location, enabled ? 1.0f : 0.0f);
+    gl.uniform_1f(packed_video_location, packed ? 1.0f : 0.0f);
+    gl.uniform_2f(filter_direction_location, filter_x, filter_y);
+    glViewport(0, 0, target_width, target_height);
+    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+  }
+
+  bool PrepareScaleTarget(size_t index, int width, int height) {
+    gl.active_texture(GL_TEXTURE0);
+    glBindTexture(GL_TEXTURE_2D, scale_textures[index]);
+    if (scale_sizes[index] != std::pair{width, height}) {
+      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA,
+                   GL_UNSIGNED_BYTE, nullptr);
+      scale_sizes[index] = {width, height};
+    }
+    gl.framebuffer_texture_2d(framebuffer_target, GL_COLOR_ATTACHMENT0,
+                              GL_TEXTURE_2D, scale_textures[index], 0);
+    return gl.check_framebuffer_status(framebuffer_target) ==
+               GL_FRAMEBUFFER_COMPLETE &&
+           glGetError() == GL_NO_ERROR;
+  }
+
+  bool ScaleVideo(GLuint y, GLuint uv, int width, int height, int output_width,
+                  int output_height) {
+    if (!scaling_available) {
+      return false;
+    }
+    if (scaled_sequence == uploaded_sequence &&
+        scale_sizes[1] == std::pair{output_width, output_height}) {
+      return true;
+    }
+
+    GLint previous_framebuffer = 0;
+    glGetIntegerv(framebuffer_binding, &previous_framebuffer);
+    if (scale_framebuffer == 0) {
+      gl.gen_framebuffers(1, &scale_framebuffer);
+      glGenTextures(static_cast<GLsizei>(scale_textures.size()),
+                      scale_textures.data());
+      gl.active_texture(GL_TEXTURE0);
+      for (const GLuint texture : scale_textures) {
+        glBindTexture(GL_TEXTURE_2D, texture);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+      }
+    }
+    // A CUDA upload may have left its PBO bound: nullptr below allocates empty
+    // render targets and must never be interpreted as a PBO byte offset.
+    if (pixel_unpack_buffer_available) {
+      gl.bind_buffer(GL_PIXEL_UNPACK_BUFFER, 0);
+    }
+    gl.bind_framebuffer(framebuffer_target, scale_framebuffer);
+    bool success = scale_framebuffer != 0 && scale_textures[0] != 0 &&
+                   scale_textures[1] != 0;
+    bool packed = false;
+    while (success && (width != output_width || height != output_height)) {
+      // Bound shader work without truncating the filter for very small windows.
+      const int next_width = std::max(output_width, (width + 3) / 4);
+      const int next_height = std::max(output_height, (height + 3) / 4);
+      if (!PrepareScaleTarget(0, next_width, height)) {
+        success = false;
+        break;
+      }
+      DrawVideo(y, uv, width, height, next_width, height, 0, 0, next_width,
+                height, 0, true, packed, 1.0f, 0.0f);
+      if (!PrepareScaleTarget(1, next_width, next_height)) {
+        success = false;
+        break;
+      }
+      DrawVideo(scale_textures[0], uv, next_width, height, next_width,
+                next_height, 0, 0, next_width, next_height, 0, true, true,
+                0.0f, 1.0f);
+      success = glGetError() == GL_NO_ERROR;
+      y = scale_textures[1];
+      width = next_width;
+      height = next_height;
+      packed = true;
+    }
+    gl.bind_framebuffer(framebuffer_target,
+                         static_cast<GLuint>(previous_framebuffer));
+    if (!success) {
+      scaling_available = false;
+      while (glGetError() != GL_NO_ERROR) {
+      }
+      LOG_WARN("OpenGL video downsampling unavailable; using linear sampling");
+      return false;
+    }
+    scaled_sequence = uploaded_sequence;
+    return true;
+  }
+
   void ResetGlHandles() {
     program = 0;
     vertex_buffer = 0;
@@ -517,6 +654,15 @@ struct OpenGlVideoRenderer::Impl {
     video_rect_location = -1;
     corner_radius_location = -1;
     video_enabled_location = -1;
+    source_size_location = -1;
+    filter_direction_location = -1;
+    packed_video_location = -1;
+    scale_framebuffer = 0;
+    scale_textures = {};
+    scale_sizes = {};
+    scaled_sequence = 0;
+    scaling_available = false;
+    logged_render_size = {};
     texture_width = 0;
     texture_height = 0;
     cpu_texture_width = 0;
@@ -559,6 +705,10 @@ bool OpenGlVideoRenderer::Setup() {
                     HasOpenGlExtension(extensions, "GL_ARB_pixel_buffer_object")));
   impl_->unpack_subimage_available = !is_gles || major >= 3 ||
       HasOpenGlExtension(extensions, "GL_EXT_unpack_subimage");
+  impl_->scaling_available = impl_->gl.LoadFramebufferFunctions();
+  impl_->framebuffer_target = major >= 3 ? GL_DRAW_FRAMEBUFFER : GL_FRAMEBUFFER;
+  impl_->framebuffer_binding =
+      major >= 3 ? GL_DRAW_FRAMEBUFFER_BINDING : GL_FRAMEBUFFER_BINDING;
 #if CROSSDESK_OPENGL_CUDA_INTEROP
   // GLX may return entry points even if the current GLES 2 context cannot
   // use them. Gate CUDA interop on context capabilities as well as symbols.
@@ -577,8 +727,8 @@ bool OpenGlVideoRenderer::Setup() {
   }
 #endif
 
-  static constexpr char kGlesVertexShader[] = R"glsl(
-#version 100
+  const std::string vertex_source =
+      std::string(is_gles ? "#version 100\n" : "#version 110\n") + R"glsl(
 attribute vec2 position;
 attribute vec2 texcoord;
 varying vec2 video_texcoord;
@@ -587,20 +737,56 @@ void main() {
   gl_Position = vec4(position, 0.0, 1.0);
 }
 )glsl";
-  static constexpr char kGlesFragmentShader[] = R"glsl(
-#version 100
-#ifdef GL_FRAGMENT_PRECISION_HIGH
-precision highp float;
-#else
-precision mediump float;
-#endif
+  const std::string fragment_source =
+      std::string(is_gles ? "#version 100\n"
+                           "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
+                           "precision highp float;\n"
+                           "#else\nprecision mediump float;\n#endif\n"
+                         : "#version 110\n") + R"glsl(
 uniform sampler2D y_texture;
 uniform sampler2D uv_texture;
 uniform vec2 target_size;
+uniform vec2 source_size;
+uniform vec2 filter_direction;
+uniform float packed_video;
 uniform vec4 video_rect;
 uniform float corner_radius;
 uniform float video_enabled;
 varying vec2 video_texcoord;
+// A separable Lanczos-2 low-pass filter. Each pass reduces by at most 4x,
+// so 16 taps cover its complete support even for non-integer scale ratios.
+float lanczos2(float x) {
+  x = abs(x);
+  if (x < 0.0001) return 1.0;
+  if (x >= 2.0) return 0.0;
+  float p = 3.14159265359 * x;
+  return sin(p) * sin(p * 0.5) / (p * p * 0.5);
+}
+vec4 sample_plane(sampler2D plane, vec2 size, vec2 coord) {
+  // FBO textures have the opposite vertical origin to the decoded NV12 planes.
+  if (packed_video > 0.5) coord.y = 1.0 - coord.y;
+  if (filter_direction.x + filter_direction.y < 0.5)
+    return texture2D(plane, coord);
+  float scale = max(1.0, dot(size / video_rect.zw, filter_direction));
+  float center = dot(coord * size - vec2(0.5), filter_direction);
+  float first = floor(center - 2.0 * scale) + 1.0;
+  vec4 sum = vec4(0.0);
+  float weight_sum = 0.0;
+  for (int tap = 0; tap < 16; ++tap) {
+    float offset = first + float(tap) - center;
+    if (offset >= 2.0 * scale) break;
+    float weight = lanczos2(offset / scale);
+    sum += weight * texture2D(plane, coord + filter_direction * offset / size);
+    weight_sum += weight;
+  }
+  return sum / weight_sum;
+}
+vec3 sample_video(vec2 coord) {
+  vec4 y_sample = sample_plane(y_texture, source_size, coord);
+  if (packed_video > 0.5) return y_sample.rgb;
+  return vec3(y_sample.r,
+              sample_plane(uv_texture, source_size * 0.5, coord).ra);
+}
 void main() {
   vec2 surface_point = video_texcoord * target_size;
   vec3 rgb = vec3(0.0);
@@ -611,10 +797,14 @@ void main() {
       surface_point.y <= video_rect.y + video_rect.w) {
     vec2 frame_texcoord =
         (surface_point - video_rect.xy) / video_rect.zw;
-    float y = 1.16438356 *
-              (texture2D(y_texture, frame_texcoord).r - 16.0 / 255.0);
-    vec2 uv =
-        texture2D(uv_texture, frame_texcoord).ra - vec2(0.5, 0.5);
+    vec3 yuv = sample_video(frame_texcoord);
+    if (filter_direction.x + filter_direction.y > 0.5) {
+      // Intermediate RGBA textures carry Y/U/V until the final conversion.
+      gl_FragColor = vec4(yuv, 1.0);
+      return;
+    }
+    float y = 1.16438356 * (yuv.x - 16.0 / 255.0);
+    vec2 uv = yuv.yz - vec2(0.5);
     rgb = clamp(vec3(y + 1.59602678 * uv.y,
                      y - 0.39176229 * uv.x - 0.81296764 * uv.y,
                      y + 2.01723214 * uv.x),
@@ -633,67 +823,11 @@ void main() {
   gl_FragColor = vec4(rgb * coverage, coverage);
 }
 )glsl";
-  static constexpr char kDesktopVertexShader[] = R"glsl(
-#version 110
-attribute vec2 position;
-attribute vec2 texcoord;
-varying vec2 video_texcoord;
-void main() {
-  video_texcoord = texcoord;
-  gl_Position = vec4(position, 0.0, 1.0);
-}
-)glsl";
-  static constexpr char kDesktopFragmentShader[] = R"glsl(
-#version 110
-uniform sampler2D y_texture;
-uniform sampler2D uv_texture;
-uniform vec2 target_size;
-uniform vec4 video_rect;
-uniform float corner_radius;
-uniform float video_enabled;
-varying vec2 video_texcoord;
-void main() {
-  vec2 surface_point = video_texcoord * target_size;
-  vec3 rgb = vec3(0.0);
-  if (video_enabled > 0.5 &&
-      surface_point.x >= video_rect.x &&
-      surface_point.x <= video_rect.x + video_rect.z &&
-      surface_point.y >= video_rect.y &&
-      surface_point.y <= video_rect.y + video_rect.w) {
-    vec2 frame_texcoord =
-        (surface_point - video_rect.xy) / video_rect.zw;
-    float y = 1.16438356 *
-              (texture2D(y_texture, frame_texcoord).r - 16.0 / 255.0);
-    vec2 uv =
-        texture2D(uv_texture, frame_texcoord).ra - vec2(0.5, 0.5);
-    rgb = clamp(vec3(y + 1.59602678 * uv.y,
-                     y - 0.39176229 * uv.x - 0.81296764 * uv.y,
-                     y + 2.01723214 * uv.x),
-                0.0, 1.0);
-  }
-  float coverage = 1.0;
-  if (corner_radius > 0.0) {
-    vec2 half_size = target_size * 0.5;
-    vec2 corner = abs(surface_point - half_size) -
-                  (half_size - vec2(corner_radius));
-    float distance_to_edge =
-        length(max(corner, vec2(0.0))) +
-        min(max(corner.x, corner.y), 0.0) - corner_radius;
-    coverage = clamp(0.5 - distance_to_edge, 0.0, 1.0);
-  }
-  gl_FragColor = vec4(rgb * coverage, coverage);
-}
-)glsl";
-
-  const char *vertex_source =
-      is_gles ? kGlesVertexShader : kDesktopVertexShader;
-  const char *fragment_source =
-      is_gles ? kGlesFragmentShader : kDesktopFragmentShader;
 
   const GLuint vertex_shader =
-      CompileShader(impl_->gl, GL_VERTEX_SHADER, vertex_source);
+      CompileShader(impl_->gl, GL_VERTEX_SHADER, vertex_source.c_str());
   const GLuint fragment_shader =
-      CompileShader(impl_->gl, GL_FRAGMENT_SHADER, fragment_source);
+      CompileShader(impl_->gl, GL_FRAGMENT_SHADER, fragment_source.c_str());
   if (vertex_shader == 0 || fragment_shader == 0) {
     if (vertex_shader != 0)
       impl_->gl.delete_shader(vertex_shader);
@@ -743,11 +877,18 @@ void main() {
       impl_->gl.get_uniform_location(impl_->program, "corner_radius");
   impl_->video_enabled_location =
       impl_->gl.get_uniform_location(impl_->program, "video_enabled");
+  impl_->source_size_location =
+      impl_->gl.get_uniform_location(impl_->program, "source_size");
+  impl_->filter_direction_location =
+      impl_->gl.get_uniform_location(impl_->program, "filter_direction");
+  impl_->packed_video_location =
+      impl_->gl.get_uniform_location(impl_->program, "packed_video");
   if (impl_->position_location < 0 || impl_->texcoord_location < 0 ||
       impl_->y_texture_location < 0 || impl_->uv_texture_location < 0 ||
       impl_->target_size_location < 0 || impl_->video_rect_location < 0 ||
       impl_->corner_radius_location < 0 ||
-      impl_->video_enabled_location < 0) {
+      impl_->video_enabled_location < 0 || impl_->source_size_location < 0 ||
+      impl_->filter_direction_location < 0 || impl_->packed_video_location < 0) {
     LOG_ERROR("OpenGL NV12 program is missing required shader bindings");
     impl_->gl.delete_program(impl_->program);
     impl_->ResetGlHandles();
@@ -817,6 +958,11 @@ void main() {
 
 void OpenGlVideoRenderer::Teardown() {
   impl_->ready.store(false, std::memory_order_release);
+  if (impl_->scale_framebuffer != 0) {
+    impl_->gl.delete_framebuffers(1, &impl_->scale_framebuffer);
+  }
+  glDeleteTextures(static_cast<GLsizei>(impl_->scale_textures.size()),
+                    impl_->scale_textures.data());
 #if CROSSDESK_OPENGL_CUDA_INTEROP
   impl_->ReleaseCudaInterop();
 #endif
@@ -879,25 +1025,22 @@ void OpenGlVideoRenderer::DiscardStream(std::string_view remote_id) {
   }
 }
 
-OpenGlVideoRenderer::SubmitResult
-OpenGlVideoRenderer::SubmitNv12(std::string_view remote_id,
-                                       const uint8_t *data, size_t size,
-                                       int width, int height) {
-  return SubmitNv12Internal(remote_id, data, size, width, height, true);
+OpenGlVideoRenderer::SubmitResult OpenGlVideoRenderer::SubmitNv12(
+    std::string_view remote_id, const uint8_t *data, size_t size, int width,
+    int height, VideoLatencyFrame timing) {
+  return SubmitNv12Internal(remote_id, data, size, width, height, true, timing);
 }
 
-OpenGlVideoRenderer::SubmitResult
-OpenGlVideoRenderer::SubmitCachedNv12(std::string_view remote_id,
-                                             const uint8_t *data, size_t size,
-                                             int width, int height) {
-  return SubmitNv12Internal(remote_id, data, size, width, height, false);
+OpenGlVideoRenderer::SubmitResult OpenGlVideoRenderer::SubmitCachedNv12(
+    std::string_view remote_id, const uint8_t *data, size_t size, int width,
+    int height, VideoLatencyFrame timing) {
+  return SubmitNv12Internal(remote_id, data, size, width, height, false,
+                            timing);
 }
 
-OpenGlVideoRenderer::SubmitResult
-OpenGlVideoRenderer::SubmitNv12Internal(std::string_view remote_id,
-                                               const uint8_t *data, size_t size,
-                                               int width, int height,
-                                               bool replace_pending) {
+OpenGlVideoRenderer::SubmitResult OpenGlVideoRenderer::SubmitNv12Internal(
+    std::string_view remote_id, const uint8_t *data, size_t size, int width,
+    int height, bool replace_pending, VideoLatencyFrame timing) {
   if (!IsReady()) {
     return SubmitResult::failed;
   }
@@ -960,14 +1103,15 @@ OpenGlVideoRenderer::SubmitNv12Internal(std::string_view remote_id,
   target->height = height;
   target->remote_id.assign(remote_id);
   target->sequence = frames.next_sequence++;
+  target->timing = timing;
   target->use = SlotUse::pending;
   target->valid = true;
   return SubmitResult::submitted;
 }
 
-OpenGlVideoRenderer::SubmitResult
-OpenGlVideoRenderer::SubmitNativeFrame(std::string_view remote_id,
-                                       const MiniRtcNativeVideoFrame &frame) {
+OpenGlVideoRenderer::SubmitResult OpenGlVideoRenderer::SubmitNativeFrame(
+    std::string_view remote_id, const MiniRtcNativeVideoFrame &frame,
+    VideoLatencyFrame timing) {
   if (!IsReady()) {
     return SubmitResult::failed;
   }
@@ -1039,6 +1183,7 @@ OpenGlVideoRenderer::SubmitNativeFrame(std::string_view remote_id,
   target->height = static_cast<int>(native->height);
   target->remote_id.assign(remote_id);
   target->sequence = frames.next_sequence++;
+  target->timing = timing;
   target->use = SlotUse::pending;
   target->valid = true;
   return SubmitResult::submitted;
@@ -1060,6 +1205,7 @@ OpenGlVideoRenderer::RenderLatest(std::string_view remote_id,
   const unsigned char *y_data = nullptr;
   const unsigned char *uv_data = nullptr;
   NativeVideoFrameRef active_native_frame;
+  VideoLatencyFrame timing;
   {
     std::lock_guard lock(impl_->frames->mutex);
     for (size_t index = 0; index < impl_->frames->slots.size(); ++index) {
@@ -1077,6 +1223,7 @@ OpenGlVideoRenderer::RenderLatest(std::string_view remote_id,
       source_width = selected.width;
       source_height = selected.height;
       active_native_frame = selected.native_frame;
+      timing = selected.timing;
       if (!selected.bytes.empty()) {
         const size_t y_size = static_cast<size_t>(source_width) * source_height;
         y_data = selected.bytes.data();
@@ -1277,6 +1424,7 @@ OpenGlVideoRenderer::RenderLatest(std::string_view remote_id,
         impl_->texture_height = source_height;
         impl_->uploaded_stream.assign(remote_id);
         impl_->uploaded_sequence = sequence;
+        impl_->uploaded_timing = timing;
         if (!use_pixel_unpack_buffer) {
           impl_->cpu_texture_width = source_width;
           impl_->cpu_texture_height = source_height;
@@ -1356,24 +1504,8 @@ OpenGlVideoRenderer::RenderLatest(std::string_view remote_id,
   }
 #endif
   impl_->gl.use_program(impl_->program);
-  impl_->gl.active_texture(GL_TEXTURE0);
-  glBindTexture(GL_TEXTURE_2D, displayed_y_texture);
   impl_->gl.uniform_1i(impl_->y_texture_location, 0);
-  impl_->gl.active_texture(GL_TEXTURE1);
-  glBindTexture(GL_TEXTURE_2D, displayed_uv_texture);
   impl_->gl.uniform_1i(impl_->uv_texture_location, 1);
-  impl_->gl.uniform_2f(impl_->target_size_location,
-                       static_cast<GLfloat>(target_width),
-                       static_cast<GLfloat>(target_height));
-  impl_->gl.uniform_4f(
-      impl_->video_rect_location, static_cast<GLfloat>(video_x),
-      static_cast<GLfloat>(video_y), static_cast<GLfloat>(video_width),
-      static_cast<GLfloat>(video_height));
-  impl_->gl.uniform_1f(
-      impl_->corner_radius_location,
-      static_cast<GLfloat>(std::clamp(
-          corner_radius_pixels, 0, std::min(target_width, target_height) / 2)));
-  impl_->gl.uniform_1f(impl_->video_enabled_location, has_video ? 1.0f : 0.0f);
   impl_->gl.bind_buffer(GL_ARRAY_BUFFER, impl_->vertex_buffer);
   impl_->gl.vertex_attrib_pointer(
       static_cast<GLuint>(impl_->position_location), 2, GL_FLOAT, GL_FALSE,
@@ -1386,7 +1518,25 @@ OpenGlVideoRenderer::RenderLatest(std::string_view remote_id,
       static_cast<GLuint>(impl_->position_location));
   impl_->gl.enable_vertex_attrib_array(
       static_cast<GLuint>(impl_->texcoord_location));
-  glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+  const bool downscaled = has_video &&
+      (source_width > video_width || source_height > video_height) &&
+      impl_->ScaleVideo(displayed_y_texture, displayed_uv_texture, source_width,
+                        source_height, video_width, video_height);
+  impl_->DrawVideo(
+      downscaled ? impl_->scale_textures[1] : displayed_y_texture,
+      displayed_uv_texture, downscaled ? video_width : source_width,
+      downscaled ? video_height : source_height, target_width, target_height,
+      video_x, video_y, video_width, video_height,
+      std::clamp(corner_radius_pixels, 0, std::min(target_width, target_height) / 2),
+      has_video, downscaled);
+  const std::array<int, 4> render_size{
+      source_width, source_height, video_width, video_height};
+  if (has_video && impl_->logged_render_size != render_size) {
+    LOG_INFO("OpenGL video presentation: source={}x{}, display={}x{} physical "
+             "pixels, filter={}", source_width, source_height, video_width,
+             video_height, downscaled ? "Lanczos2" : "linear");
+    impl_->logged_render_size = render_size;
+  }
 #if CROSSDESK_OPENGL_CUDA_INTEROP
   if (impl_->displayed_cuda_upload_slot < impl_->cuda_upload_slots.size()) {
     auto &cuda_slot =
@@ -1403,6 +1553,8 @@ OpenGlVideoRenderer::RenderLatest(std::string_view remote_id,
   }
 #endif
   const GLenum draw_error = glGetError();
+  if (has_video && draw_error == GL_NO_ERROR)
+    impl_->uploaded_timing.MarkSubmitted();
   RenderOutcome outcome{
       !upload_succeeded || draw_error != GL_NO_ERROR
           ? RenderResult::failed

apps/desktop/src/platform/common/gui/opengl_video_renderer.h

@@ -39,11 +39,14 @@ public:
 
   // Thread-safe; called from MiniRTC's decode callback thread.
   SubmitResult SubmitNv12(std::string_view remote_id, const uint8_t *data,
-                          size_t size, int width, int height) override;
+                          size_t size, int width, int height,
+                          VideoLatencyFrame timing = {}) override;
   SubmitResult SubmitCachedNv12(std::string_view remote_id, const uint8_t *data,
-                                size_t size, int width, int height) override;
+                                size_t size, int width, int height,
+                                VideoLatencyFrame timing = {}) override;
   SubmitResult SubmitNativeFrame(std::string_view remote_id,
-                                 const MiniRtcNativeVideoFrame &frame) override;
+                                 const MiniRtcNativeVideoFrame &frame,
+                                 VideoLatencyFrame timing = {}) override;
 
   // Draws below Slint while its OpenGL context is current. All dimensions are
   // physical pixels in the window client area. corner_radius_pixels clips the
@@ -61,7 +64,8 @@ public:
 private:
   SubmitResult SubmitNv12Internal(std::string_view remote_id,
                                   const uint8_t *data, size_t size, int width,
-                                  int height, bool replace_pending);
+                                  int height, bool replace_pending,
+                                  VideoLatencyFrame timing);
 
   struct Impl;
   std::unique_ptr<Impl> impl_;