File: Core\CSharp\System\Windows\Input\AccessKeyManager.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.Globalization;
using System.Threading;
using System.Windows.Media;
using System.Windows.Interop;
using MS.Internal;
using System.Diagnostics;
using System.Windows;
using System.Security;
using System.Security.Permissions;
 
using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID;
 
namespace System.Windows.Input
{
    /// <summary>
    ///   AccessKeyManager object is created on demand and it is one per thread.
    /// It attached an event handler for PostProcessInput on InputManager and expose registration and 
    /// unregistration of access keys. When the access key is pressed in calls OnAccessKey method on the target element
    /// </summary>
    public sealed class AccessKeyManager
    {
        #region Public API
        /// <summary>
        ///   Register the access key binding to the element that is the accesskey.
        /// </summary>
        /// <param name="key">When the key is pressed the element OnAccessKey method is called</param>
        /// <param name="element">The registration element</param>
        public static void Register(string key, IInputElement element)
        {
            if (element == null)
            {
                throw new ArgumentNullException("element");
            }
            key = NormalizeKey(key);
 
            AccessKeyManager akm = AccessKeyManager.Current;
 
            lock (akm._keyToElements)
            {
                ArrayList elements = (ArrayList)akm._keyToElements[key];
 
                if (elements == null)
                {
                    elements = new ArrayList(1);
                    akm._keyToElements[key] = elements;
                }
                else
                {
                    // There were some elements there, remove dead ones
                    PurgeDead(elements, null);
                }
 
                elements.Add(new WeakReference(element));
            }
        }
 
        /// <summary>
        /// Unregister one key bound to a particular element
        /// </summary>
        /// <param name="key"></param>
        /// <param name="element"></param>
        public static void Unregister(string key, IInputElement element)
        {
            if (element == null)
            {
                throw new ArgumentNullException("element");
            }
            key = NormalizeKey(key);
 
            AccessKeyManager akm = AccessKeyManager.Current;
 
            lock (akm._keyToElements)
            {
                // Get all elements bound to this key and remove this element
                ArrayList elements = (ArrayList)akm._keyToElements[key];
 
                if (elements != null)
                {
                    PurgeDead(elements, element);
                    if (elements.Count == 0)
                    {
                        akm._keyToElements.Remove(key);
                    }
                }
            }
        }
 
        /// <summary>
        /// Tells if there is a particular key registered at the global scope in this Context.
        /// </summary>
        /// <param name="scope">Scope to query (for example the PresentationSource of the visual)</param>
        /// <param name="key"></param>
        /// <returns></returns>
        public static bool IsKeyRegistered(object scope, string key)
        {
            key = NormalizeKey(key);
 
            AccessKeyManager akm = AccessKeyManager.Current;
            List<IInputElement> targets = akm.GetTargetsForScope(scope, key, null, AccessKeyInformation.Empty);
            return (targets != null && targets.Count > 0);
        }
 
        /// <summary>
        /// Process the given key as if the key were pressed at the global scope in this context.
        /// </summary>
        /// <param name="scope">scope in which to invoke the access key</param>
        /// <param name="key">character being pressed</param>
        /// <param name="isMultiple">True if this key has multiple matches</param>
        /// <returns>false if there are no more keys that match, true otherwise</returns>
        /// <summary>
        ///     Executes the command on the given command source.
        /// </summary>
        /// <SecurityNote>
        ///     Critical - calls critical function (ProcessKeyForScope)
        ///     PublicOK - always passes in false for userInitiated, which is safe
        /// </SecurityNote>
        [SecurityCritical]
        public static bool ProcessKey(object scope, string key, bool isMultiple)
        {
            key = NormalizeKey(key);
 
            AccessKeyManager akm = AccessKeyManager.Current;
            return (akm.ProcessKeyForScope(scope, key, isMultiple,false) == ProcessKeyResult.MoreMatches);
        }
 
        /// <summary>
        /// Returns StringInfo.GetNextTextElement(key).ToUpperInvariant() throwing exceptions for null
        /// and multi-char strings.
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        private static string NormalizeKey(string key)
        {
            if (key == null)
            {
                throw new ArgumentNullException("key");
            }
 
            string firstCharacter = StringInfo.GetNextTextElement(key);
 
            if (key != firstCharacter)
            {
                throw new ArgumentException(SR.Get(SRID.AccessKeyManager_NotAUnicodeCharacter, "key"));
            }
 
            return firstCharacter.ToUpperInvariant();
        }
 
