File: Core\CSharp\System\Windows\Input\FocusManager.cs
Project: wpf\src\PresentationCore.csproj (PresentationCore)
//---------------------------------------------------------------------------
//
// Copyright (C) Microsoft Corporation.  All rights reserved.
//
//---------------------------------------------------------------------------
 
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Windows.Threading;
using System.Threading;
using System.Windows;
using System.Windows.Interop;
using System.Windows.Media;
using System.Windows.Media.Media3D;
using System.Security;
using System.Security.Permissions;
using MS.Internal.KnownBoxes;
 
 
namespace System.Windows.Input
{
    /// <summary>
    ///   FocusManager define attached property used for tracking the FocusedElement with a focus scope
    /// </summary>
    public static class FocusManager
    {
        #region Public Events
 
        /// <summary>
        ///     GotFocus event
        /// </summary>
        public static readonly RoutedEvent GotFocusEvent = EventManager.RegisterRoutedEvent("GotFocus", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(FocusManager));
 
        /// <summary>
        ///     Adds a handler for the GotFocus attached event
        /// </summary>
        /// <param name="element">UIElement or ContentElement that listens to this event</param>
        /// <param name="handler">Event Handler to be added</param>
        public static void AddGotFocusHandler(DependencyObject element, RoutedEventHandler handler)
        {
            UIElement.AddHandler(element, GotFocusEvent, handler);
        }
 
        /// <summary>
        ///     Removes a handler for the GotFocus attached event
        /// </summary>
        /// <param name="element">UIElement or ContentElement that listens to this event</param>
        /// <param name="handler">Event Handler to be removed</param>
        public static void RemoveGotFocusHandler(DependencyObject element, RoutedEventHandler handler)
        {
            UIElement.RemoveHandler(element, GotFocusEvent, handler);
        }
 
        /// <summary>
        ///     LostFocus event
        /// </summary>
        public static readonly RoutedEvent LostFocusEvent = EventManager.RegisterRoutedEvent("LostFocus", RoutingStrategy.Bubble, typeof(RoutedEventHandler), typeof(FocusManager));
 
        /// <summary>
        ///     Adds a handler for the LostFocus attached event
        /// </summary>
        /// <param name="element">UIElement or ContentElement that listens to this event</param>
        /// <param name="handler">Event Handler to be added</param>
        public static void AddLostFocusHandler(DependencyObject element, RoutedEventHandler handler)
        {
            UIElement.AddHandler(element, LostFocusEvent, handler);
        }
 
        /// <summary>
        ///     Removes a handler for the LostFocus attached event
        /// </summary>
        /// <param name="element">UIElement or ContentElement that listens to this event</param>
        /// <param name="handler">Event Handler to be removed</param>
        public static void RemoveLostFocusHandler(DependencyObject element, RoutedEventHandler handler)
        {
            UIElement.RemoveHandler(element, LostFocusEvent, handler);
        }
 
        #endregion Public Events
 
        #region Public Properties
 
        #region FocusedElement property
 
        /// <summary>
        /// The DependencyProperty for the FocusedElement property. This internal property tracks IsActive
        /// element ref inside TrackFocus
        /// Default Value:      null
        /// </summary>
        public static readonly DependencyProperty FocusedElementProperty =
                DependencyProperty.RegisterAttached(
                        "FocusedElement",
                        typeof(IInputElement),
                        typeof(FocusManager),
                        new PropertyMetadata(new PropertyChangedCallback(OnFocusedElementChanged)));
 
        #endregion FocusedElement property
 
        #region IsFocusScope Property
        /// <summary>
        ///     The DependencyProperty for the IsFocusScope property.
        /// This property is used to mark the special containers (like Window, Menu) so they can
        /// keep track of the FocusedElement element inside the container. Once focus is set
        /// on the container - it is delegated to the FocusedElement element
        ///     Default Value:      false
        /// </summary>
        public static readonly DependencyProperty IsFocusScopeProperty
            = DependencyProperty.RegisterAttached("IsFocusScope", typeof(bool), typeof(FocusManager),
                                                        new PropertyMetadata(BooleanBoxes.FalseBox));
 
        #endregion IsFocusScope Property
 
        #endregion
 
        #region Public static methods
 
        /// <summary>
        /// Return the property value of FocusedElement property.
        /// </summary>
        /// <param name="element"></param>
        /// <returns></returns>
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public static IInputElement GetFocusedElement(DependencyObject element)
        {
            return GetFocusedElement(element, false);
        }
 
