public void Right_On_TopLevel_Child_Navigates_TopLevel_Selection()
            {
                var target     = new DefaultMenuInteractionHandler(false);
                var menu       = new Mock <IMenu>();
                var parentItem = Mock.Of <IMenuItem>(x =>
                                                     x.IsSubMenuOpen == true &&
                                                     x.IsTopLevel == true &&
                                                     x.HasSubMenu == true &&
                                                     x.Parent == menu.Object);
                var nextItem = Mock.Of <IMenuItem>(x =>
                                                   x.IsTopLevel == true &&
                                                   x.HasSubMenu == true &&
                                                   x.Parent == menu.Object);
                var item = Mock.Of <IMenuItem>(x => x.Parent == parentItem);
                var e    = new KeyEventArgs {
                    Key = Key.Right, Source = item
                };

                menu.Setup(x => x.MoveSelection(NavigationDirection.Right, true))
                .Callback(() => menu.SetupGet(x => x.SelectedItem).Returns(nextItem))
                .Returns(true);

                target.KeyDown(item, e);

                menu.Verify(x => x.MoveSelection(NavigationDirection.Right, true));
                Mock.Get(parentItem).Verify(x => x.Close());
                Mock.Get(nextItem).Verify(x => x.Open());
                Mock.Get(nextItem).Verify(x => x.MoveSelection(NavigationDirection.First, true));
                Assert.True(e.Handled);
            }
            public void PointerEnter_Opens_Item_When_Old_Item_Is_Open()
            {
                var target = new DefaultMenuInteractionHandler(false);
                var menu   = new Mock <IMenu>();
                var item   = Mock.Of <IMenuItem>(x =>
                                                 x.IsSubMenuOpen == true &&
                                                 x.IsTopLevel == true &&
                                                 x.HasSubMenu == true &&
                                                 x.Parent == menu.Object);
                var nextItem = Mock.Of <IMenuItem>(x =>
                                                   x.IsTopLevel == true &&
                                                   x.HasSubMenu == true &&
                                                   x.Parent == menu.Object);
                var e = CreateArgs(MenuItem.PointerEnterItemEvent, nextItem);

                menu.SetupGet(x => x.SelectedItem).Returns(item);

                target.PointerEnter(nextItem, e);

                Mock.Get(item).Verify(x => x.Close());
                menu.VerifySet(x => x.SelectedItem = nextItem);
                Mock.Get(nextItem).Verify(x => x.Open());
                Mock.Get(nextItem).Verify(x => x.MoveSelection(NavigationDirection.First, true), Times.Never);
                Assert.False(e.Handled);
            }
            public void Doesnt_Throw_On_Menu_Keypress()
            {
                // Issue #3459
                var target = new DefaultMenuInteractionHandler(false);
                var menu   = Mock.Of <IMenu>();
                var item   = Mock.Of <IMenuItem>(x => x.IsTopLevel == true && x.Parent == menu);
                var e      = new KeyEventArgs {
                    Key = Key.Tab, Source = menu
                };

                target.KeyDown(menu, e);
            }
            public void PointerLeave_Deselects_Item_When_Menu_Not_Open()
            {
                var target = new DefaultMenuInteractionHandler(false);
                var menu   = new Mock <IMenu>();
                var item   = Mock.Of <IMenuItem>(x => x.IsTopLevel == true && x.Parent == menu.Object);
                var e      = CreateArgs(MenuItem.PointerLeaveItemEvent, item);

                menu.SetupGet(x => x.SelectedItem).Returns(item);
                target.PointerLeave(item, e);

                menu.VerifySet(x => x.SelectedItem = null);
                Assert.False(e.Handled);
            }
            public void PointerEnter_Selects_Item()
            {
                var target     = new DefaultMenuInteractionHandler(false);
                var menu       = Mock.Of <IMenu>();
                var parentItem = Mock.Of <IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true && x.Parent == menu);
                var item       = Mock.Of <IMenuItem>(x => x.Parent == parentItem);
                var e          = CreateArgs(MenuItem.PointerEnterItemEvent, item);

                target.PointerEnter(item, e);

                Mock.Get(parentItem).VerifySet(x => x.SelectedItem = item);
                Assert.False(e.Handled);
            }
            public void PointerLeave_Doesnt_Deselect_Item_If_Pointer_Over_Submenu()
            {
                var target     = new DefaultMenuInteractionHandler(false);
                var menu       = Mock.Of <IMenu>();
                var parentItem = Mock.Of <IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true && x.Parent == menu);
                var item       = Mock.Of <IMenuItem>(x => x.Parent == parentItem && x.HasSubMenu == true && x.IsPointerOverSubMenu == true);
                var e          = CreateArgs(MenuItem.PointerLeaveItemEvent, item);

                target.PointerLeave(item, e);

                Mock.Get(parentItem).VerifySet(x => x.SelectedItem = null, Times.Never);
                Assert.False(e.Handled);
            }
            public void Down_Selects_First_Item_Of_Already_Opened_Submenu()
            {
                var target = new DefaultMenuInteractionHandler(false);
                var item   = Mock.Of <IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true && x.IsSubMenuOpen);
                var e      = new KeyEventArgs {
                    Key = Key.Down, Source = item
                };

                target.KeyDown(item, e);

                Mock.Get(item).Verify(x => x.MoveSelection(NavigationDirection.First, true));
                Assert.True(e.Handled);
            }
            public void Escape_Closes_Parent_Menu()
            {
                var target = new DefaultMenuInteractionHandler(false);
                var menu   = Mock.Of <IMenu>();
                var item   = Mock.Of <IMenuItem>(x => x.IsTopLevel == true && x.Parent == menu);
                var e      = new KeyEventArgs {
                    Key = Key.Escape, Source = item
                };

                target.KeyDown(item, e);

                Mock.Get(menu).Verify(x => x.Close());
                Assert.True(e.Handled);
            }
            public void Up_Opens_MenuItem_With_SubMenu()
            {
                var target = new DefaultMenuInteractionHandler(false);
                var item   = Mock.Of <IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true);
                var e      = new KeyEventArgs {
                    Key = Key.Up, Source = item
                };

                target.KeyDown(item, e);

                Mock.Get(item).Verify(x => x.Open());
                Mock.Get(item).Verify(x => x.MoveSelection(NavigationDirection.First, true));
                Assert.True(e.Handled);
            }
            public void Left_Selects_Previous_MenuItem()
            {
                var target = new DefaultMenuInteractionHandler(false);
                var menu   = Mock.Of <IMenu>(x => x.MoveSelection(NavigationDirection.Left, true) == true);
                var item   = Mock.Of <IMenuItem>(x => x.IsTopLevel == true && x.Parent == menu);
                var e      = new KeyEventArgs {
                    Key = Key.Left, Source = item
                };

                target.KeyDown(item, e);

                Mock.Get(menu).Verify(x => x.MoveSelection(NavigationDirection.Left, true));
                Assert.True(e.Handled);
            }
            public void Down_Selects_Next_MenuItem()
            {
                var target     = new DefaultMenuInteractionHandler(false);
                var parentItem = Mock.Of <IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true);
                var item       = Mock.Of <IMenuItem>(x => x.Parent == parentItem);
                var e          = new KeyEventArgs {
                    Key = Key.Down, Source = item
                };

                target.KeyDown(item, e);

                Mock.Get(parentItem).Verify(x => x.MoveSelection(NavigationDirection.Down, true));
                Assert.True(e.Handled);
            }
            public void PointerReleased_On_Item_With_No_SubMenu_Causes_Click()
            {
                var target     = new DefaultMenuInteractionHandler(false);
                var menu       = Mock.Of <IMenu>();
                var parentItem = Mock.Of <IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true && x.Parent == menu);
                var item       = Mock.Of <IMenuItem>(x => x.Parent == parentItem);
                var e          = CreateReleased(item);

                target.PointerReleased(item, e);

                Mock.Get(item).Verify(x => x.RaiseClick());
                Mock.Get(menu).Verify(x => x.Close());
                Assert.True(e.Handled);
            }
            public void PointerPressed_On_Disabled_Item_Doesnt_Close_SubMenu()
            {
                var target     = new DefaultMenuInteractionHandler(false);
                var menu       = Mock.Of <IMenu>();
                var parentItem = Mock.Of <IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true && x.IsSubMenuOpen == true && x.Parent == menu);
                var popup      = new Popup();
                var e          = CreatePressed(popup);

                ((ISetLogicalParent)popup).SetParent(parentItem);
                target.PointerPressed(parentItem, e);

                Mock.Get(parentItem).Verify(x => x.Close(), Times.Never);
                Assert.True(e.Handled);
            }
            public void Down_Selects_Selects_First_MenuItem_When_No_Selection()
            {
                var target      = new DefaultMenuInteractionHandler(true);
                var contextMenu = Mock.Of <IMenu>(x => x.MoveSelection(NavigationDirection.Down, true) == true);
                var e           = new KeyEventArgs {
                    Key = Key.Down, Source = contextMenu
                };

                target.Attach(contextMenu);
                target.KeyDown(contextMenu, e);

                Mock.Get(contextMenu).Verify(x => x.MoveSelection(NavigationDirection.Down, true));
                Assert.True(e.Handled);
            }
            public void PointerPressed_On_Item_With_SubMenu_Causes_Opens_Submenu()
            {
                var target     = new DefaultMenuInteractionHandler(false);
                var menu       = Mock.Of <IMenu>();
                var parentItem = Mock.Of <IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true && x.Parent == menu);
                var item       = Mock.Of <IMenuItem>(x => x.Parent == parentItem && x.HasSubMenu == true);
                var e          = CreatePressed(item);

                target.PointerPressed(item, e);

                Mock.Get(item).Verify(x => x.Open());
                Mock.Get(item).Verify(x => x.MoveSelection(NavigationDirection.First, true), Times.Never);
                Assert.True(e.Handled);
            }
            public void PointerExited_Doesnt_Deselect_Sibling()
            {
                var target     = new DefaultMenuInteractionHandler(false);
                var menu       = Mock.Of <IMenu>();
                var parentItem = Mock.Of <IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true && x.Parent == menu);
                var item       = Mock.Of <IMenuItem>(x => x.Parent == parentItem);
                var sibling    = Mock.Of <IMenuItem>(x => x.Parent == parentItem);
                var e          = CreateArgs(MenuItem.PointerExitedItemEvent, item);

                Mock.Get(parentItem).SetupGet(x => x.SelectedItem).Returns(sibling);
                target.PointerExited(item, e);

                Mock.Get(parentItem).VerifySet(x => x.SelectedItem = null, Times.Never);
                Assert.False(e.Handled);
            }
            public void Left_Closes_Parent_SubMenu()
            {
                var target     = new DefaultMenuInteractionHandler(false);
                var parentItem = Mock.Of <IMenuItem>(x => x.HasSubMenu == true && x.IsSubMenuOpen == true);
                var item       = Mock.Of <IMenuItem>(x => x.Parent == parentItem);
                var e          = new KeyEventArgs {
                    Key = Key.Left, Source = item
                };

                target.KeyDown(item, e);

                Mock.Get(parentItem).Verify(x => x.Close());
                Mock.Get(parentItem).Verify(x => x.Focus());
                Assert.True(e.Handled);
            }
            public void Enter_On_Item_With_No_SubMenu_Causes_Click()
            {
                var target = new DefaultMenuInteractionHandler(false);
                var menu   = Mock.Of <IMenu>();
                var item   = Mock.Of <IMenuItem>(x => x.IsTopLevel == true && x.Parent == menu);
                var e      = new KeyEventArgs {
                    Key = Key.Enter, Source = item
                };

                target.KeyDown(item, e);

                Mock.Get(item).Verify(x => x.RaiseClick());
                Mock.Get(menu).Verify(x => x.Close());
                Assert.True(e.Handled);
            }
            public void Click_On_Open_TopLevel_Menu_Closes_Menu()
            {
                var target = new DefaultMenuInteractionHandler(false);
                var menu   = Mock.Of <IMenu>();
                var item   = Mock.Of <IMenuItem>(x =>
                                                 x.IsSubMenuOpen == true &&
                                                 x.IsTopLevel == true &&
                                                 x.HasSubMenu == true &&
                                                 x.Parent == menu);

                var e = CreatePressed(item);

                target.PointerPressed(item, e);
                Mock.Get(menu).Verify(x => x.Close());
            }
