Implement element selection event within profile editor VMs

src/Artemis.UI/Utilities/BindableSelectedItemBehavior.cs

@@ -0,0 +1,47 @@
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Interactivity;
+
+namespace Artemis.UI.Utilities
+{
+    public class BindableSelectedItemBehavior : Behavior<TreeView>
+    {
+        protected override void OnAttached()
+        {
+            base.OnAttached();
+
+            AssociatedObject.SelectedItemChanged += OnTreeViewSelectedItemChanged;
+        }
+
+        protected override void OnDetaching()
+        {
+            base.OnDetaching();
+
+            if (AssociatedObject != null) AssociatedObject.SelectedItemChanged -= OnTreeViewSelectedItemChanged;
+        }
+
+        private void OnTreeViewSelectedItemChanged(object sender, RoutedPropertyChangedEventArgs<object> e)
+        {
+            SelectedItem = e.NewValue;
+        }
+
+        #region SelectedItem Property
+
+        public object SelectedItem
+        {
+            get => GetValue(SelectedItemProperty);
+            set => SetValue(SelectedItemProperty, value);
+        }
+
+        public static readonly DependencyProperty SelectedItemProperty =
+            DependencyProperty.Register("SelectedItem", typeof(object), typeof(BindableSelectedItemBehavior), new UIPropertyMetadata(null, OnSelectedItemChanged));
+
+        private static void OnSelectedItemChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
+        {
+            var item = e.NewValue as TreeViewItem;
+            if (item != null) item.SetValue(TreeViewItem.IsSelectedProperty, true);
+        }
+
+        #endregion
+    }
+}

src/Artemis.UI/Utilities/SizeObserver.cs

@@ -0,0 +1,77 @@
+using System.Windows;
+
+namespace Artemis.UI.Utilities
+{
+    public static class SizeObserver
+    {
+        public static readonly DependencyProperty ObserveProperty = DependencyProperty.RegisterAttached(
+            "Observe",
+            typeof(bool),
+            typeof(SizeObserver),
+            new FrameworkPropertyMetadata(OnObserveChanged));
+
+        public static readonly DependencyProperty ObservedWidthProperty = DependencyProperty.RegisterAttached(
+            "ObservedWidth",
+            typeof(double),
+            typeof(SizeObserver));
+
+        public static readonly DependencyProperty ObservedHeightProperty = DependencyProperty.RegisterAttached(
+            "ObservedHeight",
+            typeof(double),
+            typeof(SizeObserver));
+
+        public static bool GetObserve(FrameworkElement frameworkElement)
+        {
+            return (bool) frameworkElement.GetValue(ObserveProperty);
+        }
+
+        public static void SetObserve(FrameworkElement frameworkElement, bool observe)
+        {
+            frameworkElement.SetValue(ObserveProperty, observe);
+        }
+
+        public static double GetObservedWidth(FrameworkElement frameworkElement)
+        {
+            return (double) frameworkElement.GetValue(ObservedWidthProperty);
+        }
+
+        public static void SetObservedWidth(FrameworkElement frameworkElement, double observedWidth)
+        {
+            frameworkElement.SetValue(ObservedWidthProperty, observedWidth);
+        }
+
+        public static double GetObservedHeight(FrameworkElement frameworkElement)
+        {
+            return (double) frameworkElement.GetValue(ObservedHeightProperty);
+        }
+
+        public static void SetObservedHeight(FrameworkElement frameworkElement, double observedHeight)
+        {
+            frameworkElement.SetValue(ObservedHeightProperty, observedHeight);
+        }
+
+        private static void OnObserveChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
+        {
+            var frameworkElement = (FrameworkElement) dependencyObject;
+
+            if ((bool) e.NewValue)
+            {
+                frameworkElement.SizeChanged += OnFrameworkElementSizeChanged;
+                UpdateObservedSizesForFrameworkElement(frameworkElement);
+            }
+            else
+                frameworkElement.SizeChanged -= OnFrameworkElementSizeChanged;
+        }
+
+        private static void OnFrameworkElementSizeChanged(object sender, SizeChangedEventArgs e)
+        {
+            UpdateObservedSizesForFrameworkElement((FrameworkElement) sender);
+        }
+
+        private static void UpdateObservedSizesForFrameworkElement(FrameworkElement frameworkElement)
+        {
+            frameworkElement.SetCurrentValue(ObservedWidthProperty, frameworkElement.ActualWidth);
+            frameworkElement.SetCurrentValue(ObservedHeightProperty, frameworkElement.ActualHeight);
+        }
+    }
+}

