bring back some fixes.

Author: LoneWandererProductions

CommonControls/Thumbnails.xaml.cs

@@ -57,23 +57,23 @@ public sealed partial class Thumbnails : IDisposable
     public static readonly DependencyProperty DependencyThumbHeight = DependencyProperty.Register(
         nameof(DependencyThumbHeight),
         typeof(int),
-        typeof(Thumbnails), new PropertyMetadata(100));
+        typeof(Thumbnails));
 
     /// <summary>
     ///     The Thumb Length (in lines)
     /// </summary>
     public static readonly DependencyProperty DependencyThumbWidth = DependencyProperty.Register(
         nameof(DependencyThumbWidth),
         typeof(int),
-        typeof(Thumbnails), new PropertyMetadata(100));
+        typeof(Thumbnails));
 
     /// <summary>
     ///     The Thumb Cell Size
     /// </summary>
     public static readonly DependencyProperty DependencyThumbCellSize = DependencyProperty.Register(
         nameof(DependencyThumbCellSize),
         typeof(int),
-        typeof(Thumbnails), new PropertyMetadata(100));
+        typeof(Thumbnails));
 
     /// <summary>
     ///     The dependency thumb grid
@@ -144,6 +144,11 @@ public sealed partial class Thumbnails : IDisposable
     /// </summary>
     private int _originalHeight;
 
+    /// <summary>
+    /// The loaded
+    /// </summary>
+    private bool _loaded;
+
     /// <summary>
     ///     The original width
     /// </summary>
@@ -448,92 +453,102 @@ private async Task OnItemsSourceChanged()
     /// </summary>
     /// <param name="sender">The source of the event.</param>
     /// <param name="e">The <see cref="RoutedEventArgs" /> instance containing the event data.</param>
-    private async void UserControl_Loaded(object sender, RoutedEventArgs e)
+    private void UserControl_Loaded(object sender, RoutedEventArgs e)
     {
         try
         {
+            _loaded = true;
+
+            // Capture original width/height immediately
             _originalWidth = ThumbWidth;
             _originalHeight = ThumbHeight;
 
-            await LoadImages(); // safe to await here
+            // Start loading images asynchronously
+            if (ItemsSource != null)
+            {
+                _ = LoadItemsAsync();
+            }
         }
         catch (Exception ex)
         {
-            // Log or handle exceptions gracefully
-            Trace.WriteLine($"Error loading images: {ex}");
+            Trace.WriteLine($"Error in Loaded: {ex}");
         }
     }
 