        /// <summary>
        /// Return the property value of FocusedElement property. The return value is validated
        /// to be in the subtree of element. If FocusedElement element is not a descendant of element this method return null
        /// </summary>
        /// <param name="element"></param>
        /// <param name="validate"></param>
        /// <returns></returns>
        /// <SecurityNote>
        ///     Critical: This code accesses PresentationSource.CriticalFromVisual which is critical
        ///     TreatAsSafe: This code does not expose it and simply uses it for determining if the FocusedElement is valid
        /// </SecurityNote>
        [SecurityCritical, SecurityTreatAsSafe]
        internal static IInputElement GetFocusedElement(DependencyObject element, bool validate)
        {
            if (element == null)
            {
                throw new ArgumentNullException("element");
            }
 
            DependencyObject focusedElement = (DependencyObject) element.GetValue(FocusedElementProperty);
 
            // Validate FocusedElement wrt to its FocusScope. If the two do not belong to the same PresentationSource 
            // then sever this link between them. The classic scenario for this is when an element with logical focus is 
            // dragged out into a floating widow. We want to prevent the MainWindow (focus scope) to point to the 
            // element in the floating window as its logical FocusedElement.
            
            if (validate && focusedElement != null)
            {
                DependencyObject focusScope = element;
 
                if (PresentationSource.CriticalFromVisual(focusScope) != PresentationSource.CriticalFromVisual(focusedElement))
                {
                    SetFocusedElement(focusScope, null);
                    focusedElement = null;
                }
            }
 
            return (IInputElement)focusedElement;
        }
 
        /// <summary>
        ///     Set FocusedElement property for element.
        /// </summary>
        /// <param name="element"></param>
        /// <param name="value"></param>
        public static void SetFocusedElement(DependencyObject element, IInputElement value)
        {
            if (element == null)
            {
                throw new ArgumentNullException("element");
            }
 
            element.SetValue(FocusedElementProperty, value);
        }
 
        /// <summary>
        /// Writes the attached property IsFocusScope to the given element.
        /// </summary>
        /// <param name="element">The element to which to write the attached property.</param>
        /// <param name="value">The property value to set</param>
        public static void SetIsFocusScope(DependencyObject element, bool value)
        {
            if (element == null)
            {
                throw new ArgumentNullException("element");
            }
            element.SetValue(IsFocusScopeProperty, value);
        }
 
        /// <summary>
        /// Reads the attached property IsFocusScope from the given element.
        /// </summary>
        /// <param name="element">The element from which to read the attached property.</param>
        /// <returns>The property's value.</returns>
        public static bool GetIsFocusScope(DependencyObject element)
        {
            if (element == null)
            {
                throw new ArgumentNullException("element");
            }
            return (bool)element.GetValue(IsFocusScopeProperty);
        }
 
        /// <summary>
        /// Find the closest visual ancestor that has IsFocusScope set to true
        /// </summary>
        /// <param name="element"></param>
        /// <returns></returns>
        public static DependencyObject GetFocusScope(DependencyObject element)
        {
            if (element == null)
            {
                throw new ArgumentNullException("element");
            }
            return _GetFocusScope(element);
        }
 
        #endregion Public methods
 
        #region private implementation
// 
 
 
        private static void OnFocusedElementChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            IInputElement newFocusedElement = (IInputElement)e.NewValue;
            DependencyObject oldVisual = (DependencyObject)e.OldValue;
            DependencyObject newVisual = (DependencyObject)e.NewValue;
 
            if (oldVisual != null)
            {
                oldVisual.ClearValue(UIElement.IsFocusedPropertyKey);
            }
 
