Merge branch 'master' of https://twinetfs.visualstudio.com/Tango/_git/Tango

3 files changed, 274 insertions, 97 deletions

diff --git a/Software/Visual_Studio/Tango.SharedUI/Animations/GridLengthAnimation.cs b/Software/Visual_Studio/Tango.SharedUI/Animations/GridLengthAnimation.cs
new file mode 100644
index 000000000..52dcacedf
--- /dev/null
+++ b/Software/Visual_Studio/Tango.SharedUI/Animations/GridLengthAnimation.cs
@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Windows.Media.Animation;
+using System.Windows;
+
+namespace Tango.SharedUI.Animations
+{
+    public class GridLengthAnimation : AnimationTimeline
+    {
+        public static readonly DependencyProperty FromProperty;
+        public static readonly DependencyProperty ToProperty;
+
+        static GridLengthAnimation()
+        {
+            FromProperty = DependencyProperty.Register("From", typeof(GridLength), typeof(GridLengthAnimation));
+            ToProperty = DependencyProperty.Register("To", typeof(GridLength), typeof(GridLengthAnimation));
+        }
+
+        protected override Freezable CreateInstanceCore()
+        {
+            return new GridLengthAnimation();
+        }
+
+        public override Type TargetPropertyType
+        {
+            get { return typeof(GridLength); }
+        }
+
+        public GridLength From
+        {
+            get
+            {
+                return (GridLength)GetValue(GridLengthAnimation.FromProperty);
+            }
+            set
+            {
+                SetValue(GridLengthAnimation.FromProperty, value);
+            }
+        }
+
+        public GridLength To
+        {
+            get
+            {
+                return (GridLength)GetValue(GridLengthAnimation.ToProperty);
+            }
+            set
+            {
+                SetValue(GridLengthAnimation.ToProperty, value);
+            }
+        }
+
+        public override object GetCurrentValue(object defaultOriginValue, object defaultDestinationValue, AnimationClock animationClock)
+        {
+
+            double fromValue = ((GridLength)GetValue(GridLengthAnimation.FromProperty)).Value;
+            double toValue = ((GridLength)GetValue(GridLengthAnimation.ToProperty)).Value;
+
+            if (fromValue > toValue)
+            {
+                return new GridLength((1 - animationClock.CurrentProgress.Value) * (fromValue - toValue) + toValue, this.To.IsStar ? GridUnitType.Star : GridUnitType.Pixel);
+            }
+            else
+            {
+                return new GridLength((animationClock.CurrentProgress.Value) * (toValue - fromValue) + fromValue, this.To.IsStar ? GridUnitType.Star : GridUnitType.Pixel);
+            }
+
+        }
+    }
+}
diff --git a/Software/Visual_Studio/Tango.SharedUI/Controls/NavigationControl.cs b/Software/Visual_Studio/Tango.SharedUI/Controls/NavigationControl.cs
index 89427e1ed..15d15decb 100644
--- a/Software/Visual_Studio/Tango.SharedUI/Controls/NavigationControl.cs
+++ b/Software/Visual_Studio/Tango.SharedUI/Controls/NavigationControl.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Diagnostics;
 using System.Linq;
 using System.Text;
 using System.Threading;
@@ -12,6 +13,7 @@ using System.Windows.Markup;
 using System.Windows.Media;
 using System.Windows.Media.Animation;
 using System.Windows.Threading;
+using Tango.Core;
 using Tango.SharedUI.Helpers;
 
 namespace Tango.SharedUI.Controls
