QuickImage – Diff between revs 7 and 8

Subversion Repositories:

?pathlinks?

Rev 7 – Rev 9 – Go to most recent revision – Details – Blame – Last modification – View Log

         private readonly SemaphoreSlim _imageListViewLock;
         private readonly ImageTool _imageTool;
         private readonly Progress<ImageListViewItemProgress<ListViewItem>> _listViewItemProgress;
         private readonly MagicMime _magicMime;
         private readonly MD5 _md5;
-        private readonly LogMemorySink _memorySink;
+        private readonly LogMemorySink _memorySink = new LogMemorySink();
         private readonly QuickImageDatabase _quickImageDatabase;
         private readonly Progress<ImageListViewItemProgress<(ListViewItem Item, Database.QuickImage Image)>>
         public enum MenuItemsToggleOperation
+        {
             NONE,
             ENABLE,
             DISABLE
         }
+        private Configuration.Configuration Configuration { get; set; }
+        public bool MemorySinkEnabled { get; set; } = true;
         private Form1()
+        {
             _quickImageListViewProgress =
                 new Progress<ImageListViewItemProgress<(ListViewItem Item, Database.QuickImage Image)>>();
             _tagAutoCompleteStringCollection = new AutoCompleteStringCollection();
             textBox1.AutoCompleteCustomSource = _tagAutoCompleteStringCollection;
             tagTextBox.AutoCompleteCustomSource = _tagAutoCompleteStringCollection;
+            _quickImageDatabase = new QuickImageDatabase(_cancellationToken);
+            _tagManager = new TagManager(_fileMutex);
-            _memorySink = new LogMemorySink();
+            _imageTool = new ImageTool();
             Log.Logger = new LoggerConfiguration()
                 .MinimumLevel.Debug()
             _sparkle = new SparkleUpdater("https://quickimage.grimore.org/update/appcast.xml",
                 new Ed25519Checker(SecurityMode.Strict, "LonrgxVjSF0GnY4hzwlRJnLkaxnDn2ikdmOifILzLJY="))
+            {
                 UIFactory = new UIFactory(icon),
-                RelaunchAfterUpdate = true,
-                //SecurityProtocolType = SecurityProtocolType.Tls12,
-                //ShowsUIOnMainThread = false,
-                LogWriter = new LogWriter(LogWriterOutputMode.None)
+                RelaunchAfterUpdate = true
-            };
-            _sparkle.StartLoop(true, true);
-            _quickImageDatabase = new QuickImageDatabase(_cancellationToken);
+            };
             _tagManager = new TagManager(_fileMutex);
-            _imageTool = new ImageTool();
+            _sparkle.StartLoop(true, true);
+        }
-        public Form1(Mutex mutex) : this()
-        {
-        }
         public Form1(Mutex mutex) : this()
         private Configuration.Configuration Configuration { get; set; }
-        public bool MemorySinkEnabled { get; set; }
+        }
         private async Task SortImageListView(IComparer<ListViewItem> comparer)
         private async Task SortImageListView(IComparer<ListViewItem> comparer)
             var taskCompletionSources = new[]
-                { new TaskCompletionSource<object>(), new TaskCompletionSource<object>() };
+            var taskCompletionSources = new[] { new TaskCompletionSource<object>(), new TaskCompletionSource<object>() };
             finally
+            {
                 this.InvokeIfRequired(form =>
+                {
                     toolStripStatusLabel1.Text = "Sorting complete.";
                     form.toolStripProgressBar1.MarqueeAnimationSpeed = 0;
                 });
                 _imageListViewLock.Release();
+            }
+        }
         private async Task BalanceTags(IEnumerable<ListViewItem> items)
