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

This also includes a small progress view.

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);
     });
 

src/App.tsx

@@ -497,6 +497,8 @@ function App() {
     status: Status.Idle,
   });
 
+  const [autoAdjustProgress, setAutoAdjustProgress] = useState<{ completed: number; total: number } | null>(null);
+
   useEffect(() => {
     currentFolderPathRef.current = currentFolderPath;
   }, [currentFolderPath]);
@@ -3235,6 +3237,16 @@ function App() {
           }));
         }
       }),
+      listen('auto-adjust-progress', (event: any) => {
+        if (isEffectActive) {
+          setAutoAdjustProgress({ completed: event.payload.completed, total: event.payload.total });
+        }
+      }),
+      listen('auto-adjust-complete', () => {
+        if (isEffectActive) {
+          setAutoAdjustProgress(null);
+        }
+      }),
     ];
     return () => {
       isEffectActive = false;
@@ -4276,9 +4288,13 @@ function App() {
       if (finalSelection.length === 0) return;
       finalSelection.forEach((p) => imageCacheRef.current.delete(p));
 
-      invoke(Invokes.ApplyAutoAdjustmentsToPaths, { paths: finalSelection })
-        .then(async () => {
-          if (selectedImage && finalSelection.includes(selectedImage.path)) {
+      setAutoAdjustProgress({ completed: 0, total: finalSelection.length });
+
+      const selectionSnapshot = [...finalSelection];
+      const unlistenComplete = listen('auto-adjust-complete', async () => {
+        unlistenComplete.then((ul) => ul());
+        if (selectedImage && selectionSnapshot.includes(selectedImage.path)) {
+          try {
             const metadata: Metadata = await invoke(Invokes.LoadMetadata, {
               path: selectedImage.path,
             });
@@ -4287,21 +4303,31 @@ function App() {
               setLiveAdjustments(normalized);
               resetAdjustmentsHistory(normalized);
             }
+          } catch (err) {
+            console.error('Failed to reload adjustments after auto-adjust:', err);
           }
-          if (libraryActivePath && finalSelection.includes(libraryActivePath)) {
+        }
+        if (libraryActivePath && selectionSnapshot.includes(libraryActivePath)) {
+          try {
             const metadata: Metadata = await invoke(Invokes.LoadMetadata, {
               path: libraryActivePath,
             });
             if (metadata.adjustments && !metadata.adjustments.is_null) {
               const normalized = normalizeLoadedAdjustments(metadata.adjustments);
               setLibraryActiveAdjustments(normalized);
             }
+          } catch (err) {
+            console.error('Failed to reload library adjustments after auto-adjust:', err);
           }
-        })
-        .catch((err) => {
-          console.error('Failed to apply auto adjustments to paths:', err);
-          setError(`Failed to apply auto adjustments: ${err}`);
-        });
+        }
+      });
+
+      invoke(Invokes.ApplyAutoAdjustmentsToPaths, { paths: finalSelection }).catch((err) => {
+        unlistenComplete.then((ul) => ul());
+        setAutoAdjustProgress(null);
+        console.error('Failed to apply auto adjustments to paths:', err);
+        setError(`Failed to apply auto adjustments: ${err}`);
+      });
     };
 
     const onExportClick = () => {
@@ -5423,6 +5449,36 @@ function App() {
         sourceImages={collageModalState.sourceImages}
         thumbnails={thumbnails}
       />
+      <AnimatePresence>
+        {autoAdjustProgress !== null && (
+          <motion.div
+            animate={{ opacity: 1, y: 0 }}
+            className="fixed bottom-6 right-6 z-[9999] flex flex-col gap-2 rounded-xl border border-border-color bg-surface px-5 py-4 shadow-2xl"
+            exit={{ opacity: 0, y: 16 }}
+            initial={{ opacity: 0, y: 16 }}
+            transition={{ duration: 0.2 }}
+          >
+            <div className="flex items-center gap-3">
+              <Gauge className="h-4 w-4 shrink-0 text-text-secondary" />
+              <span className="text-sm font-medium text-text-primary">Applying Auto Adjustments</span>
+            </div>
+            <div className="flex items-center gap-3">
+              <div className="h-1.5 w-48 overflow-hidden rounded-full bg-surface-secondary">
+                <motion.div
+                  animate={{
+                    width: `${autoAdjustProgress.total > 0 ? (autoAdjustProgress.completed / autoAdjustProgress.total) * 100 : 0}%`,
+                  }}
+                  className="h-full rounded-full bg-accent"
+                  transition={{ duration: 0.15 }}
+                />
+              </div>
+              <span className="text-xs text-text-secondary">
+                {autoAdjustProgress.completed} / {autoAdjustProgress.total}
+              </span>
+            </div>
+          </motion.div>
+        )}
+      </AnimatePresence>
       <ToastContainer
         position="bottom-right"
         autoClose={5000}