Write A Program To Generate Key Stroke On Windows

Write A Program To Generate Key Stroke On Windows 3,6/5 5131 reviews

Jul 22, 2015 There are myriad ways to open programs in Windows 10 - use the Start menu/screen, pin shortcuts to the taskbar, or use Cortana. But if hands-free isn't your thing, you can also use keyboard. Aug 24, 2011.

Write A Program To Generate Key Stroke On Windows 7
Write A Program To Generate Keystroke On Windows 1
Write A Program To Generate Keystroke On Windows 5

-->

Windows Forms provides several options for programmatically simulating mouse and keyboard input. This topic provides an overview of these options.

Simulating Mouse Input

The best way to simulate mouse events is to call the OnEventName method that raises the mouse event you want to simulate. This option is usually possible only within custom controls and forms, because the methods that raise events are protected and cannot be accessed outside the control or form. For example, the following steps illustrate how to simulate clicking the right mouse button in code.

To programmatically click the right mouse button

Create a MouseEventArgs whose Button property is set to the MouseButtons.Right value.
Call the OnMouseClick method with this MouseEventArgs as the argument.

For more information on custom controls, see Developing Windows Forms Controls at Design Time.

There are other ways to simulate mouse input. For example, you can programmatically set a control property that represents a state that is typically set through mouse input (such as the Checked property of the CheckBox control), or you can directly call the delegate that is attached to the event you want to simulate.

Simulating Keyboard Input

Although you can simulate keyboard input by using the strategies discussed above for mouse input, Windows Forms also provides the SendKeys class for sending keystrokes to the active application.

Caution

If your application is intended for international use with a variety of keyboards, the use of SendKeys.Send could yield unpredictable results and should be avoided.

Note

The SendKeys class has been updated for the .NET Framework 3.0 to enable its use in applications that run on Windows Vista. The enhanced security of Windows Vista (known as User Account Control or UAC) prevents the previous implementation from working as expected.

The SendKeys class is susceptible to timing issues, which some developers have had to work around. The updated implementation is still susceptible to timing issues, but is slightly faster and may require changes to the workarounds. The SendKeys class tries to use the previous implementation first, and if that fails, uses the new implementation. As a result, the SendKeys class may behave differently on different operating systems. Additionally, when the SendKeys class uses the new implementation, the SendWait method will not wait for messages to be processed when they are sent to another process.

If your application relies on consistent behavior regardless of the operating system, you can force the SendKeys class to use the new implementation by adding the following application setting to your app.config file.

To force the SendKeys class to use the previous implementation, use the value 'JournalHook' instead.

To send a keystroke to the same application

Call the Send or SendWait method of the SendKeys class. The specified keystrokes will be received by the active control of the application. The following code example uses Send to simulate pressing the ENTER key when the user double-clicks the surface of the form. This example assumes a Form with a single Button control that has a tab index of 0.

To send a keystroke to a different application

Activate the application window that will receive the keystrokes, and then call the Send or SendWait method. Because there is no managed method to activate another application, you must use native Windows methods to force focus on other applications. The following code example uses platform invoke to call the FindWindow and SetForegroundWindow methods to activate the Calculator application window, and then calls SendWait to issue a series of calculations to the Calculator application.
Note
The correct parameters of the FindWindow call that locates the Calculator application vary based on your version of Windows. The following code finds the Calculator application on Windows 7. On Windows Vista, change the first parameter to 'SciCalc'. You can use the Spy++ tool, included with Visual Studio, to determine the correct parameters.

Example

The following code example is the complete application for the previous code examples.

Compiling the Code

This example requires:

References to the System, System.Drawing and System.Windows.Forms assemblies.

Create and build a driver

Open Microsoft Visual Studio. On the File menu, choose New > Project.
In the New Project dialog box, in the left pane, go to Visual C++ > Windows Drivers > WDF.
In the middle pane, select Kernel Mode Driver, Empty (KMDF).
In the Name field, enter 'KmdfHelloWorld' for the project name. Quick heal total security 2013 serial key generator free download.
Note
When you create a new KMDF or UMDF driver, you must select a driver name that has 32 characters or less. This length limit is defined in wdfglobals.h.
In the Location field, enter the directory where you want to create the new project.
Check Create directory for solution. Click OK.
Visual Studio creates one project and a solution. You can see them in the Solution Explorer window, shown here. (If the Solution Explorer window is not visible, choose Solution Explorer from the View menu.) The solution has a driver project named KmdfHelloWorld.
In the Solution Explorer window, right-click the KmdfHelloWorld project and choose Properties. Navigate to Configuration Properties > Driver Settings > General, and note that Target Platform defaults to Universal. Click Cancel.
In the Solution Explorer window, again right-click the KmdfHelloWorld project and choose Add > New Item.
In the Add New Item dialog box, select C++ File. For Name, enter 'Driver.c'.
Click Add. The Driver.c file is added under Source Files, as shown here.

