Ejemplo n.º 1
0
 /// <summary>
 ///     Uses a multi-case delegate to invoke individual HotKeySets if the Key is in use by any HotKeySets.
 /// </summary>
 /// <param name="e"></param>
 internal void OnKey(KeyEventArgsExt e)
 {
     if (m_keyChain != null)
     {
         m_keyChain(e);
     }
 }
Ejemplo n.º 2
0
 public KeyHoldEventArgs(KeyInfo keyInfo, KeyEventArgsExt keyEventArgs, int timeKeyHolded, bool hasKeyBeenHolded)
 {
     KeyInfo            = keyInfo;
     this.KeyEventArgs  = keyEventArgs;
     this.TimeHoldedKey = timeKeyHolded;
     this.HasBeenHolded = hasKeyBeenHolded;
 }
Ejemplo n.º 3
0
            private KeyHoldEventArgs CreateKeyHoldEventArgs(KeyEventArgsExt e, KeyInfo keyInfo)
            {
                long handlerStop   = new DateTimeOffset(DateTime.Now).ToUnixTimeMilliseconds();
                int  timeKeyHolded = (int)(handlerStop - this.handlerStart);

                return(new KeyHoldEventArgs(keyInfo, e, timeKeyHolded, this.hasKeyBeenHolded));
            }
        private void InvokeKeyDown(KeyEventArgsExt e)
        {
            if (KeyDown == null) return;
              if (e.Handled) return;
              if (!e.IsKeyDown) return;

              KeyDown(this, e);
        }
Ejemplo n.º 5
0
        private KeyDownTxtEventArgs GetDownTxtEventArgs(KeyEventArgsExt eDownUp,
                                                        IEnumerable <KeyPressEventArgsExt> pressEventArgs)
        {
            var charsCollection = pressEventArgs.Where(e => !e.IsNonChar).Select(e => e.KeyChar);
            var chars           = string.Join(string.Empty, charsCollection);

            return(new KeyDownTxtEventArgs(eDownUp, chars));
        }
Ejemplo n.º 6
0
        /// <summary>
        /// This method processes the data from the hook and initiates event firing.
        /// </summary>
        /// <param name="wParam">The first Windows Messages parameter.</param>
        /// <param name="lParam">The second Windows Messages parameter.</param>
        /// <returns>
        /// True - The hook will be passed along to other applications.
        /// <para>
        /// False - The hook will not be given to other applications, effectively blocking input.
        /// </para>
        /// </returns>
        protected override bool ProcessCallback(int wParam, System.IntPtr lParam)
        {
            KeyEventArgsExt e = KeyEventArgsExt.FromRawData(wParam, lParam, IsGlobal);

            m_hksCollection.OnKey(e);

            //Can bypass the base by setting the 3 Invoke methods to protected, which will reduce having to create KeyEventArgsExt twice.
            return(base.ProcessCallback(wParam, lParam));
        }
Ejemplo n.º 7
0
 public void InvokeKeyUp(KeyEventArgsExt e)
 {
     var handler = KeyUp;
     if (handler == null || e.Handled || !e.IsKeyUp)
     {
         return;
     }
     handler(this, e);
 }
        private KeyInfo GetKeyInfo(KeyEventArgsExt e)
        {
            string key            = KeyboardInputUtils.GetCharsFromKeys(e.KeyData, (uint)e.ScanCode, e.Shift, e.Control, e.Alt, e.IsExtendedKey);
            bool   capslock       = this.isCapsLockOn();
            bool   isAlphaNumeric = KeyboardInputUtils.IsAlphaNumeric(key);
            bool   isWordChar     = KeyboardInputUtils.IsWordChar(key);

            return(new KeyInfo(e.KeyCode.ToString(), key, isAlphaNumeric, isWordChar, capslock));
        }
Ejemplo n.º 9
0
        // Token: 0x06000280 RID: 640 RVA: 0x0000E198 File Offset: 0x0000C398
        public void InvokeKeyUp(KeyEventArgsExt e)
        {
            KeyEventHandler keyUp = this.KeyUp;

            if (keyUp != null && !e.Handled && e.IsKeyUp)
            {
                keyUp(this, e);
                return;
            }
        }
