コード例 #1
0
        public static void AsyncHoldKey(VirtualKeyCode keycode)
        {
            if (InputSimulator.asyncHoldThread == null || !InputSimulator.asyncHoldThread.IsAlive)
            {
                InputSimulator.asyncHoldThread = new System.Threading.Thread( new System.Threading.ThreadStart(() =>
                {
                    while (InputSimulator.currentAsyncHoldKeys.Count > 0)
                    {
                        lock (InputSimulator.currentAsyncHoldKeys)
                        {
                            foreach (VirtualKeyCode iter in InputSimulator.currentAsyncHoldKeys)
                            {
                                Console.WriteLine(iter);
                                WindowsInput.InputSimulator.SimulateKeyDown(iter);
                            }
                        }
                        System.Threading.Thread.Sleep(10);
                    }
                }));
                InputSimulator.asyncHoldThread.IsBackground = true;
                InputSimulator.asyncHoldThread.Start();
            }

            currentAsyncHoldKeys.Add(keycode);
        }
コード例 #2
0
ファイル: BotCommon.cs プロジェクト: plewt/mu97bot
 public static void DoKeyPress(VirtualKeyCode aKey)
 {
     InputSimulator.SimulateKeyDown(aKey);
     Thread.Sleep(200);
     InputSimulator.SimulateKeyUp(aKey);
     Thread.Sleep(200);
 }
コード例 #3
0
ファイル: GameAction.cs プロジェクト: cignoir/KinecTh
 public static void UpKey(VirtualKeyCode keyCode)
 {
     if (Status.isKeyEnabled && InputSimulator.IsKeyDown(keyCode))
     {
         InputSimulator.SimulateKeyUp(keyCode);
     }
 }
コード例 #4
0
 public ModifierKey(VirtualKeyCode key, params VirtualKeyCode[] additional)
 {
     _key = key;
     _additional = additional;
     if(_additional == null)
         _additional = new VirtualKeyCode[0];
 }
コード例 #5
0
        public static Command GenerateCommand(InstructionData instruction)
        {
            VirtualKeyCode[] keys=new VirtualKeyCode[Values.GetLength(0)];
            Values.CopyTo(keys, 0);

            switch (instruction.commandType)
            {
                case InstructionData_CommandType.JOYSTICKAXIS:
                    return new Command(new JoystickCommandData(0,(JoystickDataType)instruction.axis,(short)instruction.value));
                case InstructionData_CommandType.JOYSTICKBUTTON_PRESS:
                    return new Command(new JoystickCommandData(0, JoystickDataType.BUTTON_PRESS, 0, instruction.value));
                case InstructionData_CommandType.JOYSTICKBUTTON_HOLD:
                    return new Command(new JoystickCommandData(0, JoystickDataType.BUTTON_HOLD, 0, instruction.value));
                case InstructionData_CommandType.JOYSTICKBUTTON_RELEASE:
                    return new Command(new JoystickCommandData(0, JoystickDataType.BUTTON_RELEASE, 0, instruction.value));
                case InstructionData_CommandType.KEYBOARD_PRESS:
                    return new Command(new KeyboardCommandData(keys[instruction.value], KeyboardCommandType.PRESS, instruction.control, instruction.shift));
                case InstructionData_CommandType.KEYBOARD_HOLD:
                    return new Command(new KeyboardCommandData(keys[instruction.value], KeyboardCommandType.HOLD, instruction.control, instruction.shift));
                case InstructionData_CommandType.KEYBOARD_RELEASE:
                    return new Command(new KeyboardCommandData(keys[instruction.value], KeyboardCommandType.RELEASE, instruction.control, instruction.shift));
            }

            return null;
        }
コード例 #6
0
        public static void SimulateKeyPress(VirtualKeyCode keyCode)
        {
            var down = new Input();
            down.Type = (UInt32)InputType.KEYBOARD;
            down.Data.Keyboard = new KeybdInput
                                     {
                                         Vk = (UInt16) keyCode,
                                         Scan = 0,
                                         Flags = 0,
                                         Time = 0,
                                         ExtraInfo = IntPtr.Zero
                                     };

            var up = new Input();
            up.Type = (UInt32)InputType.KEYBOARD;
            up.Data.Keyboard = new KeybdInput
                                   {
                                       Vk = (UInt16) keyCode,
                                       Scan = 0,
                                       Flags = (UInt32) KeyboardFlag.KEYUP,
                                       Time = 0,
                                       ExtraInfo = IntPtr.Zero
                                   };

            var inputList = new Input[2];
            inputList[0] = down;
            inputList[1] = up;

            var numberOfSuccessfulSimulatedInputs = User32.SendInput(2, inputList, Marshal.SizeOf(typeof(Input)));
            if (numberOfSuccessfulSimulatedInputs == 0) throw new Exception(string.Format("The key press simulation for {0} was not successful.", keyCode));
        }
コード例 #7
0
ファイル: GameAction.cs プロジェクト: cignoir/KinecTh
 public static void PressKey(VirtualKeyCode keyCode)
 {
     if (Status.isKeyEnabled)
     {
         InputSimulator.SimulateKeyPress(keyCode);
     }
 }
コード例 #8
0
 /// <summary>
 /// Эмулирует действие 'нажать и держать' над кнопкой.
 /// </summary>
 /// <param name="keyCode">
 /// Ключ целевой кнопки.
 /// </param>
 public IKeyboard KeyDown(VirtualKeyCode keyCode)
 {
     this.logger.Info("Key down '{0}'", keyCode.ToString());
     this.keyboardSimulator.KeyDown(keyCode);
     Thread.Sleep(250);
     return this;
 }
コード例 #9
0
ファイル: Command.cs プロジェクト: Manu343726/KinectStick
 public KeyboardCommandData(VirtualKeyCode key, KeyboardCommandType type, bool control = false, bool shift = false)
 {
     this.key = key;
     this.type = type;
     this.control = control;
     this.shift = shift;
 }
コード例 #10
0
 public void Set(VirtualKeyCode key, KeyState keyState)
 {
     if(_modifierKeyState.ContainsKey(key))
         _modifierKeyState[key] = keyState;
     else
         _modifierKeyState.Add(key, keyState);
 }
