Exemplo n.º 1
0
        private IntPtr _Hook(int code, IntPtr wParam, IntPtr lParam)
        {
            if (code >= 0)
            {
                var kb = (NativeStructs.KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(NativeStructs.KBDLLHOOKSTRUCT));

                if (kb.flags == NativeEnums.KBDLLHOOKSTRUCTFlags.LLKHF_DOWN ||
                    kb.flags == NativeEnums.KBDLLHOOKSTRUCTFlags.LLKHF_ALTDOWN ||
                    kb.flags == NativeEnums.KBDLLHOOKSTRUCTFlags.LLKHF_EXTENDED)
                {
                    bool throwInput = false;
                    OnKeyDown?.Invoke(this, (Keys)kb.vkCode, ref throwInput);

                    if (throwInput)
                    {
                        //return new IntPtr(1);
                    }
                }
                else
                {
                    OnKeyUp?.Invoke(this, (Keys)kb.vkCode);
                }
            }

            return(NativeMethods.CallNextHookEx(mHookPtr, code, wParam, lParam));
        }
 public void handler(IHTMLEventObj e)
 {
     if (!OnKeyUp.IsNull())
     {
         OnKeyUp(this, new IControlHtmlKeyDownEventArgs(e, spanElement));
     }
 }
 private void InvokeEvents()
 {
     foreach (var key in Enum.GetValues(typeof(Keys)).Cast <Keys>())
     {
         if (IsKeyDown(key))
         {
             OnKeyDown?.Invoke(key);
             if (IsKeyPressed(key))
             {
                 OnKeyPressed?.Invoke(key);
             }
             if (IsKeyClicked(key))
             {
                 OnKeyClicked?.Invoke(key);
             }
         }
         else
         {
             OnKeyUp?.Invoke(key);
             if (IsKeyReleased(key))
             {
                 OnKeyReleased?.Invoke(key);
             }
         }
     }
 }
Exemplo n.º 4
0
        public override void OnInputEvent(DeviceInputEventArgs e)
        {
            if (e.DeviceType != Type)
            {
                return;
            }
            var inputEvent = e as KeyboardInputEventArgs;

            if (inputEvent.KeyboardEvent.KeyState == KeyState.Press)
            {
                if (!mThePressKeys.Contains(inputEvent.KeyboardEvent.KeyCode))
                {
                    mThePressKeys.Add(inputEvent.KeyboardEvent.KeyCode);
                    mKeysStateDic[inputEvent.KeyboardEvent.KeyCode] = KeyState.Press;
                    TriggerActionMapping((int)inputEvent.KeyboardEvent.KeyCode, KeyState.Press);
                    OnKeyDown?.Invoke(this, inputEvent.KeyboardEvent);
                }
            }
            else
            {
                mKeysStateDic[inputEvent.KeyboardEvent.KeyCode] = KeyState.Release;
                mThePressKeys.Remove(inputEvent.KeyboardEvent.KeyCode);
                PulseEndAxisMapping((int)inputEvent.KeyboardEvent.KeyCode);
                TriggerActionMapping((int)inputEvent.KeyboardEvent.KeyCode, KeyState.Release);
                OnKeyUp?.Invoke(this, inputEvent.KeyboardEvent);
            }
        }
Exemplo n.º 5
0
 public override void Tick()
 {
     for (int i = 0; i < mThePressKeys.Count; ++i)
     {
         //正常情况下用该用IsPlatformKeyDown 但是android的IsPlatformKeyDown 没有找到接口
         if (!IsKeyDown(mThePressKeys[i]))
         {
             mTheReleaseKeys.Add(mThePressKeys[i]);
         }
         //else
         //{
         //    PulseAxisMapping((int)mThePressKeys[i]);
         //}
     }
     for (int i = 0; i < mTheReleaseKeys.Count; ++i)
     {
         mThePressKeys.Remove(mTheReleaseKeys[i]);
         mKeysStateDic[mTheReleaseKeys[i]] = KeyState.Release;
         var keyEvent = new KeyboardEventArgs();
         keyEvent.KeyCode  = mTheReleaseKeys[i];
         keyEvent.KeyValue = (int)mTheReleaseKeys[i];
         keyEvent.KeyState = KeyState.Release;
         keyEvent.Alt      = IsPlatformKeyDown(Keys.Menu);
         keyEvent.Shift    = IsPlatformKeyDown(Keys.ShiftKey);
         keyEvent.Control  = IsPlatformKeyDown(Keys.ControlKey);
         //PulseEndAxisMapping((int)mTheReleaseKeys[i]);
         TriggerActionMapping((int)mTheReleaseKeys[i], KeyState.Release);
         OnKeyUp?.Invoke(this, keyEvent);
     }
     mTheReleaseKeys.Clear();
     PulseAxisMapping();
 }
