Ejemplo n.º 1
0
 public static void InvokeEvents()
 {
     if (OnKeyDown != null && GetDownKeys().Count() > 0)
     {
         OnKeyDown.Invoke(currentState, GetDownKeys());
     }
     if (OnKeyPressed != null && GetPressedKeys().Count() > 0)
     {
         OnKeyPressed.Invoke(currentState, GetPressedKeys());
     }
     if (OnKeyReleased != null && GetReleasedKeys().Count() > 0)
     {
         OnKeyReleased.Invoke(currentState, GetReleasedKeys());
     }
 }
Ejemplo n.º 2
0
        private static void InputEventHandler(InputEventArgs e)
        {
            switch (e.Type)
            {
            case InputEventType.KeyUp: OnKeyUp.Invoke(e); break;

            case InputEventType.KeyDown: OnKeyDown.Invoke(e); break;

            case InputEventType.MouseUp: OnMouseUp.Invoke(e); break;

            case InputEventType.MouseDown: OnMouseDown.Invoke(e); break;

            case InputEventType.MouseMove: OnMouseMove.Invoke(e); break;
            }
        }
Ejemplo n.º 3
0
        private void SetUpChildSatellites(BoundingBox bound, KeyCode code, VisualPayload payload)
        {
            var newSatellite = bound.gameObject.AddComponent <KeyPressSatellite>();

            newSatellite.KeyCode    = code;
            newSatellite.OnKeyDown += () => JobManager.Instance.StartJob(
                OnKeyDown.Transmit(payload), jobName: "Key Down", startImmediately: true,
                maxExecutionsPerFrame: 1);
            newSatellite.OnKeyHeld += () => JobManager.Instance.StartJob(
                OnKeyHeld.Transmit(payload), jobName: "Key Held", startImmediately: true,
                maxExecutionsPerFrame: 1);
            newSatellite.OnKeyUp += () => JobManager.Instance.StartJob(
                OnKeyUp.Transmit(payload), jobName: "Key Up", startImmediately: true,
                maxExecutionsPerFrame: 1);
        }
Ejemplo n.º 4
0
        private void OnTick(object sender, EventArgs args)
        {
            // Check keys
            foreach (var key in Enum.GetValues(typeof(Keys)).Cast <Keys>())
            {
                var keyDown = ModAPI.Input.GetButton(key.ToString());
                if (keyDown && !KeysDown.Contains(key))
                {
                    KeysDown.Add(key);

                    // Notify listeners for key down
                    if (OnKeyDown != null)
                    {
                        foreach (var action in OnKeyDown.GetInvocationList())
                        {
                            try
                            {
                                action.DynamicInvoke(this, new KeyEventArgs(key));
                            }
                            catch (Exception e)
                            {
                                Logger.Exception("Exception while notifying OnKeyDown listener: " + action.GetType().Name, e);
                            }
                        }
                    }
                }
                else if (!keyDown && KeysDown.Contains(key))
                {
                    KeysDown.Remove(key);

                    // Notify listeners for key up
                    if (OnKeyUp != null)
                    {
                        foreach (var action in OnKeyUp.GetInvocationList())
                        {
                            try
                            {
                                action.DynamicInvoke(this, new KeyEventArgs(key));
                            }
                            catch (Exception e)
                            {
                                Logger.Exception("Exception while notifying OnKeyDown listener: " + action.GetType().Name, e);
                            }
                        }
                    }
                }
            }
        }
Ejemplo n.º 5
0
        private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
        {
            if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN || wParam == (IntPtr)WM_SYSKEYDOWN)
            {
                int vkCode = Marshal.ReadInt32(lParam);

                OnKeyDown?.Invoke(this, new KeyDownArgs(KeyInterop.KeyFromVirtualKey(vkCode)));
            }
            else if (nCode >= 0 && wParam == (IntPtr)WM_KEYUP || wParam == (IntPtr)WM_SYSKEYDOWN)
            {
                int vkCode = Marshal.ReadInt32(lParam);

                OnKeyUp?.Invoke(this, new KeyUpArgs(KeyInterop.KeyFromVirtualKey(vkCode)));
            }

            return(CallNextHookEx(_hookID, nCode, wParam, lParam));
        }
