From ff4a8edf995788c51e5f01bcc717041b49f8016e Mon Sep 17 00:00:00 2001
From: Ruben <ruben@live.dk>
Date: Sat, 7 Dec 2024 23:10:24 +0100
Subject: [PATCH] Batch resize - Cancellation, refactor #165

---
 .../Views/BatchResizeView.axaml               |   6 +-
 .../Views/BatchResizeView.axaml.cs            | 473 ++++++++++--------
 2 files changed, 258 insertions(+), 221 deletions(-)

diff --git a/src/PicView.Avalonia/Views/BatchResizeView.axaml b/src/PicView.Avalonia/Views/BatchResizeView.axaml
index 0ab5dafe..71913a05 100644
--- a/src/PicView.Avalonia/Views/BatchResizeView.axaml
+++ b/src/PicView.Avalonia/Views/BatchResizeView.axaml
@@ -950,14 +950,14 @@
             <Button
                 Classes="BorderStyle altHover mainBtn"
                 CornerRadius="4"
-                IsEnabled="False"
                 x:Name="CancelButton">
                 <TextBlock
                     Classes="txt"
                     Padding="15,0"
-                    Text="{CompiledBinding Cancel,
+                    Text="{CompiledBinding Reset,
                                            Mode=OneWay}"
-                    TextAlignment="Center" />
+                    TextAlignment="Center"
+                    x:Name="CancelButtonTextBlock" />
             </Button>
 
             <Button
diff --git a/src/PicView.Avalonia/Views/BatchResizeView.axaml.cs b/src/PicView.Avalonia/Views/BatchResizeView.axaml.cs
index 1f3bb943..5b23ddca 100644
--- a/src/PicView.Avalonia/Views/BatchResizeView.axaml.cs
+++ b/src/PicView.Avalonia/Views/BatchResizeView.axaml.cs
@@ -13,6 +13,9 @@ namespace PicView.Avalonia.Views;
 public partial class BatchResizeView : UserControl
 {
     private bool _isKeepingAspectRatio = true;
+    private bool _isRunning;
+    
+    private CancellationTokenSource? _cancellationTokenSource;
 
     public BatchResizeView()
     {
@@ -53,23 +56,34 @@ public BatchResizeView()
                 OutputFolderTextBox.Text = directory;
             };
 
-            LinkChainButton.Click += delegate
+            LinkChainButton.Click += delegate { ToggleAspectRatio(); };
+
+            StartButton.Click += async (_, _) =>
             {
-                if (_isKeepingAspectRatio)
+                try
                 {
-                    _isKeepingAspectRatio = false;
-                    LinkChainImage.IsVisible = false;
-                    UnlinkChainImage.IsVisible = true;
+                    await StartBatchResize();
                 }
-                else
+                catch (Exception e)
                 {
-                    _isKeepingAspectRatio = true;
-                    LinkChainImage.IsVisible = true;
-                    UnlinkChainImage.IsVisible = false;
+#if DEBUG
+                    Console.WriteLine(e);
+#endif
                 }
             };
 
-            StartButton.Click += async (_, _) => await StartBatchResize();
+            CancelButton.Click += async delegate
+            {
+                if (_isRunning)
+                {
+                    await CancelBatchResize();
+                }
+                else
+                {
+                    Reset();
+                }
+
+            };
 
             if (!NavigationHelper.CanNavigate(vm))
             {
@@ -79,267 +93,290 @@ public BatchResizeView()
             SourceFolderTextBox.Text = vm.FileInfo?.DirectoryName ?? string.Empty;
         };
     }
-
-    private async Task StartBatchResize()
+    
+    private void ToggleAspectRatio()
     {
-        if (DataContext is not MainViewModel vm)
-        {
-            return;
-        }
+        _isKeepingAspectRatio = !_isKeepingAspectRatio;
+        LinkChainImage.IsVisible = _isKeepingAspectRatio;
+        UnlinkChainImage.IsVisible = !_isKeepingAspectRatio;
+    }
 
-        var files = await Task.FromResult(FileListHelper.RetrieveFiles(new FileInfo(SourceFolderTextBox.Text)));
+    private void Reset()
+    {
+        
+    }
+    
+    private async Task CancelBatchResize()
+    {
+        await _cancellationTokenSource?.CancelAsync();
+        CancelButtonTextBlock.Text = TranslationHelper.Translation.Reset;
+        StartButton.IsEnabled = true;
+        _isRunning = false;
+        ProgressBar.Value = 0;
+        await Task.CompletedTask;
+    }
 