Exemplo n.º 6
0
 static public void InvokeOnKeyUp(OpenTK.Input.KeyboardKeyEventArgs e)
 {
     if (OnKeyUp != null)
     {
         OnKeyUp.Invoke(null, e);
     }
 }
Exemplo n.º 7
0
        private void HookKeyboardCallback(HookData hookData)
        {
            KeyEventInformation info = KeyEventInformation.Get(hookData);

            Keys key = info.KeyCode |
                       (info.Control ? Keys.Control : Keys.None) |
                       (info.Shift ? Keys.Shift : Keys.None) |
                       (info.Alt ? Keys.Alt : Keys.None);


            if (info.IsKeyDown)
            {
                m_KeyState[info.KeyCode] = true;

                OnKeyCombo?.Invoke(key);

                OnKeyDown?.Invoke(key);

                m_KeyboardDownHandlers.TryInvoke(key);
            }

            if (info.IsKeyUp)
            {
                m_KeyState[info.KeyCode] = false;

                OnKeyUp?.Invoke(key);

                m_KeyboardUpHandlers.TryInvoke(key);
            }
        }
Exemplo n.º 8
0
        private void FireKeyboardEvents()
        {
            // Check through each key in the key list
            foreach (Keys key in KeyList)
            {
                // Is the key currently down?
                if (CurrentKeyboardState.IsKeyDown(key))
                {
                    // Fire the OnKeyDown event
                    OnKeyDown?.Invoke(this, new KeyboardEventArgs(key, CurrentKeyboardState, PrevKeyboardState));
                }

                // Has the key been released? (Was down and is now up)
                if (PrevKeyboardState.IsKeyDown(key) && CurrentKeyboardState.IsKeyUp(key))
                {
                    OnKeyUp?.Invoke(this, new KeyboardEventArgs(key, CurrentKeyboardState, PrevKeyboardState));
                }

                // Has the key been pressed? (Was up and is now down)
                if (PrevKeyboardState.IsKeyUp(key) && CurrentKeyboardState.IsKeyDown(key))
                {
                    OnKeyPressed?.Invoke(this, new KeyboardEventArgs(key, CurrentKeyboardState, PrevKeyboardState));
                }
            }
        }
Exemplo n.º 9
0
 // Update is called once per frame
 void Update()
 {
     if (Input.anyKey)
     {
         foreach (KeyCode keyCode in Enum.GetValues(typeof(KeyCode)))
         {
             if (Input.GetKey(keyCode))
             {
                 OnKey?.Invoke(keyCode);
                 break;
             }
         }
     }
     if (Input.anyKeyDown)
     {
         foreach (KeyCode keyCode in Enum.GetValues(typeof(KeyCode)))
         {
             if (Input.GetKey(keyCode))
             {
                 codes.Add(keyCode);
                 OnKeyDown?.Invoke(keyCode);
                 break;
             }
         }
     }
     foreach (KeyCode keyCode in codes)
     {
         if (Input.GetKeyUp(keyCode))
         {
             OnKeyUp?.Invoke(keyCode);
             break;
         }
     }
 }
Exemplo n.º 10
0
        private void Update()
        {
            if (!IsTracking)
            {
                return;
            }

            bool isKey     = Input.GetKey(key);
            bool isKeyDown = Input.GetKeyDown(key);
            bool isKeyUp   = Input.GetKeyUp(key);

            if (isKey)
            {
                OnKey?.Invoke();
            }

            if (isKeyDown)
            {
                OnKeyDown?.Invoke();
            }

            if (isKeyUp)
            {
                OnKeyUp?.Invoke();
            }
        }
