nSonic Homepage » Keyboard

nSonic #152 – Mac – Schaltflächen mit Tastatur bedienen

nSonic — Sat, 26 Apr 2008 18:47:17 +0000

Geht es Euch auch so? Ihr arbeitet viel mit bzw. an der Tastatur und ärgert Euch jedesmal ein wenig, wenn mal wieder ein Dialog erscheint und Ihr nun zur Maus greifen müsst um eine Schaltfläche, einen Button, zu drücken.
Das muss aber nicht sein! Man kann die meisten Schaltflächen nämlich auch mit der Tastatur bedienen. Außerdem gibt es eine Einstellung mit der man dann zukünftig alle Schaltflächen (und andere Elemente in Bildschirmmasken) einfach erreichen kann. Wie das geht, das erfahrt Ihr in dieser Folge #152.

Folge in voller Auflösung herunterladen

Get the Flash Player to see this player.

Key Codes

nSonic — Sat, 12 May 2007 15:16:35 +0000

{ Virtual Keys, Standard Set }

VK_LBUTTON = 1;
VK_RBUTTON = 2;
VK_CANCEL = 3;
VK_MBUTTON = 4; { NOT contiguous with L & RBUTTON }
VK_BACK = 8;
VK_TAB = 9;
VK_CLEAR = 12;
VK_RETURN = 13;
VK_SHIFT = $10;
VK_CONTROL = 17;
VK_MENU = 18;

VK_PAUSE = 19;
VK_CAPITAL = 20;
VK_KANA = 21;
VK_HANGUL = 21;
VK_JUNJA = 23;
VK_FINAL = 24;
VK_HANJA = 25;
VK_KANJI = 25;
VK_CONVERT = 28;
VK_NONCONVERT = 29;
VK_ACCEPT = 30;
VK_MODECHANGE = 31;
VK_ESCAPE = 27;
VK_SPACE = $20;
VK_PRIOR = 33;
VK_NEXT = 34;
VK_END = 35;
VK_HOME = 36;
VK_LEFT = 37;
VK_UP = 38;
VK_RIGHT = 39;
VK_DOWN = 40;
VK_SELECT = 41;
VK_PRINT = 42;
VK_EXECUTE = 43;
VK_SNAPSHOT = 44;
VK_INSERT = 45;
VK_DELETE = 46;
VK_HELP = 47;
{ VK_0 thru VK_9 are the same as ASCII ‘0′ thru ‘9′ ($30 – $39) }
{ VK_A thru VK_Z are the same as ASCII ‘A’ thru ‘Z’ ($41 – $5A) }
VK_LWIN = 91;
VK_RWIN = 92;
VK_APPS = 93;
VK_NUMPAD0 = 96;
VK_NUMPAD1 = 97;
VK_NUMPAD2 = 98;
VK_NUMPAD3 = 99;
VK_NUMPAD4 = 100;
VK_NUMPAD5 = 101;
VK_NUMPAD6 = 102;
VK_NUMPAD7 = 103;
VK_NUMPAD8 = 104;
VK_NUMPAD9 = 105;
VK_MULTIPLY = 106;
VK_ADD = 107;
VK_SEPARATOR = 108;
VK_SUBTRACT = 109;
VK_DECIMAL = 110;
VK_DIVIDE = 111;
VK_F1 = 112;
VK_F2 = 113;
VK_F3 = 114;
VK_F4 = 115;
VK_F5 = 116;
VK_F6 = 117;
VK_F7 = 118;
VK_F8 = 119;
VK_F9 = 120;
VK_F10 = 121;
VK_F11 = 122;
VK_F12 = 123;
VK_F13 = 124;
VK_F14 = 125;
VK_F15 = 126;
VK_F16 = 127;
VK_F17 = 128;
VK_F18 = 129;
VK_F19 = 130;
VK_F20 = 131;
VK_F21 = 132;
VK_F22 = 133;
VK_F23 = 134;
VK_F24 = 135;
VK_NUMLOCK = 144;
VK_SCROLL = 145;
{ VK_L & VK_R – left and right Alt, Ctrl and Shift virtual keys.
Used only as parameters to GetAsyncKeyState() and GetKeyState().
No other API or message will distinguish left and right keys in this way. }
VK_LSHIFT = 160;
VK_RSHIFT = 161;
VK_LCONTROL = 162;
VK_RCONTROL = 163;
VK_LMENU = 164;
VK_RMENU = 165;
VK_PROCESSKEY = 229;
VK_ATTN = 246;
VK_CRSEL = 247;
VK_EXSEL = 248;
VK_EREOF = 249;
VK_PLAY = 250;
VK_ZOOM = 251;
VK_NONAME = 252;
VK_PA1 = 253;
VK_OEM_CLEAR = 254;