src/Artemis.UI/Utilities/TriggerTracing.cs

@@ -0,0 +1,208 @@
+using System.Diagnostics;
+using System.Windows;
+using System.Windows.Markup;
+using System.Windows.Media.Animation;
+
+// Code from http://www.wpfmentor.com/2009/01/how-to-debug-triggers-using-trigger.html
+// No license specified - this code is trimmed out from Release build anyway so it should be ok using it this way
+
+// HOWTO: add the following attached property to any trigger and you will see when it is activated/deactivated in the output window
+//        TriggerTracing.TriggerName="your debug name"
+//        TriggerTracing.TraceEnabled="True"
+
+// Example:
+// <Trigger my:TriggerTracing.TriggerName="BoldWhenMouseIsOver"  
+//          my:TriggerTracing.TraceEnabled="True"  
+//          Property="IsMouseOver"  
+//          Value="True">  
+//     <Setter Property = "FontWeight" Value="Bold"/>  
+// </Trigger> 
+//
+// As this works on anything that inherits from TriggerBase, it will also work on <MultiTrigger>.
+
+namespace Artemis.UI.Utilities
+{
+    #if DEBUG
+
+    /// <summary>
+    ///     Contains attached properties to activate Trigger Tracing on the specified Triggers.
+    ///     This file alone should be dropped into your app.
+    /// </summary>
+    public static class TriggerTracing
+    {
+        static TriggerTracing()
+        {
+            // Initialise WPF Animation tracing and add a TriggerTraceListener
+            PresentationTraceSources.Refresh();
+            PresentationTraceSources.AnimationSource.Listeners.Clear();
+            PresentationTraceSources.AnimationSource.Listeners.Add(new TriggerTraceListener());
+            PresentationTraceSources.AnimationSource.Switch.Level = SourceLevels.All;
+        }
+
+        private enum TriggerTraceStoryboardType
+        {
+            Enter,
+            Exit
+        }
+
+        /// <summary>
+        ///     A dummy storyboard for tracing purposes
+        /// </summary>
+        private class TriggerTraceStoryboard : Storyboard
+        {
+            public TriggerTraceStoryboard(TriggerBase triggerBase, TriggerTraceStoryboardType storyboardType)
+            {
+                TriggerBase = triggerBase;
+                StoryboardType = storyboardType;
+            }
+
+            public TriggerTraceStoryboardType StoryboardType { get; }
+            public TriggerBase TriggerBase { get; }
+        }
+
+        /// <summary>
+        ///     A custom tracelistener.
+        /// </summary>
+        private class TriggerTraceListener : TraceListener
+        {
+            public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string format, params object[] args)
+            {
+                base.TraceEvent(eventCache, source, eventType, id, format, args);
+
+                if (format.StartsWith("Storyboard has begun;"))
+                {
+                    var storyboard = args[1] as TriggerTraceStoryboard;
+                    if (storyboard != null)
+                    {
+                        // add a breakpoint here to see when your trigger has been
+                        // entered or exited
+
+                        // the element being acted upon
+                        var targetElement = args[5];
+
+                        // the namescope of the element being acted upon
+                        var namescope = (INameScope) args[7];
+
+                        var triggerBase = storyboard.TriggerBase;
+                        var triggerName = GetTriggerName(storyboard.TriggerBase);
+
+                        Debug.WriteLine("Element: {0}, {1}: {2}: {3}", targetElement, triggerBase.GetType().Name, triggerName, storyboard.StoryboardType);
+                    }
+                }
+            }
+
+            public override void Write(string message)
+            {
+            }
+
+            public override void WriteLine(string message)
+            {
+            }
+        }
+
+        #region TriggerName attached property
+
+        /// <summary>
+        ///     Gets the trigger name for the specified trigger. This will be used
+        ///     to identify the trigger in the debug output.
+        /// </summary>
+        /// <param name="trigger">The trigger.</param>
+        /// <returns></returns>
+        public static string GetTriggerName(TriggerBase trigger)
+        {
+            return (string) trigger.GetValue(TriggerNameProperty);
+        }
+
+        /// <summary>
+        ///     Sets the trigger name for the specified trigger. This will be used
+        ///     to identify the trigger in the debug output.
+        /// </summary>
+        /// <param name="trigger">The trigger.</param>
+        /// <returns></returns>
+        public static void SetTriggerName(TriggerBase trigger, string value)
+        {
+            trigger.SetValue(TriggerNameProperty, value);
+        }
+
+        public static readonly DependencyProperty TriggerNameProperty =
+            DependencyProperty.RegisterAttached(
+                "TriggerName",
+                typeof(string),
+                typeof(TriggerTracing),
+                new UIPropertyMetadata(string.Empty));
+
+        #endregion
+
+        #region TraceEnabled attached property
+
+        /// <summary>
+        ///     Gets a value indication whether trace is enabled for the specified trigger.
+        /// </summary>
+        /// <param name="trigger">The trigger.</param>
+        /// <returns></returns>
+        public static bool GetTraceEnabled(TriggerBase trigger)
+        {
+            return (bool) trigger.GetValue(TraceEnabledProperty);
+        }
+
+        /// <summary>
+        ///     Sets a value specifying whether trace is enabled for the specified trigger
+        /// </summary>
+        /// <param name="trigger"></param>
+        /// <param name="value"></param>
+        public static void SetTraceEnabled(TriggerBase trigger, bool value)
+        {
+            trigger.SetValue(TraceEnabledProperty, value);
+        }
+
+        public static readonly DependencyProperty TraceEnabledProperty =
+            DependencyProperty.RegisterAttached(
+                "TraceEnabled",
+                typeof(bool),
+                typeof(TriggerTracing),
+                new UIPropertyMetadata(false, OnTraceEnabledChanged));
+
+        private static void OnTraceEnabledChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            var triggerBase = d as TriggerBase;
+
+            if (triggerBase == null)
+                return;
+
+            if (!(e.NewValue is bool))
+                return;
+
+            if ((bool) e.NewValue)
+            {
+                // insert dummy story-boards which can later be traced using WPF animation tracing
+
+                var storyboard = new TriggerTraceStoryboard(triggerBase, TriggerTraceStoryboardType.Enter);
+                triggerBase.EnterActions.Insert(0, new BeginStoryboard {Storyboard = storyboard});
+
+                storyboard = new TriggerTraceStoryboard(triggerBase, TriggerTraceStoryboardType.Exit);
+                triggerBase.ExitActions.Insert(0, new BeginStoryboard {Storyboard = storyboard});
+            }
+            else
+            {
+                // remove the dummy storyboards
+
+                foreach (var actionCollection in new[] {triggerBase.EnterActions, triggerBase.ExitActions})
+                {
+                    foreach (var triggerAction in actionCollection)
+                    {
+                        var bsb = triggerAction as BeginStoryboard;
+
+                        if (bsb != null && bsb.Storyboard != null && bsb.Storyboard is TriggerTraceStoryboard)
+                        {
+                            actionCollection.Remove(bsb);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        #endregion
+    }
+    #endif
+}