[fix] fix height when server window is restored from collapsed state

src/common/window_util_mac.h

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

src/common/window_util_mac.mm

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

src/gui/assets/localization/localization.h

@@ -197,6 +197,10 @@ static std::vector<std::string> completed = {
     reinterpret_cast<const char*>(u8"已完成"), "Completed"};
 static std::vector<std::string> failed = {
     reinterpret_cast<const char*>(u8"失败"), "Failed"};
+static std::vector<std::string> controller = {
+    reinterpret_cast<const char*>(u8"控制端:"), "Controller:"};
+static std::vector<std::string> file_transfer = {
+    reinterpret_cast<const char*>(u8"文件传输:"), "File Transfer:"};
 
 #if _WIN32
 static std::vector<std::string> minimize_to_tray = {

src/gui/panels/remote_peer_panel.cpp

@@ -207,6 +207,7 @@ int Render::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->control_data_label_.c_str(), true);
         AddDataStream(props->peer_, props->file_label_.c_str(), true);
         AddDataStream(props->peer_, props->file_feedback_label_.c_str(), true);
         AddDataStream(props->peer_, props->clipboard_label_.c_str(), true);

src/gui/render.cpp

@@ -2,6 +2,12 @@
 
 #include <libyuv.h>
 
+#if defined(__linux__) && !defined(__APPLE__)
+#include <X11/Xatom.h>
+#include <X11/Xlib.h>
+#endif
+
+#include <cstring>
 #include <filesystem>
 #include <fstream>
 #include <iostream>
@@ -21,10 +27,123 @@
 #include "screen_capturer_factory.h"
 #include "version_checker.h"
 