        /// <summary>
        /// This event is used by elements that want to define a scope for accesskeys, such as Menu and Popup.
        /// This event will never be raised, it is used to identify classes that define new scopes.
        /// </summary>
        public static readonly RoutedEvent AccessKeyPressedEvent = EventManager.RegisterRoutedEvent(
            "AccessKeyPressed", RoutingStrategy.Bubble, typeof(AccessKeyPressedEventHandler), typeof(AccessKeyManager));
 
        /// <summary>
        ///     Adds a handler for the AccessKeyPressed 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 AddAccessKeyPressedHandler(DependencyObject element, AccessKeyPressedEventHandler handler)
        {
            UIElement.AddHandler(element, AccessKeyPressedEvent, handler);
        }
 
        /// <summary>
        ///     Removes a handler for the AccessKeyPressed 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 RemoveAccessKeyPressedHandler(DependencyObject element, AccessKeyPressedEventHandler handler)
        {
            UIElement.RemoveHandler(element, AccessKeyPressedEvent, handler);
        }
 
        #endregion
        
        #region Constructor
        /// <SecurityNote>
        ///     Critical: This code accesses InputManager.Current which is critical
        ///     TreatAsSafe: This code does not expose it and simply adds an event handler that is internal
        /// </SecurityNote>
        [SecurityCritical, SecurityTreatAsSafe]
        private AccessKeyManager()
        {
            InputManager.Current.PostProcessInput += new ProcessInputEventHandler(PostProcessInput);
        }
 
        #endregion
 
        #region Properties
        
        /// <summary>
        /// Access to the current context's AccessKeyManager class
        /// </summary>
        private static AccessKeyManager Current
        {
            get 
            {
                if (_accessKeyManager == null)
                    _accessKeyManager = new AccessKeyManager();
                return _accessKeyManager;
            }
        }
 
        #endregion
 
        #region PostProcessInput Event Handlers
 
        private enum ProcessKeyResult
        {
            NoMatch,
            MoreMatches,
            LastMatch
        }
 
        /// <SecurityNote>
        ///     Critical: accesses e.StagingItem.Input
        /// </SecurityNote>
        [SecurityCritical]
        private void PostProcessInput(object sender, ProcessInputEventArgs e)
        {
            if (e.StagingItem.Input.Handled) return;
 
            if (e.StagingItem.Input.RoutedEvent == Keyboard.KeyDownEvent)
            {
                OnKeyDown((KeyEventArgs)e.StagingItem.Input);
            }
            else if (e.StagingItem.Input.RoutedEvent == TextCompositionManager.TextInputEvent)
            {
                OnText((TextCompositionEventArgs)e.StagingItem.Input);
            }
            
        }
 
        // Assumes key is already a single unicode character
        /// <SecurityNote>
        /// Critical - sets the userInitiated bit on a command, which is used
        ///            for security purposes later. 
        /// </SecurityNote>
        [SecurityCritical]
        private ProcessKeyResult ProcessKeyForSender(object sender, string key, bool existsElsewhere, bool userInitiated)
        {
            // This comes from OnKeyDown or OnText and though it is a single character it might not be uppercased.
            key = key.ToUpperInvariant();
 
            IInputElement inputElementSender = sender as IInputElement;
            List<IInputElement> targets = GetTargetsForSender(inputElementSender, key);
 
            return ProcessKey(targets, key, existsElsewhere, userInitiated);
        }
 
        // Assumes key is already a single unicode character AND is uppercased
        /// <SecurityNote>
        /// Critical - sets the userInitiated bit on a command, which is used
        ///            for security purposes later. 
        /// </SecurityNote>
        [SecurityCritical]
        private ProcessKeyResult ProcessKeyForScope(object scope, string key, bool existsElsewhere, bool userInitiated)
        {
            List<IInputElement> targets = GetTargetsForScope(scope, key, null, AccessKeyInformation.Empty);
 
            return ProcessKey(targets, key, existsElsewhere, userInitiated);
        }
 
