building up concept for pausing mechanism

Author: ButchersBoy

MainDemo.Wpf/ProvingGround.xaml

@@ -43,13 +43,17 @@
             <ColumnDefinition />
         </Grid.ColumnDefinitions>
 
+        <!-- example 1 -->
+            <!-- simplest form -->
         <materialDesign:Snackbar2 Message="hello 1" 
                                   IsActive="False"
                                   x:Name="SnackbarOne" />
 
         <ToggleButton IsChecked="{Binding ElementName=SnackbarOne, Path=IsActive, Mode=TwoWay}"
                       Grid.Row="1" Grid.Column="0" />
 
+        <!-- example 2 -->
+            <!-- long hand form for setting the message -->
         <materialDesign:Snackbar2 IsActive="True"
                                   Grid.Row="0" 
                                   Grid.Column="1" 
@@ -61,16 +65,24 @@
                       Grid.Row="1" Grid.Column="1" />
 
 
+        <!-- example 3 -->        
+            <!--
+                * using a message queue to manage queuing of messages, and getting onto correct thread
+                * notice the shorthand syntax {materialDesign:MessageQueue} for creating a new message 
+                queue without expanded XAML. useful in code-behind scenarios if you dont want to bind 
+                a message queue in to the snackbar.
+            -->
         <materialDesign:Snackbar2 MessageQueue="{materialDesign:MessageQueue}"
                                   Grid.Row="0" 
                                   Grid.Column="2"        
                                   x:Name="SnackbarThree" />
+        
         <StackPanel Orientation="Horizontal"
                     Grid.Row="1" 
-                    Grid.Column="2"                    >
-            <TextBlock>Message: </TextBlock>
-            <TextBlock x:Name="MessageTextBox">Hello World</TextBlock>
-            <Button Click="SnackBar3_OnClick">Send</Button>
+                    Grid.Column="2">
+            <TextBlock HorizontalAlignment="Center">Message: </TextBlock>
+            <TextBox x:Name="MessageTextBox" HorizontalAlignment="Center">Hello World</TextBox>
+            <Button Click="SnackBar3_OnClick" HorizontalAlignment="Center">Send</Button>
         </StackPanel>
 
     </Grid>

MainDemo.Wpf/ProvingGround.xaml.cs

@@ -32,32 +32,16 @@ public ProvingGround()
             {
                 SelectedTime = new DateTime(2000, 1, 1, 3, 15, 0)
             };
-        }
-
-        private void Button_Click(object sender, RoutedEventArgs e)
-        {
-            System.Diagnostics.Process.Start("https://twitter.com/James_Willock");
-
-        }
-
-        private void ButtonsDemoChip_OnClick(object sender, RoutedEventArgs e)
-        {
-            Console.WriteLine("Chip clicked.");
-        }
-
-        private void ButtonsDemoChip_OnDeleteClick(object sender, RoutedEventArgs e)
-        {
-            Console.WriteLine("Chip delete clicked.");
-        }
-
-        private void ButtonBase_OnClick(object sender, RoutedEventArgs e)
-        {
-            new PaletteHelper().QueryPalette();
-        }
+        }        
 
         private void SnackBar3_OnClick(object sender, RoutedEventArgs e)
         {
-            SnackbarThree.MessageQueue.Enqueue(MessageTextBox.Text);
+            //use the message queue to send a message.
+            var messageQueue = SnackbarThree.MessageQueue;
+            var message = MessageTextBox.Text;
+
+            //the message queue can be called from any thread
+            Task.Factory.StartNew(() => messageQueue.Enqueue(message));
         }
     }
 

MaterialDesignThemes.Wpf/SnackbarMessageQueue.cs