Exemplo n.º 11
0
        /// <summary>
        /// keyhook callback happens.
        /// </summary>
        /// <param name="nCode">not sure</param>
        /// <param name="wParam">event</param>
        /// <param name="lParam">the key being pressed</param>
        /// <returns></returns>
        private IntPtr KbHookCallback(int nCode, IntPtr wParam, IntPtr lParam)
        {
            if (nCode < 0)
            {
                return(CallNextHookEx(_kbHookID, nCode, wParam, lParam));
            }

            int vkCode = Marshal.ReadInt32(lParam);

            switch ((int)wParam)
            {
            case WM_KEYDOWN:
            case WM_SYSKEYDOWN:
                if (!_currentlyPressed.Contains(vkCode))
                {
                    _currentlyPressed.Add(vkCode);
                    OnKeyDown?.Invoke(this, new KeyEventArgs(vkCode));
                }
                break;

            case WM_KEYUP:
            case WM_SYSKEYUP:
                if (_currentlyPressed.Contains(vkCode))
                {
                    _currentlyPressed.Remove(vkCode);
                }
                OnKeyUp?.Invoke(this, new KeyEventArgs(vkCode));
                break;
            }
            _hookTimeoutTimer.Stop();
            _hookTimeoutTimer.Start();

            return(CallNextHookEx(_kbHookID, nCode, wParam, lParam));
        }
Exemplo n.º 12
0
        public Window(WindowConfig config)
        {
            _config = config;

            var opts = WindowOptions.DefaultVulkan;

            opts.WindowBorder = WindowBorder.Resizable;
            opts.Size         = new Silk.NET.Maths.Vector2D <int>((int)config.Width, (int)config.Height);
            opts.Title        = config.Title;
            opts.WindowState  = config.Fullscreen ? WindowState.Fullscreen : WindowState.Normal;

            _window         = Silk.NET.Windowing.Window.Create(opts);
            _window.Render += (time) => DrawFrame?.Invoke(time);

            _window.Initialize();

            _input = _window.CreateInput();
            var primaryKeyboard = _input.Keyboards.FirstOrDefault();

            if (primaryKeyboard != null)
            {
                primaryKeyboard.KeyDown += (keyboard, key, code) => OnKeyDown?.Invoke(key);
                primaryKeyboard.KeyUp   += (keyboard, key, code) => OnKeyUp?.Invoke(key);
            }
            for (int i = 0; i < _input.Mice.Count; i++)
            {
                _input.Mice[i].Cursor.CursorMode = config.CursorDisabled ? CursorMode.Disabled : CursorMode.Normal;
                _input.Mice[i].MouseMove        += (mouse, pos) => OnCursorPosition?.Invoke(pos.X, pos.Y);
                _input.Mice[i].Scroll           += (mouse, wheel) => OnScroll?.Invoke(wheel.X, wheel.Y);
                _input.Mice[i].MouseDown        += (mouse, button) => OnMouseDown?.Invoke(button);
                _input.Mice[i].MouseUp          += (mouse, button) => OnMouseUp?.Invoke(button);
            }
        }
Exemplo n.º 13
0
        protected void InterceptKeyUp(KeyboardEventArgs obj)
        {
            if (Disabled || ReadOnly)
            {
                return;
            }
            switch (obj.Key)
            {
            case "ArrowUp":
                if (RuntimeLocation.IsServerSide)
                {
                    _elementReference?.ForceRender(forceTextUpdate: true);
                }
                break;

            case "ArrowDown":
                if (RuntimeLocation.IsServerSide)
                {
                    _elementReference?.ForceRender(forceTextUpdate: true);
                }
                break;
            }

            _keyDownPreventDefault = false;
            StateHasChanged();
            OnKeyUp.InvokeAsync(obj).AndForget();
        }
Exemplo n.º 14
0
 /// <summary>
 /// Occurs when a key is released.
 /// </summary>
 /// <param name="key">Key that was released</param>
 internal static void KeyUp(Key key)
 {
     while (Keys.Contains(key))  // Suboptimal
     {
         Keys.Remove(key);
     }
     OnKeyUp?.Invoke(key);
 }