Write your first driver code

Now that you've created your empty Hello World project and added the Driver.c source file, you'll write the most basic code necessary for the driver to run by implementing two basic event callback functions.

In Driver.c, start by including these headers:
Ntddk.h contains core Windows kernel definitions for all drivers, while Wdf.h contains definitions for drivers based on the Windows Driver Framework (WDF).
Next, provide declarations for the two callbacks you'll use:
Use the following code to write your DriverEntry:
DriverEntry is the entry point for all drivers, like Main() is for many user mode applications. The job of DriverEntry is to initialize driver-wide structures and resources. In this example, you printed 'Hello World' for DriverEntry, configured the driver object to register your EvtDeviceAdd callback's entry point, then created the driver object and returned.
The driver object acts as the parent object for all other framework objects you might create in your driver, which include device objects, I/O queues, timers, spinlocks, and more. For more information about framework objects, see Introduction to Framework Objects.
Tip
For DriverEntry, we strongly recommend keeping the name as 'DriverEntry' to help with code analysis and debugging.
Next, use the following code to write your KmdfHelloWorldEvtDeviceAdd:
EvtDeviceAdd is invoked by the system when it detects that your device has arrived. Its job is to initialize structures and resources for that device. In this example, you simply printed out a 'Hello World' message for EvtDeviceAdd, created the device object, and returned. In other drivers you write, you might create I/O queues for your hardware, set up a device context storage space for device-specific information, or perform other tasks needed to prepare your device.
Tip
For the device add callback, notice how you named it with your driver's name as a prefix (KmdfHelloWorldEvtDeviceAdd). Generally, we recommend naming your driver's functions in this way to differentiate them from other drivers' functions. DriverEntry is the only one you should name exactly that.
Your complete Driver.c now looks like this:
Save Driver.c.

This example illustrates a fundamental concept of drivers: they are a 'collection of callbacks' that, once initialized, sit and wait for the system to call them when it needs something. This could be a new device arrival event, an I/O request from a user mode application, a system power shutdown event, a request from another driver, or a surprise removal event when a user unplugs the device unexpectedly. Fortunately, to say 'Hello World,' you only needed to worry about driver and device creation.

Next, you'll build your driver.

Build the driver

In the Solution Explorer window, right-click Solution 'KmdfHelloWorld' (1 project) and choose Configuration Manager. Choose a configuration and platform for the driver project. For this exercise, we choose Debug and x64.
In the Solution Explorer window, right-click KmdfHelloWorld and choose Properties. In Wpp Tracing > All Options, set Run Wpp tracing to No. Click Apply and then OK.
To build your driver, choose Build Solution from the Build menu. Visual Studio shows the build progress in the Output window. (If the Output window is not visible, choose Output from the View menu.) When you have verified that the solution built successfully, you can close Visual Studio.
To see the built driver, in File Explorer, go to your KmdfHelloWorld folder, and then to C:KmdfHelloWorldx64DebugKmdfHelloWorld. The folder includes:
- KmdfHelloWorld.sys -- the kernel-mode driver file
- KmdfHelloWorld.inf -- an information file that Windows uses when you install the driver
- KmdfHelloWorld.cat -- a catalog file that the installer uses to verify the driver's test signature

Write A Program To Generate Key Stroke On Windows 7

Tip

If you see DriverVer set to a date in the future when building your driver, change your driver project settings so that Inf2Cat sets /uselocaltime. To do so, use Configuration Properties->Inf2Cat->General->Use Local Time. Now both Stampinf and Inf2Cat use local time.

Deploy the driver

Typically when you test and debug a driver, the debugger and the driver run on separate computers. The computer that runs the debugger is called the host computer, and the computer that runs the driver is called the target computer. The target computer is also called the test computer.

So far you've used Visual Studio to build a driver on the host computer. Now you need to configure a target computer.