+        {
             var enumerable = items as ListViewItem[] ?? items.ToArray();
             var count = enumerable.Length;
-            var bufferBlock = new BufferBlock<(string Name, ConcurrentBag<string> Tags)>(new DataflowBlockOptions
-            { CancellationToken = _cancellationToken });
-            var broadcastBlock = new BroadcastBlock<(string Name, ConcurrentBag<string> Tags)>(x => x,
+            var bufferBlock = new BufferBlock<(string Name, ConcurrentBag<string> Tags)>(new DataflowBlockOptions{ CancellationToken = _cancellationToken });
-                new DataflowBlockOptions { CancellationToken = _cancellationToken });
+            var broadcastBlock = new BroadcastBlock<(string Name, ConcurrentBag<string> Tags)>(x => x, new DataflowBlockOptions { CancellationToken = _cancellationToken });
             var databaseActionBlock = new ActionBlock<(string Name, ConcurrentBag<string> Tags)>(
                 async file =>
-                {
                     await Task.WhenAll(_quickImageDatabase.AddTagsAsync(file.Name, file.Tags, _cancellationToken),
-                        _tagManager.AddIptcKeywords(file.Name, file.Tags, _cancellationToken));
+                    await Task.WhenAll(_quickImageDatabase.AddTagsAsync(file.Name, file.Tags, _cancellationToken), _tagManager.AddIptcKeywords(file.Name, file.Tags, _cancellationToken));
                 }, new ExecutionDataflowBlockOptions { CancellationToken = _cancellationToken });
             var taggingActionBlock = new ActionBlock<(string Name, ConcurrentBag<string> Tags)>(file =>
+                {
             try
+            {
                 this.InvokeIfRequired(form => { form.toolStripStatusLabel1.Text = "Balancing tags..."; });
                 var tags = new ConcurrentBag<string>();
                 foreach (var item in enumerable)
-                    await foreach (var tag in
+                {
-                                   _quickImageDatabase.GetTags(item.Name, _cancellationToken)
+                    await foreach (var tag in _quickImageDatabase.GetTags(item.Name, _cancellationToken).WithCancellation(_cancellationToken))
-                                       .WithCancellation(_cancellationToken))
+                    {
+                        tags.Add(tag);
+                    }
                         tags.Add(tag);
+                var tasks = new List<Task>();
-                var tasks = new List<Task>();
+                foreach (var item in enumerable)
+                {
-                foreach (var item in enumerable)
+                    tasks.Add(bufferBlock.SendAsync((item.Name, Tags: tags), _cancellationToken));
                     tasks.Add(bufferBlock.SendAsync((item.Name, Tags: tags), _cancellationToken));
                 await Task.WhenAll(tasks);
                 await Task.WhenAll(tasks);
                 bufferBlock.Complete();
                 bufferBlock.Complete();
                 await bufferBlock.Completion;
+                }
+            }
             if (count == 0)
+            {
+                if (_selectionCancellationTokenSource != null)
-            {
+                {
+                    _selectionCancellationTokenSource.Cancel();
                 if (_selectionCancellationTokenSource != null) _selectionCancellationTokenSource.Cancel();
                 tagListView.BeginUpdate();
                 foreach (var item in tagListView.CheckedItems.OfType<ListViewItem>())
                 tagListView.EndUpdate();
                 return;
+            }
-            }
+            if (_selectionCancellationTokenSource != null)
+            {
                 _selectionCancellationTokenSource.Cancel();
             if (_selectionCancellationTokenSource != null) _selectionCancellationTokenSource.Cancel();
             _selectionCancellationTokenSource = new CancellationTokenSource();
                 try
+                {
                     tagListView.InvokeIfRequired(view =>
+                    {
                         view.BeginUpdate();
                         foreach (var item in view.CheckedItems.OfType<ListViewItem>())
+                        {
                             item.Checked = false;
+                        }
+                    {
                         form.toolStripStatusLabel1.Text = "Selecting items...";
                         Application.Idle += IdleHandler;
                     });
-                    var tasks = new List<Task>();
+                    var tasks = new ConcurrentBag<Task>();
                     foreach (var item in enumerable)
+                    {
                         await foreach (var tag in _quickImageDatabase.GetTags(item.Name, _combinedSelectionCancellationToken).WithCancellation(_combinedSelectionCancellationToken))
+                        {
                     Log.Warning(exception, "Could not select items.");
+                }
             }, _combinedSelectionCancellationToken);
+        }
-        private async Task RelocateToAsync(IEnumerable<ListViewItem> items, string destinationDirectory,
+        private void RelocateTo(IEnumerable<ListViewItem> items, string destinationDirectory,
             CancellationToken cancellationToken)
+        {
             var enumerable = items as ListViewItem[] ?? items.ToArray();
                     return;
+                }
                 try
-                {
-                    using var _1 = transformBlock.LinkTo(actionBlock,
+                {
+                    using var _1 = transformBlock.LinkTo(actionBlock, new DataflowLinkOptions { PropagateCompletion = true });
                         new DataflowLinkOptions { PropagateCompletion = true });
                     var tasks = new ConcurrentBag<Task>();
                     foreach (var item in enumerable)
+                    {
+                        if (cancellationToken.IsCancellationRequested)
+                        {
-                    {
+                            return;
+                        }
                         if (cancellationToken.IsCancellationRequested) return;
+                        var task = transformBlock.SendAsync((Item: item, File: destinationDirectory), cancellationToken);
                         tasks.Add(task);
                         await transformBlock.SendAsync((Item: item, File: destinationDirectory), cancellationToken);
                     await Task.WhenAll(tasks);
                     transformBlock.Complete();
                     await actionBlock.Completion;
+                }
                 finally
+                {
                     _imageListViewLock.Release();
+                }
             }, cancellationToken, TaskCreationOptions.LongRunning, TaskScheduler.Current);
+        }
-        private async Task RemoveImagesAsync(IEnumerable<ListViewItem> items, CancellationToken cancellationToken)
+        private void RemoveImages(IEnumerable<ListViewItem> items, CancellationToken cancellationToken)
+        {
             var enumerable = items as ListViewItem[] ?? items.ToArray();
             toolStripProgressBar1.Style = ProgressBarStyle.Continuous;
             toolStripProgressBar1.Minimum = 0;
             toolStripProgressBar1.Maximum = enumerable.Length;
             toolStripProgressBar1.Value = 0;
-            var bufferBlock = new BufferBlock<ListViewItem>(new DataflowBlockOptions
+            var bufferBlock = new BufferBlock<ListViewItem>(new DataflowBlockOptions { CancellationToken = cancellationToken });
-            { CancellationToken = cancellationToken });
-            var actionBlock = new ActionBlock<ListViewItem>(listViewItem =>
             var actionBlock = new ActionBlock<ListViewItem>(listViewItem =>
                     toolStripStatusLabel1.Text = $"Unloading image {listViewItem.Name}";
-                    imageListView.Items.Remove(listViewItem);
+                    toolStripStatusLabel1.Text = $"Unloading image {listViewItem.Name}";
                     return;
+                }
                 try
-                {
-                    using var _ = bufferBlock.LinkTo(actionBlock,
+                {
-                        new DataflowLinkOptions { PropagateCompletion = true });
+                    using var _ = bufferBlock.LinkTo(actionBlock, new DataflowLinkOptions { PropagateCompletion = true });
                     foreach (var item in enumerable)
+                    {
                         if (cancellationToken.IsCancellationRequested) return;
+                        try
+                        {
+                            if (!await _quickImageDatabase.RemoveImageAsync(item.Name, cancellationToken))
                         try
                                 continue;
                             if (!await _quickImageDatabase.RemoveImageAsync(item.Name, cancellationToken)) continue;
                 new ExecutionDataflowBlockOptions
                 { CancellationToken = cancellationToken, TaskScheduler = _formTaskScheduler });
             var actionBlock = new ActionBlock<ListViewItem>(async item =>
             {
+                if (item == null)
+                {
+                    return;
                 if (item == null) return;
                 try
+                {
             toolStripProgressBar1.Style = ProgressBarStyle.Marquee;
             toolStripProgressBar1.MarqueeAnimationSpeed = 30;
             try
             {
-                var tasks = new List<Task>();
+                var tasks = new ConcurrentBag<Task>();
+                foreach (var group in enumerable)
-                foreach (var group in enumerable)
+                {
+                    foreach (var item in imageListView.Items.OfType<ListViewItem>())
-                    foreach (var item in imageListView.Items.OfType<ListViewItem>())
+                    {
+                        if (string.Equals(item.Group.Name, group, StringComparison.OrdinalIgnoreCase))
-                        if (string.Equals(item.Group.Name, group, StringComparison.OrdinalIgnoreCase))
+                        {
+                            tasks.Add(bufferBlock.SendAsync(item, cancellationToken));
+                        }
+                    }
                             tasks.Add(bufferBlock.SendAsync(item, cancellationToken));
+                        {
                             toolStripStatusLabel1.Text = $"File {file} already exits.";
                             return;
+                        }
+                        if (!largeImageList.Images.ContainsKey(file))
+                        {
+                            largeImageList.Images.Add(file, thumbnail);
                         if (!largeImageList.Images.ContainsKey(file)) largeImageList.Images.Add(file, thumbnail);
                         var fileInfo = new FileInfo(file);
                         if (!_imageListViewGroupDictionary.TryGetValue(fileInfo.DirectoryName, out var group))
-                        {
                             group = new ListViewGroup(fileInfo.DirectoryName, HorizontalAlignment.Left)
-                            { Name = fileInfo.DirectoryName };
+                            group = new ListViewGroup(fileInfo.DirectoryName, HorizontalAlignment.Left) { Name = fileInfo.DirectoryName };
                             _imageListViewGroupDictionary.TryAdd(fileInfo.DirectoryName, group);
-                            imageListView.Groups.Add(group);
-                        }
+                            imageListView.Groups.Add(group);
+                        }
                         var imageListViewItem = new ListViewItem(file)
-                        { Name = file, ImageKey = file, Text = fileInfo.Name, Group = group };
+                        var imageListViewItem = new ListViewItem(file) { Name = file, ImageKey = file, Text = fileInfo.Name, Group = group };
                     catch (Exception exception)
+                    {
                         Log.Warning(exception, "Could not update image list view.");
+                    }
                 },
-                new ExecutionDataflowBlockOptions
-                { CancellationToken = cancellationToken, TaskScheduler = _formTaskScheduler });
+                new ExecutionDataflowBlockOptions { CancellationToken = cancellationToken, TaskScheduler = _formTaskScheduler });
-            var fileInputBlock = new BufferBlock<string>(new ExecutionDataflowBlockOptions
-            { CancellationToken = cancellationToken });
+            var fileInputBlock = new BufferBlock<string>(new ExecutionDataflowBlockOptions { CancellationToken = cancellationToken });
             var updateImageTagsTransformBlock = new TransformBlock<string, Database.QuickImage>(async file =>
+            {
                 try
                 {
-                    var tags = new HashSet<string>();
                     var tags = new HashSet<string>();
                     var databaseTags = await _quickImageDatabase.GetTags(file, cancellationToken)
                     var mime = await magicMime.GetMimeType(file, cancellationToken);
                     if (Configuration.SupportedFormats.IsSupportedImage(mime))
+                    {
+                        var iptcTags = _tagManager.GetIptcKeywords(imageFrame);
                         var iptcTags = _tagManager.GetIptcKeywords(imageFrame);
                         tags = iptcTags.ToArray();
+                    }
             using var _4 = updateImageTagsTransformBlock.LinkTo(updateImageListViewActionBlock, new DataflowLinkOptions { PropagateCompletion = true });
             using var _5 =
                 updateImageTagsTransformBlock.LinkTo(DataflowBlock.NullTarget<Database.QuickImage>(), image =>
+                {
                     var r = image == null;
                     return r;
                 });
             using var _3 = fileInputBlock.LinkTo(createImageTransformBlock, new DataflowLinkOptions { PropagateCompletion = true });
             using var _6 = createImageTransformBlock.LinkTo(updateImageListViewActionBlock, new DataflowLinkOptions { PropagateCompletion = true });
             using var _7 =
                 createImageTransformBlock.LinkTo(DataflowBlock.NullTarget<Database.QuickImage>(), image =>
+                {
+                    var r = image == null;
                     var r = image == null;
                     return r;
                 });
             try
+            {
                 toolStripProgressBar1.Style = ProgressBarStyle.Marquee;
                 toolStripProgressBar1.MarqueeAnimationSpeed = 30;
-                var tasks = new List<Task>();
+                var tasks = new ConcurrentBag<Task>();
                 foreach (var item in enumerable)
+                {
                     await foreach (var entry in GetFilesAsync(item, Configuration, magicMime, cancellationToken).WithCancellation(cancellationToken))
+                    {
+            }
             finally
+            {
                 toolStripProgressBar1.MarqueeAnimationSpeed = 0;
                 _imageListViewLock.Release();
                 toolStripStatusLabel1.Text = "Done loading images.";
+            }
+        }
             toolStripProgressBar1.Style = ProgressBarStyle.Continuous;
             toolStripProgressBar1.Minimum = 0;
             toolStripProgressBar1.Maximum = enumerable.Length;
             toolStripProgressBar1.Value = 0;
-            void QuickImageListViewItemProgress(object sender,
-                ImageListViewItemProgress<(ListViewItem Item, Database.QuickImage Image)> e)
+            void QuickImageListViewItemProgress(object sender, ImageListViewItemProgress<(ListViewItem Item, Database.QuickImage Image)> e)
+            {
                 switch (e)
                 {
-                    case ImageListViewItemProgressSuccess<(ListViewItem Item, Database.QuickImage Image)>
-                        imageListViewItemProgressSuccess:
+                    case ImageListViewItemProgressSuccess<(ListViewItem Item, Database.QuickImage Image)> imageListViewItemProgressSuccess:
                         if (imageListViewItemProgressSuccess.Item is { } tuple)
+                        {
                             var (item, image) = tuple;
                                     _imageListViewGroupDictionary.TryAdd(fileInfo.DirectoryName, group);
                                     imageListView.Groups.Add(group);
+                                }
+                                largeImageList.Images.RemoveByKey(item.Name);
                                 largeImageList.Images.RemoveByKey(item.Name);
                                 largeImageList.Images.Add(image.File, image.Thumbnail);
                                 imageListView.Items.Add(new ListViewItem(fileInfo.DirectoryName)
             toolStripProgressBar1.Style = ProgressBarStyle.Continuous;
             toolStripProgressBar1.Minimum = 0;
             toolStripProgressBar1.Maximum = 1;
             toolStripProgressBar1.Value = 0;
-            void QuickImageListViewItemProgress(object sender,
-                ImageListViewItemProgress<(ListViewItem Item, Database.QuickImage Image)> e)
+            void QuickImageListViewItemProgress(object sender, ImageListViewItemProgress<(ListViewItem Item, Database.QuickImage Image)> e)
+            {
                 switch (e)
+                {
                     case ImageListViewItemProgressSuccess<(ListViewItem Item, Database.QuickImage Image)>
                         imageListViewItemProgressSuccess:
                         if (imageListViewItemProgressSuccess.Item is { } tuple)
+                        {
                             var (item, image) = tuple;
                             imageListView.BeginUpdate();
                             imageListView.BeginUpdate();
                             try
+                            {
                                 imageListView.Items.Remove(item);
                                 var fileInfo = new FileInfo(image.File);
                                 if (!_imageListViewGroupDictionary.TryGetValue(fileInfo.DirectoryName, out var group))
                                 if (!_imageListViewGroupDictionary.TryGetValue(fileInfo.DirectoryName, out var group))
                                     group = new ListViewGroup(fileInfo.DirectoryName, HorizontalAlignment.Left)
-                                    { Name = fileInfo.DirectoryName };
+                                    group = new ListViewGroup(fileInfo.DirectoryName, HorizontalAlignment.Left) { Name = fileInfo.DirectoryName };
             _quickImageListViewProgress.ProgressChanged += QuickImageListViewItemProgress;
             try
+            {
                 var directoryName = Path.GetDirectoryName(item.Name);
-                await RenameImage(item, Path.Combine(directoryName, destinationFileName), _quickImageListViewProgress,
-                    cancellationToken);
+                await RenameImage(item, Path.Combine(directoryName, destinationFileName), _quickImageListViewProgress, cancellationToken);
+            }
             catch (Exception exception)
+            {
             toolStripProgressBar1.Style = ProgressBarStyle.Continuous;
             toolStripProgressBar1.Minimum = 0;
             toolStripProgressBar1.Maximum = enumerable.Length;
             toolStripProgressBar1.Value = 0;
-            void QuickImageListViewItemProgress(object sender,
-                ImageListViewItemProgress<(ListViewItem Item, Database.QuickImage Image)> e)
+            void QuickImageListViewItemProgress(object sender, ImageListViewItemProgress<(ListViewItem Item, Database.QuickImage Image)> e)
+            {
                 switch (e)
                 {
-                    case ImageListViewItemProgressSuccess<(ListViewItem Item, Database.QuickImage Image)>
-                        imageListViewItemProgressSuccess:
+                    case ImageListViewItemProgressSuccess<(ListViewItem Item, Database.QuickImage Image)> imageListViewItemProgressSuccess:
                         if (imageListViewItemProgressSuccess.Item is { } tuple)
+                        {
                             var (item, image) = tuple;
                                     Name = image.File,
                                     ImageKey = image.File,
                                     Text = fileInfo.Name,
                                     Group = group
                                 });
                                 imageListView.EnsureVisible(listViewItem.Index);
+                            }
                             finally
+                            {
                                 imageListView.EndUpdate();
                     return;
+                }
                 try
-                {
-                    using var _ = bufferBlock.LinkTo(actionBlock,
+                {
-                        new DataflowLinkOptions { PropagateCompletion = true });
+                    using var _ = bufferBlock.LinkTo(actionBlock, new DataflowLinkOptions { PropagateCompletion = true });
                     foreach (var item in enumerable)
+                    {
+                        if (cancellationToken.IsCancellationRequested)
+                        {
                             return;
                         if (cancellationToken.IsCancellationRequested) return;
                         try
+                        {
+                            File.Delete(item.Name);
                             if (!await _quickImageDatabase.RemoveImageAsync(item.Name, cancellationToken))
                             File.Delete(item.Name);
                                 continue;
                             if (!await _quickImageDatabase.RemoveImageAsync(item.Name, cancellationToken)) continue;
             catch
+            {
                 return;
+            }
+            if (_selectionCancellationTokenSource != null)
+            {
+                _selectionCancellationTokenSource.Cancel();
             if (_selectionCancellationTokenSource != null) _selectionCancellationTokenSource.Cancel();
             imageListView.InvokeIfRequired(view => { imageListView.BeginUpdate(); });
             imageListView.InvokeIfRequired(view => { imageListView.BeginUpdate(); });
             try
+            {
                 var taskCompletionSource = new TaskCompletionSource<object>();
                 imageListView.InvokeIfRequired(view =>
+                {
+                    foreach (var item in view.Items.OfType<ListViewItem>())
+                    {
                         _searchStore.TryAdd(item.Name, item);
+                    }
                     foreach (var item in view.Items.OfType<ListViewItem>()) _searchStore.TryAdd(item.Name, item);
                     view.Items.Clear();
                     view.Items.Clear();
-                    taskCompletionSource.TrySetResult(new { });
-                });
+                    taskCompletionSource.TrySetResult(new { });
-                await taskCompletionSource.Task;
                 });
-                await foreach (var quickImage in _quickImageDatabase
+                await taskCompletionSource.Task;
+                await foreach (var quickImage in _quickImageDatabase.Search(keywords, _quickImageSearchType, _quickImageSearchParameters, _combinedSearchSelectionCancellationToken).WithCancellation(_combinedSearchSelectionCancellationToken))
                                    .Search(keywords, _quickImageSearchType, _quickImageSearchParameters,
-                                       _combinedSearchSelectionCancellationToken)
+                    if (!_searchStore.TryGetValue(quickImage.File, out var item))
+                    {
+                        continue;
+                    }
                                    .WithCancellation(_combinedSearchSelectionCancellationToken))
                     var directoryName = Path.GetDirectoryName(item.Name);
-                    if (!_searchStore.TryGetValue(quickImage.File, out var item)) continue;
+                    if (_imageListViewGroupDictionary.TryGetValue(directoryName, out var group))
+                    {
             catch
+            {
                 return;
+            }
+            if (_selectionCancellationTokenSource != null)
+            {
+                _selectionCancellationTokenSource.Cancel();
             if (_selectionCancellationTokenSource != null) _selectionCancellationTokenSource.Cancel();
             imageListView.InvokeIfRequired(view => { imageListView.BeginUpdate(); });
             try
+            {
+                toolStripStatusLabel1.Text = "Restoring items.";
                 toolStripStatusLabel1.Text = "Restoring items.";
                 var taskCompletionSource = new TaskCompletionSource<object>();
                 var taskCompletionSource = new TaskCompletionSource<object>();
                 imageListView.InvokeIfRequired(view =>
+                {
         private async Task OcrImages(IEnumerable<ListViewItem> items,
             IProgress<ImageListViewItemProgress<ListViewItem>> progress,
             CancellationToken cancellationToken)
         {
-            using var engine = new TesseractEngine(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "tessdata"),
-                "eng", EngineMode.Default);
+            using var engine = new TesseractEngine(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "tessdata"), "eng", EngineMode.Default);
             foreach (var item in items)
+            {
                 if (cancellationToken.IsCancellationRequested) return;
                         continue;
+                    }
                     if (!await _quickImageDatabase.AddTagsAsync(item.Name, tags, cancellationToken))
                     {
-                        progress.Report(new ImageListViewItemProgressFailure<ListViewItem>(item,
-                            new ArgumentException(MethodBase.GetCurrentMethod()?.Name)));
+                        progress.Report(new ImageListViewItemProgressFailure<ListViewItem>(item, new ArgumentException(MethodBase.GetCurrentMethod()?.Name)));
                         continue;
+                    }
             IProgress<ImageListViewItemProgress<(ListViewItem Item, Database.QuickImage Image)>> progress,
             CancellationToken cancellationToken)
+        {
             foreach (var item in items)
+            {
-                if (cancellationToken.IsCancellationRequested) return;
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return;
+                }
                 try
+                {
             CancellationToken cancellationToken)
+        {
             try
+            {
                 await Miscellaneous.CopyFileAsync(item.Name, destinationFileName, cancellationToken);
                 File.Delete(item.Name);
                 var image = await _quickImageDatabase.GetImageAsync(item.Name, cancellationToken);
             IProgress<ImageListViewItemProgress<(ListViewItem Item, Database.QuickImage Image)>> progress,
             CancellationToken cancellationToken)
+        {
             foreach (var item in items)
+            {
-                if (cancellationToken.IsCancellationRequested) return;
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return;
+                }
                 try
+                {
                     var fileName = Path.GetFileName(item.Name);
         private async Task GetTags(IReadOnlyList<ListViewItem> items,
             IProgress<ImageListViewItemProgress<ListViewItem>> progress, CancellationToken cancellationToken)
+        {
             foreach (var item in items)
+            {
-                if (cancellationToken.IsCancellationRequested) return;
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return;
+                }
                 try
+                {
                     var tags = await _quickImageDatabase.GetTags(item.Name, cancellationToken)
                 try
+                {
                     var mime = await magicMime.GetMimeType(item.Name, cancellationToken);
                     if (Configuration.SupportedFormats.IsSupportedImage(mime))
                     if (Configuration.SupportedFormats.IsSupportedImage(mime))
                         if (!await _tagManager.StripIptcProfile(item.Name, cancellationToken))
+                        {
                             progress.Report(new ImageListViewItemProgressFailure<ListViewItem>(item,
                                 new ArgumentException(MethodBase.GetCurrentMethod()?.Name)));
+                            continue;
-                            continue;
+                        }
-                        }
+                    }
                     var tags = await _quickImageDatabase.GetTags(item.Name, cancellationToken)
-                        .ToArrayAsync(cancellationToken);
+                    var tags = await _quickImageDatabase.GetTags(item.Name, cancellationToken).ToArrayAsync(cancellationToken);
                 try
+                {
                     var mime = await magicMime.GetMimeType(item.Name, cancellationToken);
                     if (Configuration.SupportedFormats.IsSupportedImage(mime))
                     if (Configuration.SupportedFormats.IsSupportedImage(mime))
                         if (!await _tagManager.RemoveIptcKeywords(item.Name, keywords, cancellationToken))
+                        {
                             progress.Report(new ImageListViewItemProgressFailure<ListViewItem>(item,
                                 new ArgumentException(MethodBase.GetCurrentMethod()?.Name)));
+                            continue;
                             continue;
+                    }
                     if (!await _quickImageDatabase.RemoveTagsAsync(item.Name, keywords, cancellationToken))
                 DateImageListViewSorterType.Modification));
+        }
         private void renameToolStripMenuItem_Click(object sender, EventArgs e)
         {
+            if (_renameForm != null)
+            {
+                return;
             if (_renameForm != null) return;
+            var item = imageListView.SelectedItems.OfType<ListViewItem>().FirstOrDefault();
+            if (item == null)
             var item = imageListView.SelectedItems.OfType<ListViewItem>().FirstOrDefault();
                 return;
             if (item == null) return;
             await RenameImageAsync(e.ListViewItem, e.FileName, _cancellationToken);
+        }
         private void RenameForm_Closing(object sender, CancelEventArgs e)
         {
+            if (_renameForm == null)
+            {
+                return;
             if (_renameForm == null) return;
             _renameForm.Closing -= RenameForm_Closing;
             _renameForm.Dispose();
                 IsFolderPicker = true
             };
             var groupItems = new List<ListViewItem>();
+            if (dialog.ShowDialog() == CommonFileDialogResult.Ok)
+            {
-            if (dialog.ShowDialog() == CommonFileDialogResult.Ok)
+                foreach (var item in imageListView.SelectedItems.OfType<ListViewItem>())
+                {
-                foreach (var item in imageListView.SelectedItems.OfType<ListViewItem>())
+                    foreach (var groupItem in item.Group.Items.OfType<ListViewItem>())
+                    {
+                        groupItems.Add(groupItem);
+                    }
-                    foreach (var groupItem in item.Group.Items.OfType<ListViewItem>())
+                }
                         groupItems.Add(groupItem);
-            await RelocateToAsync(groupItems, dialog.FileName, _cancellationToken);
+            RelocateTo(groupItems, dialog.FileName, _cancellationToken);
+        }
             _searchCancellationToken = _searchCancellationTokenSource.Token;
             _linkedSearchCancellationTokenSource =
                 CancellationTokenSource.CreateLinkedTokenSource(_cancellationToken, _searchCancellationToken);
             _combinedSearchSelectionCancellationToken = _linkedSearchCancellationTokenSource.Token;
-            _searchScheduledContinuation.Schedule(TimeSpan.FromMilliseconds(250), text,
-                async text => { await BeginSearch(text); }, _formTaskScheduler,
-                _combinedSearchSelectionCancellationToken);
+            _searchScheduledContinuation.Schedule(TimeSpan.FromMilliseconds(250), text, async text => { await BeginSearch(text); }, _formTaskScheduler, _combinedSearchSelectionCancellationToken);
+        }
         private void checkBox3_CheckedChanged(object sender, EventArgs e)
                         _quickImageSearchParameters & ~QuickImageSearchParameters.Split;
                     break;
+            }
             var text = textBox1.Text;
+            if (string.IsNullOrEmpty(text))
+            {
+                return;
+            }
-            if (string.IsNullOrEmpty(text)) return;
+            if (_searchCancellationTokenSource != null)
+            {
                 _searchCancellationTokenSource.Cancel();
             if (_searchCancellationTokenSource != null) _searchCancellationTokenSource.Cancel();
             _searchCancellationTokenSource = new CancellationTokenSource();
             _searchCancellationToken = _searchCancellationTokenSource.Token;
             _linkedSearchCancellationTokenSource =
-                CancellationTokenSource.CreateLinkedTokenSource(_cancellationToken, _searchCancellationToken);
-            _combinedSearchSelectionCancellationToken = _linkedSearchCancellationTokenSource.Token;
                 CancellationTokenSource.CreateLinkedTokenSource(_cancellationToken, _searchCancellationToken);
-            _searchScheduledContinuation.Schedule(TimeSpan.FromMilliseconds(250), text,
+            _combinedSearchSelectionCancellationToken = _linkedSearchCancellationTokenSource.Token;
                 async text => { await BeginSearch(text); }, _formTaskScheduler,
-                _combinedSearchSelectionCancellationToken);
+            _searchScheduledContinuation.Schedule(TimeSpan.FromMilliseconds(250), text, async text => { await BeginSearch(text); }, _formTaskScheduler, _combinedSearchSelectionCancellationToken);
         private async Task PerformUpgrade()
+        {
             // Manually check for updates, this will not show a ui
+            var updateCheck = await _sparkle.CheckForUpdatesQuietly();
             var updateCheck = await _sparkle.CheckForUpdatesQuietly();
             switch (updateCheck.Status)
+            {
                 case UpdateStatus.UserSkipped:
+                    var assemblyVersion = Assembly.GetExecutingAssembly().GetName().Version;
                     var assemblyVersion = Assembly.GetExecutingAssembly().GetName().Version;
                     updateCheck.Updates.Sort(UpdateComparer);
                     var latestVersion = updateCheck.Updates.FirstOrDefault();
                     if (latestVersion != null)
+                    {
                     if (fileAttributes.HasFlag(FileAttributes.Directory))
+                    {
                         continue;
+                    }
+                    using var fileStream = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read);
+                    var memoryStream = new MemoryStream();
-                    var memoryStream = new MemoryStream(File.ReadAllBytes(file));
+                    await fileStream.CopyToAsync(memoryStream);
                     memoryStream.Position = 0L;
                     var mime = await magicMime.Identify(file, cancellationToken);
             var fileNames = data.GetFileContentNames();
             for (var i = 0; i < fileNames.Length; ++i)
+            {
                 var memoryStream = data.GetFileContent(i);
                 memoryStream.Position = 0L;
                 var mime = magicMime.Identify(fileNames[i], memoryStream, cancellationToken);
-                if (mime == null) continue;
+                if (mime == null)
+                {
+                    continue;
+                }
                 yield return (File: fileNames[0], Data: memoryStream, Mime: mime.Definition);
+            }
+        }
         private static async IAsyncEnumerable<string> GetFilesAsync(string entry,
             Configuration.Configuration configuration, MagicMime magicMime,
             [EnumeratorCancellation] CancellationToken cancellationToken)
         {
-            var bufferBlock = new BufferBlock<string>(new DataflowBlockOptions
-            { CancellationToken = cancellationToken });
+            var bufferBlock = new BufferBlock<string>(new DataflowBlockOptions { CancellationToken = cancellationToken });
 #pragma warning disable CS4014
             Task.Run(async () =>
+                }
             }, cancellationToken);
             while (await bufferBlock.OutputAvailableAsync(cancellationToken))
             {
+                if (!bufferBlock.TryReceiveAll(out var files))
+                {
+                    continue;
-                if (!bufferBlock.TryReceiveAll(out var files)) continue;
+                }
+                foreach (var file in files)
+                {
                     yield return file;
                 foreach (var file in files) yield return file;
+            }
+        }
         #region Event Handlers
         private void toolStripTextBox1_KeyUp(object sender, KeyEventArgs e)
+        {
+            if (e.KeyCode != Keys.Return)
+            {
                 return;
             if (e.KeyCode != Keys.Return) return;
             // Skip the beep.
             e.Handled = true;
+            var toolStripTextBox = (ToolStripTextBox)sender;
+            var tagText = toolStripTextBox.Text;
+            toolStripTextBox.Clear();
             var toolStripTextBox = (ToolStripTextBox)sender;
-            var tagText = toolStripTextBox.Text;
+            if (string.IsNullOrEmpty(tagText))
+                }
                 toolStripStatusLabel1.Text = "Adding tags...";
                 toolStripProgressBar1.Increment(1);
+                if (toolStripProgressBar1.Value == toolStripProgressBar1.Maximum)
+                {
-                if (toolStripProgressBar1.Value == toolStripProgressBar1.Maximum)
+                    _listViewItemProgress.ProgressChanged -= ImageListViewItemProgress;
                     _listViewItemProgress.ProgressChanged -= ImageListViewItemProgress;
+            }
                     form.toolStripProgressBar1.MarqueeAnimationSpeed = 30;
                 });
                 try
-                {
-                    var images = await _quickImageDatabase.GetAll(_cancellationToken).ToArrayAsync(_cancellationToken);
+                {
-                    var imageListViewItems = new List<ListViewItem>();
+                    var imageListViewItems = new ConcurrentBag<ListViewItem>();
                     var tags = new HashSet<string>(StringComparer.Ordinal);
-                    foreach (var image in images)
+                    await foreach (var image in _quickImageDatabase.GetAll(_cancellationToken))
                     {
+                        if (!largeImageList.Images.ContainsKey(image.File))
-                        if (!largeImageList.Images.ContainsKey(image.File))
+                        {
+                            largeImageList.Images.Add(image.File, image.Thumbnail);
                             largeImageList.Images.Add(image.File, image.Thumbnail);
                         var fileInfo = new FileInfo(image.File);
-                        if (!_imageListViewGroupDictionary.TryGetValue(fileInfo.DirectoryName, out var group))
-                        {
+                        if (!_imageListViewGroupDictionary.TryGetValue(fileInfo.DirectoryName, out var group))
+                        {
-                            group = new ListViewGroup(fileInfo.DirectoryName, HorizontalAlignment.Left)
+                            group = new ListViewGroup(fileInfo.DirectoryName, HorizontalAlignment.Left) { Name = fileInfo.DirectoryName };
                                 { Name = fileInfo.DirectoryName };
+                            _imageListViewGroupDictionary.TryAdd(fileInfo.DirectoryName, group);
                             _imageListViewGroupDictionary.TryAdd(fileInfo.DirectoryName, group);
+                            imageListView.InvokeIfRequired(view =>
                             imageListView.InvokeIfRequired(view =>
                                 view.BeginUpdate();
                                 view.Groups.Add(group);
+                                view.EndUpdate();
                             });
+                        }
                         tags.UnionWith(image.Tags);
-                        imageListViewItems.Add(new ListViewItem(image.File)
+                        var imageListViewItem = new ListViewItem(image.File)
+                        {
+                            Name = image.File,
+                            ImageKey = image.File,
-                        {
+                            Text = fileInfo.Name,
-                            Name = image.File,
+                            Group = group
-                            ImageKey = image.File,
+                        };
                             Text = fileInfo.Name,
                     tagListView.InvokeIfRequired(view =>
+                    {
                         view.BeginUpdate();
                         view.Items.AddRange(tags.Select(tag => new ListViewItem(tag) { Name = tag }).ToArray());
                         view.EndUpdate();
                     });
+                }
                 catch (Exception exception)
+                {
                     Log.Error(exception, "Unable to load images.");
+                }
+        }
         private async void tagListView_MouseDown(object sender, MouseEventArgs e)
+        {
             var listView = (ListView)sender;
+            if (!listView.CheckBoxes)
+            {
+                return;
             if (!listView.CheckBoxes) return;
             // Allow clicking anywhere on tag.
+            var hitTest = listView.HitTest(e.Location);
+            if (hitTest.Item == null)
+            {
-            var hitTest = listView.HitTest(e.Location);
+                return;
             if (hitTest.Item == null) return;
                     case ImageListViewItemProgressFailure<ListViewItem> imageListViewItemProgressFailure:
                         break;
+                }
                 toolStripProgressBar1.Increment(1);
+                if (toolStripProgressBar1.Value == toolStripProgressBar1.Maximum)
-                if (toolStripProgressBar1.Value == toolStripProgressBar1.Maximum)
+                {
+                    _listViewItemProgress.ProgressChanged -= ImageListViewItemProgress;
                     _listViewItemProgress.ProgressChanged -= ImageListViewItemProgress;
+            }
             if (item.Checked)
+            {
                 toolStripStatusLabel1.Text = "Removing tags...";
                 toolStripStatusLabel1.Text = "Removing tags...";
                 _listViewItemProgress.ProgressChanged += ImageListViewItemProgress;
                 try
+                {
                     await RemoveTags(items, keywords, _magicMime, _listViewItemProgress, _cancellationToken);
+                }
                 finally
+                {
+                    _listViewItemProgress.ProgressChanged -= ImageListViewItemProgress;
+                }
-                {
+                switch(hitTest.Location)
+                {
-                    _listViewItemProgress.ProgressChanged -= ImageListViewItemProgress;
+                    case ListViewHitTestLocations.Label:
                         hitTest.Item.Checked = !hitTest.Item.Checked;
                         break;
             finally
+            {
                 _listViewItemProgress.ProgressChanged -= ImageListViewItemProgress;
+            }
+            switch(hitTest.Location)
+            {
+                case ListViewHitTestLocations.Label:
+                    hitTest.Item.Checked = !hitTest.Item.Checked;
+                    break;
             if (hitTest.Location == ListViewHitTestLocations.Label) hitTest.Item.Checked = !hitTest.Item.Checked;
+        }
         private void aboutToolStripMenuItem_Click(object sender, EventArgs e)
+        {
+            if (_aboutForm != null)
+            {
                 return;
             if (_aboutForm != null) return;
             _aboutForm = new AboutForm();
             _aboutForm.Closing += AboutForm_Closing;
             _aboutForm.Show();
         }
+        private void AboutForm_Closing(object sender, CancelEventArgs e)
+        {
             if (_aboutForm == null)
         private void AboutForm_Closing(object sender, CancelEventArgs e)
                 return;
             if (_aboutForm == null) return;
             await PerformUpgrade();
+        }
         private void viewLogsToolStripMenuItem_Click(object sender, EventArgs e)
         {
+            if (_viewLogsForm != null)
+            {
+                return;
             if (_viewLogsForm != null) return;
             _viewLogsForm = new ViewLogsForm(this, _memorySink, _cancellationToken);
             _viewLogsForm.Closing += ViewLogsForm_Closing;
             _viewLogsForm.Show();
+        }
+        private void ViewLogsForm_Closing(object sender, CancelEventArgs e)
+        {
+            if (_viewLogsForm == null)
         private void ViewLogsForm_Closing(object sender, CancelEventArgs e)
                 return;
             if (_viewLogsForm == null) return;
         private async void removeToolStripMenuItem_Click(object sender, EventArgs e)
+        {
             var items = imageListView.SelectedItems.OfType<ListViewItem>().ToArray();
-            await RemoveImagesAsync(items, _cancellationToken);
+            RemoveImages(items, _cancellationToken);
+        }
         private void textBox1_KeyDown(object sender, KeyEventArgs e)
+        {
             if (e.Control && e.KeyCode == Keys.A)
+            {
                 var textBox = (TextBox)sender;
                 textBox.SelectAll();
+            }
+        }
         private void radioButton2_CheckedChanged(object sender, EventArgs e)
+        {
             _quickImageSearchType = QuickImageSearchType.Any;
+            var text = textBox1.Text;
+            if (string.IsNullOrEmpty(text))
+            {
+                return;
+            }
-            var text = textBox1.Text;
+            if (_searchCancellationTokenSource != null)
             if (string.IsNullOrEmpty(text)) return;
                 _searchCancellationTokenSource.Cancel();
             if (_searchCancellationTokenSource != null) _searchCancellationTokenSource.Cancel();
             _searchCancellationTokenSource = new CancellationTokenSource();
             _searchCancellationToken = _searchCancellationTokenSource.Token;
-            _linkedSearchCancellationTokenSource =
-                CancellationTokenSource.CreateLinkedTokenSource(_cancellationToken, _searchCancellationToken);
-            _combinedSearchSelectionCancellationToken = _linkedSearchCancellationTokenSource.Token;
+            _linkedSearchCancellationTokenSource =
                 CancellationTokenSource.CreateLinkedTokenSource(_cancellationToken, _searchCancellationToken);
-            _searchScheduledContinuation.Schedule(TimeSpan.FromMilliseconds(250), text,
+            _combinedSearchSelectionCancellationToken = _linkedSearchCancellationTokenSource.Token;
                 async text => { await BeginSearch(text); }, _formTaskScheduler,
-                _combinedSearchSelectionCancellationToken);
+            _searchScheduledContinuation.Schedule(TimeSpan.FromMilliseconds(250), text, async text => { await BeginSearch(text); }, _formTaskScheduler, _combinedSearchSelectionCancellationToken);
         }
+        private void radiobutton1_CheckedChanged(object sender, EventArgs e)
+        {
             _quickImageSearchType = QuickImageSearchType.All;
         private void radiobutton1_CheckedChanged(object sender, EventArgs e)
             var text = textBox1.Text;
-            _quickImageSearchType = QuickImageSearchType.All;
+            if (string.IsNullOrEmpty(text))
+            {
-            var text = textBox1.Text;
+                return;
-            if (string.IsNullOrEmpty(text)) return;
+            }
-            if (_searchCancellationTokenSource != null) _searchCancellationTokenSource.Cancel();
-            _searchCancellationTokenSource = new CancellationTokenSource();
+            if (_searchCancellationTokenSource != null) _searchCancellationTokenSource.Cancel();
             _searchCancellationToken = _searchCancellationTokenSource.Token;
-            _linkedSearchCancellationTokenSource =
+            _searchCancellationTokenSource = new CancellationTokenSource();
-                CancellationTokenSource.CreateLinkedTokenSource(_cancellationToken, _searchCancellationToken);
+            _searchCancellationToken = _searchCancellationTokenSource.Token;
-            _combinedSearchSelectionCancellationToken = _linkedSearchCancellationTokenSource.Token;
-            _searchScheduledContinuation.Schedule(TimeSpan.FromMilliseconds(250), text,
-                async text => { await BeginSearch(text); }, _formTaskScheduler,
-                _combinedSearchSelectionCancellationToken);
             _linkedSearchCancellationTokenSource =
+                CancellationTokenSource.CreateLinkedTokenSource(_cancellationToken, _searchCancellationToken);
-        private async void editToolStripMenuItem1_Click(object sender, EventArgs e)
+            _combinedSearchSelectionCancellationToken = _linkedSearchCancellationTokenSource.Token;
-        {
-            var item = imageListView.SelectedItems.OfType<ListViewItem>().FirstOrDefault();
-            if (item == null) return;
+            _searchScheduledContinuation.Schedule(TimeSpan.FromMilliseconds(250), text, async text => { await BeginSearch(text); }, _formTaskScheduler, _combinedSearchSelectionCancellationToken);
+        }
             if (_editorForm != null) return;
+        private async void editToolStripMenuItem1_Click(object sender, EventArgs e)
+        {
-            string mime;
+            var item = imageListView.SelectedItems.OfType<ListViewItem>().FirstOrDefault();
-            try
+            if (item == null)
             {
-                mime = await _magicMime.GetMimeType(item.Name, _cancellationToken);
+                return;
+            }
             catch (Exception exception)
             if (_editorForm != null)
                 Log.Error(exception, "Unable to identify file.");
                 return;
             var thumbnail = new Bitmap(thumbnailBitmap);
             thumbnailBitmap.Dispose();
             try
             {
+                if (!await _quickImageDatabase.RemoveImageAsync(e.FileName, _cancellationToken))
-                var keywords = await _quickImageDatabase.GetTags(e.FileName, _cancellationToken)
+                {
+                    throw new ArgumentException($"Could not remove image {e.FileName} from database.");
-                    .ToArrayAsync(_cancellationToken);
+                }
-                if (!await _quickImageDatabase.RemoveImageAsync(e.FileName, _cancellationToken))
+                var keywords = await _quickImageDatabase.GetTags(e.FileName, _cancellationToken).ToArrayAsync(_cancellationToken);
-                    throw new ArgumentException($"Could not remove image {e.FileName} from database.");
+                if (!await _quickImageDatabase.AddImageAsync(e.FileName, hash, keywords, thumbnail, _cancellationToken))
+                {
-                if (!await _quickImageDatabase.AddImageAsync(e.FileName, hash, keywords, thumbnail, _cancellationToken))
+                    throw new ArgumentException($"Could not add image {e.FileName} to database.");
                     throw new ArgumentException($"Could not add image {e.FileName} to database.");
+            }
+        }
         private void _editorForm_Closing(object sender, CancelEventArgs e)
         {
+            if (_editorForm == null)
+            {
+                return;
             if (_editorForm == null) return;
             _editorForm.ImageSave -= _editorForm_ImageSave;
             _editorForm.ImageSaveAs -= _editorForm_ImageSaveAs;
             void ImageListViewItemProgress(object sender, ImageListViewItemProgress<ListViewItem> e)
+            {
                 switch (e)
+                {
                     case ImageListViewItemProgressSuccess<ListViewItem> imageListViewItemProgressSuccess:
-                        if (!(imageListViewItemProgressSuccess.Item is { } listViewItem)) break;
+                        if (!(imageListViewItemProgressSuccess.Item is { } listViewItem))
+                        {
+                            break;
+                        }
                         toolStripStatusLabel1.Text = $"Synchronizing tags for {listViewItem.Name}";
                         _quickImageSearchParameters & ~QuickImageSearchParameters.CaseSensitive;
                     break;
+            }
             var text = textBox1.Text;
+            if (string.IsNullOrEmpty(text))
+            {
+                return;
+            }
-            if (string.IsNullOrEmpty(text)) return;
+            if (_searchCancellationTokenSource != null)
+            {
                 _searchCancellationTokenSource.Cancel();
             if (_searchCancellationTokenSource != null) _searchCancellationTokenSource.Cancel();
             _searchCancellationTokenSource = new CancellationTokenSource();
             _searchCancellationToken = _searchCancellationTokenSource.Token;
             _linkedSearchCancellationTokenSource =
-                CancellationTokenSource.CreateLinkedTokenSource(_cancellationToken, _searchCancellationToken);
-            _combinedSearchSelectionCancellationToken = _linkedSearchCancellationTokenSource.Token;
                 CancellationTokenSource.CreateLinkedTokenSource(_cancellationToken, _searchCancellationToken);
-            _searchScheduledContinuation.Schedule(TimeSpan.FromMilliseconds(250), text,
+            _combinedSearchSelectionCancellationToken = _linkedSearchCancellationTokenSource.Token;
                 async text => { await BeginSearch(text); }, _formTaskScheduler,
-                _combinedSearchSelectionCancellationToken);
+            _searchScheduledContinuation.Schedule(TimeSpan.FromMilliseconds(250), text, async text => { await BeginSearch(text); }, _formTaskScheduler, _combinedSearchSelectionCancellationToken);
+        }
+        private void PreviewFormClosing(object sender, CancelEventArgs e)
+        {
             if (_previewForm == null)
         private void PreviewFormClosing(object sender, CancelEventArgs e)
                 return;
         private void openDirectoryToolStripMenuItem_Click(object sender, EventArgs e)
+        {
             var items = imageListView.SelectedItems.OfType<ListViewItem>().ToArray();
             var item = items.FirstOrDefault();
+            if (item == null)
+            {
+                return;
             if (item == null) return;
             Process.Start("explorer.exe", $"/select, \"{item.Name}\"");
+        }
+        private void aboutToolStripMenuItem1_Click(object sender, EventArgs e)
+        {
+            if (_aboutForm != null)
         private void aboutToolStripMenuItem1_Click(object sender, EventArgs e)
                 return;
             if (_aboutForm != null) return;
                     return;
+            }
             var item = info.Item;
+            if (item == null)
+            {
+                return;
+            }
             if (item == null) return;
             if (_previewForm != null)
             if (_previewForm != null)
                 _previewForm.InvokeIfRequired(form =>
                 {
+                    form.Close();
-                    form.Close();
+                    form = null;
-                    form = null;
+                });
                 });
             var items = imageListView.SelectedItems.OfType<ListViewItem>();
             SelectTags(items);
         }
-        private async void imageListView_KeyUp(object sender, KeyEventArgs e)
+        private void imageListView_KeyUp(object sender, KeyEventArgs e)
+        {
             var items = imageListView.SelectedItems.OfType<ListViewItem>().ToArray();
             if (e.KeyCode == Keys.Delete)
+            {
-                await RemoveImagesAsync(items, _cancellationToken);
+                RemoveImages(items, _cancellationToken);
                 return;
+            }
             toolStripProgressBar1.Style = ProgressBarStyle.Continuous;
             toolStripProgressBar1.Minimum = 0;
             toolStripProgressBar1.Value = 0;
             toolStripProgressBar1.Maximum = 3;
-            var inputBlock = new BufferBlock<ListViewItem>(new DataflowBlockOptions
-                { CancellationToken = _cancellationToken });
+            var inputBlock = new BufferBlock<ListViewItem>(new DataflowBlockOptions { CancellationToken = _cancellationToken });
             var fileTransformBlock =
-                new TransformBlock<ListViewItem, (string Source, string Path, string Name, string Mime, string Extension
-                    )>(async item =>
+                new TransformBlock<ListViewItem, (string Source, string Path, string Name, string Mime, string Extension)>(async item =>
+                {
                     var mime = await _magicMime.GetMimeType(item.Name, _cancellationToken);
                     if (Configuration.OutboundDragDrop.RenameOnDragDrop)
+                    {
                         switch (Configuration.OutboundDragDrop.DragDropRenameMethod)
+                        {
                             case DragDropRenameMethod.Random:
-                                file = string.Join("",
-                                    Enumerable.Repeat(0, 5).Select(n => (char)_random.Next('a', 'z' + 1)));
+                                file = string.Join("", Enumerable.Repeat(0, 5).Select(n => (char)_random.Next('a', 'z' + 1)));
                                 break;
                             case DragDropRenameMethod.Timestamp:
                                 file = $"{DateTimeOffset.Now.ToUnixTimeSeconds()}";
                                 break;
+                        }
                 toolStripStatusLabel1.Text = "All files scanned for drag and drop.";
                 toolStripProgressBar1.Increment(1);
             }, _formTaskScheduler);
             var noConvertTransformBlock =
-                new TransformBlock<(string Source, string Path, string Name, string Mime, string Extension), string>(
-                    async item =>
+                new TransformBlock<(string Source, string Path, string Name, string Mime, string Extension), string>(async item =>
+                    {
+                        var destination = Path.Combine(item.Path, $"{item.Name}{item.Extension}");
                         var destination = Path.Combine(item.Path, $"{item.Name}{item.Extension}");
                         await Miscellaneous.CopyFileAsync(item.Source, destination, _cancellationToken);
                         this.InvokeIfRequired(form =>
                 toolStripStatusLabel1.Text = "Conversion complete for drag and drop.";
                 toolStripProgressBar1.Increment(1);
             }, _formTaskScheduler);
             var jpegTransformBlock =
-                new TransformBlock<(string Source, string Path, string Name, string Mime, string Extension), string>(
-                    async file =>
+                new TransformBlock<(string Source, string Path, string Name, string Mime, string Extension), string>(async file =>
+                    {
                         using var imageStream =
                             await _imageTool.ConvertTo(file.Source, MagickFormat.Jpeg, _cancellationToken);
-                        var jpegDestination = Path.Combine(file.Path, $"{file.Name}.jpg");
-                        await Miscellaneous.CopyFileAsync(imageStream, jpegDestination,
+                        var jpegDestination = Path.Combine(file.Path, $"{file.Name}.jpg");
-                            _cancellationToken);
+                        await Miscellaneous.CopyFileAsync(imageStream, jpegDestination, _cancellationToken);
                         this.InvokeIfRequired(form =>
                 toolStripStatusLabel1.Text = "Conversion complete for drag and drop.";
                 toolStripProgressBar1.Increment(1);
             }, _formTaskScheduler);
             var pngTransformBlock =
-                new TransformBlock<(string Source, string Path, string Name, string Mime, string Extension), string>(
-                    async file =>
+                new TransformBlock<(string Source, string Path, string Name, string Mime, string Extension), string>(async file =>
-                    {
-                        using var imageStream =
+                    {
-                            await _imageTool.ConvertTo(file.Source, MagickFormat.Png, _cancellationToken);
+                        using var imageStream = await _imageTool.ConvertTo(file.Source, MagickFormat.Png, _cancellationToken);
                         var pngDestination = Path.Combine(file.Path, $"{file.Name}.png");
                 toolStripStatusLabel1.Text = "Conversion complete for drag and drop.";
                 toolStripProgressBar1.Increment(1);
             }, _formTaskScheduler);
             var bmpTransformBlock =
-                new TransformBlock<(string Source, string Path, string Name, string Mime, string Extension), string>(
-                    async file =>
+                new TransformBlock<(string Source, string Path, string Name, string Mime, string Extension), string>( async file =>
-                    {
-                        using var imageStream =
+                    {
-                            await _imageTool.ConvertTo(file.Source, MagickFormat.Jpeg, _cancellationToken);
+                        using var imageStream = await _imageTool.ConvertTo(file.Source, MagickFormat.Jpeg, _cancellationToken);
                         var bmpDestination = Path.Combine(file.Path, $"{file.Name}.bmp");
             var iptcStripTransformBlock = new TransformBlock<string, string>(async file =>
+            {
                 try
+                {
                     var mime = await _magicMime.GetMimeType(file, _cancellationToken);
                     if (Configuration.SupportedFormats.IsSupportedVideo(mime))
+                    {
                         return file;
+                    }
             await Task.WhenAll(
                 jpegTransformBlock.Completion,
                 pngTransformBlock.Completion,
                 bmpTransformBlock.Completion,
                 iptcStripTransformBlock.Completion,
-                noConvertTransformBlock.Completion).ContinueWith(_ => {
+                noConvertTransformBlock.Completion).ContinueWith(_ =>
+                {
                     outputBlock.Complete();
                 }, _cancellationToken);
             var files = new HashSet<string>();
+            {
                 return;
+            }
             var data = new DataObject(DataFormats.FileDrop, files.ToArray());
+            this.InvokeIfRequired(_ =>
             this.InvokeIfRequired(_ => {
                 DoDragDrop(data, DragDropEffects.Copy);
             });
+        }
                 AddToMostRecentlyUsedList = true,
                 Multiselect = true,
                 IsFolderPicker = false
             };
+            switch (dialog.ShowDialog())
+            {
-            if (dialog.ShowDialog() == CommonFileDialogResult.Ok)
+                case CommonFileDialogResult.Ok:
+                    await LoadFilesAsync(dialog.FileNames, _magicMime, _cancellationToken);
+                    break;
                 await LoadFilesAsync(dialog.FileNames, _magicMime, _cancellationToken);
+        }
         private async void importDirectoryToolStripMenuItem_Click(object sender, EventArgs e)
                 AddToMostRecentlyUsedList = true,
                 Multiselect = true,
                 IsFolderPicker = true
             };
+            switch (dialog.ShowDialog())
+            {
-            if (dialog.ShowDialog() == CommonFileDialogResult.Ok)
+                case CommonFileDialogResult.Ok:
+                    await LoadFilesAsync(dialog.FileNames, _magicMime, _cancellationToken);
+                    break;
                 await LoadFilesAsync(dialog.FileNames, _magicMime, _cancellationToken);
+        }
         private void settingsToolStripMenuItem_Click(object sender, EventArgs e)
+        {
+            if (_settingsForm != null)
+            {
                 return;
             if (_settingsForm != null) return;
             _settingsForm = new SettingsForm(Configuration, _cancellationToken);
             _settingsForm.Closing += SettingsForm_Closing;
             _settingsForm.Show();
         }
+        private void SettingsForm_Closing(object sender, CancelEventArgs e)
+        {
+            if (_settingsForm == null)
+            {
-        private void SettingsForm_Closing(object sender, CancelEventArgs e)
+                return;
+            }
-            if (_settingsForm == null) return;
+            if (_settingsForm.SaveOnClose)
+            {
-            if (_settingsForm.SaveOnClose)
+                // Commit the configuration.
-                // Commit the configuration.
+                _changedConfigurationContinuation.Schedule(TimeSpan.FromSeconds(1),
-                _changedConfigurationContinuation.Schedule(TimeSpan.FromSeconds(1),
+                    async () => { await SaveConfiguration(Configuration); }, _cancellationToken);
         private async void balanceTagsToolStripMenuItem_Click(object sender, EventArgs e)
+        {
             var items = imageListView.SelectedItems.OfType<ListViewItem>();
             var listViewItems = items as ListViewItem[] ?? items.ToArray();
+            if (listViewItems.Length < 2)
+            {
+                return;
             if (listViewItems.Length < 2) return;
             await BalanceTags(listViewItems);
+        {
             var menuItem = (ToolStripMenuItem)sender;
             foreach (var group in _imageListViewGroupDictionary.Keys)
             {
+                if (menuItem.DropDownItems.ContainsKey(group))
+                {
+                    continue;
                 if (menuItem.DropDownItems.ContainsKey(group)) continue;
                 var toolStripMenuSubItem = new ToolStripButton(group) { Name = group };
                 toolStripMenuSubItem.Click += moveTargetToolStripMenuItem_Click;
+                menuItem.DropDownItems.Add(toolStripMenuSubItem);
+            }
+        }
+        private void moveToolStripMenuItem_DropDownClosed(object sender, EventArgs e)
+        {
+            var menuItem = (ToolStripMenuItem)sender;
+            var items = new ConcurrentBag<ToolStripButton>();
+            foreach(var toolStripMenuSubItem in menuItem.DropDownItems.OfType<ToolStripButton>())
+            {
+                toolStripMenuSubItem.Click -= moveTargetToolStripMenuItem_Click;
+                items.Add(toolStripMenuSubItem);
+            }
+            foreach(var toolStripMenuSubItem in items)
+            {
-                menuItem.DropDownItems.Add(toolStripMenuSubItem);
+                menuItem.DropDownItems.Remove(toolStripMenuSubItem);
+            }
+        }
                 { "png", "image/png" },
                 { "bmp", "image/bmp" },
                 { "gif", "image/gif" }
             };
+            if (!Configuration.SupportedFormats.Images.Image.Contains(extensionToMime[extension]))
+            {
+                return;
             if (!Configuration.SupportedFormats.Images.Image.Contains(extensionToMime[extension])) return;
             var items = imageListView.SelectedItems.OfType<ListViewItem>();