Added Debounce functionality to slideshow

Means instant update when user clicks, while also providing throttle if they spam

CHANGELOG.md

@@ -1,5 +1,9 @@
 ### Changelog
 
+#### Unreleased changes
+* Nothing yet...
+* Slideshow more responsive on pressing next
+
 #### Version 1.0 alpha 2 - 10/15/2019
 * Fix installer running in wrong mode
 

Wabbajack/Extensions/ReactiveUIExt.cs

@@ -2,6 +2,8 @@
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using DynamicData;
 using DynamicData.Kernel;
@@ -92,6 +94,63 @@ namespace Wabbajack
                 .Unit();
         }
 
+        /// Inspiration:
+        /// http://reactivex.io/documentation/operators/debounce.html
+        /// https://stackoverflow.com/questions/20034476/how-can-i-use-reactive-extensions-to-throttle-events-using-a-max-window-size
+        public static IObservable<T> Debounce<T>(this IObservable<T> source, TimeSpan interval, IScheduler scheduler = null)
+        {
+            scheduler = scheduler ?? Scheduler.Default;
+            return Observable.Create<T>(o =>
+            {
+                var hasValue = false;
+                bool throttling = false;
+                T value = default;
+
+                var dueTimeDisposable = new SerialDisposable();
+
+                void internalCallback()
+                {
+                    if (hasValue)
+                    {
+                        // We have another value that came in to fire.
+                        // Reregister for callback
+                        dueTimeDisposable.Disposable = scheduler.Schedule(interval, internalCallback);
+                        o.OnNext(value);
+                        value = default;
+                        hasValue = false;
+                    }
+                    else
+                    {
+                        // Nothing to do, throttle is complete.
+                        throttling = false;
+                    }
+                }
+
+                return source.Subscribe(
+                    onNext: (x) =>
+                    {
+                        if (!throttling)
+                        {
+                            // Fire initial value
+                            o.OnNext(x);
+                            // Mark that we're throttling
+                            throttling = true;
+                            // Register for callback when throttle is complete
+                            dueTimeDisposable.Disposable = scheduler.Schedule(interval, internalCallback);
+                        }
+                        else
+                        {
+                            // In the middle of throttle
+                            // Save value and return
+                            hasValue = true;
+                            value = x;
+                        }
+                    },
+                    onError: o.OnError,
+                    onCompleted: o.OnCompleted);
+            });
+        }
+
         /// These snippets were provided by RolandPheasant (author of DynamicData)
         /// They'll be going into the official library at some point, but are here for now.
         #region Dynamic Data EnsureUniqueChanges

Wabbajack/UI/SlideShow.cs

@@ -151,8 +151,8 @@ namespace Wabbajack
                         this.WhenAny(x => x.Enable),
                         this.WhenAny(x => x.AppState.Installing),
                         resultSelector: (enabled, installing) => enabled && installing))
-                // Don't ever update more than once every half second.  ToDo: Update to debounce
-                .Throttle(TimeSpan.FromMilliseconds(500), RxApp.MainThreadScheduler)
+                // Don't ever update more than once every half second.
+                .Debounce(TimeSpan.FromMilliseconds(500), RxApp.MainThreadScheduler)
                 .ObserveOn(RxApp.MainThreadScheduler)
                 .Subscribe(_ => this.UpdateSlideShowItem())
                 .DisposeWith(this.CompositeDisposable);