@@ -4,6 +4,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using System.Windows;
+using System.Windows.Input;
 
 namespace MaterialDesignThemes.Wpf
 {
@@ -13,14 +14,15 @@ public class SnackbarMessageQueue : ISnackbarMessageQueue, IDisposable
         private readonly HashSet<Snackbar2> _pairedSnackbars = new HashSet<Snackbar2>();
         private readonly Queue<SnackbarMessageQueueItem> _snackbarMessages = new Queue<SnackbarMessageQueueItem>();        
         private readonly ManualResetEvent _disposedEvent = new ManualResetEvent(false);
+        private readonly ManualResetEvent _notPausedEvent = new ManualResetEvent(true);
         private int _pauseCounter = 0;
         private bool _isDisposed;
 
         public SnackbarMessageQueue() : this(TimeSpan.FromSeconds(3))
         { }
 
         public SnackbarMessageQueue(TimeSpan messageDuration)
-        {
+        {            
             _messageDuration = messageDuration;
             Task.Factory.StartNew(Pump);
         }
@@ -38,18 +40,15 @@ internal Action Pair(Snackbar2 snackbar)
 
         internal Action Pause()
         {
-            //TODO...dialogs, for example, can pause the "countdown" of an active message as they are hiding it
-
+            if (_isDisposed) return () => { };            
 
             if (Interlocked.Increment(ref _pauseCounter) == 1)
-                //TODO cease counting down
-                Console.WriteLine("Paused");
+                _notPausedEvent.Set();
 
             return () =>
             {
                 if (Interlocked.Decrement(ref _pauseCounter) == 0)
-                    //TODO resume counting down
-                    Console.WriteLine("Paus realesed");
+                    _notPausedEvent.Reset();
             };
         }
 
@@ -79,12 +78,13 @@ public void Enqueue<TArgument>(object content, object actionContent, Action<TArg
             }
 
             var argumentType = actionArgument != null ? typeof(TArgument) : null;
-
-            _snackbarMessages.Enqueue(new SnackbarMessageQueueItem(content, actionContent, actionHandler, actionArgument, argumentType));
+            _snackbarMessages.Enqueue(new SnackbarMessageQueueItem(content, actionContent, actionHandler,
+                actionArgument, argumentType));
             _messageWaitingEvent.Set();
         }
 
         private readonly ManualResetEvent _messageWaitingEvent = new ManualResetEvent(false);
+        private Tuple<SnackbarMessageQueueItem, DateTime> _latestShownItem;
 
         private async void Pump()
         {
@@ -114,43 +114,110 @@ private async void Pump()
                 if (snackbar != null)
                 {
                     var message = _snackbarMessages.Dequeue();
-                    await Show(snackbar, message);
+                    if (_latestShownItem == null || !Equals(_latestShownItem.Item1.Content, message.Content) ||
+                        !Equals(_latestShownItem.Item1.ActionContent, message.ActionContent) ||
+                        _latestShownItem.Item2 <= DateTime.Now.Subtract(_messageDuration))
+                    {
+                        await Show(snackbar, message);
+                        _latestShownItem = new Tuple<SnackbarMessageQueueItem, DateTime>(message, DateTime.Now);
+                    }
                 }
 
                 if (_snackbarMessages.Count > 0)
                     _messageWaitingEvent.Set();
                 else
                     _messageWaitingEvent.Reset();
-            }         
-            
+            }                     
+        }
+
+        private class MouseNotOverManagedWaitHandle : IDisposable
+        {
+            private readonly ManualResetEvent _waitHandle;
+            private Action _cleanUp;
+
+            public MouseNotOverManagedWaitHandle(UIElement uiElement)
+            {
+                if (uiElement == null) throw new ArgumentNullException(nameof(uiElement));
+
+                uiElement.MouseEnter += UiElementOnMouseEnter;
+                uiElement.MouseLeave += UiElementOnMouseLeave;
+                _waitHandle = new ManualResetEvent(!uiElement.IsMouseOver);
+
+                _cleanUp = () =>
+                {
+                    uiElement.MouseEnter -= UiElementOnMouseEnter;
+                    uiElement.MouseLeave -= UiElementOnMouseLeave;
+                    _waitHandle.Dispose();
+                    _cleanUp = () => { };
+                };
+            }
+
+            public WaitHandle WaitHandle => _waitHandle;
+
+            private void UiElementOnMouseLeave(object sender, MouseEventArgs mouseEventArgs)
+            {
+                _waitHandle.Set();
+            }
+
+            private void UiElementOnMouseEnter(object sender, MouseEventArgs mouseEventArgs)
+            {
+                _waitHandle.Reset();
+            }
+
+            public void Dispose()
+            {
+                _cleanUp();
+            }
+        }
+
+        private class TimeSpanSpinManagedHandle : IDisposable
+        {
+            public TimeSpanSpinManagedHandle(WaitHandle pausedWaitHandle)
+            {
+                //new System.Threading.Timer()
+
+
+
+            }
+
+
+
+            public void Dispose()
+            {
+                throw new NotImplementedException();
+            }
         }
 
         private async Task Show(Snackbar2 snackbar, SnackbarMessageQueueItem messageQueueItem)
         {
-            await Task.Run(() =>
+            await Task.Run(async () =>
             {
                 var completedHandle = new ManualResetEvent(false);
                 //TODO set message on snackbar
-                snackbar.Dispatcher.InvokeAsync(() =>
-                {
+
+                var mouseNotOverManagedWaitHandle = await snackbar.Dispatcher.InvokeAsync(() =>
+                {                    
                     snackbar.SetCurrentValue(Snackbar2.MessageProperty, Create(messageQueueItem));
-                    snackbar.SetCurrentValue(Snackbar2.IsActiveProperty, true);
+                    snackbar.SetCurrentValue(Snackbar2.IsActiveProperty, true);                    
+                    return new MouseNotOverManagedWaitHandle(snackbar);
                 });
 
-
 
+                WaitHandle.WaitAll(new WaitHandle[]
+                {
+                    mouseNotOverManagedWaitHandle.WaitHandle,
+                });
 
                 //TODO wait until 3 things:
-                // (
-                // * NOT PAUSED
+                // (                
                 // * NOT MOUSE OVER
                 // * TIME SPAN COMPLETED -- PAUSE MUST KEEP UPPING TIMESPAN                
                 // )
                 // OR
                 //  * ACTION CLICK
 
                 //quick hack implementation
-                _disposedEvent.WaitOne(snackbar.ActivateStoryboardDuration.Add(_messageDuration));
+                _disposedEvent.WaitOne(_messageDuration);
 
 
                 //remove message on snackbar
@@ -166,7 +233,7 @@ await Task.Run(() =>
 
 
             });
-        }
+        }        
 
         private static SnackbarMessage Create(SnackbarMessageQueueItem messageQueueItem)
         {
@@ -179,8 +246,10 @@ private static SnackbarMessage Create(SnackbarMessageQueueItem messageQueueItem)
 
         public void Dispose()
         {
-            _isDisposed = true;
+            _isDisposed = true;                  
             _disposedEvent.Set();
+            _disposedEvent.Dispose();
+            _notPausedEvent.Dispose();
         }
     }
 }