whats new ¦  programming tips ¦  indy articles ¦  intraweb articles ¦  informations ¦  links ¦  interviews
 misc ¦  tutorials ¦  Add&Win Game

Tips (1548)

Database (90)
Files (137)
Forms (107)
Graphic (116)
IDE (21)
Indy (5)
Internet / LAN (131)
IntraWeb (0)
Math (76)
Misc (127)
Multimedia (45)
Objects/
ActiveX (51)

OpenTools API (3)
Printing (35)
Strings (83)
System (268)
VCL (243)

Top15

Tips sort by
component


Search Tip

Add new Tip

Add&Win Game

Advertising

27 Visitors Online


 
...simulate the pressing of keyboard keys?
Autor: Babak Sateli
Homepage: http://www.cdcenterco.com
[ Print tip ]  

Tip Rating (100):  
     


{1. PostKeyEx32 function}

procedure PostKeyEx32(key: Word; const shift: TShiftState; specialkey: Boolean);
{************************************************************
* Procedure PostKeyEx32
*
* Parameters:
*  key    : virtual keycode of the key to send. For printable
*           keys this is simply the ANSI code (Ord(character)).
*  shift  : state of the modifier keys. This is a set, so you
*           can set several of these keys (shift, control, alt,
*           mouse buttons) in tandem. The TShiftState type is
*           declared in the Classes Unit.
*  specialkey: normally this should be False. Set it to True to
*           specify a key on the numeric keypad, for example.
* Description:
*  Uses keybd_event to manufacture a series of key events matching
*  the passed parameters. The events go to the control with focus.
*  Note that for characters key is always the upper-case version of
*  the character. Sending without any modifier keys will result in
*  a lower-case character, sending it with [ssShift] will result
*  in an upper-case character!
// Code by P. Below
************************************************************}
type
  
TShiftKeyInfo = record
    
shift: Byte;
    vkey: Byte;
  end;
  byteset = set of 0..7;
const
  
shiftkeys: array [1..3] of TShiftKeyInfo =
    ((shift: Ord(ssCtrl); vkey: VK_CONTROL),
    (shift: Ord(ssShift); vkey: VK_SHIFT),
    (shift: Ord(ssAlt); vkey: VK_MENU));
var
  
flag: DWORD;
  bShift: ByteSet absolute shift;
  i: Integer;
begin
  for 
i := 1 to do
  begin
    if 
shiftkeys[i].shift in bShift then
      
keybd_event(shiftkeys[i].vkey, MapVirtualKey(shiftkeys[i].vkey, 0), 0, 0);
  end{ For }
  
if specialkey then
    
flag := KEYEVENTF_EXTENDEDKEY
  else
    
flag := 0;

  keybd_event(key, MapvirtualKey(key, 0), flag, 0);
  flag := flag or KEYEVENTF_KEYUP;
  keybd_event(key, MapvirtualKey(key, 0), flag, 0);

  for i := 3 downto do
  begin
    if 
shiftkeys[i].shift in bShift then
      
keybd_event(shiftkeys[i].vkey, MapVirtualKey(shiftkeys[i].vkey, 0),
        KEYEVENTF_KEYUP, 0);
  end{ For }
end{ PostKeyEx32 }


// Example:

procedure TForm1.Button1Click(Sender: TObject);
begin
  
//Pressing the Left Windows Key
  
PostKeyEx32(VK_LWIN, [], False);

  //Pressing the letter D
  
PostKeyEx32(Ord('D'), [], False);

  //Pressing Ctrl-Alt-C
  
PostKeyEx32(Ord('C'), [ssctrl, ssAlt], False);
end;


{************************************************************}
{2. With keybd_event API}

procedure TForm1.Button1Click(Sender: TObject);
begin
  
{or you can also try this simple example to send any
   amount of keystrokes at the same time. }

  {Pressing the A Key and showing it in the Edit1.Text}

  
Edit1.SetFocus;
  keybd_event(VK_SHIFT, 0, 0, 0);
  keybd_event(Ord('A'), 0, 0, 0);
  keybd_event(VK_SHIFT, 0, KEYEVENTF_KEYUP, 0);

  {Presses the Left Window Key and starts the Run}
  
keybd_event(VK_LWIN, 0, 0, 0);
  keybd_event(Ord('R'), 0, 0, 0);
  keybd_event(VK_LWIN, 0, KEYEVENTF_KEYUP, 0);
end;


{***********************************************************}
{3. With keybd_event API}

procedure PostKeyExHWND(hWindow: HWnd; key: Word; const shift: TShiftState;
  specialkey: Boolean);
{************************************************************
 * Procedure PostKeyEx
 *
 * Parameters:
 *  hWindow: target window to be send the keystroke
 *  key    : virtual keycode of the key to send. For printable
 *           keys this is simply the ANSI code (Ord(character)).
 *  shift  : state of the modifier keys. This is a set, so you
 *           can set several of these keys (shift, control, alt,
 *           mouse buttons) in tandem. The TShiftState type is
 *           declared in the Classes Unit.
 *  specialkey: normally this should be False. Set it to True to
 *           specify a key on the numeric keypad, for example.
 *           If this parameter is true, bit 24 of the lparam for
 *           the posted WM_KEY* messages will be set.
 * Description:
 *  This procedure sets up Windows key state array to correctly
 *  reflect the requested pattern of modifier keys and then posts
 *  a WM_KEYDOWN/WM_KEYUP message pair to the target window. Then
 *  Application.ProcessMessages is called to process the messages
 *  before the keyboard state is restored.
 * Error Conditions:
 *  May fail due to lack of memory for the two key state buffers.
 *  Will raise an exception in this case.
 * NOTE:
 *  Setting the keyboard state will not work across applications
 *  running in different memory spaces on Win32 unless AttachThreadInput
 *  is used to connect to the target thread first.
 *Created: 02/21/96 16:39:00 by P. Below
 ************************************************************}