Follow the instructions in Provision a computer for driver deployment and testing (WDK 10).
Tip
When you follow the steps to provision the target computer automatically using a network cable, take note of the port and key. You'll use them later in the debugging step. In this example, we'll use 50000 as the port and 1.2.3.4 as the key.
In real driver debugging scenarios, we recommend using a KDNET-generated key. For more information about how to use KDNET to generate a random key, see the Debug Drivers - Step by Step Lab (Sysvad Kernel Mode) topic.
On the host computer, open your solution in Visual Studio. You can double-click the solution file, KmdfHelloWorld.sln, in your KmdfHelloWorld folder.
In the Solution Explorer window, right-click the KmdfHelloWorld project, and choose Properties.
In the KmdfHelloWorld Property Pages window, go to Configuration Properties > Driver Install > Deployment, as shown here.
Check Remove previous driver versions before deployment.
For Target Device Name, select the name of the computer that you configured for testing and debugging. In this exercise, we use a computer named MyTestComputer.
Select Hardware ID Driver Update, and enter the hardware ID for your driver. For this exercise, the hardware ID is RootKmdfHelloWorld. Click OK.
Note
In this exercise, the hardware ID does not identify a real piece of hardware. It identifies an imaginary device that will be given a place in the device tree as a child of the root node. For real hardware, do not select Hardware ID Driver Update; instead, select Install and Verify. You'll see the hardware ID in your driver's information (INF) file. In the Solution Explorer window, go to KmdfHelloWorld > Driver Files, and double-click KmdfHelloWorld.inf. The hardware ID is located under [Standard.NT$ARCH$].
On the Build menu, choose Deploy Solution. Visual Studio automatically copies the files required to install and run the driver to the target computer. This may take a minute or two.
When you deploy a driver, the driver files are copied to the %Systemdrive%drivertestdrivers folder on the test computer. If something goes wrong during deployment, you can check to see if the files are copied to the test computer. Verify that the .inf, .cat, test cert, and .sys files, and any other necessary files, are present in the %systemdrive%drivertestdrivers folder.
For more information about deploying drivers, see Deploying a Driver to a Test Computer.

Install the driver

With your Hello World driver deployed to the target computer, now you'll install the driver. When you previously provisioned the target computer with Visual Studio using the automatic option, Visual Studio set up the target computer to run test signed drivers as part of the provisioning process. Now you just need to install the driver using the DevCon tool.

On the host computer, navigate to the Tools folder in your WDK installation and locate the DevCon tool. For example, look in the following folder:
C:Program Files (x86)Windows Kits10Toolsx64devcon.exe
Copy the DevCon tool to your remote computer.
On the target computer, install the driver by navigating to the folder containing the driver files, then running the DevCon tool.
1. Here's the general syntax for the devcon tool that you will use to install the driver:
  devcon install <INF file> <hardware ID>
  The INF file required for installing this driver is KmdfHelloWorld.inf. The INF file contains the hardware ID for installing the driver binary, KmdfHelloWorld.sys. Recall that the hardware ID, located in the INF file, is RootKmdfHelloWorld.
2. Open a Command Prompt window as Administrator. Navigate to your folder containing the built driver .sys file and enter this command:
  devcon install kmdfhelloworld.inf rootkmdfhelloworld
  If you get an error message about devcon not being recognized, try adding the path to the devcon tool. For example, if you copied it to a folder on the target computer called C:Tools, then try using the following command:
  c:toolsdevcon install kmdfhelloworld.inf rootkmdfhelloworld
  A dialog box will appear indicating that the test driver is an unsigned driver. Click Install this driver anyway to proceed.

Debug the driver

Write A Program To Generate Keystroke On Windows 1

Now that you have installed your KmdfHelloWorld driver on the target computer, you'll attach a debugger remotely from the host computer.

Write A Program To Generate Keystroke On Windows 5

On the host computer, open a Command Prompt window as Administrator. Change to the WinDbg.exe directory. We will use the x64version of WinDbg.exe from the Windows Driver Kit (WDK) that was installed as part of the Windows kit installation. Here is the default path to WinDbg.exe:
C:Program Files (x86)Windows Kits10Debuggersx64
Launch WinDbg to connect to a kernel debug session on the target computer by using the following command. The value for the port and key should be the same as what you used to provision the target computer. We'll use 50000 for the port and 1.2.3.4 for the key, the values we used during the deploy step. The k flag indicates that this is a kernel debug session.
WinDbg -k net:port=50000,key=1.2.3.4
On the Debug menu, choose Break. The debugger on the host computer will break into the target computer. In the Debugger Command window, you can see the kernel debugging command prompt: kd>.
At this point, you can experiment with the debugger by entering commands at the kd> prompt. For example, you could try these commands:
To let the target computer run again, choose Go from the Debug menu or press 'g,' then press 'enter.'
To stop the debugging session, choose Detach Debuggee from the Debug menu.
Important
Make sure you use the 'go' command to let the target computer run again before exiting the debugger, or the target computer will remain unresponsive to your mouse and keyboard input because it is still talking to the debugger.

For a detailed step-by-step walkthrough of the driver debugging process, see Debug Universal Drivers - Step by Step Lab (Echo Kernel-Mode).

For more information about remote debugging, see Remote Debugging Using WinDbg.

ameblo.over-update.download