        /// <SecurityNote>
        /// Critical - Sets calls AccessKeyPressedEventArgs setting the userInitiated bit which is used
        ///            for security purposes later. 
        /// </SecurityNote>
        [SecurityCritical]
        private ProcessKeyResult ProcessKey(List<IInputElement> targets, string key, bool existsElsewhere, bool userInitiated)
        {
            if (targets != null)
            {
                bool oneUIElement = true;
                UIElement invokeUIElement = null;
                bool lastWasAccessed = false;
 
                int chosenIndex = 0;
                for (int i = 0; i < targets.Count; i++)
                {
                    UIElement target = targets[i] as UIElement;
                    Debug.Assert(target != null, "Targets should only be UIElements");
                    if (!target.IsEnabled)
                        continue;
 
                    if (invokeUIElement == null)
                    {
                        invokeUIElement = target;
                        chosenIndex = i;
                    }
                    else
                    {
                        if (lastWasAccessed)
                        {
                            invokeUIElement = target;
                            chosenIndex = i;
                        }
 
                        oneUIElement = false;
                    }
 
                    // 
                    lastWasAccessed = target.HasEffectiveKeyboardFocus;
                }
 
                if (invokeUIElement != null)
                {
                    AccessKeyEventArgs args = new AccessKeyEventArgs(key, !oneUIElement || existsElsewhere /* == isMultiple */,userInitiated);
                    try
                    {
                        invokeUIElement.InvokeAccessKey(args);
                    }
                    finally
                    {
                        args.ClearUserInitiated();
                    }
 
                    return (chosenIndex == targets.Count - 1) ? ProcessKeyResult.LastMatch : ProcessKeyResult.MoreMatches;
                }
            }
 
            return ProcessKeyResult.NoMatch;
        }
 
        /// <SecurityNote>
        /// Critical - Calls ProcessKeyForSender, setting the userInitiated 
        ///             bit, which is used for security purposes later. 
        /// </SecurityNote>
        [SecurityCritical]
        private void OnText(TextCompositionEventArgs e)
        {
            // AccessKeyManager handles both text and system text.
            string text = e.Text;
            if ((text == null) || (text.Length == 0))
            {
                text = e.SystemText;
            }
 
            if ((text != null) && (text.Length > 0))
            {
                if (ProcessKeyForSender(e.OriginalSource, text, false /* existsElsewhere */,e.UserInitiated) != ProcessKeyResult.NoMatch)
                {
                    e.Handled = true;
                }
            }
        }
 
        /// <SecurityNote>
        /// Critical - Calls ProcessKeyForSender, setting the userInitiated 
        ///             bit, which is used for security purposes later. 
        /// </SecurityNote>
        [SecurityCritical]
        private void OnKeyDown(KeyEventArgs e)
        {
            KeyboardDevice keyboard = (KeyboardDevice)e.Device;
 
            string text = null;
            switch (e.RealKey)
            {
                case Key.Enter :
                     text = "\x000D";
                     break;
 
                case Key.Escape :
                     text = "\x001B";
                     break;
            }
 
            if (text != null)
            {
                if (ProcessKeyForSender(e.OriginalSource, text, false /* existsElsewhere */,e.UserInitiated) != ProcessKeyResult.NoMatch)
                {
                    e.Handled = true;
                }
            }
        }
 
        /// <summary>
        /// Get the list of access key targets for the sender of the keyboard event.  If sender is null, 
        /// pretend key was pressed in the active window.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="key"></param>
        /// <returns></returns>
        /// <SecurityNote>
        ///     Critical: calls Critical member GetInfoForElement() and accesses Scope from AccessKeyInformation.
        ///     TreatAsSafe:  Does not pass the sender info (which may contain a PresentationSource) out.
        /// </SecurityNote>
        [SecurityCritical, SecurityTreatAsSafe]
        private List<IInputElement> GetTargetsForSender(IInputElement sender, string key)
        {
            // Find the scope for the sender -- will be matched against the possible targets' scopes
            AccessKeyInformation senderInfo = GetInfoForElement(sender, key);
 
            return GetTargetsForScope(senderInfo.Scope, key, sender, senderInfo);
        }
        
