[feat] add controller info and file transfer in server window

src/common/window_util_mac.h

@@ -7,18 +7,18 @@
 #ifndef _WINDOW_UTIL_MAC_H_
 #define _WINDOW_UTIL_MAC_H_
 
-struct SDL_Window;
-
 namespace crossdesk {
 
+struct SDL_Window;
+
 // 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);
+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);
+void MacSetWindowExcludedFromWindowMenu(SDL_Window* window, bool excluded);
 
 }  // namespace crossdesk
 

src/common/window_util_mac.mm

@@ -8,7 +8,7 @@
 
 namespace crossdesk {
 
-static NSWindow* GetNSWindowFromSDL(::SDL_Window* window) {
+static NSWindow* GetNSWindowFromSDL(SDL_Window* window) {
   if (!window) {
     return nil;
   }
@@ -26,7 +26,7 @@ static NSWindow* GetNSWindowFromSDL(::SDL_Window* window) {
 #endif
 }
 
-void MacSetWindowAlwaysOnTop(::SDL_Window* window, bool always_on_top) {
+void MacSetWindowAlwaysOnTop(SDL_Window* window, bool always_on_top) {
   NSWindow* ns_window = GetNSWindowFromSDL(window);
   if (!ns_window) {
     (void)always_on_top;
@@ -44,7 +44,7 @@ void MacSetWindowAlwaysOnTop(::SDL_Window* window, bool always_on_top) {
   [ns_window setCollectionBehavior:behavior];
 }
 
-void MacSetWindowExcludedFromWindowMenu(::SDL_Window* window, bool excluded) {
+void MacSetWindowExcludedFromWindowMenu(SDL_Window* window, bool excluded) {
   NSWindow* ns_window = GetNSWindowFromSDL(window);
   if (!ns_window) {
     (void)excluded;

src/gui/assets/localization/localization.h

@@ -201,8 +201,6 @@ 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:"};
-static std::vector<std::string> connection_status = {
-    reinterpret_cast<const char*>(u8"连接状态:"), "Connection Status:"};
 
 #if _WIN32
 static std::vector<std::string> minimize_to_tray = {

src/gui/render.cpp

@@ -829,7 +829,7 @@ int Render::CreateConnectionPeer() {
 
   params_.on_signal_status = OnSignalStatusCb;
   params_.on_connection_status = OnConnectionStatusCb;
-  params_.on_net_status_report = OnNetStatusReport;
+  params_.net_status_report = NetStatusReport;
 
   params_.user_data = this;
 
@@ -948,12 +948,6 @@ int Render::CreateMainWindow() {
     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_);
@@ -1103,18 +1097,29 @@ int Render::CreateServerWindow() {
   }
 
 #if _WIN32
-  // Hide server window from the taskbar by making it a tool window.
+  // 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);
@@ -1621,6 +1626,49 @@ void Render::MainLoop() {
     }
 
     UpdateInteractions();
+
+    if (need_to_send_host_info_) {
+      RemoteAction remote_action;
+      remote_action.i.display_num = 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++) {
+        LOG_INFO("Local display [{}:{}]", i + 1, display_info_list_[i].name);
+        remote_action.i.display_list[i] =
+            (char*)malloc(display_info_list_[i].name.length() + 1);
+        strncpy(remote_action.i.display_list[i],
+                display_info_list_[i].name.c_str(),
+                display_info_list_[i].name.length());
+        remote_action.i.display_list[i][display_info_list_[i].name.length()] =
+            '\0';
+        remote_action.i.left[i] = display_info_list_[i].left;
+        remote_action.i.top[i] = display_info_list_[i].top;
+        remote_action.i.right[i] = display_info_list_[i].right;
+        remote_action.i.bottom[i] = display_info_list_[i].bottom;
+      }
+
+      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(peer_, msg.data(), msg.size(),
+                                      control_data_label_.c_str());
+      FreeRemoteAction(remote_action);
+      if (0 == ret) {
+        need_to_send_host_info_ = false;
+      }
+    }
   }
 }
 
@@ -1737,19 +1785,13 @@ void Render::CleanupFactories() {
 void Render::CleanupPeer(std::shared_ptr<SubStreamWindowProperties> props) {
   SDL_FlushEvent(STREAM_REFRESH_EVENT);
 
-  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 (props->dst_buffer_) {
+    size_t buffer_size = props->dst_buffer_capacity_;
+    std::vector<unsigned char> buffer_copy(buffer_size);
+    memcpy(buffer_copy.data(), props->dst_buffer_, buffer_size);
 
-  if (frame_snapshot && !frame_snapshot->empty() && video_width > 0 &&
-      video_height > 0) {
-    std::vector<unsigned char> buffer_copy(*frame_snapshot);
+    int video_width = props->video_width_;
+    int video_height = props->video_height_;
     std::string remote_id = props->remote_id_;
     std::string remote_host_name = props->remote_host_name_;
     std::string password =
@@ -1830,47 +1872,22 @@ void Render::CleanSubStreamWindowProperties(
     props->stream_texture_ = nullptr;
   }
 
-  {
-    std::lock_guard<std::mutex> lock(props->video_frame_mutex_);
-    props->front_frame_.reset();
-    props->back_frame_.reset();
-    props->video_width_ = 0;
-    props->video_height_ = 0;
-    props->video_size_ = 0;
-    props->render_rect_dirty_ = true;
-    props->stream_cleanup_pending_ = false;
+  if (props->dst_buffer_) {
+    delete[] props->dst_buffer_;
+    props->dst_buffer_ = nullptr;
   }
 }
 
-std::shared_ptr<Render::SubStreamWindowProperties>
-Render::GetSubStreamWindowPropertiesByRemoteId(const std::string& remote_id) {
-  if (remote_id.empty()) {
-    return nullptr;
-  }
-
-  std::shared_lock lock(client_properties_mutex_);
-  auto it = client_properties_.find(remote_id);
-  if (it == client_properties_.end()) {
-    return nullptr;
-  }
-  return it->second;
-}
-
 void Render::StartFileTransfer(std::shared_ptr<SubStreamWindowProperties> props,
                                const std::filesystem::path& file_path,
-                               const std::string& file_label,
-                               const std::string& remote_id) {
-  const bool is_global = (props == nullptr);
-  PeerPtr* peer = is_global ? peer_ : props->peer_;
-  if (!peer) {
-    LOG_ERROR("StartFileTransfer: invalid peer");
+                               const std::string& file_label) {
+  if (!props || !props->peer_) {
+    LOG_ERROR("StartFileTransfer: invalid props or peer");
     return;
   }
 
   bool expected = false;
-  if (!(is_global ? file_transfer_.file_sending_
-                  : props->file_transfer_.file_sending_)
-           .compare_exchange_strong(expected, true)) {
+  if (!props->file_sending_.compare_exchange_strong(expected, true)) {
     // Already sending, this should not happen if called correctly
     LOG_WARN(
         "StartFileTransfer called but file_sending_ is already true, "
@@ -1879,19 +1896,13 @@ void Render::StartFileTransfer(std::shared_ptr<SubStreamWindowProperties> props,
     return;
   }
 
+  auto peer = props->peer_;
   auto props_weak = std::weak_ptr<SubStreamWindowProperties>(props);
   Render* render_ptr = this;
 
-  std::thread([peer, file_path, file_label, props_weak, render_ptr, remote_id,
-               is_global]() {
+  std::thread([peer, file_path, file_label, props_weak, render_ptr]() {
     auto props_locked = props_weak.lock();
-
-    FileTransferState* state = nullptr;
-    if (props_locked) {
-      state = &props_locked->file_transfer_;
-    } else if (is_global) {
-      state = &render_ptr->file_transfer_;
-    } else {
+    if (!props_locked) {
       return;
     }
 
@@ -1899,50 +1910,49 @@ void Render::StartFileTransfer(std::shared_ptr<SubStreamWindowProperties> props,
     uint64_t total_size = std::filesystem::file_size(file_path, ec);
     if (ec) {
       LOG_ERROR("Failed to get file size: {}", ec.message().c_str());
-      state->file_sending_ = false;
+      props_locked->file_sending_ = false;
       return;
     }
 
-    state->file_sent_bytes_ = 0;
-    state->file_total_bytes_ = total_size;
-    state->file_send_rate_bps_ = 0;
-    state->file_transfer_window_visible_ = true;
+    props_locked->file_sent_bytes_ = 0;
+    props_locked->file_total_bytes_ = total_size;
+    props_locked->file_send_rate_bps_ = 0;
+    props_locked->file_transfer_window_visible_ = true;
     {
-      std::lock_guard<std::mutex> lock(state->file_transfer_mutex_);
-      state->file_send_start_time_ = std::chrono::steady_clock::now();
-      state->file_send_last_update_time_ = state->file_send_start_time_;
-      state->file_send_last_bytes_ = 0;
+      std::lock_guard<std::mutex> lock(props_locked->file_transfer_mutex_);
+      props_locked->file_send_start_time_ = std::chrono::steady_clock::now();
+      props_locked->file_send_last_update_time_ =
+          props_locked->file_send_start_time_;
+      props_locked->file_send_last_bytes_ = 0;
     }
 
     LOG_INFO(
         "File transfer started: {} ({} bytes), file_sending_={}, "
         "total_bytes_={}",
-        file_path.filename().string(), total_size, state->file_sending_.load(),
-        state->file_total_bytes_.load());
+        file_path.filename().string(), total_size,
+        props_locked->file_sending_.load(),
+        props_locked->file_total_bytes_.load());
 
     FileSender sender;
     uint32_t file_id = FileSender::NextFileId();
 
-    if (props_locked) {
+    {
       std::lock_guard<std::shared_mutex> lock(
           render_ptr->file_id_to_props_mutex_);
       render_ptr->file_id_to_props_[file_id] = props_weak;
-    } else {
-      std::lock_guard<std::shared_mutex> lock(
-          render_ptr->file_id_to_transfer_state_mutex_);
-      render_ptr->file_id_to_transfer_state_[file_id] = state;
     }
 
-    state->current_file_id_ = file_id;
+    props_locked->current_file_id_ = file_id;
 
     // Update file transfer list: mark as sending
     // Find the queued file that matches the exact file path
     {
-      std::lock_guard<std::mutex> lock(state->file_transfer_list_mutex_);
-      for (auto& info : state->file_transfer_list_) {
+      std::lock_guard<std::mutex> lock(props_locked->file_transfer_list_mutex_);
+      for (auto& info : props_locked->file_transfer_list_) {
         if (info.file_path == file_path &&
-            info.status == FileTransferState::FileTransferStatus::Queued) {
-          info.status = FileTransferState::FileTransferStatus::Sending;
+            info.status ==
+                SubStreamWindowProperties::FileTransferStatus::Queued) {
+          info.status = SubStreamWindowProperties::FileTransferStatus::Sending;
           info.file_id = file_id;
           info.file_size = total_size;
           info.sent_bytes = 0;
@@ -1951,88 +1961,81 @@ void Render::StartFileTransfer(std::shared_ptr<SubStreamWindowProperties> props,
       }
     }
 
-    state->file_transfer_window_visible_ = true;
+    props_locked->file_transfer_window_visible_ = true;
 
     // Progress will be updated via ACK from receiver
     int ret = sender.SendFile(
         file_path, file_path.filename().string(),
-        [peer, file_label, remote_id](const char* buf, size_t sz) -> int {
-          if (remote_id.empty()) {
-            return SendReliableDataFrame(peer, buf, sz, file_label.c_str());
-          } else {
-            return SendReliableDataFrameToPeer(
-                peer, buf, sz, file_label.c_str(), remote_id.c_str(),
-                remote_id.size());
-          }
+        [peer, file_label](const char* buf, size_t sz) -> int {
+          return SendReliableDataFrame(peer, buf, sz, file_label.c_str());
         },
         64 * 1024, file_id);
 
     // file_sending_ should remain true until we receive the final ACK from
     // receiver
-    // On error, set file_sending_ to false immediately to allow next file
-    if (ret != 0) {
-      state->file_sending_ = false;
-      state->file_transfer_window_visible_ = false;
-      state->file_sent_bytes_ = 0;
-      state->file_total_bytes_ = 0;
-      state->file_send_rate_bps_ = 0;
-      state->current_file_id_ = 0;
+    auto props_locked_final = props_weak.lock();
+    if (props_locked_final) {
+      // On error, set file_sending_ to false immediately to allow next file
+      if (ret != 0) {
+        props_locked_final->file_sending_ = false;
+        props_locked_final->file_transfer_window_visible_ = false;
+        props_locked_final->file_sent_bytes_ = 0;
+        props_locked_final->file_total_bytes_ = 0;
+        props_locked_final->file_send_rate_bps_ = 0;
+        props_locked_final->current_file_id_ = 0;
 
-      // Unregister file_id mapping on error
-      if (props_locked) {
-        std::lock_guard<std::shared_mutex> lock(
-            render_ptr->file_id_to_props_mutex_);
-        render_ptr->file_id_to_props_.erase(file_id);
-      } else {
-        std::lock_guard<std::shared_mutex> lock(
-            render_ptr->file_id_to_transfer_state_mutex_);
-        render_ptr->file_id_to_transfer_state_.erase(file_id);
-      }
+        // Unregister file_id mapping on error
+        {
+          std::lock_guard<std::shared_mutex> lock(
+              render_ptr->file_id_to_props_mutex_);
+          render_ptr->file_id_to_props_.erase(file_id);
+        }
 
-      // Update file transfer list: mark as failed
-      {
-        std::lock_guard<std::mutex> lock(state->file_transfer_list_mutex_);
-        for (auto& info : state->file_transfer_list_) {
-          if (info.file_id == file_id) {
-            info.status = FileTransferState::FileTransferStatus::Failed;
-            break;
+        // Update file transfer list: mark as failed
+        {
+          std::lock_guard<std::mutex> lock(
+              props_locked_final->file_transfer_list_mutex_);
+          for (auto& info : props_locked_final->file_transfer_list_) {
+            if (info.file_id == file_id) {
+              info.status =
+                  SubStreamWindowProperties::FileTransferStatus::Failed;
+              break;
+            }
           }
         }
+
+        LOG_ERROR("FileSender::SendFile failed for [{}], ret={}",
+                  file_path.string().c_str(), ret);
+
+        render_ptr->ProcessFileQueue(props_locked_final);
       }
-
-      LOG_ERROR("FileSender::SendFile failed for [{}], ret={}",
-                file_path.string().c_str(), ret);
-
-      render_ptr->ProcessFileQueue(props_locked);
     }
   }).detach();
 }
 
 void Render::ProcessFileQueue(
     std::shared_ptr<SubStreamWindowProperties> props) {
-  FileTransferState* state = props ? &props->file_transfer_ : &file_transfer_;
-  if (!state) {
+  if (!props) {
     return;
   }
 
-  if (state->file_sending_.load()) {
+  if (props->file_sending_.load()) {
     return;
   }
 
-  FileTransferState::QueuedFile queued_file;
+  SubStreamWindowProperties::QueuedFile queued_file;
   {
-    std::lock_guard<std::mutex> lock(state->file_queue_mutex_);
-    if (state->file_send_queue_.empty()) {
+    std::lock_guard<std::mutex> lock(props->file_queue_mutex_);
+    if (props->file_send_queue_.empty()) {
       return;
     }
-    queued_file = state->file_send_queue_.front();
-    state->file_send_queue_.pop();
+    queued_file = props->file_send_queue_.front();
+    props->file_send_queue_.pop();
   }
 
   LOG_INFO("Processing next file in queue: {}",
            queued_file.file_path.string().c_str());
-  StartFileTransfer(props, queued_file.file_path, queued_file.file_label,
-                    queued_file.remote_id);
+  StartFileTransfer(props, queued_file.file_path, queued_file.file_label);
 }
 
 void Render::UpdateRenderRect() {
@@ -2124,22 +2127,10 @@ void Render::ProcessSdlEvent(const SDL_Event& event) {
         {
           // std::shared_lock lock(client_properties_mutex_);
           for (auto& [host_name, props] : client_properties_) {
-            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_ : "");
-            }
+            thumbnail_->SaveToThumbnail(
+                (char*)props->dst_buffer_, props->video_width_,
+                props->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_)
@@ -2233,52 +2224,18 @@ void Render::ProcessSdlEvent(const SDL_Event& event) {
         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;
-          }
+        if (props->video_width_ <= 0 || props->video_height_ <= 0) {
           break;
         }
-
-        if (video_width <= 0 || video_height <= 0) {
-          break;
-        }
-        if (!frame_snapshot || frame_snapshot->empty()) {
+        if (!props->dst_buffer_) {
           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;
+          if (props->video_width_ != props->texture_width_ ||
+              props->video_height_ != props->texture_height_) {
+            props->texture_width_ = props->video_width_;
+            props->texture_height_ = props->video_height_;
 
             SDL_DestroyTexture(props->stream_texture_);
             // props->stream_texture_ = SDL_CreateTexture(
@@ -2303,8 +2260,8 @@ void Render::ProcessSdlEvent(const SDL_Event& event) {
             SDL_DestroyProperties(nvProps);
           }
         } else {
-          props->texture_width_ = video_width;
-          props->texture_height_ = video_height;
+          props->texture_width_ = props->video_width_;
+          props->texture_height_ = props->video_height_;
           // props->stream_texture_ = SDL_CreateTexture(
           //     stream_renderer_, stream_pixformat_,
           //     SDL_TEXTUREACCESS_STREAMING, props->texture_width_,
@@ -2325,14 +2282,8 @@ void Render::ProcessSdlEvent(const SDL_Event& event) {
           SDL_DestroyProperties(nvProps);
         }
 
-        SDL_UpdateTexture(props->stream_texture_, NULL, frame_snapshot->data(),
+        SDL_UpdateTexture(props->stream_texture_, NULL, props->dst_buffer_,
                           props->texture_width_);
-
-        if (render_rect_dirty) {
-          UpdateRenderRect();
-          std::lock_guard<std::mutex> lock(props->video_frame_mutex_);
-          props->render_rect_dirty_ = false;
-        }
       }
       break;
   }

src/gui/render.h

@@ -42,41 +42,6 @@
 namespace crossdesk {
 class Render {
  public:
-  struct FileTransferState {
-    std::atomic<bool> file_sending_ = false;
-    std::atomic<uint64_t> file_sent_bytes_ = 0;
-    std::atomic<uint64_t> file_total_bytes_ = 0;
-    std::atomic<uint32_t> file_send_rate_bps_ = 0;
-    std::mutex file_transfer_mutex_;
-    std::chrono::steady_clock::time_point file_send_start_time_;
-    std::chrono::steady_clock::time_point file_send_last_update_time_;
-    uint64_t file_send_last_bytes_ = 0;
-    bool file_transfer_window_visible_ = false;
-    std::atomic<uint32_t> current_file_id_{0};
-
-    struct QueuedFile {
-      std::filesystem::path file_path;
-      std::string file_label;
-      std::string remote_id;
-    };
-    std::queue<QueuedFile> file_send_queue_;
-    std::mutex file_queue_mutex_;
-
-    enum class FileTransferStatus { Queued, Sending, Completed, Failed };
-
-    struct FileTransferInfo {
-      std::string file_name;
-      std::filesystem::path file_path;
-      uint64_t file_size = 0;
-      FileTransferStatus status = FileTransferStatus::Queued;
-      uint64_t sent_bytes = 0;
-      uint32_t file_id = 0;
-      uint32_t rate_bps = 0;
-    };
-    std::vector<FileTransferInfo> file_transfer_list_;
-    std::mutex file_transfer_list_mutex_;
-  };
-
   struct SubStreamWindowProperties {
     Params params_;
     PeerPtr* peer_ = nullptr;
@@ -123,13 +88,8 @@ class Render {
     float mouse_diff_control_bar_pos_y_ = 0;
     double control_bar_button_pressed_time_ = 0;
     double net_traffic_stats_button_pressed_time_ = 0;
-    // Double-buffered NV12 frame storage. Written by decode callback thread,
-    // consumed by SDL main thread.
-    std::mutex video_frame_mutex_;
-    std::shared_ptr<std::vector<unsigned char>> front_frame_;
-    std::shared_ptr<std::vector<unsigned char>> back_frame_;
-    bool render_rect_dirty_ = false;
-    bool stream_cleanup_pending_ = false;
+    unsigned char* dst_buffer_ = nullptr;
+    size_t dst_buffer_capacity_ = 0;
     float mouse_pos_x_ = 0;
     float mouse_pos_y_ = 0;
     float mouse_pos_x_last_ = 0;
@@ -169,10 +129,38 @@ class Render {
     std::chrono::steady_clock::time_point last_time_;
     XNetTrafficStats net_traffic_stats_;
 
-    using QueuedFile = FileTransferState::QueuedFile;
-    using FileTransferStatus = FileTransferState::FileTransferStatus;
-    using FileTransferInfo = FileTransferState::FileTransferInfo;
-    FileTransferState file_transfer_;
+    // File transfer progress
+    std::atomic<bool> file_sending_ = false;
+    std::atomic<uint64_t> file_sent_bytes_ = 0;
+    std::atomic<uint64_t> file_total_bytes_ = 0;
+    std::atomic<uint32_t> file_send_rate_bps_ = 0;
+    std::mutex file_transfer_mutex_;
+    std::chrono::steady_clock::time_point file_send_start_time_;
+    std::chrono::steady_clock::time_point file_send_last_update_time_;
+    uint64_t file_send_last_bytes_ = 0;
+    bool file_transfer_window_visible_ = false;
+    std::atomic<uint32_t> current_file_id_{0};
+
+    struct QueuedFile {
+      std::filesystem::path file_path;
+      std::string file_label;
+    };
+    std::queue<QueuedFile> file_send_queue_;
+    std::mutex file_queue_mutex_;
+
+    enum class FileTransferStatus { Queued, Sending, Completed, Failed };
+
+    struct FileTransferInfo {
+      std::string file_name;
+      std::filesystem::path file_path;
+      uint64_t file_size = 0;
+      FileTransferStatus status = FileTransferStatus::Queued;
+      uint64_t sent_bytes = 0;
+      uint32_t file_id = 0;
+      uint32_t rate_bps = 0;
+    };
+    std::vector<FileTransferInfo> file_transfer_list_;
+    std::mutex file_transfer_list_mutex_;
   };
 
  public:
@@ -205,13 +193,9 @@ class Render {
 
   void ProcessFileDropEvent(const SDL_Event& event);
 
-  void ProcessSelectedFile(
-      const std::string& path,
-      const std::shared_ptr<SubStreamWindowProperties>& props,
-      const std::string& file_label, const std::string& remote_id = "");
-
-  std::shared_ptr<SubStreamWindowProperties>
-  GetSubStreamWindowPropertiesByRemoteId(const std::string& remote_id);
+  void ProcessSelectedFile(const std::string& path,
+                           std::shared_ptr<SubStreamWindowProperties>& props,
+                           const std::string& file_label);
 
  private:
   int CreateStreamRenderWindow();
@@ -290,11 +274,11 @@ class Render {
   static void OnConnectionStatusCb(ConnectionStatus status, const char* user_id,
                                    size_t user_id_size, void* user_data);
 
-  static void OnNetStatusReport(const char* client_id, size_t client_id_size,
-                                TraversalMode mode,
-                                const XNetTrafficStats* net_traffic_stats,
-                                const char* user_id, const size_t user_id_size,
-                                void* user_data);
+  static void NetStatusReport(const char* client_id, size_t client_id_size,
+                              TraversalMode mode,
+                              const XNetTrafficStats* net_traffic_stats,
+                              const char* user_id, const size_t user_id_size,
+                              void* user_data);
 
   static SDL_HitTestResult HitTestCallback(SDL_Window* window,
                                            const SDL_Point* area, void* data);
@@ -335,8 +319,7 @@ class Render {
   // File transfer helper functions
   void StartFileTransfer(std::shared_ptr<SubStreamWindowProperties> props,
                          const std::filesystem::path& file_path,
-                         const std::string& file_label,
-                         const std::string& remote_id = "");
+                         const std::string& file_label);
   void ProcessFileQueue(std::shared_ptr<SubStreamWindowProperties> props);
 
   int AudioDeviceInit();
@@ -437,9 +420,6 @@ class Render {
   bool keyboard_capturer_is_started_ = false;
   bool foucs_on_main_window_ = false;
   bool foucs_on_stream_window_ = false;
-  bool main_window_minimized_ = false;
-  uint32_t last_main_minimize_request_tick_ = 0;
-  uint32_t last_stream_minimize_request_tick_ = 0;
   bool audio_capture_ = false;
   int main_window_width_real_ = 720;
   int main_window_height_real_ = 540;
@@ -489,6 +469,7 @@ class Render {
   bool just_created_ = false;
   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_;
@@ -595,10 +576,6 @@ class Render {
   std::unordered_map<uint32_t, std::weak_ptr<SubStreamWindowProperties>>
       file_id_to_props_;
   std::shared_mutex file_id_to_props_mutex_;
-
-  // Map file_id to FileTransferState for global file transfer (props == null)
-  std::unordered_map<uint32_t, FileTransferState*> file_id_to_transfer_state_;
-  std::shared_mutex file_id_to_transfer_state_mutex_;
   SDL_AudioDeviceID input_dev_;
   SDL_AudioDeviceID output_dev_;
   ScreenCapturerFactory* screen_capturer_factory_ = nullptr;
@@ -612,8 +589,8 @@ class Render {
   uint64_t last_frame_time_;
   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;
+  uint64_t new_version_icon_last_trigger_time_ = 0;
+  uint64_t new_version_icon_render_start_time_ = 0;
 #ifdef __APPLE__
   bool show_request_permission_window_ = true;
 #endif
@@ -673,10 +650,6 @@ class Render {
 
   /* ------ server mode ------ */
   std::unordered_map<std::string, ConnectionStatus> connection_status_;
-  std::unordered_map<std::string, std::string> connection_host_names_;
-  std::string selected_server_remote_id_ = "";
-  std::string selected_server_remote_hostname_ = "";
-  FileTransferState file_transfer_;
 };
 }  // namespace crossdesk
 #endif

src/gui/render_callback.cpp

@@ -4,7 +4,6 @@
 #include <cstring>
 #include <filesystem>
 #include <fstream>
-#include <limits>
 #include <unordered_map>
 
 #include "clipboard.h"
@@ -238,31 +237,31 @@ void Render::OnReceiveVideoBufferCb(const XVideoFrame* video_frame,
       render->client_properties_.find(remote_id)->second.get();
 
   if (props->connection_established_) {
-    {
-      std::lock_guard<std::mutex> lock(props->video_frame_mutex_);
+    if (!props->dst_buffer_) {
+      props->dst_buffer_capacity_ = video_frame->size;
+      props->dst_buffer_ = new unsigned char[video_frame->size];
+    }
 
-      if (!props->back_frame_) {
-        props->back_frame_ =
-            std::make_shared<std::vector<unsigned char>>(video_frame->size);
-      }
-      if (props->back_frame_->size() != video_frame->size) {
-        props->back_frame_->resize(video_frame->size);
-      }
+    if (props->dst_buffer_capacity_ < video_frame->size) {
+      delete props->dst_buffer_;
+      props->dst_buffer_capacity_ = video_frame->size;
+      props->dst_buffer_ = new unsigned char[video_frame->size];
+    }
 
-      std::memcpy(props->back_frame_->data(), video_frame->data,
-                  video_frame->size);
+    memcpy(props->dst_buffer_, video_frame->data, video_frame->size);
+    bool need_to_update_render_rect = false;
+    if (props->video_width_ != props->video_width_last_ ||
+        props->video_height_ != props->video_height_last_) {
+      need_to_update_render_rect = true;
+      props->video_width_last_ = props->video_width_;
+      props->video_height_last_ = props->video_height_;
+    }
+    props->video_width_ = video_frame->width;
+    props->video_height_ = video_frame->height;
+    props->video_size_ = video_frame->size;
 
-      const bool size_changed = (props->video_width_ != video_frame->width) ||
-                                (props->video_height_ != video_frame->height);
-      if (size_changed) {
-        props->render_rect_dirty_ = true;
-      }
-
-      props->video_width_ = video_frame->width;
-      props->video_height_ = video_frame->height;
-      props->video_size_ = video_frame->size;
-
-      props->front_frame_.swap(props->back_frame_);
+    if (need_to_update_render_rect) {
+      render->UpdateRenderRect();
     }
 
     SDL_Event event;
@@ -321,20 +320,7 @@ void Render::OnReceiveDataBufferCb(const char* data, size_t size,
     std::string remote_user_id = std::string(user_id, user_id_size);
 
     static FileReceiver receiver;
-    receiver.SetOnSendAck([render,
-                           remote_user_id](const FileTransferAck& ack) -> int {
-      bool is_server_sending = remote_user_id.rfind("C-", 0) != 0;
-      if (is_server_sending) {
-        auto props =
-            render->GetSubStreamWindowPropertiesByRemoteId(remote_user_id);
-        if (props) {
-          PeerPtr* peer = props->peer_;
-          return SendReliableDataFrame(
-              peer, reinterpret_cast<const char*>(&ack),
-              sizeof(FileTransferAck), render->file_feedback_label_.c_str());
-        }
-      }
-
+    receiver.SetOnSendAck([render](const FileTransferAck& ack) -> int {
       return SendReliableDataFrame(
           render->peer_, reinterpret_cast<const char*>(&ack),
           sizeof(FileTransferAck), render->file_feedback_label_.c_str());
@@ -375,100 +361,42 @@ void Render::OnReceiveDataBufferCb(const char* data, size_t size,
       }
     }
 
-    Render::FileTransferState* state = nullptr;
     if (!props) {
-      {
-        std::shared_lock lock(render->file_id_to_transfer_state_mutex_);
-        auto it = render->file_id_to_transfer_state_.find(ack.file_id);
-        if (it != render->file_id_to_transfer_state_.end()) {
-          state = it->second;
-        }
-      }
-
-      if (!state) {
-        LOG_WARN("FileTransferAck: no props/state found for file_id={}",
-                 ack.file_id);
-        return;
-      }
-    } else {
-      state = &props->file_transfer_;
+      LOG_WARN("FileTransferAck: no props found for file_id={}", ack.file_id);
+      return;
     }
 
     // Update progress based on ACK
-    state->file_sent_bytes_ = ack.acked_offset;
-    state->file_total_bytes_ = ack.total_size;
+    props->file_sent_bytes_ = ack.acked_offset;
+    props->file_total_bytes_ = ack.total_size;
 
     uint32_t rate_bps = 0;
     {
-      if (props) {
-        uint32_t data_channel_bitrate =
-            props->net_traffic_stats_.data_outbound_stats.bitrate;
+      uint32_t data_channel_bitrate =
+          props->net_traffic_stats_.data_outbound_stats.bitrate;
 
-        if (data_channel_bitrate > 0 && state->file_sending_.load()) {
-          rate_bps = static_cast<uint32_t>(data_channel_bitrate * 0.99f);
+      if (data_channel_bitrate > 0 && props->file_sending_.load()) {
+        rate_bps = static_cast<uint32_t>(data_channel_bitrate * 0.99f);
 
-          uint32_t current_rate = state->file_send_rate_bps_.load();
-          if (current_rate > 0) {
-            // 70% old + 30% new for smoother display
-            rate_bps =
-                static_cast<uint32_t>(current_rate * 0.7 + rate_bps * 0.3);
-          }
-        } else {
-          rate_bps = state->file_send_rate_bps_.load();
+        uint32_t current_rate = props->file_send_rate_bps_.load();
+        if (current_rate > 0) {
+          // 70% old + 30% new for smoother display
+          rate_bps = static_cast<uint32_t>(current_rate * 0.7 + rate_bps * 0.3);
         }
       } else {
-        // Global transfer: no per-connection bitrate available.
-        // Estimate send rate from ACKed bytes delta over time.
-        const uint32_t current_rate = state->file_send_rate_bps_.load();
-        uint32_t estimated_rate_bps = 0;
-        const auto now = std::chrono::steady_clock::now();
-
-        uint64_t last_bytes = 0;
-        std::chrono::steady_clock::time_point last_time;
-        {
-          std::lock_guard<std::mutex> lock(state->file_transfer_mutex_);
-          last_bytes = state->file_send_last_bytes_;
-          last_time = state->file_send_last_update_time_;
-        }
-
-        if (state->file_sending_.load() && ack.acked_offset >= last_bytes) {
-          const uint64_t delta_bytes = ack.acked_offset - last_bytes;
-          const double delta_seconds =
-              std::chrono::duration<double>(now - last_time).count();
-
-          if (delta_seconds > 0.0 && delta_bytes > 0) {
-            const double bps =
-                (static_cast<double>(delta_bytes) * 8.0) / delta_seconds;
-            if (bps > 0.0) {
-              const double capped = (std::min)(
-                  bps,
-                  static_cast<double>((std::numeric_limits<uint32_t>::max)()));
-              estimated_rate_bps = static_cast<uint32_t>(capped);
-            }
-          }
-        }
-
-        if (estimated_rate_bps > 0 && current_rate > 0) {
-          // 70% old + 30% new for smoother display
-          rate_bps = static_cast<uint32_t>(current_rate * 0.7 +
-                                           estimated_rate_bps * 0.3);
-        } else if (estimated_rate_bps > 0) {
-          rate_bps = estimated_rate_bps;
-        } else {
-          rate_bps = current_rate;
-        }
+        rate_bps = props->file_send_rate_bps_.load();
       }
 
-      state->file_send_rate_bps_ = rate_bps;
-      state->file_send_last_bytes_ = ack.acked_offset;
+      props->file_send_rate_bps_ = rate_bps;
+      props->file_send_last_bytes_ = ack.acked_offset;
       auto now = std::chrono::steady_clock::now();
-      state->file_send_last_update_time_ = now;
+      props->file_send_last_update_time_ = now;
     }
 
     // Update file transfer list: update progress and rate
     {
-      std::lock_guard<std::mutex> lock(state->file_transfer_list_mutex_);
-      for (auto& info : state->file_transfer_list_) {
+      std::lock_guard<std::mutex> lock(props->file_transfer_list_mutex_);
+      for (auto& info : props->file_transfer_list_) {
         if (info.file_id == ack.file_id) {
           info.sent_bytes = ack.acked_offset;
           info.file_size = ack.total_size;
@@ -482,8 +410,8 @@ void Render::OnReceiveDataBufferCb(const char* data, size_t size,
     if ((ack.flags & 0x01) != 0) {
       // Transfer completed - receiver has finished receiving the file
       // Reopen window if it was closed by user
-      state->file_transfer_window_visible_ = true;
-      state->file_sending_ = false;  // Mark sending as finished
+      props->file_transfer_window_visible_ = true;
+      props->file_sending_ = false;  // Mark sending as finished
       LOG_INFO(
           "File transfer completed via ACK, file_id={}, total_size={}, "
           "acked_offset={}",
@@ -491,11 +419,11 @@ void Render::OnReceiveDataBufferCb(const char* data, size_t size,
 
       // Update file transfer list: mark as completed
       {
-        std::lock_guard<std::mutex> lock(state->file_transfer_list_mutex_);
-        for (auto& info : state->file_transfer_list_) {
+        std::lock_guard<std::mutex> lock(props->file_transfer_list_mutex_);
+        for (auto& info : props->file_transfer_list_) {
           if (info.file_id == ack.file_id) {
             info.status =
-                Render::FileTransferState::FileTransferStatus::Completed;
+                SubStreamWindowProperties::FileTransferStatus::Completed;
             info.sent_bytes = ack.total_size;
             break;
           }
@@ -504,15 +432,9 @@ void Render::OnReceiveDataBufferCb(const char* data, size_t size,
 
       // Unregister file_id mapping after completion
       {
-        if (props) {
-          std::lock_guard<std::shared_mutex> lock(
-              render->file_id_to_props_mutex_);
-          render->file_id_to_props_.erase(ack.file_id);
-        } else {
-          std::lock_guard<std::shared_mutex> lock(
-              render->file_id_to_transfer_state_mutex_);
-          render->file_id_to_transfer_state_.erase(ack.file_id);
-        }
+        std::lock_guard<std::shared_mutex> lock(
+            render->file_id_to_props_mutex_);
+        render->file_id_to_props_.erase(ack.file_id);
       }
 
       // Process next file in queue
@@ -534,39 +456,24 @@ void Render::OnReceiveDataBufferCb(const char* data, size_t size,
 
   std::string remote_id(user_id, user_id_size);
   // std::shared_lock lock(render->client_properties_mutex_);
-  if (remote_action.type == ControlType::host_infomation) {
-    if (render->client_properties_.find(remote_id) !=
-        render->client_properties_.end()) {
-      // client mode
-      auto props = render->client_properties_.find(remote_id)->second;
-      if (props && props->remote_host_name_.empty()) {
-        props->remote_host_name_ = std::string(remote_action.i.host_name,
-                                               remote_action.i.host_name_size);
-        LOG_INFO("Remote hostname: [{}]", props->remote_host_name_);
-
-        for (int i = 0; i < remote_action.i.display_num; i++) {
-          props->display_info_list_.push_back(
-              DisplayInfo(remote_action.i.display_list[i],
-                          remote_action.i.left[i], remote_action.i.top[i],
-                          remote_action.i.right[i], remote_action.i.bottom[i]));
-        }
-      }
-      FreeRemoteAction(remote_action);
-    } else {
-      // server mode
-      render->connection_host_names_[remote_id] = std::string(
-          remote_action.i.host_name, remote_action.i.host_name_size);
-      LOG_INFO("Remote hostname: [{}]",
-               render->connection_host_names_[remote_id]);
+  if (render->client_properties_.find(remote_id) !=
+      render->client_properties_.end()) {
+    // local
+    auto props = render->client_properties_.find(remote_id)->second;
+    if (remote_action.type == ControlType::host_infomation &&
+        props->remote_host_name_.empty()) {
+      props->remote_host_name_ = std::string(remote_action.i.host_name,
+                                             remote_action.i.host_name_size);
+      LOG_INFO("Remote hostname: [{}]", props->remote_host_name_);
 
       for (int i = 0; i < remote_action.i.display_num; i++) {
-        render->display_info_list_.push_back(
+        props->display_info_list_.push_back(
             DisplayInfo(remote_action.i.display_list[i],
                         remote_action.i.left[i], remote_action.i.top[i],
                         remote_action.i.right[i], remote_action.i.bottom[i]));
       }
-      FreeRemoteAction(remote_action);
     }
+    FreeRemoteAction(remote_action);
   } else {
     // remote
     if (remote_action.type == ControlType::mouse && render->mouse_controller_) {
@@ -613,10 +520,6 @@ void Render::OnSignalStatusCb(SignalStatus status, const char* user_id,
       render->signal_connected_ = false;
     } else if (SignalStatus::SignalServerClosed == status) {
       render->signal_connected_ = false;
-    } else if (SignalStatus::SignalFingerprintMismatch == status) {
-      render->signal_connected_ = false;
-      LOG_ERROR("[{}] signal server fingerprint mismatch", client_id);
-      render->config_center_->ClearDefaultCertFingerprint();
     }
   } else {
     if (client_id.rfind("C-", 0) != 0) {
@@ -644,9 +547,6 @@ void Render::OnSignalStatusCb(SignalStatus status, const char* user_id,
       props->signal_connected_ = false;
     } else if (SignalStatus::SignalServerClosed == status) {
       props->signal_connected_ = false;
-    } else if (SignalStatus::SignalFingerprintMismatch == status) {
-      props->signal_connected_ = false;
-      LOG_ERROR("[{}] signal server fingerprint mismatch", remote_id);
     }
   }
 }
@@ -668,49 +568,7 @@ void Render::OnConnectionStatusCb(ConnectionStatus status, const char* user_id,
 
     switch (status) {
       case ConnectionStatus::Connected: {
-        {
-          RemoteAction remote_action;
-          remote_action.i.display_num = render->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++) {
-            LOG_INFO("Local display [{}:{}]", i + 1,
-                     render->display_info_list_[i].name);
-            remote_action.i.display_list[i] =
-                (char*)malloc(render->display_info_list_[i].name.length() + 1);
-            strncpy(remote_action.i.display_list[i],
-                    render->display_info_list_[i].name.c_str(),
-                    render->display_info_list_[i].name.length());
-            remote_action.i
-                .display_list[i][render->display_info_list_[i].name.length()] =
-                '\0';
-            remote_action.i.left[i] = render->display_info_list_[i].left;
-            remote_action.i.top[i] = render->display_info_list_[i].top;
-            remote_action.i.right[i] = render->display_info_list_[i].right;
-            remote_action.i.bottom[i] = render->display_info_list_[i].bottom;
-          }
-
-          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(),
-                                          render->control_data_label_.c_str());
-          FreeRemoteAction(remote_action);
-        }
-
+        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;
@@ -727,22 +585,12 @@ void Render::OnConnectionStatusCb(ConnectionStatus status, const char* user_id,
       case ConnectionStatus::Closed: {
         props->connection_established_ = false;
         props->mouse_control_button_pressed_ = false;
-
-        {
-          std::lock_guard<std::mutex> lock(props->video_frame_mutex_);
-          props->front_frame_.reset();
-          props->back_frame_.reset();
-          props->video_width_ = 0;
-          props->video_height_ = 0;
-          props->video_size_ = 0;
-          props->render_rect_dirty_ = true;
-          props->stream_cleanup_pending_ = true;
+        if (props->dst_buffer_ && props->stream_texture_) {
+          memset(props->dst_buffer_, 0, props->dst_buffer_capacity_);
+          SDL_UpdateTexture(props->stream_texture_, NULL, props->dst_buffer_,
+                            props->texture_width_);
         }
-
-        SDL_Event event;
-        event.type = render->STREAM_REFRESH_EVENT;
-        event.user.data1 = props.get();
-        SDL_PushEvent(&event);
+        render->CleanSubStreamWindowProperties(props);
 
         break;
       }
@@ -775,50 +623,8 @@ void Render::OnConnectionStatusCb(ConnectionStatus status, const char* user_id,
 
     switch (status) {
       case ConnectionStatus::Connected: {
-        {
-          RemoteAction remote_action;
-          remote_action.i.display_num = render->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++) {
-            LOG_INFO("Local display [{}:{}]", i + 1,
-                     render->display_info_list_[i].name);
-            remote_action.i.display_list[i] =
-                (char*)malloc(render->display_info_list_[i].name.length() + 1);
-            strncpy(remote_action.i.display_list[i],
-                    render->display_info_list_[i].name.c_str(),
-                    render->display_info_list_[i].name.length());
-            remote_action.i
-                .display_list[i][render->display_info_list_[i].name.length()] =
-                '\0';
-            remote_action.i.left[i] = render->display_info_list_[i].left;
-            remote_action.i.top[i] = render->display_info_list_[i].top;
-            remote_action.i.right[i] = render->display_info_list_[i].right;
-            remote_action.i.bottom[i] = render->display_info_list_[i].bottom;
-          }
-
-          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(render->peer_, msg.data(), msg.size(),
-                                          render->control_data_label_.c_str());
-          FreeRemoteAction(remote_action);
-        }
-
         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;
@@ -851,6 +657,7 @@ void Render::OnConnectionStatusCb(ConnectionStatus status, const char* user_id,
           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_) {
@@ -876,11 +683,11 @@ void Render::OnConnectionStatusCb(ConnectionStatus status, const char* user_id,
   }
 }
 
-void Render::OnNetStatusReport(const char* client_id, size_t client_id_size,
-                               TraversalMode mode,
-                               const XNetTrafficStats* net_traffic_stats,
-                               const char* user_id, const size_t user_id_size,
-                               void* user_data) {
+void Render::NetStatusReport(const char* client_id, size_t client_id_size,
+                             TraversalMode mode,
+                             const XNetTrafficStats* net_traffic_stats,
+                             const char* user_id, const size_t user_id_size,
+                             void* user_data) {
   Render* render = (Render*)user_data;
   if (!render) {
     return;

src/gui/toolbars/control_bar.cpp

@@ -54,16 +54,12 @@ std::string Render::OpenFileDialog(std::string title) {
 }
 
 void Render::ProcessSelectedFile(
-    const std::string& path,
-    const std::shared_ptr<SubStreamWindowProperties>& props,
-    const std::string& file_label, const std::string& remote_id) {
+    const std::string& path, std::shared_ptr<SubStreamWindowProperties>& props,
+    const std::string& file_label) {
   if (path.empty()) {
     return;
   }
 
-  FileTransferState* file_transfer_state =
-      props ? &props->file_transfer_ : &file_transfer_;
-
   LOG_INFO("Selected file: {}", path.c_str());
 
   std::filesystem::path file_path = std::filesystem::u8path(path);
@@ -78,51 +74,47 @@ void Render::ProcessSelectedFile(
 
   // Add file to transfer list
   {
-    std::lock_guard<std::mutex> lock(
-        file_transfer_state->file_transfer_list_mutex_);
-    FileTransferState::FileTransferInfo info;
+    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 = FileTransferState::FileTransferStatus::Queued;
+    info.status = SubStreamWindowProperties::FileTransferStatus::Queued;
     info.sent_bytes = 0;
     info.file_id = 0;
     info.rate_bps = 0;
-    file_transfer_state->file_transfer_list_.push_back(info);
+    props->file_transfer_list_.push_back(info);
   }
-  file_transfer_state->file_transfer_window_visible_ = true;
+  props->file_transfer_window_visible_ = true;
 
-  if (file_transfer_state->file_sending_.load()) {
+  if (props->file_sending_.load()) {
     // Add to queue
     size_t queue_size = 0;
     {
-      std::lock_guard<std::mutex> lock(file_transfer_state->file_queue_mutex_);
-      FileTransferState::QueuedFile queued_file;
+      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;
-      queued_file.remote_id = remote_id;
-      file_transfer_state->file_send_queue_.push(queued_file);
-      queue_size = file_transfer_state->file_send_queue_.size();
+      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, remote_id);
+    StartFileTransfer(props, file_path, file_label);
 
-    if (file_transfer_state->file_sending_.load()) {
+    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(
-            file_transfer_state->file_queue_mutex_);
-        FileTransferState::QueuedFile queued_file;
+        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;
-        queued_file.remote_id = remote_id;
-        file_transfer_state->file_send_queue_.push(queued_file);
-        queue_size = file_transfer_state->file_send_queue_.size();
+        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 "
@@ -283,7 +275,7 @@ int Render::ControlBar(std::shared_ptr<SubStreamWindowProperties>& props) {
       std::string title =
           localization::select_file[localization_language_index_];
       std::string path = OpenFileDialog(title);
-      ProcessSelectedFile(path, props, file_label_);
+      this->ProcessSelectedFile(path, props, file_label_);
     }
 
     ImGui::SameLine();

src/gui/toolbars/title_bar.cpp

@@ -3,8 +3,7 @@
 #include "rd_log.h"
 #include "render.h"
 
-constexpr double kNewVersionIconBlinkIntervalSec = 2.0;
-constexpr double kNewVersionIconBlinkOnTimeSec = 1.0;
+#define NEW_VERSION_ICON_RENDER_TIME_INTERVAL 2000
 
 namespace crossdesk {
 
@@ -16,28 +15,14 @@ int Render::TitleBar(bool main_window) {
   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 + 0.01f);
-      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_;
-    }
+    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 + 0.01f);
+    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 {
     title_bar_width = io.DisplaySize.x;
     title_bar_height = title_bar_button_height_;
@@ -107,11 +92,13 @@ int Render::TitleBar(bool main_window) {
 
       std::string about_str = localization::about[localization_language_index_];
       if (update_available_) {
-        const double now_time = ImGui::GetTime();
+        auto now_time = std::chrono::duration_cast<std::chrono::milliseconds>(
+                            std::chrono::steady_clock::now().time_since_epoch())
+                            .count();
 
         // every 2 seconds
         if (now_time - new_version_icon_last_trigger_time_ >=
-            kNewVersionIconBlinkIntervalSec) {
+            NEW_VERSION_ICON_RENDER_TIME_INTERVAL) {
           show_new_version_icon_ = true;
           new_version_icon_render_start_time_ = now_time;
           new_version_icon_last_trigger_time_ = now_time;
@@ -119,9 +106,9 @@ int Render::TitleBar(bool main_window) {
 
         // render for 1 second
         if (show_new_version_icon_) {
-          about_str = about_str + " " + ICON_FA_CIRCLE_ARROW_UP;
+          about_str = about_str + " " + ICON_FA_TRIANGLE_EXCLAMATION;
           if (now_time - new_version_icon_render_start_time_ >=
-              kNewVersionIconBlinkOnTimeSec) {
+              NEW_VERSION_ICON_RENDER_TIME_INTERVAL / 2) {
             show_new_version_icon_ = false;
           }
         } else {
@@ -150,11 +137,13 @@ int Render::TitleBar(bool main_window) {
     }
 
     if (update_available_ && show_new_version_icon_in_menu_) {
-      const double now_time = ImGui::GetTime();
+      auto now_time = std::chrono::duration_cast<std::chrono::milliseconds>(
+                          std::chrono::steady_clock::now().time_since_epoch())
+                          .count();
 
       // every 2 seconds
       if (now_time - new_version_icon_last_trigger_time_ >=
-          kNewVersionIconBlinkIntervalSec) {
+          NEW_VERSION_ICON_RENDER_TIME_INTERVAL) {
         show_new_version_icon_ = true;
         new_version_icon_render_start_time_ = now_time;
         new_version_icon_last_trigger_time_ = now_time;
@@ -163,13 +152,14 @@ int Render::TitleBar(bool main_window) {
       // 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::SetCursorPos(
+            ImVec2(bar_pos_x + title_bar_button_width * 0.15f,
+                   bar_pos_y - title_bar_button_width * 0.325f));
+        ImGui::Text(ICON_FA_TRIANGLE_EXCLAMATION);
         ImGui::SetWindowFontScale(1.0f);
 
         if (now_time - new_version_icon_render_start_time_ >=
-            kNewVersionIconBlinkOnTimeSec) {
+            NEW_VERSION_ICON_RENDER_TIME_INTERVAL / 2) {
           show_new_version_icon_ = false;
         }
       }
@@ -197,11 +187,6 @@ int Render::TitleBar(bool main_window) {
   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(

src/gui/windows/file_transfer_window.cpp

@@ -30,14 +30,12 @@ int BitrateDisplay(int bitrate) {
 
 int Render::FileTransferWindow(
     std::shared_ptr<SubStreamWindowProperties>& props) {
-  FileTransferState* state = props ? &props->file_transfer_ : &file_transfer_;
-
   // Only show window if there are files in transfer list or currently
   // transferring
   std::vector<SubStreamWindowProperties::FileTransferInfo> file_list;
   {
-    std::lock_guard<std::mutex> lock(state->file_transfer_list_mutex_);
-    file_list = state->file_transfer_list_;
+    std::lock_guard<std::mutex> lock(props->file_transfer_list_mutex_);
+    file_list = props->file_transfer_list_;
   }
 
   // Sort file list: Sending first, then Completed, then Queued, then Failed
@@ -68,7 +66,7 @@ int Render::FileTransferWindow(
   // It will be reopened automatically when:
   // 1. A file transfer completes (in render_callback.cpp)
   // 2. A new file starts sending from queue (in render.cpp)
-  if (!state->file_transfer_window_visible_) {
+  if (!props->file_transfer_window_visible_) {
     return 0;
   }
 
@@ -117,7 +115,7 @@ int Render::FileTransferWindow(
 
     // Close button handling
     if (!window_opened) {
-      state->file_transfer_window_visible_ = false;
+      props->file_transfer_window_visible_ = false;
       ImGui::End();
       return 0;
     }

src/gui/windows/server_window.cpp

@@ -1,9 +1,3 @@
-#include <algorithm>
-#include <cmath>
-#include <cstdio>
-#include <string>
-#include <vector>
-
 #include "layout_relative.h"
 #include "localization.h"
 #include "rd_log.h"
@@ -11,38 +5,7 @@
 
 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
+namespace {}  // namespace
 
 int Render::ServerWindow() {
   ImGui::SetNextWindowSize(ImVec2(server_window_width_, server_window_height_),
@@ -55,8 +18,6 @@ int Render::ServerWindow() {
                    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);
@@ -124,9 +85,9 @@ int Render::ServerWindow() {
 }
 
 int Render::RemoteClientInfoWindow() {
-  float remote_client_info_window_width = server_window_width_ * 0.8f;
+  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.9f;
+      (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);
@@ -139,122 +100,44 @@ int Render::RemoteClientInfoWindow() {
   ImGui::PopStyleVar();
   ImGui::PopStyleColor();
 
-  float font_scale = localization_language_index_ == 0 ? 0.5f : 0.45f;
-
-  std::vector<std::string> remote_hostnames;
-  remote_hostnames.reserve(connection_host_names_.size());
-  for (const auto& kv : connection_host_names_) {
-    remote_hostnames.push_back(kv.second);
-  }
-
-  auto find_remote_id_by_hostname =
-      [this](const std::string& hostname) -> std::string {
-    for (const auto& kv : connection_host_names_) {
-      if (kv.second == hostname) {
-        return kv.first;
-      }
-    }
-    return {};
-  };
-
-  if (!selected_server_remote_hostname_.empty()) {
-    if (std::find(remote_hostnames.begin(), remote_hostnames.end(),
-                  selected_server_remote_hostname_) == remote_hostnames.end()) {
-      selected_server_remote_hostname_.clear();
-      selected_server_remote_id_.clear();
-    }
-  }
-  if (selected_server_remote_hostname_.empty() && !remote_hostnames.empty()) {
-    selected_server_remote_hostname_ = remote_hostnames.front();
-    selected_server_remote_id_ =
-        find_remote_id_by_hostname(selected_server_remote_hostname_);
-  }
-
-  ImGui::SetWindowFontScale(font_scale);
-  ImGui::AlignTextToFramePadding();
+  ImGui::SetWindowFontScale(0.7f);
   ImGui::Text("%s",
               localization::controller[localization_language_index_].c_str());
   ImGui::SameLine();
+  ImGui::Text("%s", remote_client_id_.c_str());
 
-  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::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::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_hostnames.size()); i++) {
-      const bool selected =
-          (remote_hostnames[i] == selected_server_remote_hostname_);
-      if (ImGui::Selectable(remote_hostnames[i].c_str(), selected)) {
-        selected_server_remote_hostname_ = remote_hostnames[i];
-        selected_server_remote_id_ =
-            find_remote_id_by_hostname(selected_server_remote_hostname_);
-      }
-      if (selected) {
-        ImGui::SetItemDefaultFocus();
-      }
-    }
-    ImGui::EndCombo();
-  }
-
-  ImGui::Separator();
-
-  ImGui::SetWindowFontScale(font_scale);
-
-  if (!selected_server_remote_id_.empty()) {
-    auto it = connection_status_.find(selected_server_remote_id_);
-    const ConnectionStatus status = (it == connection_status_.end())
-                                        ? ConnectionStatus::Closed
-                                        : 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::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());
@@ -266,103 +149,11 @@ int Render::RemoteClientInfoWindow() {
     std::string title = localization::select_file[localization_language_index_];
     std::string path = OpenFileDialog(title);
     LOG_INFO("Selected file path: {}", path.c_str());
-
-    ProcessSelectedFile(path, nullptr, file_label_, selected_server_remote_id_);
   }
-
-  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, 5.0f);
-  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