Exemplo n.º 15
0
 private static void HandleKeyUp(RawKey key)
 {
     pressedKeys.Remove(key);
     if (OnKeyUp != null)
     {
         OnKeyUp.Invoke(key);
     }
 }
Exemplo n.º 16
0
        internal static void DWindowOnKeyUp(object sender, KeyboardKeyEventArgs e)
        {
            DKey       key       = (DKey)e.Key;
            DModifiers modifiers = new DModifiers(e.Shift, e.Control, e.Alt);

            rootCanvas.OnKeyUp(key, modifiers);
            OnKeyUp?.Invoke(key, modifiers);
        }
Exemplo n.º 17
0
 protected Task HandleKeyUp(KeyboardEventArgs obj)
 {
     if (Disabled || ReadOnly)
     {
         return(Task.CompletedTask);
     }
     OnKeyUp.InvokeAsync(obj).AndForget();
     return(Task.CompletedTask);
 }
Exemplo n.º 18
0
        public static void SetHook(OnKeyDown handleKeyDown, OnKeyUp handleKeyUp)
        {
            EventKeyDown = handleKeyDown;
            EventKeyUp   = handleKeyUp;

            IntPtr hInstance = LoadLibrary("User32");

            hhook = SetWindowsHookEx(WH_KEYBOARD_LL, _proc, hInstance, 0);
        }
Exemplo n.º 19
0
 /// <summary>
 /// Adds a handler for mouse button input.
 /// </summary>
 public static void AddInputHandler(
     DeviceType dt,
     MouseButton mouseButton,
     OnKeyDown onDown,
     OnKeyHeld onHeld,
     OnKeyUp onUp)
 {
     keyInfos.Add(new KeyInfo(dt, mouseButton, onDown, onHeld, onUp));
 }
Exemplo n.º 20
0
 /// <summary>
 /// Adds a handler for joystick axis input.
 /// </summary>
 public static void AddInputHandler(
     DeviceType dt,
     OVRGamepadController.Axis axis,
     OnKeyDown onDown,
     OnKeyHeld onHeld,
     OnKeyUp onUp)
 {
     keyInfos.Add(new KeyInfo(dt, axis, onDown, onHeld, onUp));
 }
Exemplo n.º 21
0
 /// <summary>
 ///  Adds a handler for key input
 /// </summary>
 public static void AddInputHandler(
     DeviceType dt,
     string keyName,
     OnKeyDown onDown,
     OnKeyHeld onHeld,
     OnKeyUp onUp)
 {
     keyInfos.Add(new KeyInfo(dt, keyName, onDown, onHeld, onUp));
 }
        internal void InitKeyboardHandlers()
        {
            _keyboardHandler = new KeyboardHandler();

            _keyboardHandler.OnKeyDown     += (key) => OnKeyDown?.Invoke(key);
            _keyboardHandler.OnKeyUp       += (key) => OnKeyUp?.Invoke(key);
            _keyboardHandler.OnKeyPressed  += (key) => OnKeyPressed?.Invoke(key);
            _keyboardHandler.OnKeyClicked  += (key) => OnKeyClicked?.Invoke(key);
            _keyboardHandler.OnKeyReleased += (key) => OnKeyReleased?.Invoke(key);
        }
Exemplo n.º 23
0
        internal override void GHook_KeyUp(object sender, KeyEventArgs e)
        {
            if (!Loaded)
            {
                return;
            }


            OnKeyUp?.Invoke(sender, e);
        }
Exemplo n.º 24
0
    //======================
    // AddInputHandler
    // Adds a hander for key input
    //======================
    public static void AddInputHandler(eDeviceType dt, string keyName,
                                       OnKeyDown onDown, OnKeyHeld onHeld, OnKeyUp onUp, int joystickNum = 0, bool exc = false)
    {
        KeyInfo k = new KeyInfo(dt, keyName, onDown, onHeld, onUp);

        k.WasDown   = Input.GetKey(keyName);
        k.exclusive = exc;

        InputMap[joystickNum].KeyInfos.Add(k);
    }
