fix: move auto adjust selected images in new thread to unblock UI

Author: moschmdt

src-tauri/src/file_management.rs

@@ -2030,127 +2030,119 @@ pub fn apply_auto_adjustments_to_paths(
     paths: Vec<String>,
     app_handle: AppHandle,
 ) -> Result<(), String> {
-    let settings = load_settings(app_handle.clone()).unwrap_or_default();
-    let highlight_compression = settings.raw_highlight_compression.unwrap_or(2.5);
-    let linear_mode = settings.linear_raw_mode;
-    let enable_xmp_sync = settings.enable_xmp_sync.unwrap_or(false);
-    let create_xmp_if_missing = settings.create_xmp_if_missing.unwrap_or(false);
+    thread::spawn(move || {
+        let settings = load_settings(app_handle.clone()).unwrap_or_default();
+        let highlight_compression = settings.raw_highlight_compression.unwrap_or(2.5);
+        let linear_mode = settings.linear_raw_mode;
+        let enable_xmp_sync = settings.enable_xmp_sync.unwrap_or(false);
+        let create_xmp_if_missing = settings.create_xmp_if_missing.unwrap_or(false);
 
-    paths.par_iter().for_each(|path| {
-        let result: Result<(), String> = (|| {
-            let (source_path, sidecar_path) = parse_virtual_path(path);
-            let source_path_str = source_path.to_string_lossy().to_string();
+        let state = app_handle.state::<AppState>();
+        let gpu_context = gpu_processing::get_or_init_gpu_context(&state).ok();
+        let thumb_cache_dir = resolve_thumbnail_cache_dir(&app_handle).ok();
 
-            let file_bytes = fs::read(&source_path).map_err(|e| e.to_string())?;
-            let image = image_loader::load_base_image_from_bytes(
-                &file_bytes,
-                &source_path_str,
-                false,
-                highlight_compression,
-                linear_mode.clone(),
-                None,
-            )
-            .map_err(|e| e.to_string())?;
+        let total_count = paths.len();
+        let completed_count = Arc::new(AtomicUsize::new(0));
 
-            let auto_results = perform_auto_analysis(&image);
-            let auto_adjustments_json = auto_results_to_json(&auto_results);
+        paths.par_iter().for_each(|path| {
+            let result: Result<(), String> = (|| {
+                let (source_path, sidecar_path) = parse_virtual_path(path);
+                let source_path_str = source_path.to_string_lossy().to_string();
 
-            let mut existing_metadata: ImageMetadata = if sidecar_path.exists() {
-                fs::read_to_string(&sidecar_path)
-                    .ok()
-                    .and_then(|content| serde_json::from_str(&content).ok())
-                    .unwrap_or_default()
-            } else {
-                ImageMetadata::default()
-            };
+                let file_bytes = fs::read(&source_path).map_err(|e| e.to_string())?;
+                let image = image_loader::load_base_image_from_bytes(
+                    &file_bytes,
+                    &source_path_str,
+                    false,
+                    highlight_compression,
+                    linear_mode.clone(),
+                    None,
+                )
+                .map_err(|e| e.to_string())?;
 
-            if existing_metadata.adjustments.is_null() {
-                existing_metadata.adjustments = serde_json::json!({});
-            }
+                let auto_results = perform_auto_analysis(&image);
+                let auto_adjustments_json = auto_results_to_json(&auto_results);
+
+                let mut existing_metadata: ImageMetadata = if sidecar_path.exists() {
+                    fs::read_to_string(&sidecar_path)
+                        .ok()
+                        .and_then(|content| serde_json::from_str(&content).ok())
+                        .unwrap_or_default()
+                } else {
+                    ImageMetadata::default()
+                };
+
+                if existing_metadata.adjustments.is_null() {
+                    existing_metadata.adjustments = serde_json::json!({});
+                }
 
-            if let (Some(existing_map), Some(auto_map)) = (
-                existing_metadata.adjustments.as_object_mut(),
-                auto_adjustments_json.as_object(),
-            ) {
-                for (k, v) in auto_map {
-                    if k == "sectionVisibility" {
-                        if let Some(existing_vis_val) = existing_map.get_mut(k) {
-                            if let (Some(existing_vis), Some(auto_vis)) =
-                                (existing_vis_val.as_object_mut(), v.as_object())
-                            {
-                                for (vis_k, vis_v) in auto_vis {
-                                    existing_vis.insert(vis_k.clone(), vis_v.clone());
+                if let (Some(existing_map), Some(auto_map)) = (
+                    existing_metadata.adjustments.as_object_mut(),
+                    auto_adjustments_json.as_object(),
+                ) {
+                    for (k, v) in auto_map {
+                        if k == "sectionVisibility" {
+                            if let Some(existing_vis_val) = existing_map.get_mut(k) {
+                                if let (Some(existing_vis), Some(auto_vis)) =
+                                    (existing_vis_val.as_object_mut(), v.as_object())
+                                {
+                                    for (vis_k, vis_v) in auto_vis {
+                                        existing_vis.insert(vis_k.clone(), vis_v.clone());
+                                    }
                                 }
+                            } else {
+                                existing_map.insert(k.clone(), v.clone());
                             }
                         } else {
                             existing_map.insert(k.clone(), v.clone());
                         }
-                    } else {
-                        existing_map.insert(k.clone(), v.clone());
                     }
                 }
-            }
 
-            existing_metadata.rating = existing_metadata.adjustments["rating"]
-                .as_u64()
-                .unwrap_or(0) as u8;
+                existing_metadata.rating = existing_metadata.adjustments["rating"]
+                    .as_u64()
+                    .unwrap_or(0) as u8;
 
-            if let Ok(json_string) = serde_json::to_string_pretty(&existing_metadata) {
-                let _ = std::fs::write(&sidecar_path, json_string);
-            }
-
-            if enable_xmp_sync {
-                sync_metadata_to_xmp(&source_path, &existing_metadata, create_xmp_if_missing);
-            }
-            Ok(())
-        })();
-        if let Err(e) = result {
-            eprintln!("Failed to apply auto adjustments to {}: {}", path, e);
-        }
-    });
-
-    thread::spawn(move || {
-        let state = app_handle.state::<AppState>();
-        let thumb_cache_dir = match resolve_thumbnail_cache_dir(&app_handle) {
-            Ok(dir) => dir,
-            Err(e) => {
-                log::warn!("Unable to initialize thumbnail cache directory: {}", e);
-                for path in &paths {
-                    emit_thumbnail_cache_setup_error(&app_handle, path, &e);
+                if let Ok(json_string) = serde_json::to_string_pretty(&existing_metadata) {
+                    let _ = std::fs::write(&sidecar_path, json_string);
                 }
-                let _ = app_handle.emit("thumbnail-generation-complete", true);
-                return;
-            }
-        };
 
-        let gpu_context = gpu_processing::get_or_init_gpu_context(&state).ok();
-        let total_count = paths.len();
-        let completed_count = Arc::new(AtomicUsize::new(0));
+                if enable_xmp_sync {
+                    sync_metadata_to_xmp(&source_path, &existing_metadata, create_xmp_if_missing);
+                }
 
-        paths.par_iter().for_each(|path_str| {
-            let result = generate_single_thumbnail_and_cache(
-                path_str,
-                &thumb_cache_dir,
-                gpu_context.as_ref(),
-                None,
-                true,
-                &app_handle,
-            );
+                // Regenerate thumbnail immediately using the already-decoded image,
+                // so the UI updates without waiting for the full batch to finish.
+                if let Some(cache_dir) = &thumb_cache_dir {
+                    if let Some((thumbnail_data, rating)) = generate_single_thumbnail_and_cache(
+                        path,
+                        cache_dir,
+                        gpu_context.as_ref(),
+                        Some(&image),
+                        true,
+                        &app_handle,
+                    ) {
+                        let _ = app_handle.emit(
+                            "thumbnail-generated",
+                            serde_json::json!({ "path": path, "data": thumbnail_data, "rating": rating }),
+                        );
+                    }
+                }
 
-            if let Some((thumbnail_data, rating)) = result {
-                let _ = app_handle.emit(
-                    "thumbnail-generated",
-                    serde_json::json!({ "path": path_str, "data": thumbnail_data, "rating": rating }),
-                );
+                Ok(())
+            })();
+            if let Err(e) = result {
+                eprintln!("Failed to apply auto adjustments to {}: {}", path, e);
             }
 
             let completed = completed_count.fetch_add(1, Ordering::Relaxed) + 1;
             let _ = app_handle.emit(
-                "thumbnail-progress",
+                "auto-adjust-progress",
                 serde_json::json!({ "completed": completed, "total": total_count }),
             );
         });
 
+        let _ = app_handle.emit("auto-adjust-complete", true);
         let _ = app_handle.emit("thumbnail-generation-complete", true);
     });