Пример #20
0
            public void PointerLeave_Doesnt_Deselect_Item_When_Menu_Open()
            {
                var target = new DefaultMenuInteractionHandler(false);
                var menu   = new Mock <IMenu>();
                var item   = Mock.Of <IMenuItem>(x => x.IsTopLevel == true && x.Parent == menu.Object);
                var e      = new PointerEventArgs {
                    RoutedEvent = MenuItem.PointerLeaveItemEvent, Source = item
                };

                menu.SetupGet(x => x.IsOpen).Returns(true);
                menu.SetupGet(x => x.SelectedItem).Returns(item);
                target.PointerLeave(item, e);

                menu.VerifySet(x => x.SelectedItem = null, Times.Never);
                Assert.False(e.Handled);
            }
Пример #21
0
            public void PointerLeave_Deselects_Item()
            {
                var target     = new DefaultMenuInteractionHandler(false);
                var menu       = Mock.Of <IMenu>();
                var parentItem = Mock.Of <IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true && x.Parent == menu);
                var item       = Mock.Of <IMenuItem>(x => x.Parent == parentItem);
                var e          = new PointerEventArgs {
                    RoutedEvent = MenuItem.PointerLeaveItemEvent, Source = item
                };

                Mock.Get(parentItem).SetupGet(x => x.SelectedItem).Returns(item);
                target.PointerLeave(item, e);

                Mock.Get(parentItem).VerifySet(x => x.SelectedItem = null);
                Assert.False(e.Handled);
            }
