private void CoreWindow_KeyDown(CoreWindow sender, Windows.UI.Core.KeyEventArgs args)
        {
            if (IsInTransitionState)
            {
                return;
            }

            if (NavigateUsingKeyboard(args, this, Orientation))
            {
                return;
            }

            string gestureKey = MapInputToGestureKey(args.VirtualKey);

            if (gestureKey == null)
            {
                return;
            }

            if (MenuItemInputGestureCache.ContainsKey(gestureKey))
            {
                var cachedMenuItem = MenuItemInputGestureCache[gestureKey];
                if (cachedMenuItem is MenuFlyoutItem)
                {
                    var menuFlyoutItem = (MenuFlyoutItem)cachedMenuItem;
                    menuFlyoutItem.Command?.Execute(menuFlyoutItem.CommandParameter);
                }
            }
        }
Example #2
0
        private void Dispatcher_AcceleratorKeyActivated(CoreDispatcher sender, AcceleratorKeyEventArgs args)
        {
            _lastFocusElement = FocusManager.GetFocusedElement() as Control;
            if (args.VirtualKey == VirtualKey.Menu && !args.KeyStatus.WasKeyDown)
            {
                _altHandled = false;
            }
            else if (args.KeyStatus.IsMenuKeyDown && args.KeyStatus.IsKeyReleased && !_altHandled)
            {
                _altHandled = true;
                string gestureKey = MapInputToGestureKey(args.VirtualKey);

                if (gestureKey == null)
                {
                    return;
                }

                if (MenuItemInputGestureCache.ContainsKey(gestureKey))
                {
                    var cachedMenuItem = MenuItemInputGestureCache[gestureKey];
                    if (cachedMenuItem is MenuItem)
                    {
                        var menuItem = (MenuItem)cachedMenuItem;
                        menuItem.ShowMenu();
                        menuItem.Focus(FocusState.Keyboard);
                    }
                }
            }
            else if (args.VirtualKey == VirtualKey.Menu && args.KeyStatus.IsKeyReleased && !_altHandled)
            {
                _altHandled = true;
                if (!IsOpened)
                {
                    if (_isLostFocus)
                    {
                        LostFocus -= Menu_LostFocus;
                        Focus(FocusState.Programmatic);
                        _lastFocusElementBeforeMenu = _lastFocusElement;
                        _isLostFocus = false;

                        if (AllowTooltip)
                        {
                            ShowSubItemToolTips();
                        }

                        LostFocus += Menu_LostFocus;
                    }
                    else
                    {
                        _lastFocusElementBeforeMenu?.Focus(FocusState.Keyboard);
                    }
                }
            }
        }
        private static void InputGestureTextChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            var element = sender as FrameworkElement;

            var inputGestureValue = element?.GetValue(InputGestureTextProperty).ToString();

            if (string.IsNullOrEmpty(inputGestureValue))
            {
                return;
            }

            inputGestureValue = inputGestureValue.ToUpper();
            if (MenuItemInputGestureCache.ContainsKey(inputGestureValue))
            {
                MenuItemInputGestureCache[inputGestureValue] = element;
                return;
            }

            MenuItemInputGestureCache.Add(inputGestureValue.ToUpper(), element);
        }
        private static void RemoveElementFromCache(FrameworkElement descendant)
        {
            var value = descendant.GetValue(InputGestureTextProperty);
            if (value == null)
            {
                return;
            }

            var inputGestureText = value.ToString().ToUpper();
            if (!MenuItemInputGestureCache.ContainsKey(inputGestureText))
            {
                return;
            }

            var cachedMenuItem = MenuItemInputGestureCache[inputGestureText];
            if (cachedMenuItem == descendant)
            {
                MenuItemInputGestureCache.Remove(inputGestureText);
            }
        }
        private void Dispatcher_AcceleratorKeyActivated(CoreDispatcher sender, AcceleratorKeyEventArgs args)
        {
            if (Items.Count == 0)
            {
                return;
            }

            if (ControlHelpers.IsXamlRootAvailable && XamlRoot != null)
            {
                _lastFocusElement = FocusManager.GetFocusedElement(XamlRoot) as Control;
            }
            else
            {
                _lastFocusElement = FocusManager.GetFocusedElement() as Control;
            }

            if (args.KeyStatus.ScanCode != AltScanCode)
            {
                _onlyAltCharacterPressed = false;
            }

            if (args.VirtualKey == VirtualKey.Menu)
            {
                if (!IsOpened)
                {
                    if (_isLostFocus)
                    {
                        if (_onlyAltCharacterPressed && args.KeyStatus.IsKeyReleased)
                        {
                            ((MenuItem)Items[0]).Focus(FocusState.Programmatic);

                            if (!(_lastFocusElement is MenuItem))
                            {
                                _lastFocusElementBeforeMenu = _lastFocusElement;
                            }
                        }

                        if (AllowTooltip)
                        {
                            ShowMenuItemsToolTips();
                        }
                        else
                        {
                            UnderlineMenuItems();
                        }

                        if (args.KeyStatus.IsKeyReleased)
                        {
                            _isLostFocus = false;
                        }
                    }
                    else if (args.KeyStatus.IsKeyReleased)
                    {
                        HideToolTip();
                        _lastFocusElementBeforeMenu?.Focus(FocusState.Keyboard);
                    }
                }
            }
            else if ((args.KeyStatus.IsMenuKeyDown || !_isLostFocus) && args.KeyStatus.IsKeyReleased)
            {
                var gestureKey = MapInputToGestureKey(args.VirtualKey, !_isLostFocus);
                if (gestureKey == null)
                {
                    return;
                }

                if (MenuItemInputGestureCache.ContainsKey(gestureKey))
                {
                    var cachedMenuItem = MenuItemInputGestureCache[gestureKey];
                    if (cachedMenuItem is MenuItem)
                    {
                        var menuItem = (MenuItem)cachedMenuItem;
                        menuItem.ShowMenu();
                        menuItem.Focus(FocusState.Keyboard);
                    }
                }
            }

            if (args.KeyStatus.IsKeyReleased && args.EventType == CoreAcceleratorKeyEventType.KeyUp)
            {
                _onlyAltCharacterPressed = true;
                _isLostFocus             = true;
                HideToolTip();
            }
        }
        private void Dispatcher_AcceleratorKeyActivated(CoreDispatcher sender, AcceleratorKeyEventArgs args)
        {
            if (Items.Count == 0)
            {
                return;
            }

            _lastFocusElement = FocusManager.GetFocusedElement() as Control;

            if (args.VirtualKey == VirtualKey.Menu)
            {
                if (!IsOpened)
                {
                    if (_isLostFocus)
                    {
                        ((MenuItem)Items[0]).Focus(FocusState.Programmatic);

                        if (!(_lastFocusElement is MenuItem))
                        {
                            _lastFocusElementBeforeMenu = _lastFocusElement;
                        }

                        if (AllowTooltip)
                        {
                            ShowMenuItemsToolTips();
                        }
                        else
                        {
                            UnderlineMenuItems();
                        }

                        if (args.KeyStatus.IsKeyReleased)
                        {
                            _isLostFocus = false;
                        }
                    }
                    else if (!_isLostFocus && args.KeyStatus.IsKeyReleased)
                    {
                        if (AllowTooltip)
                        {
                            HideMenuItemsTooltips();
                        }
                        else
                        {
                            RemoveUnderlineMenuItems();
                        }

                        _lastFocusElementBeforeMenu?.Focus(FocusState.Keyboard);
                    }
                }
            }
            else if ((args.KeyStatus.IsMenuKeyDown || !_isLostFocus) && args.KeyStatus.IsKeyReleased)
            {
                var gestureKey = MapInputToGestureKey(args.VirtualKey, !_isLostFocus);
                if (gestureKey == null)
                {
                    return;
                }

                if (MenuItemInputGestureCache.ContainsKey(gestureKey))
                {
                    var cachedMenuItem = MenuItemInputGestureCache[gestureKey];
                    if (cachedMenuItem is MenuItem)
                    {
                        var menuItem = (MenuItem)cachedMenuItem;
                        menuItem.ShowMenu();
                        menuItem.Focus(FocusState.Keyboard);
                    }
                }
            }
        }