internal void Initialize(
     string name,
     int month,
     int year,
     CalendarViewDisplayMode mode)
 {
     m_name  = name;
     m_month = month;
     m_year  = year;
     m_mode  = mode;
 }
示例#2
0
        // Handles when a key is pressed down on the CalendarView.
        protected override void OnKeyDown(         // TODO UNO: Does this should really override the method from Control, or just list for event on ScrollViewers ?
            KeyRoutedEventArgs pArgs)
        {
            bool isHandled = false;
            bool handled   = false;
            KeyRoutedEventArgs spKeyDownArgsFromCalendarItem;

            VirtualKey          key       = VirtualKey.None;
            VirtualKeyModifiers modifiers = VirtualKeyModifiers.None;

            base.OnKeyDown(pArgs);

            // Check if this keydown events comes from CalendarItem.
            m_wrKeyDownEventArgsFromCalendarItem.TryGetTarget(out spKeyDownArgsFromCalendarItem);

            if (spKeyDownArgsFromCalendarItem is null)
            {
                return;
            }

            if (spKeyDownArgsFromCalendarItem != pArgs)
            {
                m_wrKeyDownEventArgsFromCalendarItem.SetTarget(null);
                return;
            }

            // Ignore already handled events
            isHandled = pArgs.Handled;
            if (isHandled)
            {
                return;
            }

            modifiers = pArgs.KeyboardModifiers;
            key       = pArgs.Key;

            if (key == VirtualKey.GamepadLeftTrigger)
            {
                key = VirtualKey.PageUp;
            }

            if (key == VirtualKey.GamepadRightTrigger)
            {
                key = VirtualKey.PageDown;
            }

            // navigation keys without modifier . do keyboard navigation.
            if (modifiers == VirtualKeyModifiers.None)
            {
                switch (key)
                {
                case VirtualKey.Home:
                case VirtualKey.End:
                case VirtualKey.PageUp:
                case VirtualKey.PageDown:
                case VirtualKey.Left:
                case VirtualKey.Right:
                case VirtualKey.Up:
                case VirtualKey.Down:
                {
                    VirtualKey originalKey = VirtualKey.None;
                    originalKey = pArgs.OriginalKey;

                    handled = OnKeyboardNavigation(key, originalKey);
                    break;
                }

                default:
                    break;
                }
            }
            // Ctrl+Up/Down . switch display modes.
            else if (modifiers == VirtualKeyModifiers.Control)
            {
                switch (key)
                {
                case VirtualKey.Up:
                case VirtualKey.Down:
                {
                    CalendarViewDisplayMode mode = CalendarViewDisplayMode.Month;

                    mode = DisplayMode;

                    CalendarViewDisplayMode newMode = mode;
                    switch (mode)
                    {
                    case CalendarViewDisplayMode.Month:
                        if (key == VirtualKey.Up)
                        {
                            newMode = CalendarViewDisplayMode.Year;
                        }

                        break;

                    case CalendarViewDisplayMode.Year:
                        if (key == VirtualKey.Up)
                        {
                            newMode = CalendarViewDisplayMode.Decade;
                        }
                        else
                        {
                            newMode = CalendarViewDisplayMode.Month;
                        }

                        break;

                    case CalendarViewDisplayMode.Decade:
                        if (key == VirtualKey.Down)
                        {
                            newMode = CalendarViewDisplayMode.Year;
                        }

                        break;

                    default:
                        global::System.Diagnostics.Debug.Assert(false);
                        break;
                    }

                    if (newMode != mode)
                    {
                        handled = true;
                        // after display mode changed, we want the new item to be focused by keyboard.
                        m_focusItemAfterDisplayModeChanged  = true;
                        m_focusStateAfterDisplayModeChanged = FocusState.Keyboard;
                        DisplayMode = newMode;
                    }
                }
                break;

                default:
                    break;
                }
            }

            if (handled)
            {
                pArgs.Handled = true;
            }

            return;
        }