perf: update windows

Author: ibuler

go-client/pkg/awaken/awaken_linux.go

@@ -73,6 +73,38 @@ func splitArgsWithLiteral(template string, literals map[string]string) []string
 	return args
 }
 
+func buildArgsFromTemplate(template string, values map[string]string) []string {
+	if strings.TrimSpace(template) == "" {
+		return nil
+	}
+
+	replaced := template
+	tokenValues := map[string]string{}
+	index := 0
+
+	for placeholder, value := range values {
+		token := fmt.Sprintf("__JMS_LITERAL_%d__", index)
+		replaced = strings.ReplaceAll(replaced, "{"+placeholder+"}", token)
+		tokenValues[token] = value
+		index++
+	}
+
+	fields := strings.Fields(replaced)
+	args := make([]string, 0, len(fields))
+	for _, field := range fields {
+		if value, ok := tokenValues[field]; ok {
+			args = append(args, value)
+			continue
+		}
+		for token, value := range tokenValues {
+			field = strings.ReplaceAll(field, token, value)
+		}
+		args = append(args, field)
+	}
+
+	return args
+}
+
 func buildLinuxTerminalCommand(terminalPath, clientPath, commands string) *exec.Cmd {
 	terminalName := strings.ToLower(filepath.Base(strings.TrimSpace(terminalPath)))
 	if terminalName == "" {
@@ -116,9 +148,17 @@ func awakenRDPCommand(filePath string, cfg *config.AppConfig) *exec.Cmd {
 	if appItem == nil {
 		return nil
 	}
-	args := splitArgsWithLiteral(appItem.ArgFormat, map[string]string{
-		"{file}": filePath,
-	})
+	connectMap := map[string]string{
+		"name":     r.getName(),
+		"protocol": r.Protocol,
+		"username": r.getUserName(),
+		"value":    r.Value,
+		"host":     r.Host,
+		"port":     strconv.Itoa(r.Port),
+		"file":     filePath,
+	}
+
+	args := buildArgsFromTemplate(appItem.ArgFormat, connectMap)
 	cmd := exec.Command(appItem.Name, args...)
 	return cmd
 }

go-client/pkg/plugin/loader.go

@@ -176,9 +176,12 @@ func sanitizeState(state *pluginState) bool {
 		}
 	}
 
-	if runtime.GOOS == "linux" && state.Selections["remotedesktop:rdp"] == "builtin.mstsc" {
-		delete(state.Selections, "remotedesktop:rdp")
-		changed = true
+	if runtime.GOOS == "linux" {
+		switch state.Selections["remotedesktop:rdp"] {
+		case "builtin.mstsc", "builtin.remmina":
+			state.Selections["remotedesktop:rdp"] = "builtin.xfreerdp"
+			changed = true
+		}
 	}
 
 	if state.Selections["filetransfer:sftp"] != "builtin.iterm-sftp" {

src-tauri/src/service/plugin.rs

@@ -19,24 +19,51 @@ impl PluginService {
         }
     }
 
+    fn resolve_resource_dir(app: &AppHandle, candidates: &[&str], marker: &str) -> Option<PathBuf> {
+        for candidate in candidates {
+            let Ok(path) = app
+                .path()
+                .resolve(candidate, tauri::path::BaseDirectory::Resource)
+            else {
+                continue;
+            };
+
+            if path.join(marker).is_file() {
+                log::info!("Resolved resource dir '{}' to {:?}", candidate, path);
+                return Some(path);
+            }
+        }
+
+        None
+    }
+
+    fn resolve_resource_file(app: &AppHandle, candidates: &[&str]) -> Option<PathBuf> {
+        for candidate in candidates {
+            let Ok(path) = app
+                .path()
+                .resolve(candidate, tauri::path::BaseDirectory::Resource)
+            else {
+                continue;
+            };
+
+            if path.is_file() {
+                log::info!("Resolved resource file '{}' to {:?}", candidate, path);
+                return Some(path);
+            }
+        }
+
+        None
+    }
+
     fn resolve_builtin_dir(app: &AppHandle) -> Option<PathBuf> {
-        let resource = app
-            .path()
-            .resolve(
-                "resources/plugins/builtin",
-                tauri::path::BaseDirectory::Resource,
-            )
-            .ok()
-            .filter(|p| p.join("index.json").is_file())
-            .or_else(|| {
-                app.path()
-                    .resolve("plugins/builtin", tauri::path::BaseDirectory::Resource)
-                    .ok()
-                    .filter(|p| p.join("index.json").is_file())
-            });
-
-        if resource.is_some() {
-            return resource;
+        let resource = Self::resolve_resource_dir(
+            app,
+            &["resources/plugins/builtin", "plugins/builtin", "builtin"],
+            "index.json",
+        );
+
+        if let Some(path) = resource {
+            return Some(path);
         }
 
         let cwd = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
@@ -45,40 +72,43 @@ impl PluginService {
             cwd.join("../plugins/builtin"),
             cwd.join("../../plugins/builtin"),
         ];
-        candidates
+        let resolved = candidates
             .into_iter()
-            .find(|p| p.join("index.json").is_file())
+            .find(|p| p.join("index.json").is_file());
+
+        if let Some(path) = resolved.as_ref() {
+            log::info!("Resolved builtin plugins from cwd fallback: {:?}", path);
+        }
+
+        resolved
     }
 
     fn resolve_defaults_path(app: &AppHandle) -> Option<PathBuf> {
-        let resource = app
-            .path()
-            .resolve(
+        let resource = Self::resolve_resource_file(
+            app,
+            &[
                 "resources/plugins/plugins-state.defaults.json",
-                tauri::path::BaseDirectory::Resource,
-            )
-            .ok()
-            .filter(|p| p.is_file())
-            .or_else(|| {
-                app.path()
-                    .resolve(
-                        "plugins/plugins-state.defaults.json",
-                        tauri::path::BaseDirectory::Resource,
-                    )
-                    .ok()
-                    .filter(|p| p.is_file())
-            });
-
-        if resource.is_some() {
-            return resource;
+                "plugins/plugins-state.defaults.json",
+                "plugins-state.defaults.json",
+            ],
+        );
+
+        if let Some(path) = resource {
+            return Some(path);
         }
 
         let cwd = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
         let candidates = [
             cwd.join("plugins/plugins-state.defaults.json"),
             cwd.join("../plugins/plugins-state.defaults.json"),
         ];
-        candidates.into_iter().find(|p| p.is_file())
+        let resolved = candidates.into_iter().find(|p| p.is_file());
+
+        if let Some(path) = resolved.as_ref() {
+            log::info!("Resolved plugin defaults from cwd fallback: {:?}", path);
+        }
+
+        resolved
     }
 
     fn read_json(path: &Path) -> Result<Value, String> {
@@ -95,7 +125,10 @@ impl PluginService {
 
         let mut changed = false;
         if Self::os_key() != "windows" {
-            if let Some(selections) = state_obj.get_mut("selections").and_then(|v| v.as_object_mut()) {
+            if let Some(selections) = state_obj
+                .get_mut("selections")
+                .and_then(|v| v.as_object_mut())
+            {
                 for key in ["terminal:ssh", "terminal:telnet"] {
                     if selections.get(key).and_then(|v| v.as_str()) == Some("builtin.putty") {
                         selections.remove(key);
@@ -105,6 +138,24 @@ impl PluginService {
             }
         }
 
+        if Self::os_key() == "linux" {
+            if let Some(selections) = state_obj
+                .get_mut("selections")
+                .and_then(|v| v.as_object_mut())
+            {
+                match selections.get("remotedesktop:rdp").and_then(|v| v.as_str()) {
+                    Some("builtin.mstsc") | Some("builtin.remmina") => {
+                        selections.insert(
+                            "remotedesktop:rdp".to_string(),
+                            Value::String("builtin.xfreerdp".to_string()),
+                        );
+                        changed = true;
+                    }
+                    _ => {}
+                }
+            }
+        }
+
         let should_remove_sftp_iterm = state_obj
             .get("selections")
             .and_then(|v| v.get("filetransfer:sftp"))
@@ -120,7 +171,9 @@ impl PluginService {
             .and_then(|v| v.get("builtin.iterm-sftp"))
             .and_then(|v| v.as_object())
             .map(|obj| {
-                obj.get("enabled").and_then(|v| v.as_bool()).unwrap_or(false)
+                obj.get("enabled")
+                    .and_then(|v| v.as_bool())
+                    .unwrap_or(false)
                     || obj
                         .get("path")
                         .and_then(|v| v.as_str())
@@ -133,7 +186,10 @@ impl PluginService {
             return changed;
         }
 
-        if let Some(selections) = state_obj.get_mut("selections").and_then(|v| v.as_object_mut()) {
+        if let Some(selections) = state_obj
+            .get_mut("selections")
+            .and_then(|v| v.as_object_mut())
+        {
             if selections.remove("filetransfer:sftp").is_some() {
                 changed = true;
             }

src-tauri/src/setup/tray.rs

@@ -129,13 +129,7 @@ where
         true,
         None::<&str>,
     )?;
-    let quit_i = MenuItem::with_id(
-        app,
-        "quit",
-        labels.quit_label.as_str(),
-        true,
-        None::<&str>,
-    )?;
+    let quit_i = MenuItem::with_id(app, "quit", labels.quit_label.as_str(), true, None::<&str>)?;
 
     Menu::with_items(
         app,

src-tauri/src/transcode/transcode.rs

@@ -3,9 +3,7 @@
 use crate::transcode::encoder::{create_encoder, H264Encoder};
 use crate::transcode::parser::Parser;
 use crate::transcode::renderer::Renderer;
-use crate::transcode::{
-    bitrate_for_resolution, compute_target_dimensions, OutputResolution,
-};
+use crate::transcode::{bitrate_for_resolution, compute_target_dimensions, OutputResolution};
 use fast_image_resize::images::{Image, ImageRef};
 use fast_image_resize::PixelType::U8x3;
 use fast_image_resize::{FilterType, ResizeAlg, ResizeOptions, Resizer};
@@ -429,18 +427,12 @@ pub fn transcode_to_mp4(
                                         && (enc_w_frame != rw as usize
                                             || enc_h_frame != rh as usize)
                                     {
-                                        let src_view = ImageRef::new(
-                                            rw,
-                                            rh,
-                                            &frame_buf[..src_len],
-                                            U8x3,
-                                        )
-                                        .map_err(|e| format!("create image view: {}", e))?;
+                                        let src_view =
+                                            ImageRef::new(rw, rh, &frame_buf[..src_len], U8x3)
+                                                .map_err(|e| format!("create image view: {}", e))?;
 
-                                        rgba_buf.resize(
-                                            (enc_w_frame * enc_h_frame * 3) as usize,
-                                            0,
-                                        );
+                                        rgba_buf
+                                            .resize((enc_w_frame * enc_h_frame * 3) as usize, 0);
                                         let mut dst_image = Image::from_slice_u8(
                                             enc_w_frame as u32,
                                             enc_h_frame as u32,
@@ -463,20 +455,17 @@ pub fn transcode_to_mp4(
                                         src_w = enc_w_frame;
                                         src_h = enc_h_frame;
                                     } else {
-                                        let mut cropped = vec![
-                                            255u8;
-                                            (enc_w_frame * enc_h_frame * 3) as usize
-                                        ];
+                                        let mut cropped =
+                                            vec![255u8; (enc_w_frame * enc_h_frame * 3) as usize];
                                         let src_stride = rw as usize * 3;
                                         let dst_stride = enc_w_frame * 3;
                                         for y in 0..enc_h_frame.min(rh as usize) {
                                             let src_off = y * src_stride;
                                             let dst_off = y * dst_stride;
                                             let copy_len = dst_stride.min(src_stride);
-                                            cropped[dst_off..dst_off + copy_len]
-                                                .copy_from_slice(
-                                                    &frame_buf[src_off..src_off + copy_len],
-                                                );
+                                            cropped[dst_off..dst_off + copy_len].copy_from_slice(
+                                                &frame_buf[src_off..src_off + copy_len],
+                                            );
                                         }
                                         rgb_data = cropped.into();
                                         src_w = enc_w_frame;
@@ -580,7 +569,11 @@ fn parse_and_build_timeline(guac_data: &[u8]) -> Result<TimelineInfo, String> {
         instruction_offset = parser.current_offset();
     }
 
-    Ok(TimelineInfo { frames, max_width: max_w, max_height: max_h })
+    Ok(TimelineInfo {
+        frames,
+        max_width: max_w,
+        max_height: max_h,
+    })
 }
 
 fn encode_chunks(

ui/app.vue

@@ -11,7 +11,7 @@ const LOCALE_PREFIX_RE = /^\/[a-z]{2}(?:-[A-Z]{2})?(?=\/|$)/;
 
 const route = useRoute();
 
-const { isMacOS } = usePlatform();
+const { isLinux, isMacOS, isWindows } = usePlatform();
 const { locale, setLocale } = useI18n();
 const { userTheme, applyThemePreference, applySystemThemePreference } = useThemeAdapter();
 
@@ -27,18 +27,25 @@ const unlistenFont = ref<UnlistenFn | null>(null);
 const backgroundColor = computed(() => {
   const isDark = userTheme.value === "dark";
 
-  // 只在 macOS 下设置透明度
   if (isMacOS.value) {
     return isDark ? "rgba(30, 30, 30, 0.8)" : "rgba(240, 240, 240, 0.4)";
-  } else {
-    return isDark ? "rgba(30, 30, 30, 0.8)" : "rgba(240, 240, 240, 0.83)";
   }
+
+  if (isWindows.value) {
+    return isDark ? "#1e1e1e" : "#f4f4f5";
+  }
+
+  if (isLinux.value) {
+    return isDark ? "#1e1e1e" : "#f0f0f0";
+  }
+
+  return isDark ? "#1e1e1e" : "#f4f4f5";
 });
 
 const pageKey = computed(() => route.path.replace(LOCALE_PREFIX_RE, ""));
 
 const platformClass = computed(() => {
-  const platformKey = isMacOS.value ? "darwin" : "windows";
+  const platformKey = isMacOS.value ? "darwin" : isLinux.value ? "linux" : isWindows.value ? "windows" : "unknown";
   return `platform-${platformKey}`;
 });