Lose focus when control removed from visual tree.

Perspex.Controls/Button.cs

@@ -102,6 +102,8 @@ namespace Perspex.Controls
 
         protected override void OnDetachedFromVisualTree(IRenderRoot oldRoot)
         {
+            base.OnDetachedFromVisualTree(oldRoot);
+
             if (this.IsDefault)
             {
                 var inputElement = oldRoot as IInputElement;

Perspex.Controls/Control.cs

@@ -218,7 +218,7 @@ namespace Perspex.Controls
             
             if (this.focusAdorner != null)
             {
-                var adornerLayer = AdornerLayer.GetAdornerLayer(this);
+                var adornerLayer = this.focusAdorner.Parent as Panel;
                 adornerLayer.Children.Remove(this.focusAdorner);
                 this.focusAdorner = null;
             }

Perspex.Input/FocusManager.cs

@@ -44,44 +44,66 @@ namespace Perspex.Input
         /// </param>
         public void Focus(IInputElement control, bool keyboardNavigated = false)
         {
-            Contract.Requires<ArgumentNullException>(control != null);
+            if (control != null)
+            {
+                var scope = control.GetSelfAndVisualAncestors()
+                    .OfType<IFocusScope>()
+                    .FirstOrDefault();
 
-            var current = this.Current as IInteractive;
+                if (scope != null)
-            var next = control as IInteractive;
+                {
-            var scope = control.GetSelfAndVisualAncestors()
+                    this.SetFocusedElement(scope, control, keyboardNavigated);
-                .OfType<IFocusScope>()
+                }
-                .FirstOrDefault();
+            }
+            else
+            {
+                this.SetFocusedElement(this.Scope, null);
+            }
+        }
 
-            if (scope != null && control != current)
+        /// <summary>
+        /// Sets the currently focused element in the specified scope.
+        /// </summary>
+        /// <param name="scope">The focus scope.</param>
+        /// <param name="element">The element to focus. May be null.</param>
+        /// <param name="keyboardNavigated">
+        /// Whether the control was focused by a keypress (e.g. the Tab key).
+        /// </param>
+        /// <remarks>
+        /// If the specified scope is the current <see cref="Scope"/> then the keyboard focus
+        /// will change.
+        /// </remarks>
+        public void SetFocusedElement(
+            IFocusScope scope, 
+            IInputElement element, 
+            bool keyboardNavigated = false)
+        {
+            Contract.Requires<ArgumentNullException>(scope != null);
+
+            this.focusScopes[scope] = element;
+
+            if (this.Scope == scope)
             {
-                this.focusScopes[scope] = control;
+                var interactive = this.Current as IInteractive;
 
-                if (current != null)
+                if (interactive != null)
                 {
-                    current.RaiseEvent(new RoutedEventArgs
+                    interactive.RaiseEvent(new RoutedEventArgs
                     {
                         RoutedEvent = InputElement.LostFocusEvent,
-                        Source = current,
-                        OriginalSource = current,
                     });
                 }
 
-                this.Current = control;
+                this.Current = element;
+                KeyboardDevice.Instance.FocusedElement = element;
 
-                IKeyboardDevice keyboard = Locator.Current.GetService<IKeyboardDevice>();
+                interactive = element as IInteractive;
 
-                if (keyboard != null)
+                if (interactive != null)
                 {
-                    keyboard.FocusedElement = control;
+                    interactive.RaiseEvent(new GotFocusEventArgs
-                }
-
-                if (next != null)
-                {
-                    next.RaiseEvent(new GotFocusEventArgs
                     {
                         RoutedEvent = InputElement.GotFocusEvent,
-                        Source = next,
-                        OriginalSource = next,
                         KeyboardNavigated = keyboardNavigated,
                     });
                 }
@@ -92,10 +114,6 @@ namespace Perspex.Input
         /// Notifies the focus manager of a change in focus scope.
         /// </summary>
         /// <param name="scope">The new focus scope.</param>
-        /// <remarks>
-        /// This should not be called by client code. It is called by an <see cref="IFocusScope"/>
-        /// when it activates, e.g. when a Window is activated.
-        /// </remarks>
         public void SetFocusScope(IFocusScope scope)
         {
             Contract.Requires<ArgumentNullException>(scope != null);

Perspex.Input/InputElement.cs

@@ -9,6 +9,7 @@ namespace Perspex.Input
     using System;
     using System.Linq;
     using Perspex.Interactivity;
+    using Perspex.Rendering;
     using Perspex.VisualTree;
 
     public class InputElement : Interactive, IInputElement
@@ -196,6 +197,16 @@ namespace Perspex.Input
             FocusManager.Instance.Focus(this);
         }
 
+        protected override void OnDetachedFromVisualTree(IRenderRoot oldRoot)
+        {
+            base.OnDetachedFromVisualTree(oldRoot);
+
+            if (this.IsFocused)
+            {
+                FocusManager.Instance.Focus(null);
+            }
+        }
+
         protected override void OnVisualParentChanged(Visual oldParent)
         {
             this.UpdateIsEnabledCore();

Perspex.Input/KeyboardDevice.cs

@@ -22,6 +22,11 @@ namespace Perspex.Input
                 .Subscribe(this.ProcessRawEvent);
         }
 
+        public static IKeyboardDevice Instance
+        {
+            get { return Locator.Current.GetService<IKeyboardDevice>(); }
+        }
+
         public IInputManager InputManager
         {
             get { return Locator.Current.GetService<IInputManager>(); }