Provides access to keyboard devices. Note: this API is not implemented yet.
示例#1
0
        /// <summary>
        ///     when the user press a key change value of display view
        /// </summary>
        private void UIElement_OnKeyDown(object sender, KeyEventArgs e)
        {
            if (!_glControl.Focused)
            {
                return;
            }
            var keyboardState = Keyboard.GetState();

            if (keyboardState.IsKeyDown(Key.Delete))
            {
                RotateX = 0;
                RotateY = 0;
                Zoom    = 100f;
            }
            else
            {
                if (keyboardState.IsKeyDown(Key.Up) || keyboardState.IsKeyDown(Key.W) ||
                    keyboardState.IsKeyDown(Key.Z))
                {
                    RotateX += 3;
                }
                if (keyboardState.IsKeyDown(Key.Left) || keyboardState.IsKeyDown(Key.A) ||
                    keyboardState.IsKeyDown(Key.Q))
                {
                    RotateY -= 3;
                }
                if (keyboardState.IsKeyDown(Key.Down) || keyboardState.IsKeyDown(Key.S))
                {
                    RotateX -= 3;
                }
                if (keyboardState.IsKeyDown(Key.Right) || keyboardState.IsKeyDown(Key.D))
                {
                    RotateY += 3;
                }
                if (keyboardState.IsKeyDown(Key.PageUp))
                {
                    ChangeZoom(1);
                }
                if (keyboardState.IsKeyDown(Key.PageDown))
                {
                    ChangeZoom(-1);
                }
            }
        }
示例#2
0
        static EntryField()
        {
            TKKeys    = Enum.GetValues(typeof(TKKey)).Cast <TKKey>().ToList();
            TKButtons = Enum.GetValues(typeof(XInputGamePadButton)).Cast <XInputGamePadButton>().ToList();

            TKKeysHeld    = new HashSet <TKKey>();
            TKButtonsHeld = TKButtons.ToDictionary(b => b, b => false);

            TKButtonsInitialState = new Dictionary <int, Dictionary <XInputGamePadButton, bool?> >();

            var inputPoll = new Timer(50);

            inputPoll.Elapsed += (sender, args) =>
            {
                var inputPressed = false;

                try
                {
                    var keyState = TKKeyboard.GetState();
                    if (keyState.IsConnected)
                    {
                        foreach (var key in TKKeys)
                        {
                            if (keyState.IsKeyDown(key))
                            {
                                if (!TKKeysHeld.Contains(key))
                                {
                                    OnTKKeyPress(key);
                                }
                                TKKeysHeld.Add(key);
                                inputPressed = true;
                            }
                            else
                            {
                                TKKeysHeld.Remove(key);
                            }
                        }
                    }
                }
                catch { }

                if (CreateController())
                {
                    var buttons = CaptureControllerInput();
                    if (DXButtonInitialState == null)
                    {
                        DXButtonInitialState = buttons.Cast <bool?>().ToArray();
                    }

                    for (int i = 0; buttons != null && i < buttons.Length; i++)
                    {
                        if (buttons[i] != DXButtonInitialState[i])
                        {
                            DXButtonInitialState[i] = null;
                        }

                        if (DXButtonInitialState[i] == null)
                        {
                            if (buttons[i])
                            {
                                if (!DXButtonsHeld[i])
                                {
                                    OnButtonPress(i);
                                }
                                DXButtonsHeld[i] = true;
                                inputPressed     = true;
                            }
                            else
                            {
                                DXButtonsHeld[i] = false;
                            }
                        }
                    }
                }

                for (int i = 0; i <= 3; i++)
                {
                    var isFirstRun = TKButtonsInitialState.Count <= i || TKButtonsInitialState[i] == null;
                    if (isFirstRun)
                    {
                        TKButtonsInitialState[i] = new Dictionary <XInputGamePadButton, bool?>();
                    }

                    var initialState = TKButtonsInitialState[i];

                    try
                    {
                        var gamePadState = GamePad.GetState(i);

                        if (gamePadState.IsConnected)
                        {
                            foreach (var button in TKButtons)
                            {
                                var buttonIsPressed = gamePadState.IsPressed(button);

                                if (isFirstRun)
                                {
                                    initialState.TryGetValue(button, out var state);
                                    initialState[button] = (state ?? false) || buttonIsPressed;
                                    continue;
                                }

                                if (initialState[button] != null &&
                                    initialState[button] != buttonIsPressed)
                                {
                                    initialState[button] = null;
                                }

                                if (initialState[button] == null)
                                {
                                    if (buttonIsPressed)
                                    {
                                        if (!TKButtonsHeld[button])
                                        {
                                            OnTKButtonPress(button);
                                        }
                                        TKButtonsHeld[button] = true;
                                        inputPressed          = true;
                                    }
                                    else
                                    {
                                        TKButtonsHeld[button] = false;
                                    }
                                }
                            }
                        }
                    }
                    catch
                    {
                        TKButtonsInitialState[i] = null;
                    }
                }

                if (!inputPressed && FieldSet)
                {
                    InputComplete();
                }

                inputPoll.Start();
            };
            inputPoll.AutoReset = false;
            inputPoll.Start();

            Application.Current.Exit += (sender, args) =>
            {
                DXJoystick?.Dispose();
                DirectInput?.Dispose();
                inputPoll.Close();
            };
        }