コード例 #11
0
ファイル: BotCommon.cs プロジェクト: plewt/mu97bot
 public static void DoBuff(VirtualKeyCode aKey, bool aSelf)
 {
     Point OldMousePos = MouseGetPos();;
     if (aSelf) CenterMouse();
     DoSkill(aKey);
     if (aSelf) MouseMove(OldMousePos);
 }
コード例 #12
0
 public ShiftSensitiveKey(VirtualKeyCode keyCode, string normal, string modified, string displayText)
 {
     _keyCode = keyCode;
     _normal = normal;
     _modified = modified;
     _displayText = displayText;
     Display = !string.IsNullOrEmpty(_displayText) ? _displayText : _normal;
 }
コード例 #13
0
ファイル: InputManager.cs プロジェクト: Grifs99/ShareX
 private void AddKeyInput(VirtualKeyCode keyCode, bool isKeyUp)
 {
     INPUT input = new INPUT();
     input.Type = InputType.InputKeyboard;
     input.Data.Keyboard = new KEYBDINPUT();
     input.Data.Keyboard.wVk = keyCode;
     if (isKeyUp) input.Data.Keyboard.dwFlags = KeyboardEventFlags.KEYEVENTF_KEYUP;
     InputList.Add(input);
 }
コード例 #14
0
        public static void AsyncReleaseKey(VirtualKeyCode keycode)
        {
            lock (InputSimulator.currentAsyncHoldKeys)
            {
                InputSimulator.SimulateKeyUp(keycode);

                InputSimulator.currentAsyncHoldKeys.RemoveAll(key => key.Equals(keycode));
            }
        }
コード例 #15
0
 public MultiCharacterKey(VirtualKeyCode keyCode, IList<string> keyDisplays) :
     base(keyCode)
 {
     if (keyDisplays == null) throw new ArgumentNullException("keyDisplays");
     if (keyDisplays.Count <= 0)
         throw new ArgumentException("Please provide a list of one or more keyDisplays", "keyDisplays");
     KeyDisplays = keyDisplays;
     DisplayName = keyDisplays[0];
 }
コード例 #16
0
        public VirtualKey(VirtualKeyCode virtualKey,
            string displayText,
            List<int> characters,
            bool isAffectedByCapsLock)
        {
            _virtualKey = virtualKey;
            _characters = characters;
            _isAffectedByCapsLock = isAffectedByCapsLock;
            _displayText = displayText;

            for (var x = 0; x < characters.Count; x++)
            {
                var character = default(char);
                var value = characters[x];
                if (value == Definitions.WCH_DEAD)
                {
                    character = ' ';
                }
                else if (value == Definitions.WCH_LGTR)
                {
                    character = ' ';
                }
                else if (value == Definitions.WCH_NONE)
                {
                    character = ' ';
                }
                else
                {
                    character = (char)value;
                }

                switch (x)
                {
                    case 0:
                        characterBase = character;
                        break;
                    case 1:
                        characterShift = character;
                        break;
                    case 2:
                        characterAltGraphics = character;
                        break;
                    case 3:
                        characterControl = character;
                        break;
                    case 4:
                        characterShiftControl = character;
                        break;
                    case 5:
                        characterShiftAltGraphics = character;
                        break;
                }
            }

            Display = GetDisplayValue(false, false);
        }
コード例 #17
0
        /// <summary>
        /// Calls the Win32 SendInput method with a KeyDown and KeyUp message in the same input sequence in order to simulate a Key PRESS.
        /// </summary>
        /// <param name="keyCode">The <see cref="VirtualKeyCode"/> to press</param>
        public void KeyPress(VirtualKeyCode keyCode)
        {
            var inputList =
                new InputBuilder()
                    .AddKeyDown(keyCode)
                    .AddKeyUp(keyCode)
                    .ToArray();

            SendSimulatedInput(inputList);
        }
コード例 #18
0
ファイル: InputManager.cs プロジェクト: fusspawn/utils
        public static void PressKey(VirtualKeyCode S)
        {
            if (WindowHandle == null) {
                Console.WriteLine("Cant Send Keypress to Null Window");
                return;
            }

            InputSimulator.SimulateKeyPress(S);
            Console.WriteLine("Sent Key");
        }
コード例 #19
0
ファイル: PublishService.cs プロジェクト: nekulin/OptiKey
 public void KeyUp(VirtualKeyCode virtualKeyCode)
 {
     try
     {
         Log.DebugFormat("Simulating key up: {0}", virtualKeyCode);
         inputSimulator.Keyboard.KeyUp(virtualKeyCode);
     }
     catch (Exception exception)
     {
         PublishError(this, exception);
     }
 }
コード例 #20
0
        public void SendMessage(VirtualKeyCode key, VirtualKeyCode? modifier = null)
        {
            SetForegroundWindow(hWndLast);

            if (modifier != null)
            {
                InputSimulator.SimulateModifiedKeyStroke((VirtualKeyCode)modifier, key);
                return;
            }

            InputSimulator.SimulateKeyPress(key);
        }
コード例 #21
0
ファイル: KbEvt.cs プロジェクト: mind0n/hive
 public override void Parse(EvtItem item)
 {
     //Modifiers = item.modifier;
     Code = ParseCode(item.key);
     if (item.modifier != null && item.modifier.Length > 0)
     {
         foreach (var i in item.modifier)
         {
             var vc = ParseCode(i);
             Modifiers.Add(vc);
         }
     }
 }
コード例 #22
0
ファイル: InputManager.cs プロジェクト: noscripter/ShareX
        public void AddKeyPressModifiers(VirtualKeyCode keyCode, params VirtualKeyCode[] modifiers)
        {
            foreach (VirtualKeyCode modifier in modifiers)
            {
                AddKeyDown(modifier);
            }

            AddKeyPress(keyCode);

            foreach (VirtualKeyCode modifier in modifiers)
            {
                AddKeyUp(modifier);
            }
        }