Ejemplo n.º 10
0
        // Token: 0x0600027E RID: 638 RVA: 0x0000E138 File Offset: 0x0000C338
        public void InvokeKeyDown(KeyEventArgsExt e)
        {
            KeyEventHandler keyDown = this.KeyDown;

            if (keyDown != null && !e.Handled && e.IsKeyDown)
            {
                keyDown(this, e);
                return;
            }
        }
Ejemplo n.º 11
0
        public void InvokeKeyUp(KeyEventArgsExt e)
        {
            var handler = KeyUp;

            if (handler == null || e.Handled || !e.IsKeyUp)
            {
                return;
            }
            handler(this, e);
        }
Ejemplo n.º 12
0
        // Token: 0x06000281 RID: 641 RVA: 0x0000E1C8 File Offset: 0x0000C3C8
        protected override bool Callback(CallbackData data)
        {
            KeyEventArgsExt downUpEventArgs = this.GetDownUpEventArgs(data);
            IEnumerable <KeyPressEventArgsExt> pressEventArgs = this.GetPressEventArgs(data);

            this.InvokeKeyDown(downUpEventArgs);
            foreach (KeyPressEventArgsExt e in pressEventArgs)
            {
                this.InvokeKeyPress(e);
            }
            this.InvokeKeyUp(downUpEventArgs);
            return(!downUpEventArgs.Handled);
        }
Ejemplo n.º 13
0
        // Token: 0x0600022A RID: 554 RVA: 0x0000DE90 File Offset: 0x0000C090
        internal void OnKey(KeyEventArgsExt kex)
        {
            if (!this.Enabled)
            {
                return;
            }
            Keys primaryKey = this.GetPrimaryKey(kex.KeyCode);

            if (kex.IsKeyDown)
            {
                this.OnKeyDown(primaryKey);
                return;
            }
            this.OnKeyUp(primaryKey);
        }
Ejemplo n.º 14
0
        bool processKeyUp(KeyboardLowLevelHookStruct data)
        {
            data.scanCode &= 0xFF;
            if ((data.flags & 0x01) == 0x01)
            {
                data.scanCode |= 0x100;
            }
            KeyEventArgsExt    e      = new KeyEventArgsExt((System.Windows.Forms.Keys)data.vkCode, data.scanCode);
            KeyEventHandlerExt eKeyUp = this.GlobalKeyUp;

            if (eKeyUp != null)
            {
                eKeyUp(this, e);
            }
            return(e.Handled);
        }
Ejemplo n.º 15
0
        /// <summary>
        /// </summary>
        /// <param name="kex"></param>
        internal void OnKey(KeyEventArgsExt kex)
        {
            if (!Enabled)
            {
                return;
            }

            //Gets the primary key if mapped to a single key or gets the key itself
            var primaryKey = GetPrimaryKey(kex.KeyCode);

            if (kex.IsKeyDown)
            {
                OnKeyDown(primaryKey);
            }
            else //reset
            {
                OnKeyUp(primaryKey);
            }
        }
Ejemplo n.º 16
0
 protected void OnKeyUp(KeyEventArgsExt e) => KeyUp?.Invoke(this, e);
Ejemplo n.º 17
0
 protected void OnKeyDown(KeyEventArgsExt e) => KeyDown?.Invoke(this, e);
Ejemplo n.º 18
0
        public static bool isWinKeyPressed(this KeyEventArgsExt _)
        {
            KeyboardState keyboardState = KeyboardState.GetCurrent();

            return(keyboardState.IsDown(Keys.LWin) || keyboardState.IsDown(Keys.RWin));
        }
Ejemplo n.º 19
0
 protected override KeyEventArgsExt GetDownUpEventArgs(CallbackData data)
 {
     return(KeyEventArgsExt.FromRawDataGlobal(data));
 }
Ejemplo n.º 20
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="kex"></param>
        internal bool OnKey( KeyEventArgsExt kex )
        {
            if ( !Enabled )
                return true;

            //Gets the primary key if mapped to a single key or gets the key itself
            Keys primaryKey = GetPrimaryKey( kex.KeyCode );

            if ( kex.IsKeyDown )
                OnKeyDown( primaryKey );
            else //reset
                OnKeyUp( primaryKey );

            return HaveToHandle(kex);
        }
