From 379c9be29eb6c256f1fc34c12c89ffc6c1135480 Mon Sep 17 00:00:00 2001
From: Tom Arrow <davorfilms@googlemail.com>
Date: Mon, 25 Jan 2021 06:10:52 +0100
Subject: [PATCH] Progress in batch finally works better.

---
 BatchProgress.xaml.cs |   6 +--
 Helpers.cs            | 118 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 121 insertions(+), 3 deletions(-)

diff --git a/BatchProgress.xaml.cs b/BatchProgress.xaml.cs
index 36fea5e..5c392e9 100644
--- a/BatchProgress.xaml.cs
+++ b/BatchProgress.xaml.cs
@@ -24,12 +24,12 @@ public partial class BatchProgress : Window
 
         
 
-        public ObservableCollection<ProgressItem> ProgressStrings
+        public FullyObservableCollection<ProgressItem> ProgressStrings
         {
             get { return progressStrings; }
         }
 
-        public ObservableCollection<ProgressItem> progressStrings = new ObservableCollection<ProgressItem>();
+        public FullyObservableCollection<ProgressItem> progressStrings = new FullyObservableCollection<ProgressItem>();
         public BatchProgress()
         {
             InitializeComponent();
@@ -76,7 +76,7 @@ public void RemoveProgressItem(int id, string message="...")
         }
     }
 
-    public class ProgressItem
+    public class ProgressItem : INotifyPropertyChanged
     {
         public int id;
         public string ProgressText
diff --git a/Helpers.cs b/Helpers.cs
index 22bf99f..52c42b8 100644
--- a/Helpers.cs
+++ b/Helpers.cs
@@ -8,12 +8,130 @@
 using System.IO;
 using System.Runtime.CompilerServices;
 using System.Numerics;
+using System.ComponentModel;
+using System.Collections.Specialized;
+using System.Collections.ObjectModel;
 
 namespace ColorMatch3D
 {
+
+    // This class is from: https://stackoverflow.com/questions/1427471/observablecollection-not-noticing-when-item-in-it-changes-even-with-inotifyprop
+    public class FullyObservableCollection<T> : ObservableCollection<T>
+        where T : INotifyPropertyChanged
+    {
+        /// <summary>
+        /// Occurs when a property is changed within an item.
+        /// </summary>
+        public event EventHandler<ItemPropertyChangedEventArgs> ItemPropertyChanged;
+
+        public FullyObservableCollection() : base()
+        { }
+
+        public FullyObservableCollection(List<T> list) : base(list)
+        {
+            ObserveAll();
+        }
+
+        public FullyObservableCollection(IEnumerable<T> enumerable) : base(enumerable)
+        {
+            ObserveAll();
+        }
+
+        protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
+        {
+            if (e.Action == NotifyCollectionChangedAction.Remove ||
+                e.Action == NotifyCollectionChangedAction.Replace)
+            {
+                foreach (T item in e.OldItems)
+                    item.PropertyChanged -= ChildPropertyChanged;
+            }
+
+            if (e.Action == NotifyCollectionChangedAction.Add ||
+                e.Action == NotifyCollectionChangedAction.Replace)
+            {
+                foreach (T item in e.NewItems)
+                    item.PropertyChanged += ChildPropertyChanged;
+            }
+
+            base.OnCollectionChanged(e);
+        }
+
+        protected void OnItemPropertyChanged(ItemPropertyChangedEventArgs e)
+        {
+            ItemPropertyChanged?.Invoke(this, e);
+        }
+
+        protected void OnItemPropertyChanged(int index, PropertyChangedEventArgs e)
+        {
+            OnItemPropertyChanged(new ItemPropertyChangedEventArgs(index, e));
+        }
+
+        protected override void ClearItems()
+        {
+            foreach (T item in Items)
+                item.PropertyChanged -= ChildPropertyChanged;
+
+            base.ClearItems();
+        }
+
+        private void ObserveAll()
+        {
+            foreach (T item in Items)
+                item.PropertyChanged += ChildPropertyChanged;
+        }
+
+        private void ChildPropertyChanged(object sender, PropertyChangedEventArgs e)
+        {
+            T typedSender = (T)sender;
+            int i = Items.IndexOf(typedSender);
+
+            if (i < 0)
+                throw new ArgumentException("Received property notification from item not in collection");
+
+            OnItemPropertyChanged(i, e);
+        }
+    }
+
+    /// <summary>
+    /// Provides data for the <see cref="FullyObservableCollection{T}.ItemPropertyChanged"/> event.
+    /// </summary>
+    public class ItemPropertyChangedEventArgs : PropertyChangedEventArgs
+    {
+        /// <summary>
+        /// Gets the index in the collection for which the property change has occurred.
+        /// </summary>
+        /// <value>
+        /// Index in parent collection.
+        /// </value>
+        public int CollectionIndex { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ItemPropertyChangedEventArgs"/> class.
+        /// </summary>
+        /// <param name="index">The index in the collection of changed item.</param>
+        /// <param name="name">The name of the property that changed.</param>
+        public ItemPropertyChangedEventArgs(int index, string name) : base(name)
+        {
+            CollectionIndex = index;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ItemPropertyChangedEventArgs"/> class.
+        /// </summary>
+        /// <param name="index">The index.</param>
+        /// <param name="args">The <see cref="PropertyChangedEventArgs"/> instance containing the event data.</param>
+        public ItemPropertyChangedEventArgs(int index, PropertyChangedEventArgs args) : this(index, args.PropertyName)
+        { }
+    }
+
+
     static class Helpers
     {
 
+
+
+
+
         static public BitmapImage BitmapToImageSource(Bitmap bitmap)
         {
             using (MemoryStream memory = new MemoryStream())