Exemplo n.º 25
0
        private void _inputListener_OnKeyUp(object sender, KeyboardEventArgs e)
        {
            if (_keyUpCommands.ContainsKey(e.Key))
            {
                _keyUpCommands[e.Key](e.GameTime);
            }

            // There is also a generic Key Up delegate mainly for detecting idleness
            OnKeyUp?.Invoke(sender, e);
        }
Exemplo n.º 26
0
    //======================
    // AddInputHandler
    // Adds a hander for mouse button input
    //======================
    public static void AddInputHandler(eDeviceType dt, eMouseButton mouseButton,
                                       OnKeyDown onDown, OnKeyHeld onHeld, OnKeyUp onUp, int joystickNum = 0, bool exc = false)
    {
        KeyInfo k = new KeyInfo(dt, mouseButton, onDown, onHeld, onUp);

        k.WasDown   = GetMouseButton(mouseButton);
        k.exclusive = exc;

        InputMap[joystickNum].KeyInfos.Add(k);
    }
Exemplo n.º 27
0
 private static unsafe void KeyCallback(WindowHandle *_, Keys key, int __, InputAction action, KeyModifiers ___)
 {
     if (action == InputAction.Press)
     {
         OnKeyDown?.Invoke(key);
     }
     else if (action == InputAction.Release)
     {
         OnKeyUp?.Invoke(key);
     }
 }
Exemplo n.º 28
0
        private IntPtr HookCallback(int nCode, WindowsMessages wParam, KBDLLHOOKSTRUCT lParam)
        {
            if (nCode >= 0 && wParam == WindowsMessages.WM_KEYDOWN || wParam == WindowsMessages.WM_SYSKEYDOWN)
            {
                OnKeyDown.Invoke(this, ((Keys)lParam.vkCode));
            }
            else if (nCode >= 0 && wParam == WindowsMessages.WM_KEYUP || wParam == WindowsMessages.WM_SYSKEYUP)
            {
                OnKeyUp.Invoke(this, ((Keys)lParam.vkCode));
            }

            return(User.CallNextHookEx(_hookID, nCode, wParam, lParam));
        }
Exemplo n.º 29
0
        public static void InvokeKeyUp(object args)
        {
            string[] a = args.ToString().Replace("[", null).Replace("]", null).Split(",");

            bool ctrl  = bool.Parse(a[1]);
            bool shift = bool.Parse(a[2]);
            bool alt   = bool.Parse(a[3]);

            ConsoleKey consoleKey = (ConsoleKey)Enum.Parse(typeof(ConsoleKey), a[0]);

            keyboardState = new BWHKeyboardState(consoleKey, ctrl, shift, alt, false);
            OnKeyUp?.Invoke(keyboardState);
        }
Exemplo n.º 30
0
        /// <summary>
        /// Overrides KeyUp event, if needed reset <see cref="_keyDownPreventDefault"/> set by <see cref="InterceptArrowKey(KeyboardEventArgs)"/>.
        /// </summary>
        protected void InterceptKeyUp(KeyboardEventArgs obj)
        {
            if (Disabled || ReadOnly)
            {
                return;
            }

            if (_keyDownPreventDefault != KeyDownPreventDefault)
            {
                _keyDownPreventDefault = KeyDownPreventDefault;
                StateHasChanged();
            }
            OnKeyUp.InvokeAsync(obj).AndForget();
        }
Exemplo n.º 31
0
				// key constructor
				public KeyInfo( eDeviceType inDeviceType, 
						string inKeyName, 
						OnKeyDown inDownHandler, 
						OnKeyHeld inHeldHandler, 
						OnKeyUp inUpHandler ) 
				{
					DeviceType = inDeviceType;
					KeyName = inKeyName;
					MouseButton = eMouseButton.None;
					JoystickButton = OVRGamepadController.Button.None;
					JoystickAxis = OVRGamepadController.Axis.None;
					Threshold = 1000.0f;
					WasDown = false;
					DownHandler = inDownHandler;
					HeldHandler = inHeldHandler;
					UpHandler = inUpHandler;
				}				