Ejemplo n.º 21
0
        public bool HaveToHandle(KeyEventArgsExt kex)
        {
            //Keys primaryKey = GetPrimaryKey(kex.KeyCode);

            if (kex.Modifiers != Keys.None)
                return !this.Equals(new HotKeySet(new Keys[] { kex.KeyData, (Keys)kex.KeyValue }));

            return !this.Equals(new HotKeySet(new Keys[] { (Keys)kex.KeyValue }));

            //return (m_hotkeystate.ContainsKey(kex.KeyValue) && !m_hotkeystate[kex.KeyValue]);
        }
Ejemplo n.º 22
0
 protected override IKeyEventArgs GetDownUpEventArgs(CallbackData data)
 {
     return(KeyEventArgsExt.FromRawDataApp(data));
 }
Ejemplo n.º 23
0
 public KeyboardKeyData(KeyEventArgsExt e)
 {
     Key = e.KeyCode;
 }
        private static IntPtr KeyboardHookProc2(int code, IntPtr wParam, IntPtr lParam)
        {
            bool handled = false;

//it was ok and someone listens to events

            if ((code >= 0) && (KeyDown != null || KeyUp != null || KeyPress != null))
            {
                //read structure KeyboardHookStruct at lParam

                KeyboardHookStruct MyKeyboardHookStruct =
                    (KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct));

                //raise KeyDown

                if (KeyDown != null && (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN))
                {
                    Keys keyData = (Keys)MyKeyboardHookStruct.vkCode;

                    //  System.Windows.Input.KeyEventArgs e =
                    //    new System.Windows.Input.KeyEventArgs(Keyboard.PrimaryDevice, Keyboard.PrimaryDevice.ActiveSource, 0, keyData);

                    bool isDownAlt   = wParam == WM_SYSKEYDOWN;
                    bool isDownShift = ((GetKeyState(VirtualKeyStates.VK_SHIFT) & 0x80) == 0x80 ? true : false);

                    bool isDownCapslock = (GetKeyState(VirtualKeyStates.VK_CAPITAL) != 0 ? true : false);

                    bool isDownControl = (GetKeyState(VirtualKeyStates.VK_CONTROL) != 0 ? true : false);

                    KeyEventArgsExt e = new KeyEventArgsExt(keyData, isDownAlt, isDownShift, isDownControl);

                    KeyDown(null, e);

                    handled = handled || e.Handled;
                }

                // raise KeyPress

                if (KeyPress != null && wParam == WM_KEYDOWN)
                {
                    bool isDownShift = ((GetKeyState(VirtualKeyStates.VK_SHIFT) & 0x80) == 0x80 ? true : false);

                    bool isDownCapslock = (GetKeyState(VirtualKeyStates.VK_CAPITAL) != 0 ? true : false);

                    byte[] keyState = new byte[256];

                    GetKeyboardState(keyState);

                    byte[] inBuffer = new byte[2];

                    if (ToAscii(MyKeyboardHookStruct.vkCode, MyKeyboardHookStruct.scanCode, keyState, inBuffer, MyKeyboardHookStruct.flags) == 1)
                    {
                        char key = (char)inBuffer[0];

                        if ((isDownCapslock ^ isDownShift) && Char.IsLetter(key))
                        {
                            key = Char.ToUpper(key);
                        }

                        KeyPressEventArgs e = new KeyPressEventArgs(key);

                        KeyPress(null, e);

                        handled = handled || e.Handled;
                    }
                }

                if (KeyUp != null && (wParam == WM_KEYUP || wParam == WM_SYSKEYUP))
                {
                    Keys keyData = (Keys)MyKeyboardHookStruct.vkCode;

                    KeyEventArgs e = new KeyEventArgs(keyData);

                    KeyUp(null, e);

                    handled = handled || e.Handled;
                }
            }

            //if event handled in application do not handoff to other listeners

            if (handled)
            {
                return((IntPtr)1);
            }


            return(CallNextHookEx(_hHook, code, wParam, lParam));
        }