コード例 #23
0
ファイル: KeyAction.cs プロジェクト: MajorTom327/LicornBot
 public KeyAction(VirtualKeyCode key)
 {
     this._key = key;
 }
コード例 #24
0
        /// <summary>
        /// Determines whether the toggling key is toggled on (in-effect) or not by calling the <see cref="NativeMethods.GetKeyState"/> function.  (See: http://msdn.microsoft.com/en-us/library/ms646301(VS.85).aspx)
        /// </summary>
        /// <param name="keyCode">The <see cref="VirtualKeyCode"/> for the key.</param>
        /// <returns>
        ///     <c>true</c> if the toggling key is toggled on (in-effect); otherwise, <c>false</c>.
        /// </returns>
        /// <remarks>
        /// The key status returned from this function changes as a thread reads key messages from its message queue. The status does not reflect the interrupt-level state associated with the hardware. Use the GetAsyncKeyState function to retrieve that information.
        /// An application calls GetKeyState in response to a keyboard-input message. This function retrieves the state of the key when the input message was generated.
        /// To retrieve state information for all the virtual keys, use the GetKeyboardState function.
        /// An application can use the virtual-key code constants VK_SHIFT, VK_CONTROL, and VK_MENU as values for the nVirtKey parameter. This gives the status of the SHIFT, CTRL, or ALT keys without distinguishing between left and right. An application can also use the following virtual-key code constants as values for nVirtKey to distinguish between the left and right instances of those keys.
        /// VK_LSHIFT
        /// VK_RSHIFT
        /// VK_LCONTROL
        /// VK_RCONTROL
        /// VK_LMENU
        /// VK_RMENU
        ///
        /// These left- and right-distinguishing constants are available to an application only through the GetKeyboardState, SetKeyboardState, GetAsyncKeyState, GetKeyState, and MapVirtualKey functions.
        /// </remarks>
        public bool IsTogglingKeyInEffect(VirtualKeyCode keyCode)
        {
            Int16 result = NativeMethods.GetKeyState((UInt16)keyCode);

            return((result & 0x01) == 0x01);
        }
コード例 #25
0
 static public MotionResult KeyboardPress(
     this IHostToScript sanderling,
     VirtualKeyCode key) =>
 sanderling?.KeyboardPressCombined(new[] { key });
コード例 #26
0
 static public bool IsAltKey(this VirtualKeyCode key) =>
 VirtualKeyCode.MENU == key || VirtualKeyCode.LMENU == key || VirtualKeyCode.RMENU == key;
コード例 #27
0
 /// <summary>
 /// Adds a key press to the list of <see cref="INPUT"/> messages which is equivalent to a key down followed by a key up.
 /// </summary>
 /// <param name="keyCode">The <see cref="VirtualKeyCode"/>.</param>
 /// <returns>This <see cref="InputBuilder"/> instance.</returns>
 public InputBuilder AddKeyPress(VirtualKeyCode keyCode)
 {
     AddKeyDown(keyCode);
     AddKeyUp(keyCode);
     return(this);
 }
コード例 #28
0
ファイル: VirtualKey.cs プロジェクト: ZT-/WPFKeyboard
        public VirtualKey(VirtualKeyCode virtualKey,
                          string displayText,
                          List <int> characters,
                          bool isAffectedByCapsLock)
        {
            _virtualKey           = virtualKey;
            _characters           = characters;
            _isAffectedByCapsLock = isAffectedByCapsLock;
            _displayText          = displayText;

            for (var x = 0; x < characters.Count; x++)
            {
                var character = default(char);
                var value     = characters[x];
                if (value == Definitions.WCH_DEAD)
                {
                    character = ' ';
                }
                else if (value == Definitions.WCH_LGTR)
                {
                    character = ' ';
                }
                else if (value == Definitions.WCH_NONE)
                {
                    character = ' ';
                }
                else
                {
                    character = (char)value;
                }

                switch (x)
                {
                case 0:
                    characterBase = character;
                    break;

                case 1:
                    characterShift = character;
                    break;

                case 2:
                    characterAltGraphics = character;
                    break;

                case 3:
                    characterControl = character;
                    break;

                case 4:
                    characterShiftControl = character;
                    break;

                case 5:
                    characterShiftAltGraphics = character;
                    break;
                }
            }

            Display = GetDisplayValue(false, false);
        }