+#if defined(__APPLE__)
+#include "window_util_mac.h"
+#endif
+
 #define NV12_BUFFER_SIZE 1280 * 720 * 3 / 2
 
 namespace crossdesk {
 
+namespace {
+#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
+
 std::vector<char> Render::SerializeRemoteAction(const RemoteAction& action) {
   std::vector<char> buffer;
   buffer.push_back(static_cast<char>(action.type));
@@ -131,6 +250,20 @@ SDL_HitTestResult Render::HitTestCallback(SDL_Window* window,
     return SDL_HITTEST_NORMAL;
   }
 
+  // Server window: OS-level dragging for the title bar, but keep the left-side
+  // collapse/expand button clickable.
+  if (render->server_window_ && window == render->server_window_) {
+    const float title_h = render->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);
 
@@ -716,6 +849,7 @@ int Render::CreateConnectionPeer() {
 
     AddAudioStream(peer_, audio_label_.c_str());
     AddDataStream(peer_, data_label_.c_str(), false);
+    AddDataStream(peer_, control_data_label_.c_str(), true);
     AddDataStream(peer_, file_label_.c_str(), true);
     AddDataStream(peer_, file_feedback_label_.c_str(), true);
     AddDataStream(peer_, clipboard_label_.c_str(), true);
@@ -810,10 +944,16 @@ int Render::CreateMainWindow() {
   if (std::abs(dpi_scale_ - dpi_scale) > 0.01f) {
     dpi_scale_ = dpi_scale;
 
-    main_window_width_ = (int)(main_window_width_ * dpi_scale_);
-    main_window_height_ = (int)(main_window_height_ * dpi_scale_);
-    stream_window_width_ = (int)(stream_window_width_ * dpi_scale_);
-    stream_window_height_ = (int)(stream_window_height_ * 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_);
 
     SDL_SetWindowSize(main_window_, (int)main_window_width_,
                       (int)main_window_height_);
@@ -824,7 +964,7 @@ int Render::CreateMainWindow() {
   // for window region action
   SDL_SetWindowHitTest(main_window_, HitTestCallback, this);
 
-  SetupFontAndStyle(true);
+  SetupFontAndStyle(&main_windows_system_chinese_font_);
 
   ImGuiStyle& style = ImGui::GetStyle();
   style.ScaleAllSizes(dpi_scale_);
@@ -868,6 +1008,9 @@ int Render::CreateStreamWindow() {
     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");
@@ -893,7 +1036,7 @@ int Render::CreateStreamWindow() {
   // for window region action
   SDL_SetWindowHitTest(stream_window_, HitTestCallback, this);
 
-  SetupFontAndStyle(false);
+  SetupFontAndStyle(&stream_windows_system_chinese_font_);
 
   ImGuiStyle& style = ImGui::GetStyle();
   style.ScaleAllSizes(dpi_scale_);
@@ -938,7 +1081,126 @@ int Render::DestroyStreamWindow() {
   return 0;
 }
 
-int Render::SetupFontAndStyle(bool main_window) {
+int Render::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("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 an owned 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);
+
+    HWND owner_hwnd = nullptr;
+    if (main_window_) {
+      SDL_PropertiesID main_props = SDL_GetWindowProperties(main_window_);
+      owner_hwnd = (HWND)SDL_GetPointerProperty(
+          main_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);
+
+      if (owner_hwnd) {
+        SetWindowLongPtr(server_hwnd, GWLP_HWNDPARENT, (LONG_PTR)owner_hwnd);
+      }
+
+      // 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 Render::DestroyServerWindow() {
+  if (server_ctx_) {
+    ImGui::SetCurrentContext(server_ctx_);
+  }
+
+  if (server_renderer_) {
+    SDL_DestroyRenderer(server_renderer_);
+  }
+
+  if (server_window_) {
+    SDL_DestroyWindow(server_window_);
+  }
+
+  server_window_created_ = false;
+
+  return 0;
+}
+
+int Render::SetupFontAndStyle(ImFont** system_chinese_font_out) {
   float font_size = 32.0f;
 
   // Setup Dear ImGui style
@@ -960,10 +1222,8 @@ int Render::SetupFontAndStyle(bool main_window) {
   // Load system Chinese font as fallback
   config.MergeMode = false;
   config.FontDataOwnedByAtlas = false;
-  if (main_window) {
-    main_windows_system_chinese_font_ = nullptr;
-  } else {
-    stream_windows_system_chinese_font_ = nullptr;
+  if (system_chinese_font_out) {
+    *system_chinese_font_out = nullptr;
   }
 
 #if defined(_WIN32)
@@ -990,37 +1250,36 @@ int Render::SetupFontAndStyle(bool main_window) {
     std::ifstream font_file(font_paths[i], std::ios::binary);
     if (font_file.good()) {
       font_file.close();
-      if (main_window) {
-        main_windows_system_chinese_font_ =
-            io.Fonts->AddFontFromFileTTF(font_paths[i], font_size, &config,
-                                         io.Fonts->GetGlyphRangesChineseFull());
-        if (main_windows_system_chinese_font_ != nullptr) {
-          LOG_INFO("Loaded system Chinese font: {}", font_paths[i]);
-          break;
-        }
-      } else {
-        stream_windows_system_chinese_font_ =
-            io.Fonts->AddFontFromFileTTF(font_paths[i], font_size, &config,
-                                         io.Fonts->GetGlyphRangesChineseFull());
-        if (stream_windows_system_chinese_font_ != nullptr) {
-          LOG_INFO("Loaded system Chinese font: {}", font_paths[i]);
-          break;
-        }
+      if (!system_chinese_font_out) {
+        break;
+      }
+
+      *system_chinese_font_out =
+          io.Fonts->AddFontFromFileTTF(font_paths[i], font_size, &config,
+                                       io.Fonts->GetGlyphRangesChineseFull());
+      if (*system_chinese_font_out != nullptr) {
+        // Merge FontAwesome icons into the Chinese font
+        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, &config, icon_ranges);
+        config.MergeMode = false;
+        LOG_INFO("Loaded system Chinese font with icons: {}", font_paths[i]);
+        break;
       }
     }
   }
 
   // If no system font found, use default font
-  if (main_window) {
-    if (main_windows_system_chinese_font_ == nullptr) {
-      main_windows_system_chinese_font_ = io.Fonts->AddFontDefault(&config);
-      LOG_WARN("System Chinese font not found, using default font");
-    }
-  } else {
-    if (stream_windows_system_chinese_font_ == nullptr) {
-      stream_windows_system_chinese_font_ = io.Fonts->AddFontDefault(&config);
-      LOG_WARN("System Chinese font not found, using default font");
-    }
+  if (system_chinese_font_out && *system_chinese_font_out == nullptr) {
+    *system_chinese_font_out = io.Fonts->AddFontDefault(&config);
+    // Merge FontAwesome icons into the default font
+    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, &config, icon_ranges);
+    config.MergeMode = false;
+    LOG_WARN("System Chinese font not found, using default font with icons");
   }
 
   ImGui::StyleColorsLight();
@@ -1158,6 +1417,35 @@ int Render::DrawStreamWindow() {
   return 0;
 }
 
+int Render::DrawServerWindow() {
+  if (!server_ctx_) {
+    LOG_ERROR("Server context is null");
+    return -1;
+  }
+
+  if (server_window_) {
+    int w = 0;
+    int h = 0;
+    SDL_GetWindowSize(server_window_, &w, &h);
+    if (w > 0 && h > 0) {
+      server_window_width_ = (float)w;
+      server_window_height_ = (float)h;
+    }
+  }
+
+  ImGui::SetCurrentContext(server_ctx_);
+  ImGui_ImplSDLRenderer3_NewFrame();
+  ImGui_ImplSDL3_NewFrame();
+  ImGui::NewFrame();
+  ServerWindow();
+  ImGui::Render();
+  SDL_SetRenderDrawColor(server_renderer_, 255, 255, 255, 255);
+  SDL_RenderClear(server_renderer_);
+  ImGui_ImplSDLRenderer3_RenderDrawData(ImGui::GetDrawData(), server_renderer_);
+  SDL_RenderPresent(server_renderer_);
+  return 0;
+}
+
 int Render::Run() {
   latest_version_info_ = CheckUpdate();
   if (!latest_version_info_.empty() &&
@@ -1332,12 +1620,17 @@ void Render::MainLoop() {
     UpdateLabels();
     HandleRecentConnections();
     HandleStreamWindow();
+    HandleServerWindow();
 
     DrawMainWindow();
     if (stream_window_inited_) {
       DrawStreamWindow();
     }
 
+    if (is_server_mode_) {
+      DrawServerWindow();
+    }
+
     UpdateInteractions();
 
     if (need_to_send_host_info_) {
@@ -1375,8 +1668,8 @@ void Render::MainLoop() {
       remote_action.i.host_name_size = host_name.size();
 
       std::string msg = remote_action.to_json();
-      int ret =
-          SendDataFrame(peer_, msg.data(), msg.size(), data_label_.c_str());
+      int ret = SendReliableDataFrame(peer_, msg.data(), msg.size(),
+                                      control_data_label_.c_str());
       FreeRemoteAction(remote_action);
       if (0 == ret) {
         need_to_send_host_info_ = false;
@@ -1429,6 +1722,18 @@ void Render::HandleStreamWindow() {
   }
 }
 
+void Render::HandleServerWindow() {
+  if (need_to_create_server_window_) {
+    CreateServerWindow();
+    need_to_create_server_window_ = false;
+  }
+
+  if (need_to_destroy_server_window_) {
+    DestroyServerWindow();
+    need_to_destroy_server_window_ = false;
+  }
+}
+
 void Render::Cleanup() {
   Clipboard::StopMonitoring();
 
@@ -1807,6 +2112,16 @@ void Render::ProcessSdlEvent(const SDL_Event& event) {
     }
   }
 
+  if (server_window_inited_) {
+    if (server_ctx_) {
+      ImGui::SetCurrentContext(server_ctx_);
+      ImGui_ImplSDL3_ProcessEvent(&event);
+    } else {
+      LOG_ERROR("Server context is null");
+      return;
+    }
+  }
+
   switch (event.type) {
     case SDL_EVENT_QUIT:
       if (stream_window_inited_) {
@@ -1896,6 +2211,9 @@ void Render::ProcessSdlEvent(const SDL_Event& event) {
         foucs_on_main_window_ = false;
       }
       break;
+    case SDL_EVENT_DROP_FILE:
+      ProcessFileDropEvent(event);
+      break;
 
     case SDL_EVENT_MOUSE_MOTION:
     case SDL_EVENT_MOUSE_BUTTON_DOWN:
@@ -1976,4 +2294,112 @@ void Render::ProcessSdlEvent(const SDL_Event& event) {
       break;
   }
 }
+
+void Render::ProcessFileDropEvent(const SDL_Event& event) {
+  if (!((stream_window_ &&
+         SDL_GetWindowID(stream_window_) == event.window.windowID) ||
+        (server_window_ &&
+         SDL_GetWindowID(server_window_) == event.window.windowID))) {
+    return;
+  }
+
+  if (event.type != SDL_EVENT_DROP_FILE) {
+    return;
+  }
+
+  if (SDL_GetWindowID(stream_window_) == event.window.windowID) {
+    if (!stream_window_inited_) {
+      return;
+    }
+
+    std::shared_lock lock(client_properties_mutex_);
+    for (auto& [_, props] : client_properties_) {
+      if (props->tab_selected_) {
+        if (event.drop.data == nullptr) {
+          LOG_ERROR("ProcessFileDropEvent: drop event data is null");
+          break;
+        }
+
+        if (!props || !props->peer_) {
+          LOG_ERROR("ProcessFileDropEvent: invalid props or peer");
+          break;
+        }
+
+        std::string utf8_path = static_cast<const char*>(event.drop.data);
+        std::filesystem::path file_path = std::filesystem::u8path(utf8_path);
+
+        // Check if file exists
+        std::error_code ec;
+        if (!std::filesystem::exists(file_path, ec)) {
+          LOG_ERROR("ProcessFileDropEvent: file does not exist: {}",
+                    file_path.string().c_str());
+          break;
+        }
+
+        // Check if it's a regular file
+        if (!std::filesystem::is_regular_file(file_path, ec)) {
+          LOG_ERROR("ProcessFileDropEvent: path is not a regular file: {}",
+                    file_path.string().c_str());
+          break;
+        }
+
+        // Get file size
+        uint64_t file_size = std::filesystem::file_size(file_path, ec);
+        if (ec) {
+          LOG_ERROR("ProcessFileDropEvent: failed to get file size: {}",
+                    ec.message().c_str());
+          break;
+        }
+
+        LOG_INFO("Drop file [{}] to send (size: {} bytes)", event.drop.data,
+                 file_size);
+
+        // Use ProcessSelectedFile to handle the file processing
+        ProcessSelectedFile(utf8_path, props, props->file_label_);
+
+        break;
+      }
+    }
+  } else if (SDL_GetWindowID(server_window_) == event.window.windowID) {
+    if (!server_window_inited_) {
+      return;
+    }
+
+    if (event.drop.data == nullptr) {
+      LOG_ERROR("ProcessFileDropEvent: drop event data is null");
+      return;
+    }
+
+    std::string utf8_path = static_cast<const char*>(event.drop.data);
+    std::filesystem::path file_path = std::filesystem::u8path(utf8_path);
+
+    // Check if file exists
+    std::error_code ec;
+    if (!std::filesystem::exists(file_path, ec)) {
+      LOG_ERROR("ProcessFileDropEvent: file does not exist: {}",
+                file_path.string().c_str());
+      return;
+    }
+
+    // Check if it's a regular file
+    if (!std::filesystem::is_regular_file(file_path, ec)) {
+      LOG_ERROR("ProcessFileDropEvent: path is not a regular file: {}",
+                file_path.string().c_str());
+      return;
+    }
+
+    // Get file size
+    uint64_t file_size = std::filesystem::file_size(file_path, ec);
+    if (ec) {
+      LOG_ERROR("ProcessFileDropEvent: failed to get file size: {}",
+                ec.message().c_str());
+      return;
+    }
+
+    LOG_INFO("Drop file [{}] on server window (size: {} bytes)",
+             event.drop.data, file_size);
+
+    // Handle the dropped file on server window as needed
+  }
+}
 }  // namespace crossdesk

src/gui/render.h

@@ -46,8 +46,9 @@ class Render {
     Params params_;
     PeerPtr* peer_ = nullptr;
     std::string audio_label_ = "control_audio";
-    std::string data_label_ = "control_data";
+    std::string data_label_ = "data";
     std::string file_label_ = "file";
+    std::string control_data_label_ = "control_data";
     std::string file_feedback_label_ = "file_feedback";
     std::string clipboard_label_ = "clipboard";
     std::string local_id_ = "";
@@ -180,6 +181,7 @@ class Render {
   void UpdateInteractions();
   void HandleRecentConnections();
   void HandleStreamWindow();
+  void HandleServerWindow();
   void Cleanup();
   void CleanupFactories();
   void CleanupPeer(std::shared_ptr<SubStreamWindowProperties> props);
@@ -189,12 +191,20 @@ class Render {
   void UpdateRenderRect();
   void ProcessSdlEvent(const SDL_Event& event);
 
+  void ProcessFileDropEvent(const SDL_Event& event);
+
+  void ProcessSelectedFile(const std::string& path,
+                           std::shared_ptr<SubStreamWindowProperties>& props,
+                           const std::string& file_label);
+
  private:
   int CreateStreamRenderWindow();
   int TitleBar(bool main_window);
   int MainWindow();
   int UpdateNotificationWindow();
   int StreamWindow();
+  int ServerWindow();
+  int RemoteClientInfoWindow();
   int LocalWindow();
   int RemoteWindow();
   int RecentConnectionsWindow();
@@ -211,6 +221,7 @@ class Render {
   void Hyperlink(const std::string& label, const std::string& url,
                  const float window_width);
   int FileTransferWindow(std::shared_ptr<SubStreamWindowProperties>& props);
+  std::string OpenFileDialog(std::string title);
 
  private:
   int ConnectTo(const std::string& remote_id, const char* password,
@@ -219,11 +230,15 @@ class Render {
   int DestroyMainWindow();
   int CreateStreamWindow();
   int DestroyStreamWindow();
-  int SetupFontAndStyle(bool main_window);
+  int CreateServerWindow();
+  int DestroyServerWindow();
+  int SetupFontAndStyle(ImFont** system_chinese_font_out);
   int DestroyMainWindowContext();
   int DestroyStreamWindowContext();
+  int DestroyServerWindowContext();
   int DrawMainWindow();
   int DrawStreamWindow();
+  int DrawServerWindow();
   int ConfirmDeleteConnection();
   int NetTrafficStats(std::shared_ptr<SubStreamWindowProperties>& props);
   void DrawConnectionStatusText(
@@ -382,6 +397,7 @@ class Render {
   ImGuiContext* main_ctx_ = nullptr;
   ImFont* main_windows_system_chinese_font_ = nullptr;
   ImFont* stream_windows_system_chinese_font_ = nullptr;
+  ImFont* server_windows_system_chinese_font_ = nullptr;
   bool exit_ = false;
   const int sdl_refresh_ms_ = 16;  // ~60 FPS
 #if _WIN32
@@ -454,6 +470,7 @@ class Render {
   std::string controlled_remote_id_ = "";
   std::string focused_remote_id_ = "";
   bool need_to_send_host_info_ = false;
+  std::string remote_client_id_ = "";
   SDL_Event last_mouse_event;
   SDL_AudioStream* output_stream_;
   uint32_t STREAM_REFRESH_EVENT = 0;
@@ -480,6 +497,42 @@ class Render {
   float stream_window_dpi_scaling_w_ = 1.0f;
   float stream_window_dpi_scaling_h_ = 1.0f;
 
+  // server window render
+  SDL_Window* server_window_ = nullptr;
+  SDL_Renderer* server_renderer_ = nullptr;
+  ImGuiContext* server_ctx_ = nullptr;
+
+  // server window properties
+  bool need_to_create_server_window_ = false;
+  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;
+  SDL_PixelFormat server_pixformat_ = SDL_PIXELFORMAT_NV12;
+  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;
+
+  // server window collapsed mode
+  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;
+
+  // server window drag normal mode
+  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;
+
   bool label_inited_ = false;
   bool connect_button_pressed_ = false;
   bool password_validating_ = false;
@@ -496,6 +549,7 @@ class Render {
   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 delete_connection_ = false;

src/gui/render_callback.cpp

@@ -568,6 +568,7 @@ void Render::OnConnectionStatusCb(ConnectionStatus status, const char* user_id,
 
     switch (status) {
       case ConnectionStatus::Connected: {
+        render->need_to_send_host_info_ = true;
         if (!render->need_to_create_stream_window_ &&
             !render->client_properties_.empty()) {
           render->need_to_create_stream_window_ = true;
@@ -622,9 +623,12 @@ void Render::OnConnectionStatusCb(ConnectionStatus status, const char* user_id,
 
     switch (status) {
       case ConnectionStatus::Connected: {
+        render->need_to_create_server_window_ = true;
         render->need_to_send_host_info_ = true;
+        render->is_server_mode_ = true;
         render->start_screen_capturer_ = true;
         render->start_speaker_capturer_ = true;
+        render->remote_client_id_ = remote_id;
 #ifdef CROSSDESK_DEBUG
         render->start_mouse_controller_ = false;
         render->start_keyboard_capturer_ = false;
@@ -647,11 +651,14 @@ void Render::OnConnectionStatusCb(ConnectionStatus status, const char* user_id,
                                  kv.second == ConnectionStatus::Failed ||
                                  kv.second == ConnectionStatus::Disconnected;
                         })) {
+          render->need_to_destroy_server_window_ = true;
+          render->is_server_mode_ = false;
           render->start_screen_capturer_ = false;
           render->start_speaker_capturer_ = false;
           render->start_mouse_controller_ = false;
           render->start_keyboard_capturer_ = false;
           render->need_to_send_host_info_ = false;
+          render->remote_client_id_ = "";
           if (props) props->connection_established_ = false;
           if (render->audio_capture_) {
             render->StopSpeakerCapturer();

src/gui/toolbars/control_bar.cpp

@@ -15,18 +15,6 @@
 
 namespace crossdesk {
 
-std::string 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 CountDigits(int number) {
   if (number == 0) return 1;
   return (int)std::floor(std::log10(std::abs(number))) + 1;
@@ -53,6 +41,89 @@ int LossRateDisplay(float loss_rate) {
   return 0;
 }
 
+std::string Render::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 : "";
+}
+
+void Render::ProcessSelectedFile(
+    const std::string& path, std::shared_ptr<SubStreamWindowProperties>& props,
+    const std::string& file_label) {
+  if (path.empty()) {
+    return;
+  }
+
+  LOG_INFO("Selected file: {}", path.c_str());
+
+  std::filesystem::path file_path = std::filesystem::u8path(path);
+
+  // Get file size
+  std::error_code ec;
+  uint64_t file_size = std::filesystem::file_size(file_path, ec);
+  if (ec) {
+    LOG_ERROR("Failed to get file size: {}", ec.message().c_str());
+    file_size = 0;
+  }
+
+  // Add file to transfer list
+  {
+    std::lock_guard<std::mutex> lock(props->file_transfer_list_mutex_);
+    SubStreamWindowProperties::FileTransferInfo info;
+    info.file_name = file_path.filename().u8string();
+    info.file_path = file_path;  // Store full path for precise matching
+    info.file_size = file_size;
+    info.status = SubStreamWindowProperties::FileTransferStatus::Queued;
+    info.sent_bytes = 0;
+    info.file_id = 0;
+    info.rate_bps = 0;
+    props->file_transfer_list_.push_back(info);
+  }
+  props->file_transfer_window_visible_ = true;
+
+  if (props->file_sending_.load()) {
+    // Add to queue
+    size_t queue_size = 0;
+    {
+      std::lock_guard<std::mutex> lock(props->file_queue_mutex_);
+      SubStreamWindowProperties::QueuedFile queued_file;
+      queued_file.file_path = file_path;
+      queued_file.file_label = file_label;
+      props->file_send_queue_.push(queued_file);
+      queue_size = props->file_send_queue_.size();
+    }
+    LOG_INFO("File added to queue: {} ({} files in queue)",
+             file_path.filename().string().c_str(), queue_size);
+  } else {
+    StartFileTransfer(props, file_path, file_label);
+
+    if (props->file_sending_.load()) {
+    } else {
+      // Failed to start (race condition: another file started between
+      // check and call) Add to queue
+      size_t queue_size = 0;
+      {
+        std::lock_guard<std::mutex> lock(props->file_queue_mutex_);
+        SubStreamWindowProperties::QueuedFile queued_file;
+        queued_file.file_path = file_path;
+        queued_file.file_label = file_label;
+        props->file_send_queue_.push(queued_file);
+        queue_size = props->file_send_queue_.size();
+      }
+      LOG_INFO(
+          "File added to queue after race condition: {} ({} files in "
+          "queue)",
+          file_path.filename().string().c_str(), queue_size);
+    }
+  }
+}
+
 int Render::ControlBar(std::shared_ptr<SubStreamWindowProperties>& props) {
   float button_width = title_bar_height_ * 0.8f;
   float button_height = title_bar_height_ * 0.8f;
@@ -95,8 +166,8 @@ int Render::ControlBar(std::shared_ptr<SubStreamWindowProperties>& props) {
           remote_action.d = i;
           if (props->connection_status_ == ConnectionStatus::Connected) {
             std::string msg = remote_action.to_json();
-            SendDataFrame(props->peer_, msg.c_str(), msg.size(),
-                          props->data_label_.c_str());
+            SendReliableDataFrame(props->peer_, msg.c_str(), msg.size(),
+                                  props->control_data_label_.c_str());
           }
         }
         props->display_selectable_hovered_ = ImGui::IsWindowHovered();
@@ -176,8 +247,8 @@ int Render::ControlBar(std::shared_ptr<SubStreamWindowProperties>& props) {
         remote_action.type = ControlType::audio_capture;
         remote_action.a = props->audio_capture_button_pressed_;
         std::string msg = remote_action.to_json();
-        SendDataFrame(props->peer_, msg.c_str(), msg.size(),
-                      props->data_label_.c_str());
+        SendReliableDataFrame(props->peer_, msg.c_str(), msg.size(),
+                              props->control_data_label_.c_str());
       }
     }
 
@@ -204,71 +275,7 @@ int Render::ControlBar(std::shared_ptr<SubStreamWindowProperties>& props) {
       std::string title =
           localization::select_file[localization_language_index_];
       std::string path = OpenFileDialog(title);
-      if (!path.empty()) {
-        LOG_INFO("Selected file: {}", path.c_str());
-
-        std::filesystem::path file_path = std::filesystem::path(path);
-        std::string file_label = file_label_;
-
-        // Get file size
-        std::error_code ec;
-        uint64_t file_size = std::filesystem::file_size(file_path, ec);
-        if (ec) {
-          LOG_ERROR("Failed to get file size: {}", ec.message().c_str());
-          file_size = 0;
-        }
-
-        // Add file to transfer list
-        {
-          std::lock_guard<std::mutex> lock(props->file_transfer_list_mutex_);
-          SubStreamWindowProperties::FileTransferInfo info;
-          info.file_name = file_path.filename().string();
-          info.file_path = file_path;  // Store full path for precise matching
-          info.file_size = file_size;
-          info.status = SubStreamWindowProperties::FileTransferStatus::Queued;
-          info.sent_bytes = 0;
-          info.file_id = 0;
-          info.rate_bps = 0;
-          props->file_transfer_list_.push_back(info);
-        }
-        props->file_transfer_window_visible_ = true;
-
-        if (props->file_sending_.load()) {
-          // Add to queue
-          size_t queue_size = 0;
-          {
-            std::lock_guard<std::mutex> lock(props->file_queue_mutex_);
-            SubStreamWindowProperties::QueuedFile queued_file;
-            queued_file.file_path = file_path;
-            queued_file.file_label = file_label;
-            props->file_send_queue_.push(queued_file);
-            queue_size = props->file_send_queue_.size();
-          }
-          LOG_INFO("File added to queue: {} ({} files in queue)",
-                   file_path.filename().string().c_str(), queue_size);
-        } else {
-          StartFileTransfer(props, file_path, file_label);
-
-          if (props->file_sending_.load()) {
-          } else {
-            // Failed to start (race condition: another file started between
-            // check and call) Add to queue
-            size_t queue_size = 0;
-            {
-              std::lock_guard<std::mutex> lock(props->file_queue_mutex_);
-              SubStreamWindowProperties::QueuedFile queued_file;
-              queued_file.file_path = file_path;
-              queued_file.file_label = file_label;
-              props->file_send_queue_.push(queued_file);
-              queue_size = props->file_send_queue_.size();
-            }
-            LOG_INFO(
-                "File added to queue after race condition: {} ({} files in "
-                "queue)",
-                file_path.filename().string().c_str(), queue_size);
-          }
-        }
-      }
+      this->ProcessSelectedFile(path, props, file_label_);
     }
 
     ImGui::SameLine();

src/gui/windows/file_transfer_window.cpp

@@ -87,6 +87,11 @@ int Render::FileTransferWindow(
       ImVec2(file_transfer_window_width, file_transfer_window_height),
       ImGuiCond_Always);
 
+  // Set Chinese font for proper display
+  if (stream_windows_system_chinese_font_) {
+    ImGui::PushFont(stream_windows_system_chinese_font_);
+  }
+
   ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 3.0f);
   ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 1.0f);
   ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(1.0f, 1.0f, 1.0f, 0.9f));
@@ -121,9 +126,9 @@ int Render::FileTransferWindow(
     } 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_Border);
+      ImGui::BeginChild(
+          "FileList", ImVec2(0, file_transfer_window_height * 0.75f),
+          ImGuiChildFlags_Border, ImGuiWindowFlags_HorizontalScrollbar);
       ImGui::SetWindowFontScale(1.0f);
       ImGui::SetWindowFontScale(0.5f);
 
@@ -220,6 +225,11 @@ int Render::FileTransferWindow(
     ImGui::SetWindowFontScale(0.5f);
     ImGui::End();
     ImGui::SetWindowFontScale(1.0f);
+
+    // Pop Chinese font if it was pushed
+    if (stream_windows_system_chinese_font_) {
+      ImGui::PopFont();
+    }
   } else {
     ImGui::PopStyleColor(4);
     ImGui::PopStyleVar(2);

src/gui/windows/server_window.cpp

@@ -0,0 +1,161 @@
+#include "layout_relative.h"
+#include "localization.h"
+#include "rd_log.h"
+#include "render.h"
+
+namespace crossdesk {
+
+namespace {}  // namespace
+
+int Render::ServerWindow() {
+  ImGui::SetNextWindowSize(ImVec2(server_window_width_, server_window_height_),
+                           ImGuiCond_Always);
+  ImGui::SetNextWindowPos(ImVec2(0, 0), ImGuiCond_Always);
+
+  ImGui::Begin("##server_window", nullptr,
+               ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
+                   ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoCollapse |
+                   ImGuiWindowFlags_NoScrollbar |
+                   ImGuiWindowFlags_NoScrollWithMouse);
+
+  server_window_title_bar_height_ = title_bar_height_;
+
+  ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
+  ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0));
+  ImGui::SetNextWindowPos(ImVec2(0, 0), ImGuiCond_Always);
+  ImGui::BeginChild(
+      "ServerTitleBar",
+      ImVec2(server_window_width_, server_window_title_bar_height_),
+      ImGuiChildFlags_Border,
+      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";
+    if (ImGui::Button(toggle_label.c_str(),
+                      ImVec2(server_title_bar_button_width,
+                             server_title_bar_button_height))) {
+      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();
+  ImGui::PopStyleColor();
+
+  RemoteClientInfoWindow();
+
+  ImGui::End();
+  return 0;
+}
+
+int Render::RemoteClientInfoWindow() {
+  float remote_client_info_window_width = server_window_width_ * 0.75f;
+  float remote_client_info_window_height =
+      (server_window_height_ - server_window_title_bar_height_) * 0.3f;
+
+  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_Border,
+      ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
+          ImGuiWindowFlags_NoBringToFrontOnFocus);
+  ImGui::PopStyleVar();
+  ImGui::PopStyleColor();
+
+  ImGui::SetWindowFontScale(0.7f);
+  ImGui::Text("%s",
+              localization::controller[localization_language_index_].c_str());
+  ImGui::SameLine();
+  ImGui::Text("%s", remote_client_id_.c_str());
+
+  ImGui::SetWindowFontScale(1.0f);
+
+  ImGui::EndChild();
+
+  ImGui::SameLine();
+
+  float close_connection_button_width = server_window_width_ * 0.15f;
+  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, 5.0f);
+  ImGui::SetWindowFontScale(0.7f);
+  if (ImGui::Button(ICON_FA_XMARK, ImVec2(close_connection_button_width,
+                                          close_connection_button_height))) {
+    LeaveConnection(peer_, self_hosted_id_);
+  }
+  ImGui::SetWindowFontScale(1.0f);
+  ImGui::PopStyleColor(3);
+  ImGui::PopStyleVar();
+
+  ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(1.0f, 1.0f, 1.0f, 0.0f));
+  ImGui::BeginChild(
+      "RemoteClientInfoFileTransferWindow",
+      ImVec2(remote_client_info_window_width, remote_client_info_window_height),
+      ImGuiChildFlags_Border,
+      ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
+          ImGuiWindowFlags_NoBringToFrontOnFocus);
+  ImGui::PopStyleColor();
+
+  ImGui::SetWindowFontScale(0.7f);
+  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());
+  }
+  ImGui::SetWindowFontScale(1.0f);
+
+  ImGui::EndChild();
+
+  return 0;
+}
+}  // namespace crossdesk

xmake.lua

@@ -70,6 +70,9 @@ target("common")
     set_kind("object")
     add_deps("rd_log")
     add_files("src/common/*.cpp")
+    if is_os("macosx") then
+        add_files("src/common/*.mm")
+    end
     add_includedirs("src/common", {public = true})
 
 target("path_manager")