        /// <SecurityNote>
        ///     Critical: calls CriticalGetActiveSource()
        ///     TreatAsSafe:  Does not pass the returned scope to any other method, nor is it
        ///                 returned from GetTargetsForScope.  Also returned value is not critical.
        /// </SecurityNote>
        [SecurityCritical, SecurityTreatAsSafe]
        private List<IInputElement> GetTargetsForScope(object scope, string key, IInputElement sender, AccessKeyInformation senderInfo)
        {
            // null scope defaults to the active window
            if (scope == null)
            {
                scope = CriticalGetActiveSource();
 
                // if there is no active scope then give up
                if (scope == null)
                {
                    return null;
                }
            }
 
            if (CoreCompatibilityPreferences.GetIsAltKeyRequiredInAccessKeyDefaultScope() && 
                (scope is PresentationSource) && (Keyboard.Modifiers & ModifierKeys.Alt) != ModifierKeys.Alt)
            {
                // If AltKey is required and it isnt pressed then dont match against any targets
                return null;
            }
            
            //Scoping:
            //    1) When key is pressed, find matching AKs -> S
            //    3) find scope for keyevent.Source
            //    4) find scope for everything in S. throw away those that don't match.
            //    5) Final selection uses S.  yay!
            // 
            // 
            List<IInputElement> possibleElements;
            lock (_keyToElements)
            {
                possibleElements = CopyAndPurgeDead(_keyToElements[key] as ArrayList);
            }
 
            if (possibleElements == null) return null;
 
            List<IInputElement> finalTargets = new List<IInputElement>(1);
 
            // Go through all the possible elements, find the interesting candidates
            for (int i = 0; i < possibleElements.Count;  i++)
            {
                IInputElement element = possibleElements[i];
                if (element != sender)
                {
                    if (IsTargetable(element))
                    {
                        AccessKeyInformation elementInfo = GetInfoForElement(element, key);
 
                        if (elementInfo.target == null) continue;
 
                        if (scope == elementInfo.Scope)
                        {
                            finalTargets.Add(elementInfo.target);
                        }
                    }
                }
                else
                {
                    // This is the same element that sent the event so it must be in the same scope.  
                    // Just add it to the final targets
                    if (senderInfo.target != null)
                    {
                        finalTargets.Add(senderInfo.target);
                    }
                }
            }
 
            return finalTargets;
        }
        
        /// <summary>
        /// Returns scope for the given element.
        /// </summary>
        /// <param name="element"></param>
        /// <param name="key"></param>
        /// <returns>Scope for the given element, null means the context global scope</returns>
        /// <SecurityNote>
        ///     Critical: calls GetSourceForElement(), CriticalGetActiveSource(), and returns AccessKeyInformation.
        /// </SecurityNote>
        [SecurityCritical]
        private AccessKeyInformation GetInfoForElement(IInputElement element, string key)
        {
            AccessKeyInformation info = new AccessKeyInformation();
            if (element != null)
            {
                AccessKeyPressedEventArgs args = new AccessKeyPressedEventArgs(key);
 
                element.RaiseEvent(args);
                info.Scope = args.Scope;
                info.target = args.Target;
                if (info.Scope == null)
                {
                    info.Scope = GetSourceForElement(element);
                }
            }
            else
            {
                info.Scope = CriticalGetActiveSource();
            }
            return info;
        }
 
        /// <SecurityNote>
        ///     Critical: calls PresentationSource.CriticalFromVisual, and returns PresentationSource
        /// </SecurityNote>
        [SecurityCritical]
        private PresentationSource GetSourceForElement(IInputElement element)
        {
            PresentationSource source = null;
            DependencyObject elementDO = element as DependencyObject;
 
            // Use internal helpers to try to find the source of the element.
            // Because IInputElements can move around without notification we need to
            // look up the source every time.
            if (elementDO != null)
            {
                DependencyObject containingVisual = InputElement.GetContainingVisual(elementDO);
 
                if (containingVisual != null)
                {
                    source = PresentationSource.CriticalFromVisual(containingVisual);
                }
            }
            
            // NOTE: source can be null but IsTargetable(element) == true if the
            // element is in an orphaned tree but the tree has not yet been garbage collected.  
            return source;
        }
 