type
  
TBuffers = array [0..1] of TKeyboardState;
var
  
pKeyBuffers: ^TBuffers;
  lParam: LongInt;
begin
  
(* check if the target window exists *)
  
if IsWindow(hWindow) then
  begin
    
(* set local variables to default values *)
    
pKeyBuffers := nil;
    lParam := MakeLong(0, MapVirtualKey(key, 0));

    (* modify lparam if special key requested *)
    
if specialkey then
      
lParam := lParam or $1000000;

    (* allocate space for the key state buffers *)
    
New(pKeyBuffers);
    try
      
(* Fill buffer 1 with current state so we can later restore it.
         Null out buffer 0 to get a "no key pressed" state. *)
      
GetKeyboardState(pKeyBuffers^[1]);
      FillChar(pKeyBuffers^[0], SizeOf(TKeyboardState), 0);

      (* set the requested modifier keys to "down" state in the buffer*)
      
if ssShift in shift then
        
pKeyBuffers^[0][VK_SHIFT] := $80;
      if ssAlt in shift then
      begin
        
(* Alt needs special treatment since a bit in lparam needs also be set *)
        
pKeyBuffers^[0][VK_MENU] := $80;
        lParam := lParam or $20000000;
      end;
      if ssCtrl in shift then
        
pKeyBuffers^[0][VK_CONTROL] := $80;
      if ssLeft in shift then
        
pKeyBuffers^[0][VK_LBUTTON] := $80;
      if ssRight in shift then
        
pKeyBuffers^[0][VK_RBUTTON] := $80;
      if ssMiddle in shift then
        
pKeyBuffers^[0][VK_MBUTTON] := $80;

      (* make out new key state array the active key state map *)
      
SetKeyboardState(pKeyBuffers^[0]);
      (* post the key messages *)
      
if ssAlt in Shift then
      begin
        
PostMessage(hWindow, WM_SYSKEYDOWN, key, lParam);
        PostMessage(hWindow, WM_SYSKEYUP, key, lParam or $C0000000);
      end
      else
      begin
        
PostMessage(hWindow, WM_KEYDOWN, key, lParam);
        PostMessage(hWindow, WM_KEYUP, key, lParam or $C0000000);
      end;
      (* process the messages *)
      
Application.ProcessMessages;

      (* restore the old key state map *)
      
SetKeyboardState(pKeyBuffers^[1]);
    finally
      
(* free the memory for the key state buffers *)
      
if pKeyBuffers <> nil then
        
Dispose(pKeyBuffers);
    end{ If }
  
end;
end{ PostKeyEx }

// Example:

procedure TForm1.Button1Click(Sender: TObject);
var
  
targetWnd: HWND;
begin
  
targetWnd := FindWindow('notepad', nil)
    if targetWnd <> 0 then
    begin
      
PostKeyExHWND(targetWnd, Ord('I'), [ssAlt], False);
  end;
end;

{***********************************************************}
{3. With SendInput API}

// Example: Send text
procedure TForm1.Button1Click(Sender: TObject);
const
   
Str: string = 'writing writing writing';
var
  
Inp: TInput;
  I: Integer;
begin
  
Edit1.SetFocus;

  for I := 1 to Length(Str) do
  begin
    
// press
    
Inp.Itype := INPUT_KEYBOARD;
    Inp.ki.wVk := Ord(UpCase(Str[i]));
    Inp.ki.dwFlags := 0;
    SendInput(1, Inp, SizeOf(Inp));

    // release
    
Inp.Itype := INPUT_KEYBOARD;
    Inp.ki.wVk := Ord(UpCase(Str[i]));
    Inp.ki.dwFlags := KEYEVENTF_KEYUP;
    SendInput(1, Inp, SizeOf(Inp));

    Application.ProcessMessages;
    Sleep(80);
  end;
end;

// Example: Simulate Alt+Tab
procedure SendAltTab;
var
  
KeyInputs: array of TInput;
  KeyInputCount: Integer;

  procedure KeybdInput(VKey: Byte; Flags: DWORD);
  begin
    
Inc(KeyInputCount);
    SetLength(KeyInputs, KeyInputCount);
    KeyInputs[KeyInputCount - 1].Itype := INPUT_KEYBOARD;
    with  KeyInputs[KeyInputCount - 1].ki do
    begin
      
wVk := VKey;
      wScan := MapVirtualKey(wVk, 0);
      dwFlags := KEYEVENTF_EXTENDEDKEY;
      dwFlags := Flags or dwFlags;
      time := 0;
      dwExtraInfo := 0;
    end;
  end;
begin
  
KeybdInput(VK_MENU, 0);                // Alt
  
KeybdInput(VK_TAB, 0);                 // Tab
  
KeybdInput(VK_TAB, KEYEVENTF_KEYUP);   // Tab
  
KeybdInput(VK_MENU, KEYEVENTF_KEYUP); // Alt
  
SendInput(KeyInputCount, KeyInputs[0], SizeOf(KeyInputs[0]));
end;


 

Rate this tip:

poor
very good


Copyright © by SwissDelphiCenter.ch
All trademarks are the sole property of their respective owners