-        if (!Directory.Exists(OutputFolderTextBox.Text))
+    private async Task StartBatchResize()
+    {
+        try
         {
-            Directory.CreateDirectory(OutputFolderTextBox.Text);
-        }
-
-        var outputFolder = string.IsNullOrWhiteSpace(OutputFolderTextBox.Text)
-            ? SourceFolderTextBox.Text
-            : OutputFolderTextBox.Text;
-
-        var toConvert = !NoConversion.IsSelected;
-        var pngSelected = PngItem.IsSelected;
-        var jpgSelected = JpgItem.IsSelected;
-        var webpSelected = WebpItem.IsSelected;
-        var avifSelected = AvifItem.IsSelected;
-        var heicSelected = HeicItem.IsSelected;
-        var jxlSelected = JxlItem.IsSelected;
-
-        var qualityEnabled = IsQualityEnabledBox.IsChecked.HasValue && IsQualityEnabledBox.IsChecked.Value;
-        var qualityValue = (uint)QualitySlider.Value;
+            _cancellationTokenSource = new CancellationTokenSource();
+            
+            CancelButtonTextBlock.Text = TranslationHelper.Translation.Cancel;
+            CancelButton.Classes.Remove("altHover");
+            CancelButton.Classes.Add("errorHover");
+            StartButton.IsEnabled = false;
 
-        var losslessCompress = Lossless.IsSelected;
-        var lossyCompress = Lossy.IsSelected;
+            _isRunning = true;
 
-        Percentage? percentage = null;
-        if (PercentageResizeBox.IsSelected)
-        {
-            if (int.TryParse(PercentageValueBox.Text, out var percentageValue))
-            {
-                percentage = new Percentage(percentageValue);
-            }
-        }
+            var files = await Task.FromResult(
+                    FileListHelper.RetrieveFiles(new FileInfo(SourceFolderTextBox.Text)))
+                .ConfigureAwait(true);
 
-        uint width = 0, height = 0;
-        if (WidthResizeBox.IsSelected)
-        {
-            if (uint.TryParse(WidthValueBox.Text, out var widthValue))
-            {
-                width = widthValue;
-            }
-        }
-        else if (HeightResizeBox.IsSelected)
-        {
-            if (uint.TryParse(HeightValueBox.Text, out var heightValue))
+            if (!Directory.Exists(OutputFolderTextBox.Text))
             {
-                height = heightValue;
-            }
-        }
-        else if (WidthAndHeightResizeBox.IsSelected)
-        {
-            if (uint.TryParse(WidthAndHeightWidthValueBox.Text, out var widthValue))
-            {
-                width = widthValue;
+                Directory.CreateDirectory(OutputFolderTextBox.Text);
             }
 
-            if (uint.TryParse(WidthAndHeightHeightValueBox.Text, out var heightValue))
-            {
-                height = heightValue;
-            }
-        }
+            var outputFolder = string.IsNullOrWhiteSpace(OutputFolderTextBox.Text)
+                ? SourceFolderTextBox.Text
+                : OutputFolderTextBox.Text;
 
-        ProgressBar.Maximum = files.Count();
+            var toConvert = !NoConversion.IsSelected;
+            var pngSelected = PngItem.IsSelected;
+            var jpgSelected = JpgItem.IsSelected;
+            var webpSelected = WebpItem.IsSelected;
+            var avifSelected = AvifItem.IsSelected;
+            var heicSelected = HeicItem.IsSelected;
+            var jxlSelected = JxlItem.IsSelected;
 
-        await Parallel.ForEachAsync(files, async (file, token) =>
-        {
-            var ext = Path.GetExtension(file);
+            var qualityEnabled = IsQualityEnabledBox.IsChecked.HasValue && IsQualityEnabledBox.IsChecked.Value;
+            var qualityValue = (uint)QualitySlider.Value;
 
-            var destination = Path.Combine(outputFolder, Path.GetFileName(file));
+            var losslessCompress = Lossless.IsSelected;
+            var lossyCompress = Lossy.IsSelected;
 
-            if (toConvert)
+            Percentage? percentage = null;
+            if (PercentageResizeBox.IsSelected)
             {
-                if (pngSelected)
+                if (int.TryParse(PercentageValueBox.Text, out var percentageValue))
                 {
-                    ext = ".png";
-                    destination = Path.ChangeExtension(destination, ".png");
+                    percentage = new Percentage(percentageValue);
                 }
-                else if (jpgSelected)
-                {
-                    ext = ".jpg";
-                    destination = Path.ChangeExtension(destination, ".jpg");
-                }
-                else if (webpSelected)
+            }
+
+            uint width = 0, height = 0;
+            if (WidthResizeBox.IsSelected)
+            {
+                if (uint.TryParse(WidthValueBox.Text, out var widthValue))
                 {
-                    ext = ".webp";
-                    destination = Path.ChangeExtension(destination, ".webp");
+                    width = widthValue;
                 }
-                else if (avifSelected)
+            }
+            else if (HeightResizeBox.IsSelected)
+            {
+                if (uint.TryParse(HeightValueBox.Text, out var heightValue))
                 {
-                    ext = ".avif";
-                    destination = Path.ChangeExtension(destination, ".avif");
+                    height = heightValue;
                 }
-                else if (heicSelected)
+            }
+            else if (WidthAndHeightResizeBox.IsSelected)
+            {
+                if (uint.TryParse(WidthAndHeightWidthValueBox.Text, out var widthValue))
                 {
-                    ext = ".heic";
-                    destination = Path.ChangeExtension(destination, ".heic");
+                    width = widthValue;
                 }
-                else if (jxlSelected)
+
+                if (uint.TryParse(WidthAndHeightHeightValueBox.Text, out var heightValue))
                 {
-                    ext = ".jxl";
-                    destination = Path.ChangeExtension(destination, ".jxl");
+                    height = heightValue;
                 }
             }
 
-            uint? quality = null;
-            if (qualityEnabled)
+            ProgressBar.Maximum = files.Count();
+            ProgressBar.Value = 0;
+
+            await Parallel.ForEachAsync(files, _cancellationTokenSource.Token, async (file, token) =>
             {
-                if (ext.Equals(".jpg", StringComparison.OrdinalIgnoreCase) || Path.GetExtension(destination)
-                        .Equals(".jpg", StringComparison.OrdinalIgnoreCase) ||
-                    Path.GetExtension(destination).Equals(".jpeg", StringComparison.OrdinalIgnoreCase) ||
-                    ext.Equals(".png", StringComparison.OrdinalIgnoreCase) || Path.GetExtension(destination)
-                        .Equals(".png", StringComparison.OrdinalIgnoreCase))
+                token.ThrowIfCancellationRequested();
+                
+                var ext = Path.GetExtension(file);
+                var destination = Path.Combine(outputFolder, Path.GetFileName(file));
+
+                if (toConvert)
                 {
-                    quality = qualityValue;
+                    string GetTargetExtension()
+                    {
+                        if (pngSelected) return ".png";
+                        if (jpgSelected) return ".jpg";
+                        if (webpSelected) return ".webp";
+                        if (avifSelected) return ".avif";
+                        if (heicSelected) return ".heic";
+                        if (jxlSelected) return ".jxl";
+                        return ext;
+                    }
+
+                    ext = GetTargetExtension();
+                    destination = Path.ChangeExtension(destination, ext);
                 }
-            }
 
-            var success = await SaveImageFileHelper.SaveImageAsync(null,
-                file,
-                destination,
-                width,
-                height,
-                quality,
-                ext,
-                null,
-                percentage,
-                losslessCompress,
-                lossyCompress,
-                _isKeepingAspectRatio).ConfigureAwait(false);
-
-            if (success)
-            {
-#if DEBUG
-                Console.WriteLine($"Saved {file} to {destination}");
-#endif
-                try
+                uint? quality = null;
+                if (qualityEnabled)
                 {
-                    await ProcessThumbs(file, Path.GetDirectoryName(destination), quality, ext);
+                    if (ext.Equals(".jpg", StringComparison.OrdinalIgnoreCase) || Path.GetExtension(destination)
+                            .Equals(".jpg", StringComparison.OrdinalIgnoreCase) ||
+                        Path.GetExtension(destination).Equals(".jpeg", StringComparison.OrdinalIgnoreCase) ||
+                        ext.Equals(".png", StringComparison.OrdinalIgnoreCase) || Path.GetExtension(destination)
+                            .Equals(".png", StringComparison.OrdinalIgnoreCase))
+                    {
+                        quality = qualityValue;
+                    }
                 }
-                catch (Exception e)
+
+                var success = await SaveImageFileHelper.SaveImageAsync(null,
+                    file,
+                    destination,
+                    width,
+                    height,
+                    quality,
+                    ext,
+                    null,
+                    percentage,
+                    losslessCompress,
+                    lossyCompress,
+                    _isKeepingAspectRatio).ConfigureAwait(false);
+
+                if (success)
                 {
-                    #if DEBUG
-                    Console.WriteLine(e);
-                    #endif
+                    await ProcessThumbs(file, Path.GetDirectoryName(destination), quality, ext).ConfigureAwait(false);
+
+                    await Dispatcher.UIThread.InvokeAsync(() => { ProgressBar.Value++; });
                 }
-                await Dispatcher.UIThread.InvokeAsync(() => { ProgressBar.Value++; });
-            }
-        });
-        
-        return;
+            }).ConfigureAwait(false);
 