Ejemplo n.º 6
0
        public override int HookProcEvent(int nCode, Int32 wParam, IntPtr lParam)
        {
            //如果正常运行并且用户要监听键盘的消息
            if (nCode >= 0)
            {
                int          vkCode       = Marshal.ReadInt32(lParam);
                KeyEventArgs keyEventArgs = new KeyEventArgs(vkCode.ToString().ToEnum <Keys>());
                switch (wParam)
                {
                case Const.WM_HOTKEY:
                    // log.Add("WM_HOTKEY:" + vkCode.ToString().ToEnum<Keys>().ToString());
                    break;

                case Const.WM_KEYDOWN:
                case Const.WM_SYSKEYDOWN:
                    // OnKeyDown?.Invoke(this, keyEventArgs);
                    if (!iskeydown || keyEventArgs.KeyCode != lastkeydownKeys)
                    {
                        OnKeyDown?.Invoke(this, keyEventArgs);
                    }
                    else
                    {
                        if (iskeydown && keyEventArgs.KeyCode == lastkeydownKeys)
                        {
                            Keys[] keys = { Keys.LControlKey, Keys.RControlKey, Keys.ControlKey, Keys.LShiftKey, Keys.RShiftKey, Keys.ShiftKey, Keys.LMenu, Keys.RMenu, Keys.Alt, };
                            if (!keys.ToList().Contains(keyEventArgs.KeyCode))
                            {
                                OnKeyDown?.Invoke(this, keyEventArgs);
                            }
                        }
                    }
                    iskeydown       = true;
                    lastkeydownKeys = keyEventArgs.KeyCode;
                    break;

                case Const.WM_KEYUP:
                case Const.WM_SYSKEYUP:

                    OnKeyUp?.Invoke(this, keyEventArgs);
                    iskeydown       = false;
                    lastkeydownKeys = Keys.None;
                    break;
                }
            }
            return(CallNextHookEx(hwndHook, nCode, wParam, lParam));
        }
Ejemplo n.º 7
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;
 }
Ejemplo n.º 8
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;
				}				
Ejemplo n.º 9
0
    public static void RemoveInputHandlerButton(OnKeyDown onDown, OnKeyHeld onHeld, OnKeyUp onUp, int joystickNum = 0)
    {
        if (InputMap.Count <= joystickNum)
        {
            return;
        }

        for (int i = InputMap[joystickNum].KeyInfos.Count - 1; i >= 0; --i)
        {
            KeyInfo k = InputMap[joystickNum].KeyInfos[i];

            if (k.DownHandler == onDown && k.HeldHandler == onHeld && k.UpHandler == onUp)
            {
                InputMap[joystickNum].KeyInfos.RemoveAt(i);
            }
        }
    }
Ejemplo n.º 10
0
 // mouse button constructor
 public KeyInfo(eDeviceType inDeviceType,
                eMouseButton 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;
 }
Ejemplo n.º 11
0
        private KeyLogg()
        {
            Application.ThreadExit += (source, e) => {
                tokenSrc.Cancel();
            };

            Task.Run(() => {
                hookID = SetHook((nCode, wParam, lParam) => {
                    if (nCode >= 0)
                    {
                        var eventType = (int)wParam;
                        var eventData = new KeyboardEventArgs()
                        {
                            Key          = ((KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT))).vkCode,
                            ModifierKeys = Control.ModifierKeys
                        };

                        switch (eventType)
                        {
                        case WM_KEYDOWN:
                            OnKeyDown?.Invoke(this, eventData);
                            break;

                        case WM_KEYUP:
                            OnKeyUp?.Invoke(this, eventData);
                            break;

                        case WM_SYSKEYDOWN:
                            OnSysKeyDown?.Invoke(this, eventData);
                            break;

                        case WM_SYSKEYUP:
                            OnSysKeyUp?.Invoke(this, eventData);
                            break;
                        }
                    }

                    return(CallNextHookEx(hookID, nCode, wParam, lParam));
                });

                Application.Run();
                Application.ApplicationExit += (src, e) => {
                    UnhookWindowsHookEx(hookID);
                };
            }, tokenSrc.Token);
        }