        /// <SecurityNote>
        ///     Critical: calls UnsafeNativeMethod GetActiveWindow(), and Critical method
        ///               HwndSource.FromHwnd().
        ///     TreatAsSafe: Does not pass any parameters to GetActiveWindow(), and does
        ///                 not expose the return value, and HwndSource.FromHwnd will demand 
        ///                 UIPermissionWindow.AllWindows.
        /// </SecurityNote>
        [SecurityCritical, SecurityTreatAsSafe]
        private PresentationSource GetActiveSource()
        {
            IntPtr hwnd = MS.Win32.UnsafeNativeMethods.GetActiveWindow();
            if (hwnd != IntPtr.Zero)
                return HwndSource.FromHwnd(hwnd);
 
            return null;
        }
 
        /// <SecurityNote>
        ///     Critical: calls UnsafeNativeMethod GetActiveWindow() and HwndSource.CriticalFromHwnd()
        /// </SecurityNote>
        [SecurityCritical]
        private PresentationSource CriticalGetActiveSource()
        {
            IntPtr hwnd = MS.Win32.UnsafeNativeMethods.GetActiveWindow();
            if (hwnd != IntPtr.Zero)
                return HwndSource.CriticalFromHwnd(hwnd);
 
            return null;
        }
 
        
        private bool IsTargetable(IInputElement element)
        {
            DependencyObject uielement = InputElement.GetContainingUIElement((DependencyObject)element);
 
            // For an element to be a valid target it must be visible and enabled
            if (uielement != null 
                && IsVisible(uielement)
                && IsEnabled(uielement))
            {
                return true;
            }
 
            return false;
        }
 
        private static bool IsVisible(DependencyObject element)
        {
            while (element != null)
            {
                Visibility visibility;
                UIElement uiElem = element as UIElement;
                UIElement3D uiElem3D = element as UIElement3D;
                
                if (uiElem != null)
 
                {
                    visibility = uiElem.Visibility;
                }
                else
                {
                    visibility = uiElem3D.Visibility;                    
                }
                
                if (visibility != Visibility.Visible)
                {
                    return false;
                }
                
                element = UIElementHelper.GetUIParent(element);
            }
            
            return true;
        }
 
        // returns whether the given DO is enabled or not
        private static bool IsEnabled(DependencyObject element)
        {
            return ((bool)element.GetValue(UIElement.IsEnabledProperty));                               
        }
 
        private struct AccessKeyInformation
        {
            /// <SecurityNote>
            ///     Critical: Scope may contain an PresentationSource which we
            ///               would not want exposed.
            /// </SecurityNote>
            public object Scope
            {
                [SecurityCritical]
                get 
                {
                    return _scope;
                }
                set 
                {
                    _scope = value;
                }
            }
 
            
            public UIElement target;
 
            private static AccessKeyInformation _empty = new AccessKeyInformation();
            public static AccessKeyInformation Empty
            {
                get
                {
                    return _empty;
                }
            }
 
            private object _scope;
        }
 
        private static void PurgeDead(ArrayList elements, object elementToRemove)
        {
            for (int i = 0; i < elements.Count; )
            {
                WeakReference weakReference = (WeakReference)elements[i];
                object element = weakReference.Target;
 
                if (element == null || element == elementToRemove)
                {
                    elements.RemoveAt(i);
                }
                else
                {
                    i++;
                }
            }
        }
 
        /// <summary>
        ///     Takes an ArrayList of WeakReferences, removes the dead references and returns
        ///     a generic List of IInputElements (strong references)
        /// </summary>
        private static List<IInputElement> CopyAndPurgeDead(ArrayList elements)
        {
            if (elements == null)
            {
                return null;
            }
 
            List<IInputElement> copy = new List<IInputElement>(elements.Count);
 
            for (int i = 0; i < elements.Count; )
            {
                WeakReference weakReference = (WeakReference)elements[i];
                object element = weakReference.Target;
 
                if (element == null)
                {
                    elements.RemoveAt(i);
                }
                else
                {
                    Debug.Assert(element is IInputElement, "Element in AccessKeyManager store was not of type IInputElement");
                    copy.Add((IInputElement)element);
                    i++;
                }
            }
 
            return copy;
        }
 
        #endregion
 
        #region Private Properties
        
