Introduce proper testing

Stylet/ViewManager.cs

@@ -239,8 +239,8 @@ namespace Stylet
         /// <param name="viewModel">ViewModel to bind the View to</param>
         public virtual void BindViewToModel(UIElement view, object viewModel)
         {
-            logger.Info("Setting {0}'s ActionTarget to {1}", view, viewModel);
-            View.SetActionTarget(view, viewModel);
+            //logger.Info("Setting {0}'s ActionTarget to {1}", view, viewModel);
+            //View.SetActionTarget(view, viewModel);
 
             var viewAsFrameworkElement = view as FrameworkElement;
             if (viewAsFrameworkElement != null)

Stylet/Xaml/ActionBase.cs

@@ -212,11 +212,15 @@ namespace Stylet.Xaml
         {
             public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
             {
-                foreach (var value in values)
-                {
-                    if (value != View.InitialActionTarget)
-                        return value;
-                }
+                // We expect 2 values: [0] is the actiontarget, and [1] is the viewmodel from resource
+                if (values.Length != 2)
+                    throw new ArgumentException("Values must have 2 elements");
+
+                if (values[0] != View.InitialActionTarget)
+                    return values[0];
+
+                if (values[1] != null)
+                    return values[1];
 
                 return View.InitialActionTarget;
             }

Stylet/Xaml/BindingProxy.cs

@@ -1,9 +1,5 @@
 using System;
-using System.Collections.Generic;
 using System.Globalization;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Data;
 
@@ -18,7 +14,7 @@ namespace Stylet.Xaml
 
         public object Data
         {
-            get { return (object)GetValue(DataProperty); }
+            get { return GetValue(DataProperty); }
             set { SetValue(DataProperty, value); }
         }
 
@@ -26,6 +22,9 @@ namespace Stylet.Xaml
             DependencyProperty.Register("Data", typeof(object), typeof(BindingProxy), new PropertyMetadata(null));        
     }
 
+    /// <summary>
+    /// Converter which extracts the 'Data' property from a BindingProxy.
+    /// </summary>
     internal class BindingProxyToValueConverter : IValueConverter
     {
         public static readonly BindingProxyToValueConverter Instance = new BindingProxyToValueConverter();

Stylet/Xaml/View.cs

@@ -108,6 +108,35 @@ namespace Stylet.Xaml
                 }
             }));
 
+        // Dependency Properties with 'inherit' set are great, except when they're not. In particular, they lose their
+        // value when you cross a boundary into an element which does not sit inside the visual (or logica?) tree.
+        // For example, trying to get the value of a previously-set View.ActionTarget from a KeyBinding will fail, because
+        // the KeyBinding does not sit inside either the visual or logical tree, and so View.ActionTarget loses its value.
+        // However, there are ways around this. If you create an instance of an object inheriting from Freezable and set it
+        // as a resource on some parent, you can later retrieve that resource even from children where inherited Dependency
+        // Properties will fail, using {DynamicResource}.
+        // Therefore. We have a class called BindingProxy, which has a single object 'Data' property and which inherits from
+        // freezable. View.SetViewModel sets this as a resource (with key ViewModelProxyResourceKey) on whatever FrameworkElement
+        // it's given, and sets the ViewModel as the 'Data' property. Later on, we can retrieve that BindingProxy from its
+        // key, and extract the ViewModel from it.
+        // Normally we'd be able to use FrameworkElement.SetResourceReference to emulate {DynamicResource} from code, but
+        // irritatingly that's defined on FrameworkElement and not DependencyObject (even though it does nothing specific to
+        // FrameworkElement), so won't work with e.g. KeyBinding (which inherits from DependencyObject but not FrameworkElement).
+        // However, DynamicResourceExtension.ProvideValue doesn't actually require a service provider, so we can get away with
+        // using it directly (it just wraps ResourceReferenceExpression, but that's internal, boo).
+        // Because the result of {DynamicResource} can change, we need to assign it to a Dependency Property (we use
+        // View.ViewModelProxy), and we return a binding which binds to that Dependency Property, and also has a converter
+        // which extracts the 'Data' property from the BindingProxy.
+        // The final step in the puzzle is that ActionBase will first look for a View.ActionTarget, and if not set, it will
+        // then look for a ViewModel using View.GetBindingToViewModel.
+        // The ViewModelExtension Markup Extension also uses this mechanism.
+
+        // To recap: if someone wants to get the ViewModel associated with a particular UI element, they can call
+        // View.GetBindingToViewModel. This will create a lookup to our previously-stored BindingProxy resource (whose 'Data'
+        // property is set to the ViewModel) using DynamicResourceExtension, and attach that to the View.ViewModelProxy
+        // Dependency Property. It will then return a binding, which can be used to fetch the ViewModel. This mechanism
+        // is used by {s:ViewModel}, and by ActionBase when an ActionTarget is otherwise not available.
+
         /// <summary>
         /// Set the ViewModel which can be subsequently retrieved using {s:ViewModel}
         /// </summary>