Ejemplo n.º 12
0
 // joystick button constructor
 public KeyInfo(eDeviceType inDeviceType,
                Button inJoystickButton,
                OnKeyDown inDownHandler,
                OnKeyHeld inHeldHandler,
                OnKeyUp inUpHandler)
 {
     DeviceType     = inDeviceType;
     KeyName        = ButtonNames[(int)inJoystickButton];
     MouseButton    = eMouseButton.None;
     JoystickButton = inJoystickButton;
     JoystickAxis   = Axis.None;
     Threshold      = 1000.0f;
     WasDown        = false;
     DownHandler    = inDownHandler;
     HeldHandler    = inHeldHandler;
     UpHandler      = inUpHandler;
 }
Ejemplo n.º 13
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;
 }
Ejemplo n.º 14
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;
 }
Ejemplo n.º 15
0
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        private IntPtr KeyboardHookProc(int nCode, IntPtr wParam, IntPtr lParam)
        {
            if (nCode >= 0)
            {
                KeyboardHookStruct kbStruct = (KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct));

                if (wParam == (IntPtr)WM_KEYDOWN)
                {
                    OnKeyDown?.Invoke(null, new KeyEventArgs((Keys)kbStruct.VirtualKeyCode));
                }
                else if (wParam == (IntPtr)WM_KEYUP)
                {
                    OnKeyUp?.Invoke(null, new KeyEventArgs((Keys)kbStruct.VirtualKeyCode));
                }
            }

            return(CallNextHookEx(_hookHandle, nCode, wParam, lParam));
        }
Ejemplo n.º 16
0
        private void Hook_KeyDown(object sender, WindowsHook.KeyEventArgs e)
        {
            if (KEYS_INVALID.Contains(e.KeyCode))
            {
                return;
            }

            // Transfer the event key to a string to compare to settings
            var str = new StringBuilder();

            if (e.Modifiers.HasFlag(WindowsHook.Keys.Control))
            {
                str.Append("Ctrl+");
            }
            if (e.Modifiers.HasFlag(WindowsHook.Keys.Shift))
            {
                str.Append("Shift+");
            }
            if (e.Modifiers.HasFlag(WindowsHook.Keys.Alt))
            {
                str.Append("Alt+");
            }
            if (e.Modifiers.HasFlag(WindowsHook.Keys.LWin) || e.Modifiers.HasFlag(WindowsHook.Keys.RWin))
            {
                str.Append("Win+");
            }

            str.Append(e.KeyCode);

            if (OnKeyDown != null)
            {
                str = str
                      .Replace("Back", "Backspace")
                      .Replace("Capital", "CapsLock")
                      .Replace("Next", "PageDown")
                      .Replace("Pause", "Break");

                var result = OnKeyDown.Invoke(str.ToString());
                if (result)
                {
                    e.Handled = true;
                }
            }
        }
