Machine Studio v4.0.10

PPC v1.0.9

2 files changed, 191 insertions, 14 deletions

diff --git a/Software/Visual_Studio/Tango.Core/ExtensionMethods/ExceptionExtensions.cs b/Software/Visual_Studio/Tango.Core/ExtensionMethods/ExceptionExtensions.cs
index 86434cdc4..af4fc39b5 100644
--- a/Software/Visual_Studio/Tango.Core/ExtensionMethods/ExceptionExtensions.cs
+++ b/Software/Visual_Studio/Tango.Core/ExtensionMethods/ExceptionExtensions.cs
@@ -43,10 +43,14 @@ public static class ExceptionExtensions
         {
             try
             {
-                message += Environment.NewLine + String.Join(Environment.NewLine, (exception as AggregateException).InnerExceptions.Select(x => x.Message));
+                message = String.Join(Environment.NewLine, (exception as AggregateException).InnerExceptions.Select(x => x.FlattenMessage()));
             }
             catch { }
         }
+        else if (exception.InnerException != null)
+        {
+            message += Environment.NewLine + exception.InnerException.FlattenMessage();
+        }
 
         return message;
     }
diff --git a/Software/Visual_Studio/Tango.Core/ExtensionMethods/FrameworkElementExtensions.cs b/Software/Visual_Studio/Tango.Core/ExtensionMethods/FrameworkElementExtensions.cs
index 2e1791b63..08f3bb101 100644
--- a/Software/Visual_Studio/Tango.Core/ExtensionMethods/FrameworkElementExtensions.cs
+++ b/Software/Visual_Studio/Tango.Core/ExtensionMethods/FrameworkElementExtensions.cs
@@ -8,6 +8,7 @@ using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Controls.Primitives;
+using System.Windows.Input;
 using System.Windows.Markup;
 using System.Windows.Media;
 using System.Windows.Media.Animation;
@@ -18,6 +19,14 @@ public static class FrameworkElementExtensions
 {
     #region Mouse Or Touch Events
 
+    //Used to hold the registered event handlers for later use by UnRegisterMouseOrTouch.
+    private static List<ElementEventsContainer> _containers = new List<ElementEventsContainer>();
+    private class ElementEventsContainer
+    {
+        public EventHandler<MouseOrTouchEventArgs> Handler { get; set; }
+        public Action Clear { get; set; }
+    }
+
     /// <summary>
     /// Registers for mouse or touch down.
     /// </summary>
@@ -29,7 +38,7 @@ public static class FrameworkElementExtensions
         bool mousePressed = false;
         bool touchDown = false;
 
-        element.MouseDown += (x, e) =>
+        MouseButtonEventHandler mouseDownHandler = (x, e) => 
         {
             if (!touchDown)
             {
@@ -53,7 +62,9 @@ public static class FrameworkElementExtensions
             }
         };
 
-        element.TouchDown += (x, e) =>
+        element.MouseDown += mouseDownHandler;
+
+        EventHandler<TouchEventArgs> touchDownHandler = (x, e) => 
         {
             if (!mousePressed)
             {
@@ -77,16 +88,31 @@ public static class FrameworkElementExtensions
             }
         };
 
-        element.MouseUp += (_, __) =>
+        element.TouchDown += touchDownHandler;
+
+        MouseButtonEventHandler mouseUpHandler = (_, __) => 
         {
             touchDown = false;
             mousePressed = false;
         };
 
-        element.TouchDown += (_, __) =>
-        {
+        element.MouseUp += mouseUpHandler;
+
+        //element.TouchDown += (_, __) =>
+        //{
+
+        //};
 
+        ElementEventsContainer container = new ElementEventsContainer();
+        container.Handler = handler;
+        container.Clear = () => 
+        {
+            element.MouseUp -= mouseUpHandler;
+            element.TouchDown -= touchDownHandler;
+            element.MouseDown -= mouseDownHandler;
         };
+
+        _containers.Add(container);
     }
 
     /// <summary>
@@ -100,6 +126,101 @@ public static class FrameworkElementExtensions
     }
 
     /// <summary>