コード例 #29
0
        public static bool ExecuteAbility(string ability, string args, bool qc, Dota2Core core, bool forceCancel)
        {
            Dota2GSI.Nodes.Abilities abilities = core.Abilities();
            VirtualKeyCode           key       = VirtualKeyCode.VK_S;

            if (abilities == null)
            {
                return(false);
            }

            if (abilities.Count == 4)
            {
                if (ability == "Q")
                {
                    key = VirtualKeyCode.VK_Q;
                    if (!abilities[0].CanCast && (core.mainForm.Cancel() || forceCancel))
                    {
                        return(false);
                    }
                }
                if (ability == "W")
                {
                    key = VirtualKeyCode.VK_W;
                    if (!abilities[1].CanCast && (core.mainForm.Cancel() || forceCancel))
                    {
                        return(false);
                    }
                }
                if (ability == "E")
                {
                    key = VirtualKeyCode.VK_E;
                    if (!abilities[2].CanCast && (core.mainForm.Cancel() || forceCancel))
                    {
                        return(false);
                    }
                }
                if (ability == "R")
                {
                    key = VirtualKeyCode.VK_R;
                    if (!abilities[3].CanCast && (core.mainForm.Cancel() || forceCancel))
                    {
                        return(false);
                    }
                }
            }

            if (abilities.Count == 5)
            {
                if (ability == "Q")
                {
                    key = VirtualKeyCode.VK_Q;
                    if (!abilities[0].CanCast && (core.mainForm.Cancel() || forceCancel))
                    {
                        return(false);
                    }
                }
                if (ability == "W")
                {
                    key = VirtualKeyCode.VK_W;
                    if (!abilities[1].CanCast && (core.mainForm.Cancel() || forceCancel))
                    {
                        return(false);
                    }
                }
                if (ability == "E")
                {
                    key = VirtualKeyCode.VK_E;
                    if (!abilities[2].CanCast && (core.mainForm.Cancel() || forceCancel))
                    {
                        return(false);
                    }
                }
                if (ability == "D")
                {
                    key = VirtualKeyCode.VK_D;
                    if (!abilities[3].CanCast && (core.mainForm.Cancel() || forceCancel))
                    {
                        return(false);
                    }
                }
                if (ability == "R")
                {
                    key = VirtualKeyCode.VK_R;
                    if (!abilities[4].CanCast && (core.mainForm.Cancel() || forceCancel))
                    {
                        return(false);
                    }
                }
            }

            if (abilities.Count == 6)
            {
                if (ability == "Q")
                {
                    key = VirtualKeyCode.VK_Q;
                    if (!abilities[0].CanCast && (core.mainForm.Cancel() || forceCancel))
                    {
                        return(false);
                    }
                }
                if (ability == "W")
                {
                    key = VirtualKeyCode.VK_W;
                    if (!abilities[1].CanCast && (core.mainForm.Cancel() || forceCancel))
                    {
                        return(false);
                    }
                }
                if (ability == "E")
                {
                    key = VirtualKeyCode.VK_E;
                    if (!abilities[2].CanCast && (core.mainForm.Cancel() || forceCancel))
                    {
                        return(false);
                    }
                }
                if (ability == "D")
                {
                    key = VirtualKeyCode.VK_D;
                    if (!abilities[3].CanCast && (core.mainForm.Cancel() || forceCancel))
                    {
                        return(false);
                    }
                }
                if (ability == "F")
                {
                    key = VirtualKeyCode.VK_F;
                    if (!abilities[4].CanCast && (core.mainForm.Cancel() || forceCancel))
                    {
                        return(false);
                    }
                }
                if (ability == "R")
                {
                    key = VirtualKeyCode.VK_R;
                    if (!abilities[5].CanCast && (core.mainForm.Cancel() || forceCancel))
                    {
                        return(false);
                    }
                }
            }

            if (ability == "Z")
            {
                key = VirtualKeyCode.VK_Z;
            }
            if (ability == "X")
            {
                key = VirtualKeyCode.VK_X;
            }
            if (ability == "C")
            {
                key = VirtualKeyCode.VK_C;
            }
            if (ability == "V")
            {
                key = VirtualKeyCode.VK_V;
            }
            if (ability == "B")
            {
                key = VirtualKeyCode.VK_B;
            }
            if (ability == "N")
            {
                key = VirtualKeyCode.VK_N;
            }
            if (ability == "A")
            {
                key = VirtualKeyCode.VK_A;
            }

            if (core.mainForm.SelectHero() && forceCancel)
            {
                KBMHelper.SelectHero(VirtualKeyCode.F1);
            }

            if (args == "SELF")
            {
                if (qc)
                {
                    KBMHelper.PressAltKey(key);
                }
                else
                {
                    KBMHelper.PressKey(key);
                    KBMHelper.PressKey(key);
                }
            }
            else
            {
                KBMHelper.PressKey(key);
                if (!qc)
                {
                    KBMHelper.LClick();
                }
            }
            return(true);
        }
コード例 #30
0
ファイル: InputSimulator.cs プロジェクト: H-J-P/DAC-Source
 /// <summary>
 /// Performs a modified keystroke where there are multiple modifiers and one key like CTRL-ALT-C where CTRL and ALT are the modifierKeys and C is the key.
 /// The flow is Modifiers KEYDOWN in order, Key PRESS, Modifiers KEYUP in reverse order.
 /// </summary>
 /// <param name="modifierKeyCodes">The list of modifier keys</param>
 /// <param name="keyCode">The key to simulate</param>
 public static void SimulateModifiedKeyStroke(IEnumerable<VirtualKeyCode> modifierKeyCodes, VirtualKeyCode keyCode)
 {
     if (modifierKeyCodes != null) modifierKeyCodes.ToList().ForEach(x => SimulateKeyDown(x));
     SimulateKeyPress(keyCode);
     if (modifierKeyCodes != null) modifierKeyCodes.Reverse().ToList().ForEach(x => SimulateKeyUp(x));
 }
コード例 #31
0
ファイル: InputSimulator.cs プロジェクト: H-J-P/DAC-Source
        /// <summary>
        /// Calls the Win32 SendInput method to simulate a Key UP.
        /// </summary>
        /// <param name="keyCode">The VirtualKeyCode to lift up</param>
        public static void SimulateKeyUp(VirtualKeyCode keyCode)
        {
            var up = new InputSimulatorDefines();
            up.Type = (UInt32)InputType.KEYBOARD;
            up.Data.Keyboard = new KEYBDINPUT();
            up.Data.Keyboard.Vk = (UInt16)keyCode;
            up.Data.Keyboard.Scan = 0;
            up.Data.Keyboard.Flags = (UInt32)KeyboardFlag.KEYUP;
            up.Data.Keyboard.Time = 0;
            up.Data.Keyboard.ExtraInfo = IntPtr.Zero;

            InputSimulatorDefines[] inputList = new InputSimulatorDefines[1];
            inputList[0] = up;

            var numberOfSuccessfulSimulatedInputs = SendInput(1, inputList, Marshal.SizeOf(typeof(InputSimulatorDefines)));
            if (numberOfSuccessfulSimulatedInputs == 0) throw new Exception(string.Format("The key up simulation for {0} was not successful.", keyCode));
        }