        /////////////////////////////////////////////////////////////////////////////////
        // Overview: Algorithm to look up access key from the element for which it is a target.
        //           
        //     When the AccessKeyCharacter for an element is requested we see if there
        //     is a corresponding AccessKeyElement stashed on the element.  If there is,
        //     raise the AccessKeyPressed event on it to see if that element is  still the 
        //     target for it.  If not, go through all registered accesskeys and get their 
        //     targets until we find the desired element.  The "primary" access key character
        //     is the first one we find.
        //     
        //     Note: The algorithm ends up being O(n) for each request for AccessKeyCharacter 
        //     because there is no mapping from AccessKeyElement to its "primary" character.
        //     Maintaining this would require storing a hash from AccessKeyElement to character
        //     or requiring that each element registered implement an interface or some other
        //     kind of contract.  Because we don't keep track of this or enforce this, to find 
        //     the "primary" character we must go through all registered pairs of 
        //     (character, element) to find the character -- O(n).
        //
        //     This ends up being just fine, because in any given context there shouldn't be
        //     so many elements registered that this cost is at all noticable.
        //
        /////////////////////////////////////////////////////////////////////////////////
 
        /// <summary>
        ///     The primary access key element for an element.  This is stored as a WeakReference.
        /// </summary>
        private static readonly DependencyProperty AccessKeyElementProperty =
            DependencyProperty.RegisterAttached("AccessKeyElement", typeof(WeakReference), typeof(AccessKeyManager));
 
        #endregion
 
        #region Private Methods for UIAutomation
 
        internal static string InternalGetAccessKeyCharacter(DependencyObject d)
        {
            return Current.GetAccessKeyCharacter(d);
        }
 
        private string GetAccessKeyCharacter(DependencyObject d)
        {
            // See what the local value for AccessKeyElement is first and start with that.
            WeakReference cachedElementWeakRef = (WeakReference)d.GetValue(AccessKeyElementProperty);
            IInputElement accessKeyElement = (cachedElementWeakRef != null) ? (IInputElement)cachedElementWeakRef.Target : null;
 
            if (accessKeyElement != null)
            {
                // First figure out if the target of accessKeyElement is still "d", then go find
                // the "primary" character for the accessKeyElement.  
 
                AccessKeyPressedEventArgs accessKeyPressedEventArgs = new AccessKeyPressedEventArgs();
                accessKeyElement.RaiseEvent(accessKeyPressedEventArgs);
                if (accessKeyPressedEventArgs.Target == d)
                {
                    // Because there is no way to get at the access key element's character from the
                    // element (there is no interface or anything) we have to go through all registered 
                    // access keys and see if this access key element is still registered and what its
                    // "primary" character is.
                
                    foreach (DictionaryEntry entry in Current._keyToElements)
                    {
                        ArrayList elements = (ArrayList)entry.Value;
                        for (int i = 0; i < elements.Count; i++)
                        {
                            // If this element matches accessKeyElement, then return the current character
                            WeakReference currentElementWeakRef = (WeakReference)elements[i];
 
                            if (currentElementWeakRef.Target == accessKeyElement)
                            {
                                return (string)entry.Key;
                            }
                        }
                    }
                }
            }
 
 
            // There was no access key stored or it no longer matched.  Clear out the cache and figure it out again.
            d.ClearValue(AccessKeyElementProperty);
 
            foreach (DictionaryEntry entry in Current._keyToElements)
            {
                ArrayList elements = (ArrayList)entry.Value;
                for (int i = 0; i < elements.Count; i++)
                {
                    // Determine the target for this element.  Cache the weak reference for the element on the target.
                    WeakReference currentElementWeakRef = (WeakReference)elements[i];
                    IInputElement currentElement = (IInputElement)currentElementWeakRef.Target;
 
                    if (currentElement != null)
                    {
                        AccessKeyPressedEventArgs accessKeyPressedEventArgs = new AccessKeyPressedEventArgs();
                        currentElement.RaiseEvent(accessKeyPressedEventArgs);
 
                        // If the target was non-null, cache the access key element on the target.
                        // if the target matches "d", return the current character.
                        if (accessKeyPressedEventArgs.Target != null)
                        {
                            accessKeyPressedEventArgs.Target.SetValue(AccessKeyElementProperty, currentElementWeakRef);
 
                            if (accessKeyPressedEventArgs.Target == d)
                            {
                                return (string)entry.Key;
                            }
                        }
                    }
                }
            }
 
 
            return String.Empty;
        }
 