+    /// Registers for mouse or touch up.
+    /// </summary>
+    /// <param name="element">The element.</param>
+    /// <param name="relativeTo">The relative to.</param>
+    /// <param name="handler">The handler.</param>
+    public static void RegisterForMouseOrTouchUp(this FrameworkElement element, FrameworkElement relativeTo, EventHandler<MouseOrTouchEventArgs> handler)
+    {
+        bool mouseReleased = false;
+        bool touchReleased = false;
+
+        MouseButtonEventHandler mouseUpHandler = (x, e) =>
+        {
+            if (!touchReleased)
+            {
+                mouseReleased = true;
+
+                var args = new MouseOrTouchEventArgs()
+                {
+                    Location = new Point(e.GetPosition(relativeTo != null ? relativeTo : element).X, e.GetPosition(relativeTo != null ? relativeTo : element).Y),
+                    Source = e.Source,
+                    OriginalSource = e.OriginalSource,
+                    Handled = e.Handled,
+                    GetPositionAction = e.GetPosition
+                };
+
+                handler(element, args);
+                e.Handled = args.Handled;
+            }
+            else
+            {
+                touchReleased = false;
+            }
+        };
+
+        element.MouseUp += mouseUpHandler;
+
+        EventHandler<TouchEventArgs> touchUpHandler = (x, e) =>
+        {
+
+            if (!mouseReleased)
+            {
+                touchReleased = true;
+
+                var args = new MouseOrTouchEventArgs()
+                {
+                    Location = new Point(e.GetTouchPoint(relativeTo != null ? relativeTo : element).Position.X, e.GetTouchPoint(relativeTo != null ? relativeTo : element).Position.Y),
+                    Source = e.Source,
+                    OriginalSource = e.OriginalSource,
+                    Handled = e.Handled,
+                    GetPositionAction = (s) => { return e.GetTouchPoint(s).Position; },
+                };
+
+                handler(element, args);
+                e.Handled = args.Handled;
+            }
+            else
+            {
+                touchReleased = false;
+            }
+
+        };
+
+        element.TouchUp += touchUpHandler;
+
+        EventHandler<TouchEventArgs> touchDownHandler = (_, __) =>
+        {
+            touchReleased = false;
+            mouseReleased = false;
+        };
+
+        element.TouchDown += touchDownHandler;
+
+        ElementEventsContainer container = new ElementEventsContainer();
+        container.Handler = handler;
+        container.Clear = () =>
+        {
+            element.TouchDown -= touchDownHandler;
+            element.TouchUp -= touchUpHandler;
+            element.MouseUp -= mouseUpHandler;
+        };
+
+        _containers.Add(container);
+    }
+
+    /// <summary>
+    /// Registers for mouse or touch up.
+    /// </summary>
+    /// <param name="element">The element.</param>
+    /// <param name="handler">The handler.</param>
+    public static void RegisterForMouseOrTouchUp(this FrameworkElement element, EventHandler<MouseOrTouchEventArgs> handler)
+    {
+        RegisterForMouseOrTouchUp(element, null, handler);
+    }
+
+    /// <summary>
     /// Registers for preview mouse or touch down.
     /// </summary>
     /// <param name="element">The element.</param>
@@ -110,7 +231,7 @@ public static class FrameworkElementExtensions
         bool mousePressed = false;
         bool touchDown = false;
 
-        element.PreviewMouseDown += (x, e) =>
+        MouseButtonEventHandler previewMouseDownHandler = (x, e) =>
         {
             if (!touchDown)
             {
@@ -134,7 +255,9 @@ public static class FrameworkElementExtensions
             }
         };
 
-        element.PreviewTouchDown += (x, e) =>
+        element.PreviewMouseDown += previewMouseDownHandler;
+
+        EventHandler<TouchEventArgs> previewTouchDownHandler = (x, e) => 
         {
             if (!mousePressed)
             {
@@ -158,16 +281,31 @@ public static class FrameworkElementExtensions
             }
         };
 
-        element.PreviewMouseUp += (_, __) =>
+        element.PreviewTouchDown += previewTouchDownHandler;
+
+        MouseButtonEventHandler previewMouseUpHandler = (_, __) => 
         {
             touchDown = false;
             mousePressed = false;
         };
 
-        element.PreviewTouchDown += (_, __) =>
-        {
+        element.PreviewMouseUp += previewMouseUpHandler;
+
+        //element.PreviewTouchDown += (_, __) =>
+        //{
+
+        //};
 
+        ElementEventsContainer container = new ElementEventsContainer();
+        container.Handler = handler;
+        container.Clear = () =>
+        {
+            element.PreviewTouchDown -= previewTouchDownHandler;
+            element.PreviewMouseDown -= previewMouseDownHandler;
+            element.PreviewMouseUp -= previewMouseUpHandler;
         };
+
+        _containers.Add(container);
     }
 
     /// <summary>
@@ -191,7 +329,7 @@ public static class FrameworkElementExtensions
         bool mouseReleased = false;
         bool touchReleased = false;
 
-        element.PreviewMouseUp += (x, e) =>
+        MouseButtonEventHandler previewMouseUpHandler = (x, e) =>
         {
             if (!touchReleased)
             {
@@ -215,8 +353,11 @@ public static class FrameworkElementExtensions
             }
         };
 
-        element.PreviewTouchUp += (x, e) =>
+        element.PreviewMouseUp += previewMouseUpHandler;
+
+        EventHandler<TouchEventArgs> previewTouchHandler = (x, e) =>
         {
+
             if (!mouseReleased)
             {
                 touchReleased = true;
@@ -237,13 +378,29 @@ public static class FrameworkElementExtensions
             {
                 touchReleased = false;
             }
+
         };
 
-        element.PreviewTouchDown += (_, __) =>
+        element.PreviewTouchUp += previewTouchHandler;
+
+        EventHandler<TouchEventArgs> previewTouchDownHandler = (_, __) =>
         {
             touchReleased = false;
             mouseReleased = false;
         };
+
+        element.PreviewTouchDown += previewTouchDownHandler;
+
+        ElementEventsContainer container = new ElementEventsContainer();
+        container.Handler = handler;
+        container.Clear = () =>
+        {
+            element.PreviewTouchDown -= previewTouchDownHandler;
+            element.PreviewTouchUp -= previewTouchHandler;
+            element.PreviewMouseUp -= previewMouseUpHandler;
+        };
+
+        _containers.Add(container);
     }
 
     /// <summary>
@@ -257,6 +414,22 @@ public static class FrameworkElementExtensions
     }
 
     /// <summary>
+    /// Detaches the specified handler from event which it was originally registered.
+    /// </summary>
+    /// <param name="element">The element.</param>
+    /// <param name="handler">The handler.</param>
+    public static void UnRegisterMouseOrTouch(this FrameworkElement element, EventHandler<MouseOrTouchEventArgs> handler)
+    {
+        var containers = _containers.Where(x => x.Handler == handler);
+
+        foreach (var container in containers.ToList())
+        {
+            container.Clear();
+            _containers.Remove(container);
+        }
+    }
+
+    /// <summary>
     /// Registers for mouse or touch move.
     /// </summary>
     /// <param name="element">The element.</param>