Пример #22
0
            public void Click_On_Open_TopLevel_Menu_Closes_Menu()
            {
                var target = new DefaultMenuInteractionHandler(false);
                var menu   = Mock.Of <IMenu>();
                var item   = Mock.Of <IMenuItem>(x =>
                                                 x.IsSubMenuOpen == true &&
                                                 x.IsTopLevel == true &&
                                                 x.HasSubMenu == true &&
                                                 x.Parent == menu);
                var e = new PointerPressedEventArgs {
                    MouseButton = MouseButton.Left, Source = item
                };

                target.PointerPressed(item, e);
                Mock.Get(menu).Verify(x => x.Close());
            }
            public void Click_On_TopLevel_Calls_MainMenu_Open()
            {
                var target = new DefaultMenuInteractionHandler(false);
                var menu   = new Mock <IMainMenu>();

                menu.As <IMenuElement>();

                var item = Mock.Of <IMenuItem>(x =>
                                               x.IsTopLevel == true &&
                                               x.HasSubMenu == true &&
                                               x.Parent == menu.Object);

                var e = CreatePressed(item);

                target.PointerPressed(item, e);
                menu.Verify(x => x.Open());
            }
            public void PointerEnter_Opens_Submenu_After_Delay()
            {
                var timer      = new TestTimer();
                var target     = new DefaultMenuInteractionHandler(false, null, timer.RunOnce);
                var menu       = Mock.Of <IMenu>();
                var parentItem = Mock.Of <IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true && x.Parent == menu);
                var item       = Mock.Of <IMenuItem>(x => x.Parent == parentItem && x.HasSubMenu == true);
                var e          = CreateArgs(MenuItem.PointerEnterItemEvent, item);

                target.PointerEnter(item, e);
                Mock.Get(item).Verify(x => x.Open(), Times.Never);

                timer.Pulse();
                Mock.Get(item).Verify(x => x.Open());

                Assert.False(e.Handled);
            }
            public void PointerEnter_Closes_Sibling_Submenu_After_Delay()
            {
                var timer      = new TestTimer();
                var target     = new DefaultMenuInteractionHandler(false, null, timer.RunOnce);
                var menu       = Mock.Of <IMenu>();
                var parentItem = Mock.Of <IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true && x.Parent == menu);
                var item       = Mock.Of <IMenuItem>(x => x.Parent == parentItem);
                var sibling    = Mock.Of <IMenuItem>(x => x.Parent == parentItem && x.HasSubMenu == true && x.IsSubMenuOpen == true);
                var e          = CreateArgs(MenuItem.PointerEnterItemEvent, item);

                Mock.Get(parentItem).SetupGet(x => x.SubItems).Returns(new[] { item, sibling });

                target.PointerEnter(item, e);
                Mock.Get(sibling).Verify(x => x.Close(), Times.Never);

                timer.Pulse();
                Mock.Get(sibling).Verify(x => x.Close());

                Assert.False(e.Handled);
            }
