Merge pull request #762 from Keboo/fix761

Snack bar queuing improvements and fixes.

Author: ButchersBoy

MaterialDesignThemes.Wpf/ISnackbarMessageQueue.cs

@@ -41,7 +41,7 @@ public interface ISnackbarMessageQueue
         /// <param name="content">Message.</param>
         /// <param name="actionContent">Content for the action button.</param>
         /// <param name="actionHandler">Call back to be executed if user clicks the action button.</param>
-        /// <param name="promote">The message will promoted to the front ot the queue and never considered to be a duplicate.</param>
+        /// <param name="promote">The message will promoted to the front of the queue.</param>
         void Enqueue(object content, object actionContent, Action actionHandler, bool promote);
 
         /// <summary>
@@ -51,7 +51,31 @@ public interface ISnackbarMessageQueue
         /// <param name="actionContent">Content for the action button.</param>
         /// <param name="actionHandler">Call back to be executed if user clicks the action button.</param>
         /// <param name="actionArgument">Argument to pass to <paramref name="actionHandler"/>.</param>
-        /// <param name="promote">The message will promoted to the front ot the queue and never considered to be a duplicate.</param>
+        /// <param name="promote">The message will be promoted to the front of the queue and never considered to be a duplicate.</param>
         void Enqueue<TArgument>(object content, object actionContent, Action<TArgument> actionHandler, TArgument actionArgument, bool promote);
+
+        /// <summary>
+        /// Queues a notificaton message for display in a snackbar.
+        /// </summary>
+        /// <param name="content">Message.</param>
+        /// <param name="actionContent">Content for the action button.</param>
+        /// <param name="actionHandler">Call back to be executed if user clicks the action button.</param>
+        /// <param name="actionArgument">Argument to pass to <paramref name="actionHandler"/>.</param>
+        /// <param name="promote">The message will be promoted to the front of the queue.</param>
+        /// <param name="neverConsiderToBeDuplicate">The message will never be considered a duplicate.</param>
+        void Enqueue<TArgument>(object content, object actionContent, Action<TArgument> actionHandler,
+            TArgument actionArgument, bool promote, bool neverConsiderToBeDuplicate);
+
+        /// <summary>
+        /// Queues a notificaton message for display in a snackbar.
+        /// </summary>
+        /// <param name="content">Message.</param>
+        /// <param name="actionContent">Content for the action button.</param>
+        /// <param name="actionHandler">Call back to be executed if user clicks the action button.</param>
+        /// <param name="actionArgument">Argument to pass to <paramref name="actionHandler"/>.</param>
+        /// <param name="promote">The message will promoted to the front of the queue.</param>
+        /// <param name="neverConsiderToBeDuplicate">The message will never be considered a duplicate.</param>
+        void Enqueue(object content, object actionContent, Action<object> actionHandler, object actionArgument,
+            bool promote, bool neverConsiderToBeDuplicate);
     }
 }

MaterialDesignThemes.Wpf/SnackbarMessageQueue.cs

@@ -30,7 +30,7 @@ private class MouseNotOverManagedWaitHandle : IDisposable
             private readonly ManualResetEvent _disposedWaitHandle = new ManualResetEvent(false);
             private Action _cleanUp;
             private bool _isWaitHandleDisposed;