@@ -19,7 +21,15 @@ namespace Tango.SharedUI.Controls
     [ContentProperty(nameof(Elements))]
     public class NavigationControl : UserControl
     {
-        private Action _onCompleted;
+        private event Action NavigationCompleted;
+        private Thread _navigationThread;
+        private ProducerConsumerQueue<NavigationQueueItem> _navigationQueue;
+
+        private class NavigationQueueItem
+        {
+            public NavigationElement FromElement { get; set; }
+            public NavigationElement ToElement { get; set; }
+        }
 
         #region Transition Types
 
@@ -174,6 +184,26 @@ namespace Tango.SharedUI.Controls
 
         #region Properties
 
+
+
+        public object SelectedObject
+        {
+            get { return (object)GetValue(SelectedObjectProperty); }
+            set { SetValue(SelectedObjectProperty, value); }
+        }
+
+        // Using a DependencyProperty as the backing store for SelectedObject.  This enables animation, styling, binding, etc...
+        public static readonly DependencyProperty SelectedObjectProperty =
+            DependencyProperty.Register("SelectedObject", typeof(object), typeof(NavigationControl), new PropertyMetadata(null, (d, e) => (d as NavigationControl).OnSelectedObjectChanged()));
+
+        private void OnSelectedObjectChanged()
+        {
+            if (SelectedObject != null)
+            {
+                NavigateTo(SelectedObject);
+            }
+        }
+
         public ObservableCollection<FrameworkElement> Elements
         {
             get { return (ObservableCollection<FrameworkElement>)GetValue(ElementsProperty); }
@@ -296,6 +326,11 @@ namespace Tango.SharedUI.Controls
             Content = _grid;
             Elements = new ObservableCollection<FrameworkElement>();
             Loaded += NavigationControl_Loaded;
+
+            _navigationQueue = new ProducerConsumerQueue<NavigationQueueItem>();
+            _navigationThread = new Thread(NavigationThread);
+            _navigationThread.IsBackground = true;
+            _navigationThread.Start();
         }
 
         #endregion
@@ -409,135 +444,174 @@ namespace Tango.SharedUI.Controls
 
         private void Navigate(NavigationElement fromElement, NavigationElement toElement)
         {
-            if (toElement == null || toElement == fromElement)
+            _navigationQueue.BlockEnqueue(new NavigationQueueItem()
             {
-                _onCompleted?.Invoke();
-            }
+                FromElement = fromElement,
+                ToElement = toElement,
+            });
+        }
 