-        async Task ProcessThumbs(string? file, string? destinationDirectory, uint? quality, string? ext)
-        {
-            var toProcess = true;
-            
-            await Dispatcher.UIThread.InvokeAsync(() =>
+            return;
+
+            async Task ProcessThumbs(string? file, string? destinationDirectory, uint? quality, string? ext)
             {
-                if (ThumbnailsComboBox.SelectedIndex <= 0)
+                var toProcess = true;
+
+                await Dispatcher.UIThread.InvokeAsync(() =>
+                {
+                    if (ThumbnailsComboBox.SelectedIndex <= 0)
+                    {
+                        toProcess = false;
+                    }
+                });
+
+                if (!toProcess)
                 {
-                    toProcess = false;
+                    return;
                 }
-            });
-            
-            if (!toProcess)
-            {
-                return;
-            }
 
-            string destination = string.Empty;
-             
-            for (var i = 1; i <= 7; i++)
-            {
-                bool thumbIsPercentageResized;
-                bool thumbIsWidthResized;
-                bool thumbIsHeightResized;
-            
-                uint thumbWidth = 0, thumbHeight = 0;
-                Percentage? thumbPercentage = null;
-            
-                await Dispatcher.UIThread.InvokeAsync(() =>
+                var destination = string.Empty;
+
+                for (var i = 1; i <= 7; i++)
                 {
-                    // Dynamically construct the control names
-                    var percentageItemName = $"Thumb{i}PercentageItem";
-                    var widthItemName = $"Thumb{i}WidthItem";
-                    var heightItemName = $"Thumb{i}HeightItem";
-                    var valueBoxName = $"Thumb{i}ValueBox";
-                    var outputBoxName = $"Thumb{i}OutputBox";
-
-                    // Find controls based on their names
-                    var percentageItem = this.FindControl<ComboBoxItem>(percentageItemName);
-                    var widthItem = this.FindControl<ComboBoxItem>(widthItemName);
-                    var heightItem = this.FindControl<ComboBoxItem>(heightItemName);
-                    var valueBox = this.FindControl<TextBox>(valueBoxName);
-                    var outputBox = this.FindControl<TextBox>(outputBoxName);
-
-                    // Check which resizing option is selected
-                    thumbIsPercentageResized = percentageItem?.IsSelected ?? false;
-                    thumbIsWidthResized = widthItem?.IsSelected ?? false;
-                    thumbIsHeightResized = heightItem?.IsSelected ?? false;
-
-                    // Parse the value from the TextBox
-                    if (uint.TryParse(valueBox?.Text, out var thumbValue))
+                    bool thumbIsPercentageResized;
+                    bool thumbIsWidthResized;
+                    bool thumbIsHeightResized;
+
+                    uint thumbWidth = 0, thumbHeight = 0;
+                    Percentage? thumbPercentage = null;
+
+                    await Dispatcher.UIThread.InvokeAsync(() =>
                     {
-                        if (thumbIsPercentageResized)
+                        // Dynamically construct the control names
+                        var percentageItemName = $"Thumb{i}PercentageItem";
+                        var widthItemName = $"Thumb{i}WidthItem";
+                        var heightItemName = $"Thumb{i}HeightItem";
+                        var valueBoxName = $"Thumb{i}ValueBox";
+                        var outputBoxName = $"Thumb{i}OutputBox";
+
+                        // Find controls based on their names
+                        var percentageItem = this.FindControl<ComboBoxItem>(percentageItemName);
+                        var widthItem = this.FindControl<ComboBoxItem>(widthItemName);
+                        var heightItem = this.FindControl<ComboBoxItem>(heightItemName);
+                        var valueBox = this.FindControl<TextBox>(valueBoxName);
+                        var outputBox = this.FindControl<TextBox>(outputBoxName);
+
+                        // Check which resizing option is selected
+                        thumbIsPercentageResized = percentageItem?.IsSelected ?? false;
+                        thumbIsWidthResized = widthItem?.IsSelected ?? false;
+                        thumbIsHeightResized = heightItem?.IsSelected ?? false;
+
+                        // Parse the value from the TextBox
+                        if (uint.TryParse(valueBox?.Text, out var thumbValue))
                         {
-                            thumbPercentage = new Percentage(thumbValue);
+                            if (thumbIsPercentageResized)
+                            {
+                                thumbPercentage = new Percentage(thumbValue);
+                            }
+
+                            if (thumbIsWidthResized)
+                            {
+                                thumbWidth = thumbValue;
+                            }
+
+                            if (thumbIsHeightResized)
+                            {
+                                thumbHeight = thumbValue;
+                            }
                         }
-                        if (thumbIsWidthResized)
+
+                        if (!Directory.Exists(destinationDirectory))
                         {
-                            thumbWidth = thumbValue;
+                            Directory.CreateDirectory(destinationDirectory);
                         }
-                        if (thumbIsHeightResized)
+
+                        destination = Path.Combine(destinationDirectory, outputBox.Text, Path.GetFileName(file));
+
+                        if (!Directory.Exists(Path.GetDirectoryName(destination)))
                         {
-                            thumbHeight = thumbValue;
+                            Directory.CreateDirectory(Path.GetDirectoryName(destination));
                         }
-                    }
-                    
-                    if (!Directory.Exists(destinationDirectory))
-                    {
-                        Directory.CreateDirectory(destinationDirectory);
-                    }
-                    
-                    destination = Path.Combine(destinationDirectory, outputBox.Text, Path.GetFileName(file));
-                    
-                    if (!Directory.Exists(Path.GetDirectoryName(destination)))
+                    });
+
+                    var success = await SaveImageFileHelper.SaveImageAsync(null,
+                        file,
+                        destination,
+                        thumbWidth,
+                        thumbHeight,
+                        quality,
+                        ext,
+                        null,
+                        thumbPercentage,
+                        losslessCompress,
+                        lossyCompress,
+                        _isKeepingAspectRatio).ConfigureAwait(false);
+
+                    if (success)
                     {
-                        Directory.CreateDirectory(Path.GetDirectoryName(destination));
                     }
-                    
-                });
-            
-                var success = await SaveImageFileHelper.SaveImageAsync(
-                    null,
-                    file,
-                    destination,
-                    thumbWidth,
-                    thumbHeight,
-                    quality,
-                    ext,
-                    null,
-                    thumbPercentage,
-                    losslessCompress,
-                    lossyCompress,
-                    _isKeepingAspectRatio).ConfigureAwait(false);
-            
-                if (success)
-                {
-#if DEBUG
-                    Console.WriteLine($"Saved {file} to {destination}");
-#endif
                 }
             }
         }
+        catch (Exception e)
+        {
+#if DEBUG
+            Console.WriteLine(e);
+#endif
+        }
+        finally
+        {
+            await Dispatcher.UIThread.InvokeAsync(() =>
+            {
+                ProgressBar.Value = 0;
+                _isRunning = false;
+                
+                StartButton.IsEnabled = true;
+                
+                CancelButtonTextBlock.Text = TranslationHelper.Translation.Reset;
+                CancelButton.Classes.Remove("errorHover");
+                CancelButton.Classes.Add("altHover");
+            });
+            
+        }
     }
 
     private void CheckIfValidDirectory(string path)