Пример #26
0
            public void Selection_Is_Correct_When_Pointer_Temporarily_Exits_Item_To_Select_SubItem()
            {
                var timer      = new TestTimer();
                var target     = new DefaultMenuInteractionHandler(false, null, timer.RunOnce);
                var menu       = Mock.Of <IMenu>();
                var parentItem = Mock.Of <IMenuItem>(x => x.IsTopLevel == true && x.HasSubMenu == true && x.Parent == menu);
                var item       = Mock.Of <IMenuItem>(x => x.Parent == parentItem && x.HasSubMenu == true);
                var childItem  = Mock.Of <IMenuItem>(x => x.Parent == item);
                var enter      = new PointerEventArgs {
                    RoutedEvent = MenuItem.PointerEnterItemEvent, Source = item
                };
                var leave = new PointerEventArgs {
                    RoutedEvent = MenuItem.PointerLeaveItemEvent, Source = item
                };

                // Pointer enters item; item is selected.
                target.PointerEnter(item, enter);
                Assert.True(timer.ActionIsQueued);
                Mock.Get(parentItem).VerifySet(x => x.SelectedItem = item);
                Mock.Get(parentItem).ResetCalls();

                // SubMenu shown after a delay.
                timer.Pulse();
                Mock.Get(item).Verify(x => x.Open());
                Mock.Get(item).SetupGet(x => x.IsSubMenuOpen).Returns(true);
                Mock.Get(item).ResetCalls();

                // Pointer briefly exits item, but submenu remains open.
                target.PointerLeave(item, leave);
                Mock.Get(item).Verify(x => x.Close(), Times.Never);
                Mock.Get(item).ResetCalls();

                // Pointer enters child item; is selected.
                enter.Source = childItem;
                target.PointerEnter(childItem, enter);
                Mock.Get(item).VerifySet(x => x.SelectedItem       = childItem);
                Mock.Get(parentItem).VerifySet(x => x.SelectedItem = item);
                Mock.Get(item).ResetCalls();
                Mock.Get(parentItem).ResetCalls();
            }
Пример #27
0
 /// <summary>
 /// Initializes a new instance of the <see cref="MenuBase"/> class.
 /// </summary>
 protected MenuBase()
 {
     InteractionHandler = new DefaultMenuInteractionHandler(false);
 }
Пример #28
0
 /// <summary>
 /// Initializes a new instance of the <see cref="MenuBase"/> class.
 /// </summary>
 public MenuBase()
 {
     InteractionHandler = new DefaultMenuInteractionHandler(false);
 }