        #endregion
 
        #region Data
        // Map: string -> ArrayList of WeakReferences to IInputElements
        private Hashtable _keyToElements = new Hashtable(10);
 
        [ThreadStatic] private static AccessKeyManager _accessKeyManager;
 
        #endregion
    }
 
    /// <summary>
    /// The delegate type for handling a FindScope event
    /// </summary>
    public delegate void AccessKeyPressedEventHandler(object sender, AccessKeyPressedEventArgs e);
 
    /// <summary>
    /// The inputs to an AccessKeyPressedEventHandler
    /// </summary>
    public class AccessKeyPressedEventArgs : RoutedEventArgs
    {
        #region Constructors
 
        /// <summary>
        /// The constructor for AccessKeyPressed event args
        /// </summary>
        public AccessKeyPressedEventArgs()
        {
            RoutedEvent = AccessKeyManager.AccessKeyPressedEvent;
            _key = null;
        }
 
        /// <summary>
        /// Constructor for AccessKeyPressed event args
        /// </summary>
        /// <param name="key"></param>
        public AccessKeyPressedEventArgs(string key) : this()
        {
            _key = key;
        }
 
        #endregion
 
        #region Public Properties
 
        /// <summary>
        /// The scope for the element that raised this event.
        /// </summary>
        public object Scope
        {
            get { return _scope; }
            set { _scope = value; }
        }
 
        /// <summary>
        /// Target element for the element that raised this event.
        /// </summary>
        /// <value></value>
        public UIElement Target
        {
            get { return _target; }
            set { _target = value; }
        }
 
        /// <summary>
        /// Key that was pressed
        /// </summary>
        /// <value></value>
        public string Key
        {
            get { return _key; }
        }
 
        #endregion
 
        #region Protected Methods
 
        /// <summary>
        /// </summary>
        /// <param name="genericHandler">The handler to invoke.</param>
        /// <param name="genericTarget">The current object along the event's route.</param>
        protected override void InvokeEventHandler(Delegate genericHandler, object genericTarget)
        {
            AccessKeyPressedEventHandler handler = (AccessKeyPressedEventHandler)genericHandler;
 
            handler(genericTarget, this);
        }
 
        #endregion
 
        #region Data
 
        private object _scope;
        private UIElement _target;
        private string _key;
 
        #endregion
    }
 
    /// <summary>
    /// Information pertaining to when the access key associated with an element is pressed
    /// </summary>
    public class AccessKeyEventArgs : EventArgs
    {
        /// <summary>
        /// 
        /// </summary>
        /// <SecurityNote>
        /// Critical - sets the userInitiated bit on a command, which is used
        ///            for security purposes later. 
        /// </SecurityNote>
        [SecurityCritical]
        internal AccessKeyEventArgs(string key, bool isMultiple, bool userInitiated)
        {
            _key = key;
            _isMultiple = isMultiple;
            _userInitiated = new SecurityCriticalDataForSet<bool>(userInitiated);
        }
 
        /// <SecurityNote>
        /// Critical - sets the userInitiated bit on a command, which is used
        ///            for security purposes later. 
        /// TreatAsSafe: Resets the user initiated bit
        /// </SecurityNote>
        [SecurityCritical,SecurityTreatAsSafe]
        internal void ClearUserInitiated()
        {
            _userInitiated.Value = false;
        }
        /// <summary>
        /// The key that was pressed which invoked this access key
        /// </summary>
        /// <value></value>
        public string Key
        {
            get { return _key; }
        }
 
        /// <summary>
        /// Were there other elements which are also invoked by this key
        /// </summary>
        /// <value></value>
        public bool IsMultiple
        {
            get { return _isMultiple; }
        }
 
        internal bool UserInitiated
        {
            get { return _userInitiated.Value; }
        }
        
 
        private string _key;
        private bool _isMultiple;
        /// <SecurityNote>
        /// Critical -  This is critical for set, setting this bool can cause the spoofing of paste
        /// </SecurityNote>        
        private SecurityCriticalDataForSet<bool >_userInitiated;
 
    }
}