/// <summary>
        /// Simulates a key press for each of the specified key codes in the order they are specified.
        /// </summary>
        /// <param name="keyCodes"></param>
        public IKeyboardSimulator KeyPress(params VirtualKeyCode[] keyCodes)
        {
            var builder = new InputBuilder();

            KeysPress(builder, keyCodes);
            SendSimulatedInput(builder.ToArray());
            return(this);
        }
Example #2
0
        /// <summary>
        /// Simulates a modified keystroke where there are multiple modifiers and multiple keys like CTRL-ALT-K-C where CTRL and ALT are the modifierKeys and K and C are the keys.
        /// The flow is Modifiers KeyDown in order, Keys Press in order, Modifiers KeyUp in reverse order.
        /// </summary>
        /// <param name="modifierDikCodes">The list of modifier keys</param>
        /// <param name="dikCodes">The list of keys to simulate</param>
        public IKeyboardSimulator ModifiedKeyStroke(IEnumerable <DirectInputKeyCode> modifierDikCodes, IEnumerable <DirectInputKeyCode> dikCodes)
        {
            var builder = new InputBuilder();

            ModifiersDown(builder, modifierDikCodes);
            KeysPress(builder, dikCodes);
            ModifiersUp(builder, modifierDikCodes);
            SendSimulatedInput(builder.ToArray());
            return(this);
        }
        /// <summary>
        /// Simulates a modified keystroke where there are multiple modifiers and multiple keys like CTRL-ALT-K-C where CTRL and ALT are the modifierKeys and K and C are the keys.
        /// The flow is Modifiers KeyDown in order, Keys Press in order, Modifiers KeyUp in reverse order.
        /// </summary>
        /// <param name="modifierKeyCodes">The list of modifier keys</param>
        /// <param name="keyCodes">The list of keys to simulate</param>
        public IKeyboardSimulator ModifiedKeyStroke(IEnumerable <VirtualKeyCode> modifierKeyCodes, IEnumerable <VirtualKeyCode> keyCodes)
        {
            var builder = new InputBuilder(UseScanCodes);

            ModifiersDown(builder, modifierKeyCodes);
            KeysPress(builder, keyCodes);
            ModifiersUp(builder, modifierKeyCodes);

            SendSimulatedInput(builder.ToArray());
            return(this);
        }
Example #4
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 void ModifiedKeyStroke(VirtualKeyCode modifierKey, IEnumerable <VirtualKeyCode> keyCodes)
        {
            var builder = new InputBuilder();

            builder.AddKeyDown(modifierKey);
            if (keyCodes != null)
            {
                keyCodes.ToList().ForEach(x => builder.AddKeyPress(x));
            }
            builder.AddKeyUp(modifierKey);

            SendSimulatedInput(builder.ToArray());
        }
Example #5
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 void ModifiedKeyStroke(IEnumerable <VirtualKeyCode> modifierKeyCodes, VirtualKeyCode keyCode)
        {
            var builder = new InputBuilder();

            if (modifierKeyCodes != null)
            {
                modifierKeyCodes.ToList().ForEach(x => builder.AddKeyDown(x));
            }
            builder.AddKeyPress(keyCode);
            if (modifierKeyCodes != null)
            {
                modifierKeyCodes.Reverse().ToList().ForEach(x => builder.AddKeyUp(x));
            }

            SendSimulatedInput(builder.ToArray());
        }
        /// <summary>
        /// Simulates a modified keystroke where there are multiple modifiers and multiple keys like CTRL-ALT-K-C where CTRL and ALT are the modifierKeys and K and C are the keys.
        /// The flow is Modifiers KeyDown in order, Keys Press in order, Modifiers KeyUp in reverse order.
        /// </summary>
        /// <param name="modifierKeyCodes">The list of modifier keys</param>
        /// <param name="keyCodes">The list of keys to simulate</param>
        public void ModifiedKeyStroke(IEnumerable <VirtualKeyCode> modifierKeyCodes, IEnumerable <VirtualKeyCode> keyCodes)
        {
            var builder = new InputBuilder();
            var modifierKeyCodesList = modifierKeyCodes.ToList();

            if (modifierKeyCodes != null)
            {
                modifierKeyCodesList.ToList().ForEach(x => builder.AddKeyUp(x));
            }
            if (keyCodes != null)
            {
                keyCodes.ToList().ForEach(x => builder.AddKeyPress(x));
            }
            if (modifierKeyCodes != null)
            {
                modifierKeyCodesList.Reverse();
                modifierKeyCodesList.ForEach(x => builder.AddKeyUp(x));
            }

            SendSimulatedInput(builder.ToArray());
        }