            if (newVisual != null)
            {
                // set IsFocused on the element.  The element may redirect Keyboard focus
                // in response to this (e.g. Editable ComboBox redirects to the
                // child TextBox), so detect whether this happens.
                DependencyObject oldFocus = Keyboard.FocusedElement as DependencyObject;
                newVisual.SetValue(UIElement.IsFocusedPropertyKey, BooleanBoxes.TrueBox);
                DependencyObject newFocus = Keyboard.FocusedElement as DependencyObject;
 
                // set the Keyboard focus to the new element, provided that
                //  a) the element didn't already set Keyboard focus
                //  b) Keyboard focus is not already on the new element
                //  c) the new element is within the same focus scope as the current
                //      holder (if any) of Keyboard focus
                if (oldFocus == newFocus && newVisual != newFocus &&
                        (newFocus == null || GetRoot(newVisual) == GetRoot(newFocus)))
                {
                    Keyboard.Focus(newFocusedElement);
                }
            }
 
/*
            if (!_currentlyUpdatingTree)
            {
                _currentlyUpdatingTree = true;
 
                IInputElement newFocusedElement = (IInputElement) newValue;
                Visual oldVisual = GetNearestVisual(args.OldValue);
                Visual newVisual = GetNearestVisual(args.NewValue);
 
                if (oldVisual != null)
                {
                    oldVisual.ClearValue(UIElement.IsFocusedPropertyKey);
 
                    // reverse-inherit:  clear the property on all parents that aren't also in the
                    // new focused element ancestry
                    while (oldVisual != null)
                    {
                        oldVisual.ClearValue(FocusedElementProperty);
                        oldVisual = VisualTreeHelper.GetParent(oldVisual);
                        if ((oldVisual == newVisual) || oldVisual.IsAncestorOf(newVisual))
                        {
                            // only walk up until you reach a common parent -- the new value walk will take care of the rest
                            break;
                        }
                    }
                }
 
                if (newVisual != null)
                {
                    newVisual.SetValue(UIElement.IsFocusedPropertyKey, BooleanBoxes.TrueBox);
 
                    // reverse-inherit:  set the property on all parents
                    while (newVisual != null)
                    {
                        newVisual.SetValue(FocusedElementProperty, newFocusedElement);
                        newVisual = VisualTreeHelper.GetParent(newVisual);
                    }
 
                    // Set Keyboard focus to the element if not already focused && current focus is within the current focus scope
                    DependencyObject currentFocus = Keyboard.FocusedElement as DependencyObject;
                    if ((currentFocus == null) &&
                        (newVisual != currentFocus) &&
                        (GetRoot(newVisual) == GetRoot(currentFocus)))
                    {
                        Keyboard.Focus(newFocusedElement);
                    }
                }
                _currentlyUpdatingTree = false;
            }
*/
        }
        
/*
        private static Visual GetNearestVisual(object value)
        {
            Visual visual = null;
            if (value != null)
            {
                visual = value as Visual;
                if (visual == null)
                {
                    ContentElement ce = value as ContentElement;
                    if (ce != null)
                    {
                        visual = ce.GetUIParent() as Visual;
                    }
                }
            }
            return visual;
        }
*/
 
        private static DependencyObject GetRoot(DependencyObject element)
        {
            if (element == null)
                return null;
 
            DependencyObject parent = null;
            DependencyObject dependencyObject = element;
            
            ContentElement ce = element as ContentElement;
            if (ce != null)
                dependencyObject = ce.GetUIParent();
            
            while (dependencyObject != null)
            {
                parent = dependencyObject; 
                dependencyObject = VisualTreeHelper.GetParent(dependencyObject);
            }
 
            return parent;
        }
 
        // Walk up the parent chain to find the closest element with IsFocusScope=true
        private static DependencyObject _GetFocusScope(DependencyObject d)
        {
            if (d == null)
                return null;
 
            if ((bool)d.GetValue(IsFocusScopeProperty))
                return d;
 
            // Step 1: Walk up the logical tree
            UIElement uiElement = d as UIElement;
            if (uiElement != null)
            {
                DependencyObject logicalParent = uiElement.GetUIParentCore();
                if (logicalParent != null)
                {
                    return GetFocusScope(logicalParent);
                }
            }
            else
            {
                ContentElement ce = d as ContentElement;
                if (ce != null)
                {
                    DependencyObject logicalParent = ce.GetUIParent(true);
                    if (logicalParent != null)
                    {
                        return _GetFocusScope(logicalParent);
                    }
                }
                else
                {
                    UIElement3D uiElement3D = d as UIElement3D;
                    if (uiElement3D != null)
                    {
                        DependencyObject logicalParent = uiElement3D.GetUIParentCore();
                        if (logicalParent != null)
                        {
                            return GetFocusScope(logicalParent);
                        }
                    }
                }
            }
 
            // Step 2: Walk up the visual tree            
            if (d is Visual || d is Visual3D)
            {
                DependencyObject visualParent = VisualTreeHelper.GetParent(d);
                if (visualParent != null)
                {
                    return _GetFocusScope(visualParent);
                }
            }
 
            // If visual and logical parent is null - then the element is implicit focus scope
            return d;
        }
        #endregion private implementation
 
        #region private data
 
        private static readonly UncommonField<bool> IsFocusedElementSet = new UncommonField<bool>();
        private static readonly UncommonField<WeakReference> FocusedElementWeakCacheField = new UncommonField<WeakReference>();
        private static readonly UncommonField<bool> IsFocusedElementCacheValid = new UncommonField<bool>();
        private static readonly UncommonField<WeakReference> FocusedElementCache = new UncommonField<WeakReference>();
 
//        private static bool _currentlyUpdatingTree = false;
 
        #endregion private data
    }
}