[tags]Delphi, System, Keyboard[/tags]

Keys Status

nSonic — Sat, 12 May 2007 15:15:52 +0000

Procedure TForm1.GetStatusInfo;

const

  CapPanel  = 1;

  NumPanel  = 2;

  ScrlPanel = 3;

  DatePanel = 4;

begin

  with StatusBar1 do

  begin

    if GetKeyState(VK_CAPITAL) <> 0 then

      StatusBar1.Panels[CapPanel].Text := ‘ CAP’

    else

      StatusBar1.Panels[CapPanel].Text := ”;

    if GetKeyState(VK_NUMLOCK) <> 0 then

      StatusBar1.Panels[NumPanel].Text := ‘ NUM’

    else

      StatusBar1.Panels[NumPanel].Text := ”;

    if GetKeyState(VK_SCROLL) <> 0 then

      StatusBar1.Panels[ScrlPanel].Text := ‘ SCRL’

    else

      StatusBar1.Panels[ScrlPanel].Text := ”;

   StatusBar1.Panels[DatePanel].Text := FormatDateTime(‘ mmmm D, YYYYY’, now);

  end;

End;

[tags]Delphi, System, Keyboard[/tags]

Simulating a keystroke

nSonic — Sat, 12 May 2007 15:14:25 +0000

> I know this a dumb question but how do I make the system think the user
> pressed Enter from somewhere other than the onKeypress or OnKeyDown events?

{Key Down}

  keybd_Event(VK_RETURN, 0, 0, 0) ;

  Sleep(100);

  {Key Up}

  keybd_Event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);

[tags]Delphi, System, Keyboard[/tags]

EasterEggs

nSonic — Sat, 12 May 2007 14:50:29 +0000

>
> How to capture ALT+T E A M in a about box?
>

Hi … Set the form’s KeyPreview property to True and then write the
following code :

var

  Form1: TForm1;

  Text2 :String;// Global string.
implementation
{$R *.DFM}
procedure TForm1.FormCreate(Sender: TObject);

begin

  Text2 := EmptyStr;

end;
procedure TForm1.FormKeyUp(Sender: TObject; var Key: Word;

  Shift: TShiftState);

begin

  if ssAlt in Shift then

   begin

    if Pos(Text2 + UpCase(Chr(Key)), ‘TEAM’) > 0 then

      begin

        Text2 := Text2 + UpCase(Chr(Key ));

      end

    else

      begin

        Text2 := UpCase(Chr(Key ));

      end;

    if Text2 = ‘TEAM’ then

      begin

      Text2 := EmptyStr;

      // from here, you can write anything you’d like to be done …

      ShowMessage(‘Easter Egg!!’);

      end;

    end;

end;
end.

[tags]Delphi, Misc, Keyboard[/tags]

nSonic Homepage

nSonic — Sat, 12 May 2007 14:44:15 +0000

> yes, but what is the virtual-key code for ALT+F?
>

There ain’t one, this is a key *combination*, not a single keystroke.
It would require several messages:

wm_syskeydown for VK_MENU (alt)
wm_syskeydown for Ord(‘F’)
wm_syschar for ‘F’
wm_syskeyup for Ord(‘F’),
wm_syskeyup for VM_MENU

The wm_syschar is not required if you use POstMessage instead of
SendMessage. However, it will probably still not work if the receiver
window checks for Alt down with GetKeyState instead of looking at the
Alt bit in the messages lparam, sending these messages does not change
the keystate array. The following procedure fixes this by changing the
array manually:

{************************************************************

 * 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

 ************************************************************}
Procedure PostKeyEx( hWindow: HWnd; key:Word;Const shift:

TShiftState;

                     specialkey:Boolean);
Type

  TBuffers =Array[0..1]of TKeyboardState;
Var

  pKeyBuffers :^TBuffers;

  lparam:LongInt;
Begin
(* check if the target window exists *)
If IsWindow(hWindow)ThenBegin
(* 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 }            
PostKeyEx( targetWnd, Ord(‘F’), [ssAlt], false );

would send an Alt-F. But only if the target window is in the current
process. Since each thread has its own keystate array the code cannot
work properly if the receiver is in another process or even another
thread of the current process. In this case the only option is to make
the receiver window active (SetForegroundWindow) and use keybd_event to
manufacture the keystrokes.

{************************************************************

 * 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!

 *Created: 17.7.98 by P. Below

 ************************************************************}
Procedure PostKeyEx32( key:Word;Const shift: TShiftState;

                     specialkey:Boolean);
Type

    TShiftKeyInfo =Record

                      shift:Byte;

                      vkey :Byte;
End;

    byteset =Setof 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 3 DoBegin
If shiftkeys[i].shiftIn 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 1 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 }

[tags]Delphi, Misc, Keyboard[/tags]