-            if (fromElement != null)
+        private void NavigationThread()
+        {
+            while (true)
             {
-                DoubleAnimation toAnimation = new DoubleAnimation();
-                toAnimation.Duration = TransitionDuration;
-
-                DoubleAnimation fromAnimation = new DoubleAnimation();
-                fromAnimation.Duration = TransitionDuration;
+                var item = _navigationQueue.BlockDequeue();
 
-                int fromIndex = Elements.IndexOf(fromElement.Element);
-                int toIndex = Elements.IndexOf(toElement.Element);
+                var navigationCompleted = false;
 
-                fromElement.Reset();
-                toElement.Reset();
+                NavigationElement fromElement = item.FromElement;
+                NavigationElement toElement = item.ToElement;
 
-                fromAnimation.Completed += (_, __) =>
+                Dispatcher.BeginInvoke(new Action(() =>
                 {
-                    fromElement.Deactivate(!KeepElementsAttached);
-                };
-
-                bool completed = false;
+                    if (toElement == null || toElement == fromElement)
+                    {
+                        //navigationCompleted = true;
+                        Debug.WriteLine("NavigationControl: THIS MIGHT CAUSE PROBLEMS !!");
+                    }
 
-                toAnimation.Completed += (_, __) =>
-                {
-                    if (!completed)
+                    if (fromElement != null)
                     {
-                        completed = true;
+                        DoubleAnimation toAnimation = new DoubleAnimation();
+                        toAnimation.Duration = TransitionDuration;
 
-                        INavigationView fromNavigationView = fromElement.Element as INavigationView;
-                        INavigationView toNavigationView = toElement.Element as INavigationView;
+                        DoubleAnimation fromAnimation = new DoubleAnimation();
+                        fromAnimation.Duration = TransitionDuration;
 
-                        if (fromNavigationView != null)
+                        int fromIndex = Elements.IndexOf(fromElement.Element);
+                        int toIndex = Elements.IndexOf(toElement.Element);
+
+                        fromElement.Reset();
+                        toElement.Reset();
+
+                        fromAnimation.Completed += (_, __) =>
                         {
-                            fromNavigationView.OnNavigatedFrom();
-                        }
-                        if (toNavigationView != null)
+                            fromElement.Deactivate(!KeepElementsAttached);
+                        };
+
+                        bool completed = false;
+
+                        toAnimation.Completed += (_, __) =>
                         {
-                            toNavigationView.OnNavigatedTo();
-                        }
+                            if (!completed)
+                            {
+                                completed = true;
 
-                        INavigationViewModel fromVM = fromElement.Element.DataContext as INavigationViewModel;
-                        INavigationViewModel toVM = toElement.Element.DataContext as INavigationViewModel;
+                                INavigationView fromNavigationView = fromElement.Element as INavigationView;
+                                INavigationView toNavigationView = toElement.Element as INavigationView;
 
-                        if (fromVM != null && fromVM != toVM) fromVM.OnNavigatedFrom();
-                        if (toVM != null) toVM.OnNavigatedTo();
+                                if (fromNavigationView != null)
+                                {
+                                    fromNavigationView.OnNavigatedFrom();
+                                }
+                                if (toNavigationView != null)
+                                {
+                                    toNavigationView.OnNavigatedTo();
+                                }
 
-                        _onCompleted?.Invoke();
-                    }
-                };
+                                INavigationViewModel fromVM = fromElement.Element.DataContext as INavigationViewModel;
+                                INavigationViewModel toVM = toElement.Element.DataContext as INavigationViewModel;
 
-                switch (TransitionType)
-                {
-                    case TransitionTypes.Fade:
-                        fromAnimation.From = 1;
-                        fromAnimation.To = 0;
+                                if (fromVM != null && fromVM != toVM) fromVM.OnNavigatedFrom();
+                                if (toVM != null) toVM.OnNavigatedTo();
+
+                                navigationCompleted = true;
+                            }
+                        };
 
-                        toAnimation.From = 0;
-                        toAnimation.To = 1;
+                        switch (TransitionType)
+                        {
+                            case TransitionTypes.Fade:
+                                fromAnimation.From = 1;
+                                fromAnimation.To = 0;
 
-                        fromElement.AnimateOpacity(fromAnimation);
-                        toElement.AnimateOpacity(toAnimation);
+                                toAnimation.From = 0;
+                                toAnimation.To = 1;
 
-                        break;
-                    case TransitionTypes.Zoom:
-                        fromAnimation.From = 1;
-                        fromAnimation.To = 0;
+                                fromElement.AnimateOpacity(fromAnimation);
+                                toElement.AnimateOpacity(toAnimation);
 
-                        toAnimation.From = 0;
-                        toAnimation.To = 1;
+                                break;
+                            case TransitionTypes.Zoom:
+                                fromAnimation.From = 1;
+                                fromAnimation.To = 0;
 
-                        fromElement.AnimateScale(fromAnimation);
-                        toElement.AnimateScale(toAnimation);
+                                toAnimation.From = 0;
+                                toAnimation.To = 1;
 
-                        break;
-                    case TransitionTypes.Slide:
+                                fromElement.AnimateScale(fromAnimation);
+                                toElement.AnimateScale(toAnimation);
 
-                        if (toIndex > fromIndex)
-                        {
-                            fromAnimation.From = 0;
-                            fromAnimation.To = -ActualWidth;
+                                break;
+                            case TransitionTypes.Slide:
+
+                                if (toIndex > fromIndex)
+                                {
+                                    fromAnimation.From = 0;
+                                    fromAnimation.To = -ActualWidth;
 
-                            toAnimation.From = ActualWidth;
-                            toAnimation.To = 0;
+                                    toAnimation.From = ActualWidth;
+                                    toAnimation.To = 0;
+                                }
+                                else
+                                {
+                                    fromAnimation.From = 0;
+                                    fromAnimation.To = ActualWidth;
+
+                                    toAnimation.From = -ActualWidth;
+                                    toAnimation.To = 0;
+                                }
+
+                                fromElement.AnimateTranslateX(fromAnimation);
+                                toElement.AnimateTranslateX(toAnimation);
+
+                                break;
                         }
-                        else
+
+                        if (TransitionAlwaysFades && TransitionType != TransitionTypes.Fade)
                         {
-                            fromAnimation.From = 0;
-                            fromAnimation.To = ActualWidth;
+                            DoubleAnimation fromFadeAnimation = new DoubleAnimation();
+                            fromFadeAnimation.From = 1;
+                            fromFadeAnimation.To = 0;
+                            fromFadeAnimation.Duration = TransitionDuration;
 
-                            toAnimation.From = -ActualWidth;
-                            toAnimation.To = 0;
-                        }
+                            DoubleAnimation toFadeAnimation = new DoubleAnimation();
+                            toFadeAnimation.From = 0;
+                            toFadeAnimation.To = 1;
+                            toFadeAnimation.Duration = TransitionDuration;
 
-                        fromElement.AnimateTranslateX(fromAnimation);
-                        toElement.AnimateTranslateX(toAnimation);
+                            fromElement.AnimateOpacity(fromFadeAnimation);
+                            toElement.AnimateOpacity(toFadeAnimation);
+                        }
 
-                        break;
-                }
+                        fromElement.Activate();
+                        toElement.Activate();
+                    }
+                    else
+                    {
+                        toElement.Activate();
+                        toElement.Reset();
 
-                if (TransitionAlwaysFades && TransitionType != TransitionTypes.Fade)
-                {
-                    DoubleAnimation fromFadeAnimation = new DoubleAnimation();
-                    fromFadeAnimation.From = 1;
-                    fromFadeAnimation.To = 0;
-                    fromFadeAnimation.Duration = TransitionDuration;
+                        INavigationViewModel toVM = toElement.Element.DataContext as INavigationViewModel;
+                        if (toVM != null) toVM.OnNavigatedTo();
 
-                    DoubleAnimation toFadeAnimation = new DoubleAnimation();
-                    toFadeAnimation.From = 0;
-                    toFadeAnimation.To = 1;
-                    toFadeAnimation.Duration = TransitionDuration;
+                        navigationCompleted = true;
+                    }
+                }));
 