Exemplo n.º 32
0
	/// <summary>
	/// Adds a handler for mouse button input.
	/// </summary>
	public static void AddInputHandler(
			DeviceType dt,
		   	MouseButton mouseButton,
			OnKeyDown onDown,
			OnKeyHeld onHeld,
		   	OnKeyUp onUp)
	{
		keyInfos.Add(new KeyInfo(dt, mouseButton, onDown, onHeld, onUp));
	}
Exemplo n.º 33
0
	/// <summary>
	/// Adds a handler for joystick axis input.
	/// </summary>
	public static void AddInputHandler(
			DeviceType dt,
		   	OVRGamepadController.Axis axis,
			OnKeyDown onDown,
		   	OnKeyHeld onHeld,
		   	OnKeyUp onUp)
	{
		keyInfos.Add(new KeyInfo(dt, axis, onDown, onHeld, onUp));
	}
Exemplo n.º 34
0
	/// <summary>
	///  Adds a handler for key input
	/// </summary>
	public static void AddInputHandler(
			DeviceType dt,
			string keyName,
			OnKeyDown onDown,
			OnKeyHeld onHeld,
		   	OnKeyUp onUp)
	{
		keyInfos.Add(new KeyInfo(dt, keyName, onDown, onHeld, onUp));
	}
Exemplo n.º 35
0
		/// <summary>
		/// Joystick axis constructor.
		/// </summary>
		public KeyInfo(
				DeviceType inDeviceType,
				OVRGamepadController.Axis inJoystickAxis,
				OnKeyDown inDownHandler,
				OnKeyHeld inHeldHandler,
				OnKeyUp inUpHandler)
		{
			deviceType = inDeviceType;
			keyName = OVRGamepadController.AxisNames[(int)inJoystickAxis];
			mouseButton = MouseButton.None;
			joystickButton = OVRGamepadController.Button.None;
			joystickAxis = inJoystickAxis;
			threshold = 0.5f;
			wasDown = false;
			downHandler = inDownHandler;
			heldHandler = inHeldHandler;
			upHandler = inUpHandler;
		}
Exemplo n.º 36
0
		/// <summary>
		/// Mouse button constructor.
		/// </summary>
		public KeyInfo(
				DeviceType inDeviceType,
				MouseButton inMouseButton,
				OnKeyDown inDownHandler,
				OnKeyHeld inHeldHandler,
				OnKeyUp inUpHandler)
		{
			deviceType = inDeviceType;
			keyName = "Mouse Button " + (int)inMouseButton;
			mouseButton = inMouseButton;
			joystickButton = OVRGamepadController.Button.None;
			joystickAxis = OVRGamepadController.Axis.None;
			threshold = 1000.0f;
			wasDown = false;
			downHandler = inDownHandler;
			heldHandler = inHeldHandler;
			upHandler = inUpHandler;
		}
Exemplo n.º 37
0
    //======================
    // AddInputHandler
    // Adds a hander for joystick button input
    //======================
    public static void AddInputHandler( eDeviceType dt, OVRGamepadController.Button joystickButton,
			OnKeyDown onDown, OnKeyHeld onHeld, OnKeyUp onUp )
    {
        KeyInfos.Add( new KeyInfo( dt, joystickButton, onDown, onHeld, onUp ) );
    }
Exemplo n.º 38
0
        // joystick axis constructor
        public KeyInfo( eDeviceType inDeviceType, 
						OVRGamepadController.Axis inJoystickAxis,
						OnKeyDown inDownHandler, 
						OnKeyHeld inHeldHandler, 
						OnKeyUp inUpHandler )
        {
            DeviceType = inDeviceType;
                    KeyName = OVRGamepadController.AxisNames[(int)inJoystickAxis];
                    MouseButton = eMouseButton.None;
                    JoystickButton = OVRGamepadController.Button.None;
                    JoystickAxis = inJoystickAxis;
                    Threshold = 0.5f;
                    WasDown = false;
                    DownHandler = inDownHandler;
                    HeldHandler = inHeldHandler;
                    UpHandler = inUpHandler;
        }