-            private readonly object _waitHandleGate = new object();            
+            private readonly object _waitHandleGate = new object();
 
             public MouseNotOverManagedWaitHandle(UIElement uiElement)
             {
@@ -124,7 +124,7 @@ private DurationMonitor(
 
                 Task.Factory.StartNew(() =>
                 {
-                    //keep upping the completion time in case it's paused...                
+                    //keep upping the completion time in case it's paused...
                     while (DateTime.Now < _completionTime && !ceaseWaitHandle.WaitOne(granularity))
                     {
                         if (pausedWaitHandle.WaitOne(TimeSpan.Zero))
@@ -194,8 +194,7 @@ public void Enqueue(object content, bool neverConsiderToBeDuplicate)
         {
             if (content == null) throw new ArgumentNullException(nameof(content));
 
-            _snackbarMessages.AddLast(new SnackbarMessageQueueItem(content));
-            _messageWaitingEvent.Set();
+            Enqueue(content, null, null, null, false, neverConsiderToBeDuplicate);
         }
 
         public void Enqueue(object content, object actionContent, Action actionHandler)
@@ -206,34 +205,52 @@ public void Enqueue(object content, object actionContent, Action actionHandler)
         public void Enqueue(object content, object actionContent, Action actionHandler, bool promote)
         {
             if (content == null) throw new ArgumentNullException(nameof(content));
-
-            _snackbarMessages.AddLast(new SnackbarMessageQueueItem(content, actionContent, actionHandler));
-            _messageWaitingEvent.Set();
+            if (actionContent == null) throw new ArgumentNullException(nameof(actionContent));
+            if (actionHandler == null) throw new ArgumentNullException(nameof(actionHandler));
+            
+            Enqueue(content, actionContent, _ => actionHandler(), promote, false, false);
         }
 
         public void Enqueue<TArgument>(object content, object actionContent, Action<TArgument> actionHandler,
             TArgument actionArgument)
         {
-            Enqueue<TArgument>(content, actionContent, actionHandler, actionArgument, false);
+            Enqueue(content, actionContent, actionHandler, actionArgument, false, false);
         }
 
         public void Enqueue<TArgument>(object content, object actionContent, Action<TArgument> actionHandler,
-            TArgument actionArgument, bool promote)
+            TArgument actionArgument, bool promote) =>
+            Enqueue(content, actionContent, actionHandler, actionArgument, promote, promote);
+
+        public void Enqueue<TArgument>(object content, object actionContent, Action<TArgument> actionHandler,
+            TArgument actionArgument, bool promote, bool neverConsiderToBeDuplicate)
         {
             if (content == null) throw new ArgumentNullException(nameof(content));
 
-            if ((actionContent != null || actionHandler != null || actionArgument != null)
-                &&
-                actionContent == null && actionHandler == null && actionArgument == null)
+            if (actionContent == null ^ actionHandler == null)
             {
                 throw new ArgumentException("All action arguments must be provided if any are provided.",
-                    nameof(actionContent));
+                    actionContent != null ? nameof(actionContent) : nameof(actionHandler));
             }
 
-            var argumentType = actionArgument != null ? typeof(TArgument) : null;
+            Action<object> handler = actionHandler != null
+                ? new Action<object>(argument => actionHandler((TArgument)argument))
+                : null;
+            Enqueue(content, actionContent, handler, actionArgument, promote, neverConsiderToBeDuplicate);
+        }
+
+        public void Enqueue(object content, object actionContent, Action<object> actionHandler,
+            object actionArgument, bool promote, bool neverConsiderToBeDuplicate)
+        {
+            if (content == null) throw new ArgumentNullException(nameof(content));
+
+            if (actionContent == null ^ actionHandler == null)
+            {
+                throw new ArgumentException("All action arguments must be provided if any are provided.",
+                    actionContent != null ? nameof(actionContent) : nameof(actionHandler));
+            }
 
             var snackbarMessageQueueItem = new SnackbarMessageQueueItem(content, actionContent, actionHandler,
-                actionArgument, argumentType, promote);
+                actionArgument, promote, neverConsiderToBeDuplicate);
             if (promote)
                 InsertAsLastNotPromotedNode(snackbarMessageQueueItem);
             else
@@ -261,7 +278,7 @@ private async void PumpAsync()
         {
             while (!_isDisposed)
             {
-                var eventId = WaitHandle.WaitAny(new WaitHandle[] {_disposedEvent, _messageWaitingEvent});
+                var eventId = WaitHandle.WaitAny(new WaitHandle[] { _disposedEvent, _messageWaitingEvent });
                 if (eventId == 0) continue;
                 var exemplar = _pairedSnackbars.FirstOrDefault();
                 if (exemplar == null)
@@ -281,7 +298,7 @@ private async void PumpAsync()
                     var message = _snackbarMessages.First.Value;
                     _snackbarMessages.RemoveFirst();
                     if (_latestShownItem == null
-                        || message.IsPromoted
+                        || message.IgnoreDuplicate
                         || !Equals(_latestShownItem.Item1.Content, message.Content)
                         || !Equals(_latestShownItem.Item1.ActionContent, message.ActionContent)
                         || _latestShownItem.Item2 <= DateTime.Now.Subtract(_messageDuration))
@@ -331,7 +348,7 @@ await Task.Run(async () =>
                         _pausedEvent, durationPassedWaitHandle, _disposedEvent);
 
                     //wait until time span completed (including pauses and mouse overs), or the action is clicked
-                    await WaitForCompletionAsync(mouseNotOverManagedWaitHandle, durationPassedWaitHandle, actionClickWaitHandle);                    
+                    await WaitForCompletionAsync(mouseNotOverManagedWaitHandle, durationPassedWaitHandle, actionClickWaitHandle);
 
                     //close message on snackbar
                     await
@@ -399,18 +416,8 @@ private static void DoActionCallback(SnackbarMessageQueueItem messageQueueItem)
         {
             try
             {
-                var action = messageQueueItem.ActionHandler as Action;
-                if (action != null)
-                {
-                    action();
-                    return;
-                }
+                messageQueueItem.ActionHandler(messageQueueItem.ActionArgument);
 
-                if (messageQueueItem.ArgumentType == null) return;
-
-                var genericType = typeof(Action<>).MakeGenericType(messageQueueItem.ArgumentType);
-                var method = genericType.GetMethod("Invoke");
-                method.Invoke(messageQueueItem.ActionHandler, new[] { messageQueueItem.ActionArgument });
             }
             catch (Exception exc)
             {
@@ -419,7 +426,7 @@ private static void DoActionCallback(SnackbarMessageQueueItem messageQueueItem)
                 Trace.WriteLine(exc.StackTrace);
 
                 throw;
-            }            
+            }
         }
 
         private static SnackbarMessage Create(SnackbarMessageQueueItem messageQueueItem)
@@ -433,10 +440,10 @@ private static SnackbarMessage Create(SnackbarMessageQueueItem messageQueueItem)
 
         public void Dispose()
         {
-            _isDisposed = true;                  
+            _isDisposed = true;
             _disposedEvent.Set();
             _disposedEvent.Dispose();
-            _pausedEvent.Dispose();            
+            _pausedEvent.Dispose();
         }
     }
 }

MaterialDesignThemes.Wpf/SnackbarMessageQueueItem.cs

@@ -4,26 +4,45 @@ namespace MaterialDesignThemes.Wpf
 {
     internal class SnackbarMessageQueueItem
     {
-        public SnackbarMessageQueueItem(object content, object actionContent = null, object actionHandler = null, object actionArgument = null, Type argumentType = null, bool isPromoted = false)
+        public SnackbarMessageQueueItem(object content, object actionContent = null, Action<object> actionHandler = null, object actionArgument = null, 
+            bool isPromoted = false, bool ignoreDuplicate = false)
         {
             Content = content;
             ActionContent = actionContent;
             ActionHandler = actionHandler;
             ActionArgument = actionArgument;
-            ArgumentType = argumentType;
             IsPromoted = isPromoted;
+            IgnoreDuplicate = ignoreDuplicate;
         }
 
+        /// <summary>
+        /// The content to be displayed
+        /// </summary>
         public object Content { get; }
 
+        /// <summary>
+        /// The content for the action button on the snackbar
+        /// </summary>
         public object ActionContent { get; }
 
-        public object ActionHandler { get; }
+        /// <summary>
+        /// Handler to be invoked when the action button is clicked
+        /// </summary>
+        public Action<object> ActionHandler { get; }
 
+        /// <summary>
+        /// The argument to pass to the <see cref="ActionHandler"/> delegate.
+        /// </summary>
         public object ActionArgument { get; }
 
-        public Type ArgumentType { get; }
-
+        /// <summary>
+        /// Promote the message, pushing it in front of any message that is not promoted.
+        /// </summary>
         public bool IsPromoted { get; }
+
+        /// <summary>
+        /// Still display this message even if it is a duplicate.
+        /// </summary>
+        public bool IgnoreDuplicate { get; }
     }
 }