Upload FastSeekWpf/MainWindow.xaml.cs

FastSeekWpf/MainWindow.xaml.cs

@@ -51,6 +51,7 @@ public partial class MainWindow : Window, INotifyPropertyChanged
 
     public MainWindow()
     {
+        Logger.Log("MainWindow constructor");
         InitializeComponent();
         DataContext = this;
         _excludedDirs = CacheManager.LoadExclusions();
@@ -79,132 +80,171 @@ public partial class MainWindow : Window, INotifyPropertyChanged
 
             int darkMode = 1;
             Win32Api.DwmSetWindowAttribute(hwnd, Win32Api.DWMWA_USE_IMMERSIVE_DARK_MODE, ref darkMode, Marshal.SizeOf(darkMode));
+            Logger.Log("DWM rounded corners + dark mode enabled.");
+        }
+        catch (Exception ex)
+        {
+            Logger.Log($"DWM setup failed: {ex.Message}");
         }
-        catch { /* DWM not available on older Windows */ }
     }
 
     private void Window_Loaded(object sender, RoutedEventArgs e)
     {
+        Logger.Log("Window_Loaded");
         if (_initialized) return;
         _initialized = true;
 
+        CenterWindow();
         Task.Run(async () => await InitializeAsync());
     }
 
     private async Task InitializeAsync()
     {
-        _drives = DriveDiscovery.GetNtfsDrives();
-        if (_drives.Count == 0)
+        Logger.Log("InitializeAsync start");
+        try
         {
-            Dispatcher.Invoke(() =>
-            {
-                StatusText.Text = "No NTFS drives found. Run as Administrator.";
-                StatusBar.Visibility = Visibility.Visible;
-            });
-            return;
-        }
+            _drives = DriveDiscovery.GetNtfsDrives();
+            Logger.Log($"Found {_drives.Count} NTFS drives");
 
-        // Try cache first
-        bool needFullScan = true;
-        var cache = CacheManager.LoadCache();
-        if (cache != null)
-        {
-            lock (_indexLock)
+            if (_drives.Count == 0)
             {
-                _index = IndexStore.FromCache(cache);
+                Dispatcher.Invoke(() =>
+                {
+                    StatusText.Text = "No NTFS drives found. Run as Administrator.";
+                    StatusBar.Visibility = Visibility.Visible;
+                });
+                ShowError("No NTFS drives found. Make sure you are running as Administrator.");
+                return;
             }
-            Debug.WriteLine($"Loaded cache: {_index.Count} files");
 
-            // Delta catch-up
-            var checkpoints = new List<JournalCheckpoint>(cache.Checkpoints);
-            bool deltaOk = true;
-            foreach (var drive in _drives)
+            // Try cache first
+            bool needFullScan = true;
+            var cache = CacheManager.LoadCache();
+            if (cache != null)
             {
-                var cp = checkpoints.FirstOrDefault(c => c.DriveLetter == drive.Letter);
-                if (cp != null)
+                Logger.Log($"Cache loaded: {cache.Entries.Count} entries");
+                lock (_indexLock)
                 {
-                    try
+                    _index = IndexStore.FromCache(cache);
+                }
+                Logger.Log($"Loaded cache: {_index.Count} files");
+
+                // Delta catch-up
+                var checkpoints = new List<JournalCheckpoint>(cache.Checkpoints);
+                bool deltaOk = true;
+                foreach (var drive in _drives)
+                {
+                    var cp = checkpoints.FirstOrDefault(c => c.DriveLetter == drive.Letter);
+                    if (cp != null)
                     {
-                        var watcher = UsnWatcher.CreateForCheckpoint(drive, evt => _eventQueue.Enqueue(evt), cp);
-                        watcher.Drain();
-                        lock (_indexLock)
+                        try
                         {
-                            _index.Checkpoints.RemoveAll(c => c.DriveLetter == drive.Letter);
-                            _index.Checkpoints.Add(watcher.Checkpoint());
+                            var watcher = UsnWatcher.CreateForCheckpoint(drive, evt => _eventQueue.Enqueue(evt), cp);
+                            watcher.Drain();
+                            lock (_indexLock)
+                            {
+                                _index.Checkpoints.RemoveAll(c => c.DriveLetter == drive.Letter);
+                                _index.Checkpoints.Add(watcher.Checkpoint());
+                            }
+                            _watchers.Add(watcher);
+                            Logger.Log($"Delta catch-up OK for {drive.Letter}");
+                        }
+                        catch (Exception ex)
+                        {
+                            Logger.Log($"Delta catch-up failed: {ex.Message}");
+                            deltaOk = false;
+                            break;
                         }
-                        _watchers.Add(watcher);
                     }
-                    catch (Exception ex)
+                }
+
+                if (deltaOk)
+                {
+                    needFullScan = false;
+                    // Apply delta events
+                    while (_eventQueue.TryDequeue(out var evt))
                     {
-                        Debug.WriteLine($"Delta catch-up failed: {ex.Message}");
-                        deltaOk = false;
-                        break;
+                        ApplyEvent(evt);
                     }
+                    Logger.Log("Delta events applied.");
+                }
+                else
+                {
+                    Logger.Log("Delta failed, clearing cache.");
+                    CacheManager.ClearCache();
+                    _watchers.Clear();
+                    _eventQueue.Clear();
                 }
             }
 
-            if (deltaOk)
+            if (needFullScan)
             {
-                needFullScan = false;
-                // Apply delta events
-                while (_eventQueue.TryDequeue(out var evt))
+                Logger.Log("Starting full MFT scan...");
+                lock (_indexLock)
                 {
-                    ApplyEvent(evt);
+                    _index = new IndexStore();
+                    foreach (var drive in _drives)
+                    {
+                        try
+                        {
+                            Logger.Log($"Scanning {drive.Letter}...");
+                            using var reader = new MftReader(drive);
+                            var scan = reader.ScanDirect();
+                            if (scan == null) scan = reader.Scan();
+                            _index.PopulateFromScan(scan, drive.Root);
+                            Logger.Log($"Scanned {drive.Letter}: {scan.Records.Count} files");
+                        }
+                        catch (Exception ex)
+                        {
+                            Logger.Log($"Scan failed for {drive.Letter}: {ex}");
+                        }
+                    }
+                    _index.CompleteIndex();
+                    Logger.Log($"Full scan complete. Total indexed: {_index.Count}");
+                    CacheManager.SaveCache(_index);
+                    Logger.Log("Cache saved.");
                 }
-            }
-            else
-            {
-                CacheManager.ClearCache();
-                _watchers.Clear();
-                _eventQueue.Clear();
-            }
-        }
 
-        if (needFullScan)
-        {
-            lock (_indexLock)
-            {
-                _index = new IndexStore();
+                // Set up USN watchers for live updates
                 foreach (var drive in _drives)
                 {
                     try
                     {
-                        using var reader = new MftReader(drive);
-                        var scan = reader.ScanDirect();
-                        if (scan == null) scan = reader.Scan();
-                        _index.PopulateFromScan(scan, drive.Root);
-                        Debug.WriteLine($"Scanned {drive.Letter}: {scan.Records.Count} files");
+                        var watcher = new UsnWatcher(drive, evt => _eventQueue.Enqueue(evt), null);
+                        _watchers.Add(watcher);
+                        _ = watcher.RunAsync(CancellationToken.None);
+                        Logger.Log($"USN watcher started for {drive.Letter}");
                     }
                     catch (Exception ex)
                     {
-                        Debug.WriteLine($"Scan failed for {drive.Letter}: {ex.Message}");
+                        Logger.Log($"USN watcher failed for {drive.Letter}: {ex.Message}");
                     }
                 }
-                _index.CompleteIndex();
-                CacheManager.SaveCache(_index);
             }
 
-            // Set up USN watchers for live updates
-            foreach (var drive in _drives)
+            // Start live update processor
+            _cts = new CancellationTokenSource();
+            _ = Task.Run(() => LiveUpdateLoop(_cts.Token));
+
+            Dispatcher.Invoke(() =>
             {
-                try
-                {
-                    var watcher = new UsnWatcher(drive, evt => _eventQueue.Enqueue(evt), null);
-                    _watchers.Add(watcher);
-                    _ = watcher.RunAsync(CancellationToken.None);
-                }
-                catch { /* ignore */ }
-            }
+                StatusText.Text = $"{_index.Count} files indexed";
+                StatusBar.Visibility = Visibility.Collapsed;
+            });
+            Logger.Log("InitializeAsync done.");
         }
+        catch (Exception ex)
+        {
+            Logger.Log($"InitializeAsync fatal: {ex}");
+            ShowError($"Initialization failed:\n{ex.Message}\n\nCheck log at %LOCALAPPDATA%\\FastSeek\\log.txt");
+        }
+    }
 
-        // Start live update processor
-        _cts = new CancellationTokenSource();
-        _ = Task.Run(() => LiveUpdateLoop(_cts.Token));
-
+    private void ShowError(string message)
+    {
         Dispatcher.Invoke(() =>
         {
-            StatusText.Text = $"{_index.Count} files indexed";
-            StatusBar.Visibility = Visibility.Collapsed;
+            MessageBox.Show(message, "FastSeek Error", MessageBoxButton.OK, MessageBoxImage.Error);
         });
     }