コード例 #32
0
 /// <summary>
 /// Determines whether the physical key is up or down at the time the function is called regardless of whether the application thread has read the keyboard event from the message pump by calling the <see cref="NativeMethods.GetAsyncKeyState"/> function. (See: http://msdn.microsoft.com/en-us/library/ms646293(VS.85).aspx)
 /// </summary>
 /// <param name="keyCode">The <see cref="VirtualKeyCode"/> for the key.</param>
 /// <returns>
 /// 	<c>true</c> if the key is up; otherwise, <c>false</c>.
 /// </returns>
 /// <remarks>
 /// The GetAsyncKeyState function works with mouse buttons. However, it checks on the state of the physical mouse buttons, not on the logical mouse buttons that the physical buttons are mapped to. For example, the call GetAsyncKeyState(VK_LBUTTON) always returns the state of the left physical mouse button, regardless of whether it is mapped to the left or right logical mouse button. You can determine the system's current mapping of physical mouse buttons to logical mouse buttons by calling 
 /// Copy CodeGetSystemMetrics(SM_SWAPBUTTON) which returns TRUE if the mouse buttons have been swapped.
 /// 
 /// Although the least significant bit of the return value indicates whether the key has been pressed since the last query, due to the pre-emptive multitasking nature of Windows, another application can call GetAsyncKeyState and receive the "recently pressed" bit instead of your application. The behavior of the least significant bit of the return value is retained strictly for compatibility with 16-bit Windows applications (which are non-preemptive) and should not be relied upon.
 /// 
 /// You can use the virtual-key code constants VK_SHIFT, VK_CONTROL, and VK_MENU as values for the vKey parameter. This gives the state of the SHIFT, CTRL, or ALT keys without distinguishing between left and right. 
 /// 
 /// Windows NT/2000/XP: You can use the following virtual-key code constants as values for vKey to distinguish between the left and right instances of those keys. 
 /// 
 /// Code Meaning 
 /// VK_LSHIFT Left-shift key. 
 /// VK_RSHIFT Right-shift key. 
 /// VK_LCONTROL Left-control key. 
 /// VK_RCONTROL Right-control key. 
 /// VK_LMENU Left-menu key. 
 /// VK_RMENU Right-menu key. 
 /// 
 /// These left- and right-distinguishing constants are only available when you call the GetKeyboardState, SetKeyboardState, GetAsyncKeyState, GetKeyState, and MapVirtualKey functions. 
 /// </remarks>
 public bool IsHardwareKeyUp(VirtualKeyCode keyCode)
 {
     return !IsHardwareKeyDown(keyCode);
 }
コード例 #33
0
        /// <summary>
        /// Determines whether the physical key is up or down at the time the function is called regardless of whether the application thread has read the keyboard event from the message pump by calling the <see cref="NativeMethods.GetAsyncKeyState"/> function. (See: http://msdn.microsoft.com/en-us/library/ms646293(VS.85).aspx)
        /// </summary>
        /// <param name="keyCode">The <see cref="VirtualKeyCode"/> for the key.</param>
        /// <returns>
        ///     <c>true</c> if the key is down; otherwise, <c>false</c>.
        /// </returns>
        /// <remarks>
        /// The GetAsyncKeyState function works with mouse buttons. However, it checks on the state of the physical mouse buttons, not on the logical mouse buttons that the physical buttons are mapped to. For example, the call GetAsyncKeyState(VK_LBUTTON) always returns the state of the left physical mouse button, regardless of whether it is mapped to the left or right logical mouse button. You can determine the system's current mapping of physical mouse buttons to logical mouse buttons by calling
        /// Copy CodeGetSystemMetrics(SM_SWAPBUTTON) which returns TRUE if the mouse buttons have been swapped.
        ///
        /// Although the least significant bit of the return value indicates whether the key has been pressed since the last query, due to the pre-emptive multitasking nature of Windows, another application can call GetAsyncKeyState and receive the "recently pressed" bit instead of your application. The behavior of the least significant bit of the return value is retained strictly for compatibility with 16-bit Windows applications (which are non-preemptive) and should not be relied upon.
        ///
        /// You can use the virtual-key code constants VK_SHIFT, VK_CONTROL, and VK_MENU as values for the vKey parameter. This gives the state of the SHIFT, CTRL, or ALT keys without distinguishing between left and right.
        ///
        /// Windows NT/2000/XP: You can use the following virtual-key code constants as values for vKey to distinguish between the left and right instances of those keys.
        ///
        /// Code Meaning
        /// VK_LSHIFT Left-shift key.
        /// VK_RSHIFT Right-shift key.
        /// VK_LCONTROL Left-control key.
        /// VK_RCONTROL Right-control key.
        /// VK_LMENU Left-menu key.
        /// VK_RMENU Right-menu key.
        ///
        /// These left- and right-distinguishing constants are only available when you call the GetKeyboardState, SetKeyboardState, GetAsyncKeyState, GetKeyState, and MapVirtualKey functions.
        /// </remarks>
        public bool IsHardwareKeyDown(VirtualKeyCode keyCode)
        {
            var result = NativeMethods.GetAsyncKeyState((UInt16)keyCode);

            return(result < 0);
        }
コード例 #34
0
 /// <summary>
 /// Determines whether the specified key is up or downby calling the <see cref="NativeMethods.GetKeyState"/> function. (See: http://msdn.microsoft.com/en-us/library/ms646301(VS.85).aspx)
 /// </summary>
 /// <param name="keyCode">The <see cref="VirtualKeyCode"/> for the key.</param>
 /// <returns>
 ///     <c>true</c> if the key is up; otherwise, <c>false</c>.
 /// </returns>
 /// <remarks>
 /// The key status returned from this function changes as a thread reads key messages from its message queue. The status does not reflect the interrupt-level state associated with the hardware. Use the GetAsyncKeyState function to retrieve that information.
 /// An application calls GetKeyState in response to a keyboard-input message. This function retrieves the state of the key when the input message was generated.
 /// To retrieve state information for all the virtual keys, use the GetKeyboardState function.
 /// An application can use the virtual-key code constants VK_SHIFT, VK_CONTROL, and VK_MENU as values for Bthe nVirtKey parameter. This gives the status of the SHIFT, CTRL, or ALT keys without distinguishing between left and right. An application can also use the following virtual-key code constants as values for nVirtKey to distinguish between the left and right instances of those keys.
 /// VK_LSHIFT
 /// VK_RSHIFT
 /// VK_LCONTROL
 /// VK_RCONTROL
 /// VK_LMENU
 /// VK_RMENU
 ///
 /// These left- and right-distinguishing constants are available to an application only through the GetKeyboardState, SetKeyboardState, GetAsyncKeyState, GetKeyState, and MapVirtualKey functions.
 /// </remarks>
 public bool IsKeyUp(VirtualKeyCode keyCode)
 {
     return(!IsKeyDown(keyCode));
 }