+    /// <summary>
+    /// Fire-and-forget wrapper to call your async method
+    /// Loads the items asynchronous.
+    /// </summary>
+    private async Task LoadItemsAsync()
+    {
+        await OnItemsSourceChanged();
+    }
+
     /// <summary>
     ///     Loads the images.
     /// </summary>
     private async Task LoadImages()
     {
         if (ItemsSource?.Any() != true) return;
 
+        _cancellationTokenSource?.Cancel();
         _cancellationTokenSource = new CancellationTokenSource();
         var token = _cancellationTokenSource.Token;
 
+        var timer = Stopwatch.StartNew();
 
-
-        var timer = new Stopwatch();
-        timer.Start();
-
-        // Initiate all values
-        ExtendedGrid.CellSize = ThumbCellSize;
+        // Make a local copy of images
         var pics = new Dictionary<int, string>(ItemsSource);
+
+        // Initialize dictionaries
         Keys = new ConcurrentDictionary<string, int>();
         ImageDct = new ConcurrentDictionary<string, Image>();
         Border = new ConcurrentDictionary<int, Border>();
         Selection = new ConcurrentDictionary<int, bool>();
         if (SelectBox) ChkBox = new ConcurrentDictionary<int, CheckBox>();
 
+        // Capture initial values from dependency properties
         int cellSize = await Application.Current.Dispatcher.InvokeAsync(() => ThumbCellSize);
         int thumbWidth = await Application.Current.Dispatcher.InvokeAsync(() => ThumbWidth);
         int thumbHeight = await Application.Current.Dispatcher.InvokeAsync(() => ThumbHeight);
+        bool thumbGrid = await Application.Current.Dispatcher.InvokeAsync(() => ThumbGrid);
 
-        // Handle special cases
-        if (cellSize == 0)
-        {
-            cellSize = 100;
-        }
+        // --- Handle special cases ---
+        if (cellSize <= 0) cellSize = 100;
+        if (thumbHeight <= 0 && thumbWidth <= 0) thumbHeight = 1;
 
-        if (thumbHeight == 0 && thumbWidth == 0)
+        if (thumbHeight * thumbWidth < pics.Count)
         {
-            thumbHeight = 1;
-        }
-
-        if (ThumbHeight * thumbWidth < pics.Count)
-        {
-            if (thumbWidth == 1)
-            {
-                thumbHeight = pics.Count;
-            }
-
-            if (thumbHeight == 1)
-            {
-                thumbWidth = pics.Count;
-            }
+            // Only one row or one column
+            if (thumbWidth == 1) thumbHeight = pics.Count;
+            if (thumbHeight == 1) thumbWidth = pics.Count;
 
+            // Neither is 1 → calculate width based on height
             if (thumbHeight != 1 && thumbWidth != 1 && pics.Count > 1)
             {
                 var fraction = new Fraction(pics.Count, thumbHeight);
                 thumbWidth = (int)Math.Ceiling(fraction.Decimal);
             }
         }
 
-        // Setup the grid layout
-        var exGrid = ExtendedGrid.ExtendGrid(ThumbWidth, ThumbHeight, ThumbGrid);
+        // Update dependency properties so other code/XAML sees correct sizes
+        ThumbWidth = thumbWidth;
+        ThumbHeight = thumbHeight;
+        ThumbCellSize = cellSize;
 
+        // --- Setup grid layout ---
+        var exGrid = ExtendedGrid.ExtendGrid(thumbWidth, thumbHeight, thumbGrid);
+        Thb.Children.Clear();
         _ = Thb.Children.Add(exGrid);
 
-        var semaphore = new SemaphoreSlim(4); // limit concurrent image loads
+        // --- Load images concurrently with semaphore ---
+        var semaphore = new SemaphoreSlim(4);
         var tasks = pics.Select(async kv =>
         {
             await semaphore.WaitAsync(token);
             try
             {
-                await LoadSingleImage(kv.Key, kv.Value, exGrid, token);
+                await LoadSingleImage(kv.Key, kv.Value, exGrid, token, cellSize, thumbWidth);
             }
             finally
             {
@@ -543,29 +558,30 @@ private async Task LoadImages()
 
         await Task.WhenAll(tasks);
 
-        // Wait for all remaining tasks
-        await Task.WhenAll(tasks);
-
         timer.Stop();
-        Trace.WriteLine(string.Concat(ComCtlResources.DebugTimer, timer.Elapsed));
+        Trace.WriteLine($"{ComCtlResources.DebugTimer}{timer.Elapsed}");
 
         // Notify that loading is finished
         ImageLoaded?.Invoke();
     }
 
     /// <summary>
-    ///     Loads the image asynchronous.
+    /// Loads the image asynchronous.
     /// </summary>
     /// <param name="key">The key.</param>
     /// <param name="filePath">The file path.</param>
     /// <param name="exGrid">The ex grid.</param>
-    /// <returns>Load all images async</returns>
-    private async Task LoadSingleImage(int key, string filePath, Panel exGrid, CancellationToken token)
+    /// <param name="token">The token.</param>
+    /// <param name="cellSize">Size of the cell.</param>
+    /// <param name="thumbWidth">Width of the thumb.</param>
+    /// <returns>
+    /// Load all images async
+    /// </returns>
+    private async Task LoadSingleImage(int key, string filePath, Panel exGrid, CancellationToken token, int cellSize, int thumbWidth)
     {
         if (token.IsCancellationRequested) return;
 
         // Capture UI-thread values safely
-        int cellSize = await Application.Current.Dispatcher.InvokeAsync(() => ThumbCellSize);
         bool isCheckBoxSelected = await Application.Current.Dispatcher.InvokeAsync(() => IsCheckBoxSelected);
 
         // Load the bitmap off the UI thread
@@ -620,14 +636,14 @@ await Application.Current.Dispatcher.InvokeAsync(() =>
             Border.TryAdd(key, border);
 
             // Grid placement
-            Grid.SetRow(border, key / ThumbWidth);
-            Grid.SetColumn(border, key % ThumbWidth);
+            Grid.SetRow(border, key / thumbWidth);
+            Grid.SetColumn(border, key % thumbWidth);
             _ = exGrid.Children.Add(border);
 
             if (SelectBox && checkbox != null)
             {
-                Grid.SetRow(checkbox, key / ThumbWidth);
-                Grid.SetColumn(checkbox, key % ThumbWidth);
+                Grid.SetRow(checkbox, key / thumbWidth);
+                Grid.SetColumn(checkbox, key % thumbWidth);
                 _ = exGrid.Children.Add(checkbox);
 
                 // Attach right-click event for context menu

ViewModel/AsyncDelegateCommand.cs

@@ -68,7 +68,6 @@ public bool CanExecute(object parameter)
         return _canExecute?.Invoke((T)parameter) ?? true;
     }
 
-
     /// <summary>
     /// Raises the <see cref="CanExecuteChanged" /> event to force WPF to re-query CanExecute.
     /// </summary>
@@ -85,4 +84,4 @@ public event EventHandler CanExecuteChanged
         add => CommandManager.RequerySuggested += value;
         remove => CommandManager.RequerySuggested -= value;
     }
-}
+}

ViewModel/DelegateCommand.cs

@@ -32,6 +32,11 @@ public sealed class DelegateCommand<T> : ICommand
         /// </summary>
         private readonly Predicate<T>? _canExecute;
 
+        /// <summary>
+        /// The execute command.
+        /// </summary>
+        private readonly Action<T?> _execute;
+
         /// <summary>
         ///     Initializes a new instance of the <see cref="DelegateCommand{T}" /> class.
         /// </summary>
@@ -41,9 +46,9 @@ public sealed class DelegateCommand<T> : ICommand
         ///     executable.
         /// </param>
         /// <exception cref="ArgumentNullException">Thrown when the action is null.</exception>
-        public DelegateCommand(Action<T> action, Predicate<T>? canExecute = null)
+        public DelegateCommand(Action<T?> execute, Predicate<T?>? canExecute = null)
         {
-            _action = action ?? throw new ArgumentNullException(nameof(action));
+            _execute = execute ?? throw new ArgumentNullException(nameof(execute));
             _canExecute = canExecute;
         }
 
@@ -53,28 +58,22 @@ public DelegateCommand(Action<T> action, Predicate<T>? canExecute = null)
         /// </summary>
         /// <param name="parameter">The parameter for the action.</param>
         public void Execute(object? parameter)
-        {
-            _action((T)parameter);
-        }
+            => _execute((parameter is T t) ? t : default);
 
         /// <inheritdoc />
         /// <summary>
         ///     Determines if the command can execute.
         /// </summary>
         /// <param name="parameter">The parameter for the predicate.</param>
         /// <returns>True if the command can execute, otherwise false.</returns>
-        public bool CanExecute(object parameter)
-        {
-            return _canExecute?.Invoke((T)parameter) ?? true;
-        }
+        public bool CanExecute(object? parameter)
+            => _canExecute?.Invoke((parameter is T t) ? t : default) ?? true;
 
         /// <summary>
         ///     Raises the <see cref="CanExecuteChanged"/> event to force WPF to re-query CanExecute.
         /// </summary>
         public void RaiseCanExecuteChanged()
-        {
-            CommandManager.InvalidateRequerySuggested();
-        }
+            => CommandManager.InvalidateRequerySuggested();
 
         /// <inheritdoc />
         /// <summary>

ViewModel/ObservableObject.cs

@@ -28,7 +28,5 @@ public class ObservableObject : INotifyPropertyChanged
     /// </summary>
     /// <param name="propertyName">The name of the property that changed.</param>
     protected void RaisePropertyChangedEvent([CallerMemberName] string? propertyName = null)
-    {
-        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
-    }
-}
+        => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+}

ViewModel/RelayCommand.cs

@@ -67,4 +67,4 @@ public RelayCommand(Action execute, Func<bool>? canExecute = null)
         public void RaiseCanExecuteChanged() =>
             CanExecuteChanged?.Invoke(this, EventArgs.Empty);
     }
-}
+}