-                    fromElement.AnimateOpacity(fromFadeAnimation);
-                    toElement.AnimateOpacity(toFadeAnimation);
+                for (int i = 0; i < 30; i++)
+                {
+                    if (navigationCompleted)
+                    {
+                        break;
+                    }
+                    Thread.Sleep(100);
                 }
 
-                fromElement.Activate();
-                toElement.Activate();
-            }
-            else
-            {
-                toElement.Activate();
-                toElement.Reset();
-
-                INavigationViewModel toVM = toElement.Element.DataContext as INavigationViewModel;
-                if (toVM != null) toVM.OnNavigatedTo();
+                Dispatcher.BeginInvoke(new Action(() =>
+                {
+                    NavigationCompleted?.Invoke();
+                }));
             }
         }
 
@@ -569,9 +643,26 @@ namespace Tango.SharedUI.Controls
             return NavigateTo(navigationName, null);
         }
 
+        public FrameworkElement NavigateTo(Object obj)
+        {
+            return NavigateTo(obj.ToString(), null);
+        }
+
         public FrameworkElement NavigateTo(String navigationName, Action onCompleted = null)
         {
-            _onCompleted = onCompleted;
+            Action completed = null;
+
+            completed = () =>
+            {
+                try
+                {
+                    onCompleted?.Invoke();
+                }
+                catch { }
+                NavigationCompleted -= completed;
+            };
+
+            NavigationCompleted += completed;
 
             var element = Elements.SingleOrDefault(x => GetNavigationName(x) == navigationName || x.GetType().Name == navigationName);
 
@@ -586,7 +677,7 @@ namespace Tango.SharedUI.Controls
                         if (SelectedElement == element)
                         {
                             await Task.Delay((int)TransitionDuration.TimeSpan.TotalMilliseconds * 2);
-                            _onCompleted?.Invoke();
+                            NavigationCompleted?.Invoke();
                         }
                         else
                         {
@@ -599,6 +690,20 @@ namespace Tango.SharedUI.Controls
             return element;
         }
 
+        public Task<FrameworkElement> NavigateToAsync(String navigationName)
+        {
+            TaskCompletionSource<FrameworkElement> source = new TaskCompletionSource<FrameworkElement>();
+
+            FrameworkElement view = null;
+
+            view = NavigateTo(navigationName, () => 
+            {
+                source.SetResult(view);
+            });
+
+            return source.Task;
+        }
+
         public FrameworkElement GetElement(String navigationName)
         {
             return Elements.SingleOrDefault(x => GetNavigationName(x) == navigationName || x.GetType().Name == navigationName);
diff --git a/Software/Visual_Studio/Tango.SharedUI/Tango.SharedUI.csproj b/Software/Visual_Studio/Tango.SharedUI/Tango.SharedUI.csproj
index ef84d982e..a948ca649 100644
--- a/Software/Visual_Studio/Tango.SharedUI/Tango.SharedUI.csproj
+++ b/Software/Visual_Studio/Tango.SharedUI/Tango.SharedUI.csproj
@@ -149,6 +149,7 @@
     </Compile>
     <Compile Include="Effects\DisplaySettingEffect.cs" />
     <Compile Include="ExtensionMethods\FrameworkElementExtensions.cs" />
+    <Compile Include="Animations\GridLengthAnimation.cs" />
     <Compile Include="Helpers\PasswordHelper.cs" />
     <Compile Include="Helpers\ResourceHelper.cs" />
     <Compile Include="Helpers\UIHelper.cs" />