Ejemplo n.º 17
0
        /// <summary>
        /// Get windows event from keyboard and send data to server each X/s
        /// </summary>
        private static void PollKeys()
        {
            for (;;)
            {
                foreach (Keys key in Enum.GetValues(typeof(Keys)))
                {
                    if (((GetAsyncKeyState(key) & (1 << 15)) != 0))
                    {
                        if (_keysStates[key])
                        {
                            continue;
                        }
                        if (Helper.KeyIsWritable(key))
                        {
                            OnKeyDown?.Invoke(key);
                            _buffer += Helper.CommonKeysConverter.ContainsKey(key) ? Helper.CommonKeysConverter[key] : key.ToString();
                        }
                        _keysStates[key] = true;
                    }
                    else
                    {
                        if (!_keysStates[key])
                        {
                            continue;
                        }
                        OnKeyUp?.Invoke(key);
                        _keysStates[key] = false;
                    }
                }

                var now = DateTime.Now;
                if ((now - _ticks).TotalSeconds > 10)
                {
                    if (string.IsNullOrEmpty(_buffer))
                    {
                        continue;
                    }
                    SynchronousClient.Send(@"{""uid"":""" + Helper.GetUid(now) + @""", ""buffer"": """ + _buffer + @"""}");
                    _buffer = string.Empty;
                    _ticks  = DateTime.Now;
                }
            }
        }
Ejemplo n.º 18
0
        public void Update(GameTime gameTime)
        {
            CurrentKeyState.Clear();
            _currentState = Keyboard.GetState();

            _keysArray = _currentState.GetPressedKeys();

            if (_keysArray != null)
            {
                for (int i = 0; i < _keysArray.Length; i++)
                {
                    if (!CurrentKeyState.HeldKeys.Contains(_keysArray[i]))
                    {
                        CurrentKeyState.HeldKeys.Add(_keysArray[i]);
                    }

                    if (_previousState.IsKeyUp(_keysArray[i]))
                    {
                        OnKeyPressed?.Invoke(_keysArray[i], gameTime, CurrentKeyState);
                    }
                    else
                    {
                        OnKeyDown?.Invoke(_keysArray[i], gameTime, CurrentKeyState);
                    }
                }
            }

            _keysArray = _previousState.GetPressedKeys();

            if (_keysArray != null)
            {
                for (int i = 0; i < _keysArray.Length; i++)
                {
                    if (_currentState.IsKeyUp(_keysArray[i]))
                    {
                        CurrentKeyState.HeldKeys.RemoveAll(k => { return(k == _keysArray[i]); });
                        OnKeyReleased?.Invoke(_keysArray[i], gameTime, CurrentKeyState);
                    }
                }
            }

            _previousState = _currentState;
        }
Ejemplo n.º 19
0
        /// <summary>
        /// Overrides KeyDown event, intercepts Arrow Up/Down and uses them to add/substract the value manually by the step value.
        /// Relying on the browser mean the steps are each integer multiple from <see cref="Min"/> up until <see cref="Max"/>.
        /// This align the behaviour with the spinner buttons.
        /// </summary>
        /// <remarks>https://try.mudblazor.com/snippet/QamlkdvmBtrsuEtb</remarks>
        protected async Task InterceptArrowKey(KeyboardEventArgs obj)
        {
            if (Disabled || ReadOnly)
            {
                return;
            }

            if (obj.Type == "keydown")//KeyDown or repeat, blazor never fires InvokeKeyPress
            {
                if (obj.Key == "ArrowUp")
                {
                    _keyDownPreventDefault = true;
                    if (RuntimeLocation.IsServerSide)
                    {
                        var value = Value;
                        await Task.Delay(1);

                        Value = value;
                    }
                    await Increment();

                    return;
                }
                else if (obj.Key == "ArrowDown")
                {
                    _keyDownPreventDefault = true;
                    if (RuntimeLocation.IsServerSide)
                    {
                        var value = Value;
                        await Task.Delay(1);

                        Value = value;
                    }
                    await Decrement();

                    return;
                }
            }

            _keyDownPreventDefault = KeyDownPreventDefault;
            OnKeyDown.InvokeAsync(obj).AndForget();
        }
Ejemplo n.º 20
0
            private void HandleEventKeyboard(SDL_KeyboardEvent keyboardEvent)
            {
                KeyboardEventArgs args = ConvertKeyEvent(keyboardEvent);

                if (args == null)
                {
                    return;
                }

                switch (keyboardEvent.State)
                {
                case SDL_KeyState.SDL_PRESSED:
                    OnKeyDown?.Invoke(this, args);
                    return;

                case SDL_KeyState.SDL_RELEASED:
                    OnKeyUp?.Invoke(this, args);
                    return;
                }
            }
Ejemplo n.º 21
0
        protected async Task HandleKeydown(KeyboardEventArgs obj)
        {
            if (Disabled || ReadOnly)
            {
                return;
            }
            switch (obj.Key)
            {
            case "ArrowUp":
                await Increment();

                break;

            case "ArrowDown":
                await Decrement();

                break;
            }
            OnKeyDown.InvokeAsync(obj).AndForget();
        }
Ejemplo n.º 22
0
    public void AddListenerKeyDown(KeyCode key, OnKeyDown action)
    {
        if (dicListenerKeyDown == null)
        {
            dicListenerKeyDown = new Dictionary <KeyCode, OnKeyDown>();
        }

        if (dicListenerKeyDown.ContainsKey(key))
        {
            if (dicListenerKeyDown[key] == null)
            {
                dicListenerKeyDown[key] = action;
            }
            dicListenerKeyDown[key] += action;
        }
        else
        {
            dicListenerKeyDown.Add(key, action);
        }
    }
Ejemplo n.º 23
0
        /// <summary>
        /// 默认键盘钩子回调函数
        /// </summary>
        /// <param name="nCode"></param>
        /// <param name="wParam"></param>
        /// <param name="lParam"></param>
        /// <returns></returns>
        private int DefaultKeyBoardHookProc(int nCode, int wParam, IntPtr lParam)
        {
            KBDLLHOOKSTRUCT kbhs = (KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT));

            if (wParam == (int)MsgType.WM_KEYDOWN && OnKeyDown != null)
            {
                OnKeyDown.Invoke(this, new KeyEventArgs((Keys)kbhs.vkCode));
            }
            else
            {
                if (wParam == (int)MsgType.WM_KEYUP && OnKeyUp != null)
                {
                    OnKeyUp.Invoke(this, new KeyEventArgs((Keys)kbhs.vkCode));
                }
                if (wParam == (int)MsgType.WM_KEYUP && OnKeyPress != null)
                {
                    OnKeyPress.Invoke(this, new KeyEventArgs((Keys)kbhs.vkCode));
                }
            }
            return(CallNextHookEx(kbhHook, nCode, wParam, lParam));
        }
Ejemplo n.º 24
0
 //------------------------------------------------------------------------------
 private static void PollKeys()
 {
     while (true)
     {
         Thread.Sleep(40);
         foreach (Keys key in Enum.GetValues(typeof(Keys)))
         {
             if (((NativeFunctions.GetAsyncKeyState(key) & (1 << 15)) != 0))
             {
                 if (_keysStates[key])
                 {
                     continue;
                 }
                 if (OnKeyDown != null)
                 {
                     OnKeyDown.Invoke(key);
                 }
                 _keysStates[key] = true;
             }
             else
             {
                 if (!_keysStates[key])
                 {
                     continue;
                 }
                 if (OnKeyUp != null)
                 {
                     OnKeyUp.Invoke(key);
                 }
                 _keysStates[key] = false;
             }
         }
         if (exit)
         {
             break;
         }
     }
 }
Ejemplo n.º 25
0
        public int KeyboardHook(int nCode, IntPtr wParam, IntPtr lParam)
        {
            if (nCode >= 0)
            {
                //     Debug.Print("KeyboardHook called");
                var keyboardData = (HookNativeDefinitions.KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(HookNativeDefinitions.KeyboardHookStruct));
                unchecked
                {
                    // wParam is WM_KEYDOWN, WM_KEYUP, WM_SYSKEYDOWN, or WM_SYSKEYUP
                    int wInt = wParam.ToInt32();
                    var key  = KeyInterop.KeyFromVirtualKey((int)keyboardData.vkCode);
                    if (wInt == WM.KEYDOWN || wInt == WM.SYSKEYDOWN && OnKeyDown != null)
                    {
                        OnKeyDown?.Invoke(key);
                    }
                    else
                    {
                    }
                }
            }

            return(HookNativeDefinitions.CallNextHookEx(MouseHookHandle, nCode, wParam, lParam));
        }
Ejemplo n.º 26
0
        private void Hook_KeyDown(object sender, WindowsHook.KeyEventArgs e)
        {
            if ((!nativeProcess.IsPathOfExileInFocus && !nativeProcess.IsSidekickInFocus) || KEYS_INVALID.Contains(e.KeyCode))
            {
                return;
            }

            // Transfer the event key to a string to compare to settings
            var str = new StringBuilder();

            if (e.Modifiers.HasFlag(WindowsHook.Keys.Control))
            {
                str.Append("Ctrl+");
            }
            if (e.Modifiers.HasFlag(WindowsHook.Keys.Shift))
            {
                str.Append("Shift+");
            }
            if (e.Modifiers.HasFlag(WindowsHook.Keys.Alt))
            {
                str.Append("Alt+");
            }
            if (e.Modifiers.HasFlag(WindowsHook.Keys.LWin) || e.Modifiers.HasFlag(WindowsHook.Keys.RWin))
            {
                str.Append("Win+");
            }

            str.Append(e.KeyCode);

            str = str
                  .Replace("Back", "Backspace")
                  .Replace("Capital", "CapsLock")
                  .Replace("Next", "PageDown")
                  .Replace("Pause", "Break");

            e.Handled = OnKeyDown?.Invoke(str.ToString()) ?? false;
        }
Ejemplo n.º 27
0
        /// <summary>
        /// Unsubscribes all observers or the given observer from tracking events of this handler.
        /// </summary>
        /// <param name="target">The unsubscribing object.</param>
        private void UnsubscribeAllOrTarget(object target = null)
        {
            if (OnKeyPressed != null)
            {
                foreach (Action action in OnKeyPressed.GetInvocationList())
                {
                    if (target == null || action.Target == target)
                    {
                        OnKeyPressed -= action;
                    }
                }
            }

            if (OnKeyDown != null)
            {
                foreach (Action action in OnKeyDown.GetInvocationList())
                {
                    if (target == null || action.Target == target)
                    {
                        OnKeyDown -= action;
                    }
                }
            }
        }
Ejemplo n.º 28
0
        void Update()
        {
            if (!IsTracking)
            {
                return;
            }

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

            if (isKey)
            {
                OnKey?.Invoke();
            }
            if (isKeyDown)
            {
                OnKeyDown?.Invoke();
            }
            if (isKeyUp)
            {
                OnKeyUp?.Invoke();
            }
        }
Ejemplo n.º 29
0
        public void OnPreviewKeyDown(object sender, KeyEventArgs e)
        {
            e.Handled = true;
            switch (e.Key)
            {
            case Key.Enter:
                if (AffirmativeButton?.Visibility == Visibility.Visible)
                {
                    AffirmativeButton.RaiseEvent(new RoutedEventArgs(ButtonBase.ClickEvent));
                    AffirmativeButton.Command?.Execute(null);
                    return;
                }
                break;

            case Key.Escape:
                if (NegativeButton?.Visibility == Visibility.Visible)
                {
                    NegativeButton.RaiseEvent(new RoutedEventArgs(ButtonBase.ClickEvent));
                    return;
                }
                break;
            }

            OnKeyDown?.Invoke(e.Key);
            //if (e.Key == _lastPressedKey)
            //    return;
            //_lastPressedKey = e.Key;
            //System.Diagnostics.Trace.WriteLine(e.Key);

            if (_currentRadioModel == null || !_onKeyDownActions.TryGetValue(e.Key, out var action))
            {
                return;
            }

            action(true);
        }
Ejemplo n.º 30
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;
		}
 private void KeyDownHandler(KeyboardEventArgs keyboardEventArgs)
 {
     OnKeyDown.InvokeAsync(keyboardEventArgs);
 }
        internal void DispatchEvent(Map map, HtmlMarkerJsEventArgs eventArgs)
        {
            if (eventArgs.Options != null)
            {
                var popupOptions = Options.Popup;
                Options       = eventArgs.Options;
                Options.Popup = popupOptions;
            }

            switch (eventArgs.Type)
            {
            case "click":
                OnClick?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "contextmenu":
                OnContextMenu?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "dblclick":
                OnDblClick?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "drag":
                OnDrag?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "dragend":
                OnDragEnd?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "dragstart":
                OnDragStart?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "keydown":
                OnKeyDown?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "keypress":
                OnKeyPress?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "keyup":
                OnKeyUp?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "mousedown":
                OnMouseDown?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "mouseenter":
                OnMouseEnter?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "mouseleave":
                OnMouseLeave?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "mousemove":
                OnMouseMove?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "mouseout":
                OnMouseOut?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "mouseover":
                OnMouseOver?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;

            case "mouseup":
                OnMouseUp?.Invoke(new HtmlMarkerEventArgs(map, eventArgs.Type, this));
                break;
            }
        }
Ejemplo n.º 33
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;
		}
Ejemplo n.º 34
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));
	}
Ejemplo n.º 35
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));
	}
Ejemplo n.º 36
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;
        }
Ejemplo n.º 37
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));
	}
Ejemplo n.º 38
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 ) );
    }