コード例 #35
0
        /// <summary>
        /// Determines whether the specified key is up or down by calling the GetKeyState function. (See: http://msdn.microsoft.com/en-us/library/ms646301(VS.85).aspx)
        /// </summary>
        /// <param name="keyCode">The <see cref="VirtualKeyCode"/> for the key.</param>
        /// <returns>
        ///     <c>true</c> if the key is down; otherwise, <c>false</c>.
        /// </returns>
        /// <remarks>
        /// The key status returned from this function changes as a thread reads key messages from its message queue. The status does not reflect the interrupt-level state associated with the hardware. Use the GetAsyncKeyState function to retrieve that information.
        /// An application calls GetKeyState in response to a keyboard-input message. This function retrieves the state of the key when the input message was generated.
        /// To retrieve state information for all the virtual keys, use the GetKeyboardState function.
        /// An application can use the virtual-key code constants VK_SHIFT, VK_CONTROL, and VK_MENU as values for Bthe nVirtKey parameter. This gives the status of the SHIFT, CTRL, or ALT keys without distinguishing between left and right. An application can also use the following virtual-key code constants as values for nVirtKey to distinguish between the left and right instances of those keys.
        /// VK_LSHIFT
        /// VK_RSHIFT
        /// VK_LCONTROL
        /// VK_RCONTROL
        /// VK_LMENU
        /// VK_RMENU
        ///
        /// These left- and right-distinguishing constants are available to an application only through the GetKeyboardState, SetKeyboardState, GetAsyncKeyState, GetKeyState, and MapVirtualKey functions.
        /// </remarks>
        public bool IsKeyDown(VirtualKeyCode keyCode)
        {
            Int16 result = NativeMethods.GetKeyState((UInt16)keyCode);

            return(result < 0);
        }
コード例 #36
0
 public VirtualKeyCodeHolder(VirtualKeyCode virtualKeyCode)
 {
     _virtualKeyCode = virtualKeyCode;
     UpdateModifierExtendedMembers();
 }
コード例 #37
0
        public static bool ExecuteItem(string item, string args, bool qc, Dota2Core core, bool forceCancel)
        {
            Dota2GSI.Nodes.Items items = core.Items();
            VirtualKeyCode       key   = VirtualKeyCode.VK_S;

            if (items == null)
            {
                return(false);
            }

            int index = -1;

            if (!items.InventoryContains(item))
            {
                return(false);
            }

            index = items.InventoryIndexOf(item);

            if (index == -1)
            {
                return(false);
            }

            if ((index > 5 || !items.GetInventoryAt(index).CanCast) && (core.mainForm.Cancel() || forceCancel))
            {
                return(false);
            }

            if (index == 0)
            {
                key = VirtualKeyCode.VK_Z;
            }
            if (index == 1)
            {
                key = VirtualKeyCode.VK_X;
            }
            if (index == 2)
            {
                key = VirtualKeyCode.VK_C;
            }
            if (index == 3)
            {
                key = VirtualKeyCode.VK_V;
            }
            if (index == 4)
            {
                key = VirtualKeyCode.VK_B;
            }
            if (index == 5)
            {
                key = VirtualKeyCode.VK_N;
            }

            if (core.mainForm.SelectHero() && forceCancel)
            {
                KBMHelper.SelectHero(VirtualKeyCode.F1);
            }

            if (args == "SELF")
            {
                if (qc)
                {
                    KBMHelper.PressAltKey(key);
                }
                else
                {
                    KBMHelper.PressKey(key);
                    KBMHelper.PressKey(key);
                }
            }
            else
            {
                KBMHelper.PressKey(key);
                if (!qc)
                {
                    KBMHelper.LClick();
                }
            }
            return(true);
        }
コード例 #38
0
ファイル: InputSimulator.cs プロジェクト: H-J-P/DAC-Source
 /// <summary>
 /// Determines whether a key is up or down at the time the function is called by calling the GetAsyncKeyState function. (See: http://msdn.microsoft.com/en-us/library/ms646293(VS.85).aspx)
 /// </summary>
 /// <param name="keyCode">The key code.</param>
 /// <returns>
 /// 	<c>true</c> if the key is down; otherwise, <c>false</c>.
 /// </returns>
 /// <remarks>
 /// The GetAsyncKeyState function works with mouse buttons. However, it checks on the state of the physical mouse buttons, not on the logical mouse buttons that the physical buttons are mapped to. For example, the call GetAsyncKeyState(VK_LBUTTON) always returns the state of the left physical mouse button, regardless of whether it is mapped to the left or right logical mouse button. You can determine the system's current mapping of physical mouse buttons to logical mouse buttons by calling 
 /// Copy CodeGetSystemMetrics(SM_SWAPBUTTON) which returns TRUE if the mouse buttons have been swapped.
 /// 
 /// Although the least significant bit of the return value indicates whether the key has been pressed since the last query, due to the pre-emptive multitasking nature of Windows, another application can call GetAsyncKeyState and receive the "recently pressed" bit instead of your application. The behavior of the least significant bit of the return value is retained strictly for compatibility with 16-bit Windows applications (which are non-preemptive) and should not be relied upon.
 /// 
 /// You can use the virtual-key code constants VK_SHIFT, VK_CONTROL, and VK_MENU as values for the vKey parameter. This gives the state of the SHIFT, CTRL, or ALT keys without distinguishing between left and right. 
 /// 
 /// Windows NT/2000/XP: You can use the following virtual-key code constants as values for vKey to distinguish between the left and right instances of those keys. 
 /// 
 /// Code Meaning 
 /// VK_LSHIFT Left-shift key. 
 /// VK_RSHIFT Right-shift key. 
 /// VK_LCONTROL Left-control key. 
 /// VK_RCONTROL Right-control key. 
 /// VK_LMENU Left-menu key. 
 /// VK_RMENU Right-menu key. 
 /// 
 /// These left- and right-distinguishing constants are only available when you call the GetKeyboardState, SetKeyboardState, GetAsyncKeyState, GetKeyState, and MapVirtualKey functions. 
 /// </remarks>
 public static bool IsKeyDownAsync(VirtualKeyCode keyCode)
 {
     Int16 result = GetAsyncKeyState((UInt16)keyCode);
     return (result < 0);
 }