StyletIntegrationTests/ShellView.xaml

@@ -2,7 +2,7 @@
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:s="https://github.com/canton7/Stylet"
-        Title="ShellView" Height="500" Width="500">
+        Title="ShellView" Height="500" Width="500" SizeToContent="Height">
     <DockPanel LastChildFill="False">
         <GroupBox DockPanel.Dock="Top" Header="ShowDialog and DialogResult" Padding="10">
             <StackPanel Orientation="Horizontal">
@@ -41,11 +41,18 @@
                     </TextBox.InputBindings>
                     <TextBox.ContextMenu>
                         <ContextMenu>
-                            <MenuItem Header="{Binding Foo}" DataContext="{s:ViewModel}" Command="{s:Action ShowActionTargetSaved}"/>
+                            <MenuItem Header="Click Me" Command="{s:Action ShowActionTargetSaved}"/>
                         </ContextMenu>
                     </TextBox.ContextMenu>
                 </TextBox>
             </DockPanel>
         </GroupBox>
+
+        <GroupBox DockPanel.Dock="Top" Header="{}{ViewModel}" Padding="10">
+            <DockPanel DataContext="{x:Null}">
+                <TextBlock DockPanel.Dock="Top">Ensure that the label below displays the text "Pass":</TextBlock>
+                <TextBlock DockPanel.Dock="Top" DataContext="{s:ViewModel}" Text="{Binding ViewModelTestLabel}"/>
+            </DockPanel>
+        </GroupBox>
     </DockPanel>
 </Window>

StyletIntegrationTests/ShellViewModel.cs

@@ -12,8 +12,6 @@ namespace StyletIntegrationTests
     {
         private IWindowManager windowManager;
 
-        public string Foo => "Foo";
-
         public ShellViewModel(IWindowManager windowManager)
         {
             this.windowManager = windowManager;
@@ -69,7 +67,12 @@ namespace StyletIntegrationTests
         
         public void ShowActionTargetSaved()
         {
-            this.windowManager.ShowMessageBox("Saved!");
+            this.windowManager.ShowMessageBox("PASS!");
+        }
+
+        public string ViewModelTestLabel
+        {
+            get { return "Pass"; }
         }
     }
 }

StyletUnitTests/ViewManagerTests.cs

@@ -281,14 +281,13 @@ namespace StyletUnitTests
         }
 
         [Test]
-        public void BindViewToModelSetsActionTarget()
+        public void BindViewToModelDoesNotSetActionTarget()
         {
             var view = new UIElement();
-            var model = new object();
             var viewManager = new AccessibleViewManager(this.viewManagerConfig.Object);
-            viewManager.BindViewToModel(view, model);
+            viewManager.BindViewToModel(view, new object());
 
-            Assert.AreEqual(model, View.GetActionTarget(view));
+            Assert.AreEqual(View.InitialActionTarget, View.GetActionTarget(view));
         }
 
         [Test]

StyletUnitTests/ViewTests.cs

@@ -7,6 +7,7 @@ using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Controls.Primitives;
 using System.Windows.Data;
+using System.Windows.Input;
 
 namespace StyletUnitTests
 {
@@ -26,6 +27,19 @@ namespace StyletUnitTests
             }
         }
 
+
+        private class TestObjectWithDP : DependencyObject
+        {
+            public object DP
+            {
+                get { return (object)GetValue(DPProperty); }
+                set { SetValue(DPProperty, value); }
+            }
+
+            public static readonly DependencyProperty DPProperty =
+                DependencyProperty.Register("DP", typeof(object), typeof(TestObjectWithDP), new PropertyMetadata(null));
+        }
+
         private Mock<IViewManager> viewManager;
 
         [SetUp]
@@ -158,24 +172,22 @@ namespace StyletUnitTests
         }
 
         [Test]
-        public void ActionTargetIsRestoredAcrossPopupBoundaries()
+        public void ViewModelCanBeRetrievedByChildren()
         {
-            Execute.InDesignMode = true;
+            var view = new UserControl();
+            var viewModel = new object();
+            View.SetViewModel(view, viewModel);
 
-            var userControl = new UserControl();
-            var grid = new Grid();
-            userControl.Content = grid;
+            // Use something that doesn't inherit attached properties
+            var keyBinding = new KeyBinding();
+            view.InputBindings.Add(keyBinding);
 
-            var button = new Button();
-            grid.Children.Add(button);
+            var binding = View.GetBindingToViewModel(keyBinding);
 
-            var contextMenu = new ContextMenu();
-            button.ContextMenu = contextMenu;
+            var receiver = new TestObjectWithDP();
+            BindingOperations.SetBinding(receiver, TestObjectWithDP.DPProperty, binding);
 
-            var actionTarget = new object();
-
-            View.SetActionTarget(userControl, actionTarget);
-            Assert.AreEqual(actionTarget, View.GetActionTarget(button));
+            Assert.AreEqual(viewModel, receiver.DP);
         }
     }
 }