コード例 #39
0
 public KeyPressedEventArgs(VirtualKeyCode Key, bool down = true, bool up = false)
 {
     KeyCode = Key;
     KeyDown = down;
     KeyUp   = up;
 }
コード例 #40
0
ファイル: Functions.cs プロジェクト: sp1r00000/ShareX
        public override void Method()
        {
            VirtualKeyCode keyCode = (VirtualKeyCode)(Keys)Enum.Parse(typeof(Keys), Parameters[0], true);

            InputHelpers.SendKeyUp(keyCode);
        }
コード例 #41
0
        /// <summary>
        /// Gets the hotkey.
        /// </summary>
        /// <param name="timeout">The timeout.</param>
        /// <returns></returns>
        /// <exception cref="InvalidOperationException">The " + nameof(InputManager) +
        ///                                                     " needs to be initialized before it can execute this method.</exception>
        public VirtualKeyCode GetHotkey(int timeout = -1)
        {
            if (!IsInitialized)
            {
                throw new InvalidOperationException("The " + nameof(InputManager) +
                                                    " needs to be initialized before it can execute this method.");
            }

            var            threadLock = new object();
            VirtualKeyCode hotkey     = VirtualKeyCode.Invalid;

            LowLevelMouseHook.MouseEventHandler mouseEventHandler = (VirtualKeyCode key, KeyState state, int x, int y) =>
            {
                if (state != KeyState.Down)
                {
                    return;
                }

                hotkey = key;

                if (!Monitor.TryEnter(threadLock))
                {
                    return;
                }

                // someone else has the lock
                Monitor.PulseAll(threadLock);
                Monitor.Exit(threadLock);
            };
            LowLevelKeyboardHook.KeyboardEventHandler keyboardEventHandler = (VirtualKeyCode key, KeyState state) =>
            {
                if (state != KeyState.Down)
                {
                    return;
                }

                hotkey = key;

                if (!Monitor.TryEnter(threadLock))
                {
                    return;
                }

                // someone else has the lock
                Monitor.PulseAll(threadLock);
                Monitor.Exit(threadLock);
            };

            this.OnMouseEvent    += mouseEventHandler;
            this.OnKeyboardEvent += keyboardEventHandler;

            bool result;

            Monitor.Enter(threadLock);

            if (timeout < 0)
            {
                Monitor.Wait(threadLock);
                result = true;
            }
            else
            {
                result = Monitor.Wait(threadLock, timeout);
            }

            this.OnMouseEvent    -= mouseEventHandler;
            this.OnKeyboardEvent -= keyboardEventHandler;

            return(hotkey);
        }
コード例 #42
0
 public bool IsHardwareKeyUp(VirtualKeyCode keyCode)
 {
     return(true);
 }
コード例 #43
0
 static public bool IsCtrlKey(this VirtualKeyCode key) =>
 VirtualKeyCode.CONTROL == key || VirtualKeyCode.LCONTROL == key || VirtualKeyCode.RCONTROL == key;
コード例 #44
0
 public void UpdateKeyStatus(VirtualKeyCode keyCode, KeyStatus status)
 {
     KeyActionCharacteristicWrapper.NotifyKeyStatus(keyCode, status);
 }
コード例 #45
0
 static public bool WindowPostMessageKeyUp(this IHostToScript host, VirtualKeyCode key, IntPtr lParam = default(IntPtr)) =>
 host.WindowPostMessage(0x101, (IntPtr)key, lParam);
コード例 #46
0
 public Key(VirtualKeyCode code, KeyStates state)
 {
     _state = state;
     _code  = code;
 }
コード例 #47
0
 public bool IsKeyDown(VirtualKeyCode keyCode)
 {
     return(false);
 }
コード例 #48
0
        public GestureDetector(KinectSensor kinectSensor, string dataBase, string gestureName, int refID, VirtualKeyCode key, float thresh)
        {
            if (kinectSensor == null)
            {
                throw new ArgumentNullException("kinectSensor");
            }


            gestureDatabase = dataBase;
            dataName        = gestureName;
            //pressKey = key;
            keyPress    = key;
            threshHold  = thresh;
            referenceID = refID;

            // create the vgb source. The associated body tracking ID will be set when a valid body frame arrives from the sensor.
            this.vgbFrameSource = new VisualGestureBuilderFrameSource(kinectSensor, 0);
            this.vgbFrameSource.TrackingIdLost += this.Source_TrackingIdLost;

            // open the reader for the vgb frames
            this.vgbFrameReader = this.vgbFrameSource.OpenReader();
            if (this.vgbFrameReader != null)
            {
                //this.vgbFrameReader.IsPaused = true;
                this.vgbFrameReader.FrameArrived += this.Reader_GestureFrameArrived;
            }

            // load the 'Seated' gesture from the gesture database
            using (VisualGestureBuilderDatabase database = new VisualGestureBuilderDatabase(this.gestureDatabase))
            {
                // we could load all available gestures in the database with a call to vgbFrameSource.AddGestures(database.AvailableGestures),
                // but for this program, we only want to track one discrete gesture from the database, so we'll load it by name
                foreach (Gesture gesture in database.AvailableGestures)
                {
                    if (gesture.Name.Equals(this.dataName))
                    {
                        this.vgbFrameSource.AddGesture(gesture);
                    }
                }
            }
        }
コード例 #49
0
 public bool IsKeyUp(VirtualKeyCode keyCode)
 {
     return(true);
 }
コード例 #50
0
 public bool IsTogglingKeyInEffect(VirtualKeyCode keyCode)
 {
     return(false);
 }
コード例 #51
0
 /// <summary>
 /// Simulates a simple modified keystroke like CTRL-C where CTRL is the modifierKey and C is the key.
 /// The flow is Modifier KeyDown, Key Press, Modifier KeyUp.
 /// </summary>
 /// <param name="modifierKeyCode">The modifier key</param>
 /// <param name="keyCode">The key to simulate</param>
 public IKeyboardSimulator ModifiedKeyStroke(VirtualKeyCode modifierKeyCode, VirtualKeyCode keyCode)
 {
     ModifiedKeyStroke(new[] { modifierKeyCode }, new[] { keyCode });
     return(this);
 }
コード例 #52
0
 public InstantaneousModifierKey(string displayName, VirtualKeyCode keyCode) :
     base(keyCode)
 {
     DisplayName = displayName;
 }
コード例 #53
0
 public CtrlAltShiftAndCaseSensitiveKey(VirtualKeyCode keyCode, IList<string> keyDisplays)
     : base(keyCode, keyDisplays)
 {
 }
コード例 #54
0
 /// <summary>
 /// Simulates a modified keystroke where there are multiple modifiers and one key like CTRL-ALT-C where CTRL and ALT are the modifierKeys and C is the key.
 /// The flow is Modifiers KeyDown in order, Key Press, Modifiers KeyUp in reverse order.
 /// </summary>
 /// <param name="modifierKeyCodes">The list of modifier keys</param>
 /// <param name="keyCode">The key to simulate</param>
 public IKeyboardSimulator ModifiedKeyStroke(IEnumerable <VirtualKeyCode> modifierKeyCodes, VirtualKeyCode keyCode)
 {
     ModifiedKeyStroke(modifierKeyCodes, new[] { keyCode });
     return(this);
 }
コード例 #55
0
ファイル: InputSimulator.cs プロジェクト: H-J-P/DAC-Source
 /// <summary>
 /// Performs a simple modified keystroke like CTRL-C where CTRL is the modifierKey and C is the key.
 /// The flow is Modifier KEYDOWN, Key PRESS, Modifier KEYUP.
 /// </summary>
 /// <param name="modifierKeyCode">The modifier key</param>
 /// <param name="keyCode">The key to simulate</param>
 public static void SimulateModifiedKeyStroke(VirtualKeyCode modifierKeyCode, VirtualKeyCode keyCode)
 {
     SimulateKeyDown(modifierKeyCode);
     SimulateKeyPress(keyCode);
     SimulateKeyUp(modifierKeyCode);
 }
コード例 #56
0
 /// <summary>
 /// Simulates a modified keystroke where there is one modifier and multiple keys like CTRL-K-C where CTRL is the modifierKey and K and C are the keys.
 /// The flow is Modifier KeyDown, Keys Press in order, Modifier KeyUp.
 /// </summary>
 /// <param name="modifierKey">The modifier key</param>
 /// <param name="keyCodes">The list of keys to simulate</param>
 public IKeyboardSimulator ModifiedKeyStroke(VirtualKeyCode modifierKey, IEnumerable <VirtualKeyCode> keyCodes)
 {
     ModifiedKeyStroke(new[] { modifierKey }, keyCodes);
     return(this);
 }
コード例 #57
0
ファイル: InputSimulator.cs プロジェクト: H-J-P/DAC-Source
 /// <summary>
 /// Performs a modified keystroke where there is one modifier and multiple keys like CTRL-K-C where CTRL is the modifierKey and K and C are the keys.
 /// The flow is Modifier KEYDOWN, Keys PRESS in order, Modifier KEYUP.
 /// </summary>
 /// <param name="modifierKey">The modifier key</param>
 /// <param name="keyCodes">The list of keys to simulate</param>
 public static void SimulateModifiedKeyStroke(VirtualKeyCode modifierKey, IEnumerable<VirtualKeyCode> keyCodes)
 {
     SimulateKeyDown(modifierKey);
     if (keyCodes != null) keyCodes.ToList().ForEach(x => SimulateKeyPress(x));
     SimulateKeyUp(modifierKey);
 }
コード例 #58
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="keyCode"></param>
 /// <param name="displayName"></param>
 public VirtualKey(VirtualKeyCode keyCode, string displayName)
 {
     DisplayName = displayName;
     KeyCode     = keyCode;
 }
コード例 #59
0
ファイル: InputSimulator.cs プロジェクト: H-J-P/DAC-Source
 /// <summary>
 /// Determines whether the toggling key is toggled on (in-effect) or not by calling the GetKeyState function.  (See: http://msdn.microsoft.com/en-us/library/ms646301(VS.85).aspx)
 /// </summary>
 /// <param name="keyCode">The <see cref="VirtualKeyCode"/> for the key.</param>
 /// <returns>
 /// 	<c>true</c> if the toggling key is toggled on (in-effect); otherwise, <c>false</c>.
 /// </returns>
 /// <remarks>
 /// The key status returned from this function changes as a thread reads key messages from its message queue. The status does not reflect the interrupt-level state associated with the hardware. Use the GetAsyncKeyState function to retrieve that information. 
 /// An application calls GetKeyState in response to a keyboard-input message. This function retrieves the state of the key when the input message was generated. 
 /// To retrieve state information for all the virtual keys, use the GetKeyboardState function. 
 /// An application can use the virtual-key code constants VK_SHIFT, VK_CONTROL, and VK_MENU as values for the nVirtKey parameter. This gives the status of the SHIFT, CTRL, or ALT keys without distinguishing between left and right. An application can also use the following virtual-key code constants as values for nVirtKey to distinguish between the left and right instances of those keys. 
 /// VK_LSHIFT
 /// VK_RSHIFT
 /// VK_LCONTROL
 /// VK_RCONTROL
 /// VK_LMENU
 /// VK_RMENU
 /// 
 /// These left- and right-distinguishing constants are available to an application only through the GetKeyboardState, SetKeyboardState, GetAsyncKeyState, GetKeyState, and MapVirtualKey functions. 
 /// </remarks>
 public static bool IsTogglingKeyInEffect(VirtualKeyCode keyCode)
 {
     Int16 result = GetKeyState((UInt16)keyCode);
     return (result & 0x01) == 0x01;
 }
コード例 #60
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="keyCode"></param>
 public VirtualKey(VirtualKeyCode keyCode)
 {
     KeyCode = keyCode;
 }