Jump to content

Simulate input/Keyboard

From Rosetta Code
Task
Simulate input/Keyboard
You are encouraged to solve this task according to the task description, using any language you may know.
Task

Send simulated keystrokes to a GUI window, or terminal.

You should specify whether the target may be externally created (i.e., if the keystrokes are going to an application other than the application that is creating them).

AutoHotkey

Target may be externally created.

run, cmd /k   
WinWait, ahk_class ConsoleWindowClass
controlsend, ,hello console, ahk_class ConsoleWindowClass

AutoIt

Code assumes you're working on a windows box. Run() can use any program, and WinWaitActive() requires the title of the program as it will be when it opens.

Run("notepad") 
WinWaitActive("Untitled - Notepad")
Send("The answer is 42")

It takes user input in variable using "input box" and displays that in "message box"

$name="type your name here"
$name = InputBox("Name","Your name please ?",$name)
MsgBox(0,"Name","Your name is: "&$name)

BASIC

Applesoft BASIC

EXEC KB executes the text file KB from disk as if you had typed everything that is in the KB text file. MON I will MONitor Input from disk.

 100  REM SIMULATE KEYBORD INPUT
 110  GOSUB 170"OPEN&WRITE KB
 120  PRINT "HOME:RUN140"M$"MARK
 130  PRINT D$C$A$"EXEC"F$: END 
 140  INPUT "NAME? ";N$
 150  PRINT "HELLO, "N$"!"
 160  END 
 170 D$ =  CHR$ (4):C$ = "CLOSE"
 180 M$ =  CHR$ (13):O$ = "OPEN"
 190 F$ = "KB":A$ = F$ + M$ + D$
 200  PRINT D$"MON I"M$D$O$;
 210  PRINT A$C$A$"DELETE"A$O$;
 220  PRINT A$"WRITE"F$: RETURN
Output:
NAME? MARK
HELLO, MARK!

]

Commodore BASIC

Most of the logic here is dedicated to detecting which Commodore model the program is being run on, in order to use the correct addresses for the keyboard input buffer.

100 : REM SIMULATE KEYBORD INPUT
110 GOSUB 170:REM DETERMINE MODEL/LOCATIONS
120 PRINT CHR$(147);"NAME? MARK";CHR$(19);
130 POKE KB,13:POKE NC,1:REM PUT A RETURN IN BUFFER
140 INPUT "NAME"; N$
150 PRINT "HELLO, "N$"!"
160 END
170 : REM DETECT MODEL
180 V=40:GOSUB 260:IF B=58 THEN NC=158:KB=624:RETURN:REM PET
190 V=43:GOSUB 260:IF B<>58 THEN 240
200 IF A=1025 OR A=2049 OR A=4609 THEN NC=198:KB=631:RETURN:REM VIC-20 OR C64
210 IF A<>4097 THEN 240
220 IF PEEK(65305)=238 THEN NC=239:KB=1319:RETURN:REM C-16 OR PLUS/4
230 IF PEEK(36879)=27 THEN NC=198:KB=631:RETURN:REM UNEXPANDED VIC-20
240 V=45:GOSUB 260:IF B=58 THEN NC=208:KB=842:RETURN:REM C-128
250 PRINT "UNKNOWN MODEL!":END
260 A=PEEK(V)+256*PEEK(V+1):B=PEEK(A+4):RETURN
Output:
NAME? MARK
HELLO, MARK!

READY.

C

Translation of: OCaml
Library: Xlib

Compile with:

gcc -o simkeypress -L/usr/X11R6/lib -lX11 simkeypress.c
#include <stdio.h>
#include <stdlib.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>

int main(int argc, char *argv[])
{
  Display *dpy;
  Window win;
  GC gc;
  int scr;
  Atom WM_DELETE_WINDOW;
  XEvent ev;
  XEvent ev2;
  KeySym keysym;
  int loop;

  /* open connection with the server */
  dpy = XOpenDisplay(NULL);
  if (dpy == NULL) {
    fputs("Cannot open display", stderr);
    exit(1);
  }
  scr = XDefaultScreen(dpy);

  /* create window */
  win = XCreateSimpleWindow(dpy,
          XRootWindow(dpy, scr),
          /* x, y, width, height, border_width */
          10, 10, 300, 200, 1,
          /* border, background */
          XBlackPixel(dpy, scr), XWhitePixel(dpy, scr));

  /* set window name */
  XStoreName(dpy, win, argv[0]);

  /* select kind of events we are interested in */
  XSelectInput(dpy, win, ExposureMask | KeyPressMask | ButtonPressMask);

  /* map (show) the window */
  XMapWindow(dpy, win);
  XFlush(dpy);

  /* default graphics context */
  gc = XDefaultGC(dpy, scr);

  /* connect the close button in the window handle */
  WM_DELETE_WINDOW = XInternAtom(dpy, "WM_DELETE_WINDOW", True);
  XSetWMProtocols(dpy, win, &WM_DELETE_WINDOW, 1);

  /* event loop */
  loop = 1;
  while (loop) {
    XNextEvent(dpy, &ev);
    switch (ev.type)
    {
      case Expose:
        /* draw or redraw the window */
        {
          char msg1[] = "Clic in the window to generate";
          char msg2[] = "a key press event";
          XDrawString(dpy, win, gc, 10, 20, msg1, sizeof(msg1)-1);
          XDrawString(dpy, win, gc, 10, 35, msg2, sizeof(msg2)-1);
        }
        break;

      case ButtonPress:
        puts("ButtonPress event received");
        /*
        printf("> button (x,y) : %d %d\n",
               ev.xbutton.x,
               ev.xbutton.y);
        */
        ev2.type = KeyPress;
        ev2.xkey.state = ShiftMask;
        ev2.xkey.keycode = 24 + (rand() % 33);
        ev2.xkey.same_screen = True;
        XSendEvent(dpy, win, True/*propagate*/, KeyPressMask, &ev2);
        break;
   
      case ClientMessage:
        /* delete window event */
        if (ev.xclient.data.l[0] == WM_DELETE_WINDOW)
          loop = 0;
        break;
   
      case KeyPress:
        /* handle key press */
        puts("KeyPress event received");
        printf("> keycode: %d\n", ev.xkey.keycode);
        /* exit if q or escape are pressed */
        keysym = XLookupKeysym(&(ev.xkey), 0);
        if (keysym == XK_q ||
            keysym == XK_Escape) {
          loop = 0;
        } else {
          char buffer[] = "  ";
          int nchars = XLookupString(
                &(ev.xkey),
                buffer,
                2,  /* buffer size */
                &keysym,
                NULL );
          if (nchars == 1)
            printf("> Key '%c' pressed\n", buffer[0]);
        }
        break;
    }
  }
  XDestroyWindow(dpy, win);
  /* close connection to server */
  XCloseDisplay(dpy);
  return 1;
}


Library: Gadget

Compile with ./ccpre.sh siminput . -c for testing with VALGRIND

Then, execute ./siminput

#include <gadget/gadget.h>

LIB_GADGET_START

Main
   Enable_raw_mode();
   int tecla=0;
   int t=0;
   while (tecla!=27 ){
       while ( Kbhit() ){
           tecla = Getch();
           Disable_raw_mode();
          /* para algunas teclas, imprimirá el código interno que maneja
             Gadget para estos eventos, código que no es estándar */
           printf("TECLA = %d\n",tecla);
           Enable_raw_mode();
       }
       usleep(100);
       ++t;
       if ( t==10000 ){
           system("xdotool key Return");
       }else if( t==11000 ){
          // Mi teclado actual es del MacBook Pro.
          // En otro tipo de teclado, el código puede cambiar.
          // consulte X11/keysymdef.h para más informacion.
           Key_put(KEYP_ENTER); //0xff8d);

       }else if( t==12000 ){
           Key_put(KEYP_LEFT);

       }else if( t==13000 ){
           Key_put(KEYP_RIGHT);
           
       }else if( t==14000 ){
           Key_put(KEYP_UP);
       }else if( t==15000 ){
           Key_put(KEYP_DOWN);
           
       }else if( t==16000 ){
           Key_put(KEYP_PAGEUP);
       }else if( t==17000 ){
           Key_put(KEYP_PAGEDOWN);

       }else if( t==18000 ){
           Key_put(KEYP_HOME);
       }else if( t==19000 ){
           Key_put(KEYP_END);
       }else if( t==20000 ){
           Key_put(' ');
       }else if( t==21000 ){
           Key_put(KEYP_BACKSP);
       }else if( t==22000 ){
           Key_put(KEYP_TAB);
       }else if( t==23000 ){
           Key_put(KEYP_DELETE);

       }else if( t==24000 ){
           Key_put_ctrl('a');
       }else if( t==24100 ){
           Key_put_ctrl('b');
       }else if( t==24200 ){
           Key_put_ctrl('w');

       }else if( t==24300 ){
           Key_put_shift('a');

       }else if( t==24400 ){
           Key_put_alt('j'); // esto no funciona en mi teclado
           
       }else if( t>=25000 ){
           Key_put(KEYP_ESCAPE);
       }
   }

  // Put_kbd_text() reconoce estos caracteres: otros caracteres, el
  // resultado puede ser indefinido.

   Put_kbd_text("Hola mundo[](){},.:;-_=?$%&/#@! \t<cruel>\n Año 2023");
   
   String read;
   // si no se ha puesto nada en el buffer de entrada con Put_kbd_text(),
   // read será NULL:
   read = Read_typed_string();
   
   Disable_raw_mode();
   if ( read){
       printf("\nTEXTO = %s\nChar = %d\n",read, read[strlen(read)-1]);
   }
   free(read);
End
Output:
$ ./siminput
TECLA = 13
TECLA = 13
TECLA = 1000
TECLA = 1001
TECLA = 1002
TECLA = 1003
TECLA = 1007
TECLA = 1008
TECLA = 1005
TECLA = 1006
TECLA = 32
TECLA = 127
TECLA = 9
TECLA = 1004
TECLA = 1
TECLA = 2
TECLA = 23
TECLA = 65
TECLA = 27

TEXTO = Hola mundo[](){},.:;-_=?$%&/#@! 	<cruel>
 Año 2023
Char = 51

Clojure

Translation of: Java
(import java.awt.Robot)
(import java.awt.event.KeyEvent)
(defn keytype [str]
  (let [robot (new Robot)]
       (doseq [ch str] 
	      (if (Character/isUpperCase ch)
		  (doto robot
			(.keyPress (. KeyEvent VK_SHIFT))
			(.keyPress (int ch))
			(.keyRelease (int ch))
			(.keyRelease (. KeyEvent VK_SHIFT)))
		  (let [upCh (Character/toUpperCase ch)]
		       (doto robot 
			     (.keyPress (int upCh))
			     (.keyRelease (int upCh))))))))

Go

Library: keybd_event
Works with: Ubuntu 16.04

Should also work on Windows 10 though I haven't tested it.

The program runs a directory listing by sending the keys 'd', 'i', 'r', 'enter' to the terminal.

N.B. You may need to execute: 'sudo chmod +0666 /dev/uinput' first if running on Linux.

package main

import (
    "github.com/micmonay/keybd_event"
    "log"
    "runtime"
    "time"
)

func main() {
    kb, err := keybd_event.NewKeyBonding()
    if err != nil {
        log.Fatal(err)
    }

    // For linux, need to wait 2 seconds
    if runtime.GOOS == "linux" {
        time.Sleep(2 * time.Second)
    }

    //set keys
    kb.SetKeys(keybd_event.VK_D, keybd_event.VK_I, keybd_event.VK_R, keybd_event.VK_ENTER)

    //launch
    err = kb.Launching()
    if err != nil {
        log.Fatal(err)
    }
}

GUISS

Start,Programs,Accessories,Notepad,Textbox,Type:Hello World[pling]

Java

Works with: Java version 1.5+
Library: AWT

Keystrokes when this function is executed will go to whatever application has focus at the time. Special cases may need to be made for certain symbols, but most of the VK values in KeyEvent map to the ASCII values of characters.

import java.awt.Robot
public static void type(String str){
   Robot robot = new Robot();
   for(char ch:str.toCharArray()){
      if(Character.isUpperCase(ch)){
         robot.keyPress(KeyEvent.VK_SHIFT);
         robot.keyPress((int)ch);
         robot.keyRelease((int)ch);
         robot.keyRelease(KeyEvent.VK_SHIFT);
      }else{
         char upCh = Character.toUpperCase(ch);
         robot.keyPress((int)upCh);
         robot.keyRelease((int)upCh);
      }
   }
}

Kotlin

// version 1.1.2

import java.awt.Robot
import java.awt.event.KeyEvent

fun sendChars(s: String, pressReturn: Boolean = true) {
    val r = Robot()
    for (c in s) {
        val ci = c.toUpperCase().toInt()
        r.keyPress(ci)
        r.keyRelease(ci)
    }
    if (pressReturn) {
        r.keyPress(KeyEvent.VK_ENTER)
        r.keyRelease(KeyEvent.VK_ENTER)
    }
}

fun main(args: Array<String>) {
    sendChars("dir")  // runs 'dir' command 
}

LabVIEW

Uses .NET for simplicity. Run it with Highlight Execution on, to give notepad time to open. This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.

Nim

This example implements limited capability of simulating input/Keyboard on Windows using standard library only. For better Windows support we can use Winim and xdo for Linux. Current example will simulate keyboard input of typing Hello world to the current focused window.

when defined(windows):
  import winlean
else:
  {.error: "not supported os".}

type
  InputType = enum
    itMouse itKeyboard itHardware
  KeyEvent = enum
    keExtendedKey = 0x0001
    keKeyUp = 0x0002
    keUnicode = 0x0004
    keScanCode = 0x0008


  MouseInput {.importc: "MOUSEINPUT".} = object
    dx, dy: clong
    mouseData, dwFlags, time: culong
    dwExtraInfo: int # ULONG_PTR

  KeybdInput {.importc: "KEYBDINPUT".} = object
    wVk, wScan: cint
    dwFlags, time: culong
    dwExtraInfo: int

  HardwareInput {.importc: "HARDWAREINPUT".} = object
    uMsg: clong
    wParamL, wParamH: cint

  InputUnion {.union.} = object
    hi: HardwareInput
    mi: MouseInput
    ki: KeybdInput
  Input = object
    `type`: clong
    hwin: InputUnion

proc sendInput(total: cint, inp: ptr Input, size: cint) {.importc: "SendInput", header: "<windows.h>".}

proc initKey(keycode: int): Input =
  result = Input(`type`: itKeyboard.clong)
  var keybd = KeybdInput(wVk: keycode.cint, wScan: 0, time: 0,
    dwExtraInfo: 0, dwFlags: 0)
  result.hwin = InputUnion(ki: keybd)

proc pressKey(input: var Input) =
  input.hwin.ki.dwFlags = keExtendedKey.culong
  sendInput(cint 1, addr input, sizeof(Input).cint)

proc releaseKey(input: var Input) =
  input.hwin.ki.dwFlags = keExtendedKey.culong or keKeyUp.culong
  sendInput(cint 1, addr input, sizeof(Input).cint)

proc pressRelease(input: var Input) =
  input.pressKey
  input.releaseKey

proc pressReleaseKeycode(input: var Input, code: int) =
  input.hwin.ki.wVk = code.cint
  input.pressRelease

proc main =
  var
    shift = initKey 0xa0 # VK_LSHIFT
    key = initKey 0x48

  pressKey shift
  pressRelease key
  releaseKey shift
  key.pressReleaseKeycode 0x45 # e key
  key.pressReleaseKeycode 0x4c # l key
  key.pressReleaseKeycode 0x4c # l key
  key.pressReleaseKeycode 0x4f # o key
  key.pressReleaseKeycode 0x20 # VK_SPACE
  key.pressReleaseKeycode 0x57 # w key
  key.pressReleaseKeycode 0x4f # o key
  key.pressReleaseKeycode 0x52 # r key
  key.pressReleaseKeycode 0x4c # l key
  key.pressReleaseKeycode 0x44 # d key

main()

Compile and run it by (assuming we have GNU C compiler):

nim c -r ourfile.nim

OCaml

Library: OCaml-Xlib

This example uses the Xlib to create a window, then when the user clics in this window an XKeyPressedEvent is sent with the function xSendEvent.

run with:

ocaml -I +Xlib Xlib.cma keysym.cma send_event.ml
open Xlib

let () =
  (* open connection with the server *)
  let d = xOpenDisplay "" in
  let s = xDefaultScreen d in

  Random.self_init();

  (* create window *)
  let w = xCreateSimpleWindow d (xRootWindow d s) 10 10 300 200 1
                                (xBlackPixel d s) (xWhitePixel d s) in

  (* set window name *)
  xStoreName d w Sys.argv.(0);

  (* select kind of events we are interested in *)
  xSelectInput d w [ExposureMask; KeyPressMask; ButtonPressMask];

  (* map (show) the window *)
  xMapWindow d w;
  xFlush d;

  let dbl = w in
  let gc = xDefaultGC d s in

  (* connect the close button in the window handle *)
  let wm_delete_window = xInternAtom d "WM_DELETE_WINDOW" true in
  xSetWMProtocols d w wm_delete_window 1;

  (* event loop *)
  let e = new_xEvent() in
  try while true do
    xNextEvent d e;

    (* draw or redraw the window *)
    match xEventKind e with
    | XExposeEvent _ ->
        xDrawString d dbl gc 10 20 "Clic in the window to generate";
        xDrawString d dbl gc 10 35 "a key press event";

    | XButtonPressedEvent event ->
        let dat = xButtonEvent_datas event in
        (*
        Printf.printf "button x,y : %d %d\n%!"
            dat.button_x
            dat.button_y;
        *)
        let xKeyEvent_contents = {
            key_serial     = dat.button_serial;
            key_send_event = dat.button_send_event;
            key_display    = dat.button_display;
            key_window     = dat.button_window;
            key_root       = dat.button_root;
            key_subwindow  = dat.button_subwindow;
            key_time       = dat.button_time;
            key_x          = dat.button_x;
            key_y          = dat.button_y;
            key_x_root     = dat.button_x_root;
            key_y_root     = dat.button_y_root;

            key_state = [ShiftMask];
            key_keycode = (24 + Random.int 33);
            key_same_screen = true;
        } in
        let propagate = true in
        let event_mask = KeyPressMask in
        xSendEvent d w propagate event_mask (XKeyPressedEvCnt xKeyEvent_contents);

    (* delete window event *)
    | XClientMessageEvent xclient ->
        let atom = xEvent_xclient_data xclient in
        if atom = wm_delete_window then
          raise Exit

    (* handle key press *)
    | XKeyPressedEvent event ->
        print_endline "Key Pressed Event";
        begin
          let d = xKeyEvent_datas event in
          Printf.printf "keycode: %d\n%!" d.key_keycode;
        end;
        (* exit if q or escape are pressed *)
        let keysym = xLookupKeysym event 0 in
        if keysym = Keysym.xK_q ||
           keysym = Keysym.xK_Escape then
          raise Exit
        else
          let printable, c =
            let buf = "  " in
            let n, _ = xLookupString event buf in
            if (n = 1)
            then (true, buf.[0])
            else (false, '\000')
          in
          if printable then
            Printf.printf "Key '%c' pressed\n%!" c;

    | _ -> ()
  done with
  | Exit ->
      xDestroyWindow d w;
      (* close connection to server *)
      xCloseDisplay d;
;;

Oz

Library: Tk

Oz' default GUI toolkit is based on Tk. So we can do the same thing as in Tcl:

declare
  [QTk] = {Module.link ['x-oz://system/wp/QTk.ozf']}
  Entry
  Window = {QTk.build td(entry(handle:Entry))}
in
  {Window show}
  {Entry getFocus(force:true)}

  for C in "Hello, world!" do
     Key = if C == 32 then "<space>" else [C] end
  in
     {Delay 100}
     {Tk.send event(generate Entry Key)}
  end

This only works with internal windows.

Perl

Perl on linux can do this for PseudoTerminals (ptys) and Terminals (ttys) using IOCTL TIOCSTI. The same can be done with C or any other language that can use IOCTL either natively or via FFI such as JNI or JNA.

Target may be externally created, but process must be able to open tty/pty for writing.

$target = "/dev/pts/51"; 
### How to get the correct value for $TIOCSTI is discussed here : http://www.perlmonks.org/?node_id=10920
$TIOCSTI = 0x5412 ; 
open(TTY,">$target") or die "cannot open $target" ; 
$b="sleep 99334 &\015"; 
@c=split("",$b); 
sleep(2); 
foreach $a ( @c ) { ioctl(TTY,$TIOCSTI,$a); select(undef,undef,undef,0.1);} ; 
print "DONE\n";


Perl on X11 can do this using the SendKeys function from X11::GUITest

Perl on Windows can do this using the SendKeys function from Win32::GUITest

Target may be externally created.

SendKeys("Hello, how are you?\n");

Phix

Library: Phix/pGUI
--
-- demo\rosetta\Simulate_keyboard_input.exw
--
without js -- you'd better hope this sort of thing ain't possible in a browser!
include pGUI.e
 
string hw = "Look ma no hands! "
 
function timer_cb(Ihandle ih)
    if length(hw) then
        IupSetGlobalInt("KEY",hw[1])
        hw = hw[2..$]
    else
        IupSetInt(ih,"RUN",false)
    end if
    return IUP_CONTINUE
end function
 
IupOpen()
Ihandle txt = IupText("SIZE=170x10")
Ihandle dlg = IupDialog(txt,`TITLE="Simulate input", CHILDOFFSET=10x40, SIZE=200x80`)
IupShow(dlg)
Ihandle hTimer = IupTimer(Icallback("timer_cb"), 250)
if platform()!=JS then
    IupMainLoop()
    IupClose()
end if

PicoLisp

PicoLisp comes with a dedicated browser GUI. A library based on web scraping (in "lib/scrape.l") can be used to drive that GUI under program control. It allows to read GUI pages, click on HTML links, enter text into forms, and press submit buttons. In that way one application can control another application.

The documented demo application, which is also available online at app.7fach.de, is used in the following example. Keyboard input is simulated with the function 'enter' to fill the login form's name and password fields.

(load "@lib/http.l" "@lib/scrape.l")

# Connect to the demo app at http://7fach.de/8080
(scrape "7fach.de" 80 "8080")

# Log in
(expect "'admin' logged in"
   (enter 3 "admin")       # Enter user name into 3rd field
   (enter 4 "admin")       # Enter password into 4th field
   (press "login") )       # Press the "login" button

(click "Items")         # Open "Items" dialog
(click "Spare Part")    # Click on "Spare Part" article
(prinl (value 8))       # Print the price (12.50)
(click "logout")        # Log out
Output:
12.50

The same example is used in the related task Simulate input/Mouse#PicoLisp.

PowerShell

The Start-Sleep CmdLet must be used because no application loads instantaneously. The -Milliseconds parameter should be adjusted accordingly for every application.

Add-Type -AssemblyName Microsoft.VisualBasic
Add-Type -AssemblyName System.Windows.Forms
calc.exe
Start-Sleep -Milliseconds 300
[Microsoft.VisualBasic.Interaction]::AppActivate(Calc)
[System.Windows.Forms.SendKeys]::SendWait(2{ADD}2=)

PureBasic

Library: AutoWin
If AW_WinActivate("Calc")
  AW_SendKeys("123+3=")
EndIf

Python

Works with: Python version 2.7+
Works with: Python version 3.5+
Library: AutoPy
import autopy
autopy.key.type_string("Hello, world!") # Prints out "Hello, world!" as quickly as OS will allow.
autopy.key.type_string("Hello, world!", wpm=60) # Prints out "Hello, world!" at 60 WPM.
autopy.key.tap(autopy.key.Code.RETURN)
autopy.key.tap(autopy.key.Code.F1)
autopy.key.tap(autopy.key.Code.LEFT_ARROW)
Works with: Python version 2.5+
Works with: Python version 3.1+
Library: PyAutoGUI

Target may be externally created.

>>> import pyautogui
>>> pyautogui.typewrite('Hello world!')                 # prints out "Hello world!" instantly
>>> pyautogui.typewrite('Hello world!', interval=0.25)  # prints out "Hello world!" with a quarter second delay after each character
>>> pyautogui.press('enter')  # press the Enter key
>>> pyautogui.press('f1')     # press the F1 key
>>> pyautogui.press('left')   # press the left arrow key
>>> pyautogui.keyDown('shift')  # hold down the shift key
>>> pyautogui.press('left')     # press the left arrow key
>>> pyautogui.keyUp('shift')    # release the shift key
>>> pyautogui.hotkey('ctrl', 'shift', 'esc')

Racket

#lang racket/gui

(define frame (new frame%
                   (label "Example")
                   (width 300)
                   (height 300)))           ; Defines an instance of a frame to put the canvas in

(define simulate-key-canvas%
  (class canvas%
    (define/public (simulate-key key)
      (send this on-char key))              ; Creates a class that inherits from the standard canvas class, that can receive simulated key presses
    
    (define/override (on-char key)
      (displayln (send key get-key-code)))  ; Changes the method that receives key presses to show some output
    
    (super-new)))

(define canvas
  (new simulate-key-canvas%
       (parent frame)))                     ; Defines an instance of the newly created class

(send frame show #t)                        ; Shows the frame with a white canvas inside
(send canvas simulate-key (new key-event% (key-code #\k)))  ; Sends the simulated key press (with a key-event% instance)
;outputs k

Raku

(formerly Perl 6)

Works with: Rakudo version 2018.12

Use libxdo bindings to send text / keystrokes to any application that will accept keystrokes from X11.

use X11::libxdo;

my $xdo = Xdo.new;

my $active = $xdo.get-active-window;

my $command = $*VM.config<os> eq 'darwin' ?? 'open' !! 'xdg-open';

shell "$command https://www.google.com";

sleep 1;

my $match = rx[^'Google '];

say my $w = $xdo.search(:name($match))<ID>;

sleep .25;

if $w {
    $xdo.activate-window($w);
    say "Window name: ", $xdo.get-window-name( $w );
    $xdo.type($w, 'Raku language');
    sleep .25;
    $xdo.send-sequence($w, 'Tab');
    sleep .5;
    $xdo.send-sequence($w, 'Tab');
    sleep .5;
    $xdo.send-sequence($w, 'Tab');
    sleep .5;
    $xdo.send-sequence($w, 'Return');
}

REXX

Works with: PC/REXX
Works with: Personal REXX

Note:   this REXX program   only   works with the above two REXXes.

/*REXX pgm shows how to use the REXX/PC  PRESS cmd to simulate keyboard input.*/

call press 'This text will be put into a buffer as if it came from the keyboard'

        /* [↑]  text will be available for any program to use (including DOS).*/
                                       /*stick a fork in it,  we're all done. */



Rust

Works with: Rust version 1.25+
Library: AutoPilot
extern crate autopilot;
fn main() {
    autopilot::key::type_string("Hello, world!", None, None, &[]);
}

Scala

Library: Scala
import java.awt.Robot
import java.awt.event.KeyEvent

/** Keystrokes when this function is executed will go to whatever application has focus at the time.
 *  Special cases may need to be made for certain symbols, but most of
 *  the VK values in KeyEvent map to the ASCII values of characters.
 */

object Keystrokes extends App {
  def keystroke(str: String) {
    val robot = new Robot()
    for (ch <- str) {
      if (Character.isUpperCase(ch)) {
        robot.keyPress(KeyEvent.VK_SHIFT)
        robot.keyPress(ch)
        robot.keyRelease(ch)
        robot.keyRelease(KeyEvent.VK_SHIFT)
      } else {
        val upCh = Character.toUpperCase(ch)
        robot.keyPress(upCh)
        robot.keyRelease(upCh)
      }
    }
  }
  keystroke(args(0))
}

Tcl

Library: Tk

This only works with windows created by Tk; it sends a single key "x" to the given window.

set key "x"
event generate $target <Key-$key>

To send multiple keys, call repeatedly in order. Alphabetic keys can be used directly as events, " " has to be mapped to "<space>".

package require Tk
pack [text .t]
focus -force .t
foreach c [split "hello world" ""] {
   event generate .t [expr {$c eq " "?"<space>": $c}]
}

Note also that the task on keyboard macros illustrates a very closely related method.

On Windows simulate pressing the Escape, Backspace etc keys

package require twapi 
twapi::send_keys ({Esc})

VBScript

The keystrokes are sent to the active window.

Dim WshShell
Set WshShell = WScript.CreateObject("WScript.Shell")
WshShell.SendKeys "{Down}{F2}"
WScript.Sleep 1000 ' one-second delay
WshShell.SendKeys "{Left}{Left}{BkSp}{BkSp}Some text here.~" ' ~ -> Enter

Wren

Translation of: C
Library: Xlib


As it's not currently possible for Wren-cli to access Xlib directly, we embed a Wren script in a C application to complete this task.

/* Simulate_input_Keyboard.wren */

import "random" for Random

var KeyPressMask    = 1 << 0
var ShiftMask       = 1 << 0
var ButtonPressMask = 1 << 2
var ExposureMask    = 1 << 15
var KeyPress        = 2
var ButtonPress     = 4
var Expose          = 12
var ClientMessage   = 33

var XK_q            = 0x0071
var XK_Escape       = 0xff1b

foreign class XGC {
    construct default(display, screenNumber) {}
}

// XEvent is a C union, not a struct, so we amalgamate the properties
foreign class XEvent {
    construct new() {}        // creates the union and returns a pointer to it

    foreign eventType         // gets type field, common to all union members

    foreign eventType=(et)    // sets type field

    foreign state=(st)        // sets xkey.state

    foreign keycode           // gets xkey.keycode

    foreign keycode=(kc)      // sets xkey.keycode

    foreign sameScreen=(ss)   // sets xkey.same_screen

    foreign dataL             // gets xclient.data.l (data is a union)
}

foreign class XDisplay {
    construct openDisplay(displayName) {}

    foreign defaultScreen()

    foreign rootWindow(screenNumber)

    foreign blackPixel(screenNumber)

    foreign whitePixel(screenNumber)

    foreign selectInput(w, eventMask)

    foreign mapWindow(w)

    foreign closeDisplay()

    foreign nextEvent(eventReturn)

    foreign createSimpleWindow(parent, x, y, width, height, borderWidth, border, background)

    foreign drawString(d, gc, x, y, string, length)

    foreign storeName(w, windowName)

    foreign flush()

    foreign internAtom(atomName, onlyIfExists)

    foreign setWMProtocols(w, protocols, count)

    foreign sendEvent(w, propogate, eventMask, eventSend)

    foreign destroyWindow(w)
}

class X {
   foreign static lookupKeysym(keyEvent, index)

   foreign static lookupString(eventStruct, bufferReturn, bytesBuffer, keysymReturn, statusInOut)
}

 /* open connection with the server */
var xd = XDisplay.openDisplay("")
if (xd == 0) {
    System.print("Cannot open display.")
    return
}
var s = xd.defaultScreen()

/* create window */
var w = xd.createSimpleWindow(xd.rootWindow(s), 10, 10, 350, 250, 1, xd.blackPixel(s), xd.whitePixel(s))
xd.storeName(w, "Simulate keystrokes")

/* select kind of events we are interested in */
xd.selectInput(w, ExposureMask | KeyPressMask | ButtonPressMask)

/* map (show) the window */
xd.mapWindow(w)
xd.flush()

/* default graphics context */
var gc = XGC.default(xd, s)

/* connect the close button in the window handle */
var wmDeleteWindow = xd.internAtom("WM_DELETE_WINDOW", true)
xd.setWMProtocols(w, [wmDeleteWindow], 1)

/* event loop */
var e = XEvent.new()
var rand = Random.new()
while (true) {
    xd.nextEvent(e)
    var et = e.eventType
    if (et == Expose) {
        /* draw or redraw the window */
        var msg1 = "Click in the window to generate"
        var msg2 = "a random key press event"
        xd.drawString(w, gc, 10, 20, msg1, msg1.count)
        xd.drawString(w, gc, 10, 35, msg2, msg2.count)
    } else if (et == ButtonPress) {
        System.print("\nButtonPress event received")
        /* manufacture a KeyPress event and send it to the window */
        var e2 = XEvent.new()
        e2.eventType = KeyPress
        e2.state = ShiftMask
        e2.keycode = 24 + rand.int(33)
        e2.sameScreen = true
        xd.sendEvent(w, true, KeyPressMask, e2)
    } else if (et == ClientMessage) {
        /* delete window event */
         if (e.dataL[0] == wmDeleteWindow) break
    } else if (et == KeyPress) {
        /* handle key press */
        System.print("\nKeyPress event received")
        System.print("> Keycode: %(e.keycode)")
        /* exit if q or escape are pressed */
        var keysym = X.lookupKeysym(e, 0)
        if (keysym == XK_q || keysym == XK_Escape) {
            break
        } else {
            var buffer = List.filled(2, 0)
            var nchars = X.lookupString(e, buffer, 2, 0, 0) // don't need the last 2 parameters
            if (nchars == 1) {
                var b = buffer[0]
                if (b < 0) b = 256 + b 
                System.print("> Latin-1: %(b)")
                if (b < 32 || (b >= 127 && b < 160)) {
                    System.print("> Key 'control character' pressed")
                } else {
                    System.print("> Key '%(String.fromByte(b))' pressed")
                }
            }
        }
    }
}

xd.destroyWindow(w)

/* close connection to server */
xd.closeDisplay()


We now embed this Wren script in the following C program, compile and run it.

/* gcc Simulate_input_Keyboard.c -o Simulate_input_Keyboard -lX11 -lwren -lm */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include "wren.h"

/* C <=> Wren interface functions */

void C_displayAllocate(WrenVM* vm) {
    Display** pdisplay = (Display**)wrenSetSlotNewForeign(vm, 0, 0, sizeof(Display*));
    const char *displayName = wrenGetSlotString(vm, 1);
    if (displayName == "") {
        *pdisplay = XOpenDisplay(NULL);
    } else {
        *pdisplay = XOpenDisplay(displayName);
    }
}

void C_gcAllocate(WrenVM* vm) {
    GC *pgc = (GC *)wrenSetSlotNewForeign(vm, 0, 0, sizeof(GC));
    Display* display = *(Display**)wrenGetSlotForeign(vm, 1);
    int s = (int)wrenGetSlotDouble(vm, 2);
    *pgc = DefaultGC(display, s);
}

void C_eventAllocate(WrenVM* vm) {
    wrenSetSlotNewForeign(vm, 0, 0, sizeof(XEvent));
}

void C_eventType(WrenVM* vm) {
    XEvent e = *(XEvent *)wrenGetSlotForeign(vm, 0);
    wrenSetSlotDouble(vm, 0, (double)e.type);
}

void C_setEventType(WrenVM* vm) {
    XEvent *e = (XEvent *)wrenGetSlotForeign(vm, 0);
    int type = (int)wrenGetSlotDouble(vm, 1);
    e->type = type;
}

void C_setState(WrenVM* vm) {
    XKeyEvent *ke = (XKeyEvent *)wrenGetSlotForeign(vm, 0);
    unsigned int state = (unsigned int)wrenGetSlotDouble(vm, 1);
    ke->state = state;
}   

void C_keycode(WrenVM* vm) {
    XKeyEvent ke = *(XKeyEvent *)wrenGetSlotForeign(vm, 0);
    wrenSetSlotDouble(vm, 0, (double)ke.keycode);
}

void C_setKeycode(WrenVM* vm) {
    XKeyEvent *ke = (XKeyEvent *)wrenGetSlotForeign(vm, 0);
    unsigned int keycode = (unsigned int)wrenGetSlotDouble(vm, 1);
    ke->keycode = keycode;
}

void C_setSameScreen(WrenVM* vm) {
    XKeyEvent *ke = (XKeyEvent *)wrenGetSlotForeign(vm, 0);
    Bool sameScreen = (Bool)wrenGetSlotBool(vm, 1);
    ke->same_screen = sameScreen;
}

void C_dataL(WrenVM* vm) {
    XClientMessageEvent cme = *(XClientMessageEvent *)wrenGetSlotForeign(vm, 0);
    wrenEnsureSlots(vm, 2);
    wrenSetSlotNewList(vm, 0);
    int i;
    for (i = 0; i < 5; ++i) {
        wrenSetSlotDouble(vm, 1, (double)cme.data.l[i]);
        wrenInsertInList(vm, 0, i, 1);
    }
}

void C_defaultScreen(WrenVM* vm) {
    Display* display = *(Display**)wrenGetSlotForeign(vm, 0);
    int screenNumber = DefaultScreen(display);
    wrenSetSlotDouble(vm, 0, (double)screenNumber);
}

void C_rootWindow(WrenVM* vm) {
    Display* display = *(Display**)wrenGetSlotForeign(vm, 0);
    int screenNumber = (int)wrenGetSlotDouble(vm, 1);
    Window w = RootWindow(display, screenNumber);
    wrenSetSlotDouble(vm, 0, (double)w);
}

void C_blackPixel(WrenVM* vm) {
    Display* display = *(Display**)wrenGetSlotForeign(vm, 0);
    int screenNumber = (int)wrenGetSlotDouble(vm, 1);
    unsigned long p = BlackPixel(display, screenNumber);
    wrenSetSlotDouble(vm, 0, (double)p);
}

void C_whitePixel(WrenVM* vm) {
    Display* display = *(Display**)wrenGetSlotForeign(vm, 0);
    int screenNumber = (int)wrenGetSlotDouble(vm, 1);
    unsigned long p = WhitePixel(display, screenNumber);
    wrenSetSlotDouble(vm, 0, (double)p);
}

void C_selectInput(WrenVM* vm) {
    Display* display = *(Display**)wrenGetSlotForeign(vm, 0);
    Window w = (Window)wrenGetSlotDouble(vm, 1);
    long eventMask = (long)wrenGetSlotDouble(vm, 2);
    XSelectInput(display, w, eventMask);
}

void C_mapWindow(WrenVM* vm) {
    Display* display = *(Display**)wrenGetSlotForeign(vm, 0);
    Window w = (Window)wrenGetSlotDouble(vm, 1);
    XMapWindow(display, w);
}

void C_closeDisplay(WrenVM* vm) {
    Display* display = *(Display**)wrenGetSlotForeign(vm, 0);
    XCloseDisplay(display);
}

void C_nextEvent(WrenVM* vm) {
    Display* display = *(Display**)wrenGetSlotForeign(vm, 0);
    XEvent* pe = (XEvent*)wrenGetSlotForeign(vm, 1);
    XNextEvent(display, pe);
}

void C_storeName(WrenVM* vm) {
    Display* display = *(Display**)wrenGetSlotForeign(vm, 0);
    Window w = (Window)wrenGetSlotDouble(vm, 1);
    char *windowName = (char *)wrenGetSlotString(vm, 2);
    XStoreName(display, w, windowName);
}

void C_flush(WrenVM* vm) {
    Display* display = *(Display**)wrenGetSlotForeign(vm, 0);
    XFlush(display);
}

void C_internAtom(WrenVM* vm) {
    Display* display = *(Display**)wrenGetSlotForeign(vm, 0);
    char *atomName = (char *)wrenGetSlotString(vm, 1);
    Bool onlyIfExists = (Bool)wrenGetSlotBool(vm, 2);
    Atom atom = XInternAtom(display, atomName, onlyIfExists);
    wrenSetSlotDouble(vm, 0, (double)atom);
}

void C_setWMProtocols(WrenVM* vm) {
    Display *display = *(Display**)wrenGetSlotForeign(vm, 0);
    Window w = (Window)wrenGetSlotDouble(vm, 1);
    int count = (int)wrenGetSlotDouble(vm, 3);
    Atom protocols[count];
    int i;
    for (i = 0; i < count; ++i) {
        wrenGetListElement(vm, 2, i, 1);
        protocols[i] = (Atom)wrenGetSlotDouble(vm, 1);
    }
    XSetWMProtocols(display, w, protocols, count);
}

void C_sendEvent(WrenVM* vm) {
    Display *display = *(Display**)wrenGetSlotForeign(vm, 0);
    Window w = (Window)wrenGetSlotDouble(vm, 1);
    Bool propogate = (Bool)wrenGetSlotBool(vm, 2);
    long eventMask = (long)wrenGetSlotDouble(vm, 3);
    XEvent* pe = (XEvent*)wrenGetSlotForeign(vm, 4);
    XSendEvent(display, w, propogate, eventMask, pe);
}

void C_destroyWindow(WrenVM* vm) {
    Display *display = *(Display**)wrenGetSlotForeign(vm, 0);
    Window w = (Window)wrenGetSlotDouble(vm, 1);
    XDestroyWindow(display, w);
}

void C_createSimpleWindow(WrenVM* vm) {
    Display *display         = *(Display**)wrenGetSlotForeign(vm, 0);
    Window parent            = (Window)wrenGetSlotDouble(vm, 1);
    int x                    = (int)wrenGetSlotDouble(vm, 2);
    int y                    = (int)wrenGetSlotDouble(vm, 3);
    unsigned int width       = (unsigned int)wrenGetSlotDouble(vm, 4);
    unsigned int height      = (unsigned int)wrenGetSlotDouble(vm, 5);
    unsigned int borderWidth = (unsigned int)wrenGetSlotDouble(vm, 6);
    unsigned long border     = (unsigned long)wrenGetSlotDouble(vm, 7);
    unsigned long background = (unsigned long)wrenGetSlotDouble(vm, 8);
    Window w = XCreateSimpleWindow(display, parent, x, y, width, height, borderWidth, border, background);
    wrenSetSlotDouble(vm, 0, (double)w);
}

void C_drawString(WrenVM* vm) {
    Display *display    = *(Display**)wrenGetSlotForeign(vm, 0);
    Drawable d          = (Drawable)wrenGetSlotDouble(vm, 1);
    GC gc               = *(GC *)wrenGetSlotForeign(vm, 2);
    int x               = (int)wrenGetSlotDouble(vm, 3);
    int y               = (int)wrenGetSlotDouble(vm, 4);
    const char *string  = wrenGetSlotString(vm, 5);
    int length          = (int)wrenGetSlotDouble(vm, 6);
    XDrawString(display, d, gc, x, y, string, length);
}

void C_lookupKeysym(WrenVM* vm) {
    XKeyEvent *pke = (XKeyEvent*)wrenGetSlotForeign(vm, 1);
    int index = (int)wrenGetSlotDouble(vm, 2);
    KeySym k = XLookupKeysym(pke, index);
    wrenSetSlotDouble(vm, 0, (double)k);
}

void C_lookupString(WrenVM* vm) {
    XKeyEvent *pke = (XKeyEvent*)wrenGetSlotForeign(vm, 1);
    int bytesBuffer = (int)wrenGetSlotDouble(vm, 3);
    char bufferReturn[bytesBuffer];
    int i;
    for (i = 0; i < bytesBuffer; ++i) {
        wrenGetListElement(vm, 2, i, 3);
        bufferReturn[i] = (char)wrenGetSlotDouble(vm, 3);
    }
    int count = XLookupString(pke, bufferReturn, bytesBuffer, NULL, NULL);
    for (i = 0; i < 2; ++i) {
        wrenSetSlotDouble(vm, 3, (double)bufferReturn[i]);
        wrenSetListElement(vm, 2, i, 3);
    }
    wrenSetSlotDouble(vm, 0, (double)count);
}

WrenForeignClassMethods bindForeignClass(WrenVM* vm, const char* module, const char* className) {
    WrenForeignClassMethods methods;
    methods.finalize = NULL;
    if (strcmp(className, "XDisplay") == 0) {
        methods.allocate = C_displayAllocate;
    } else if (strcmp(className, "XGC") == 0) {
        methods.allocate = C_gcAllocate;
    } else if (strcmp(className, "XEvent") == 0) {
        methods.allocate = C_eventAllocate;
    } else {
        methods.allocate = NULL;
    }
    return methods;
}

WrenForeignMethodFn bindForeignMethod(
    WrenVM* vm,
    const char* module,
    const char* className,
    bool isStatic,
    const char* signature) {
    if (strcmp(module, "main") == 0) {
        if (strcmp(className, "XEvent") == 0) {
            if (!isStatic && strcmp(signature, "eventType") == 0)             return C_eventType;
            if (!isStatic && strcmp(signature, "eventType=(_)") == 0)         return C_setEventType;
            if (!isStatic && strcmp(signature, "state=(_)") == 0)             return C_setState;
            if (!isStatic && strcmp(signature, "keycode") == 0)               return C_keycode;
            if (!isStatic && strcmp(signature, "keycode=(_)") == 0)           return C_setKeycode;
            if (!isStatic && strcmp(signature, "sameScreen=(_)") == 0)        return C_setSameScreen; 
            if (!isStatic && strcmp(signature, "dataL") == 0)                 return C_dataL;
        } else if (strcmp(className, "XDisplay") == 0) {
            if (!isStatic && strcmp(signature, "defaultScreen()") == 0)       return C_defaultScreen;
            if (!isStatic && strcmp(signature, "rootWindow(_)") == 0)         return C_rootWindow;
            if (!isStatic && strcmp(signature, "blackPixel(_)") == 0)         return C_blackPixel;
            if (!isStatic && strcmp(signature, "whitePixel(_)") == 0)         return C_whitePixel;
            if (!isStatic && strcmp(signature, "selectInput(_,_)") == 0)      return C_selectInput;
            if (!isStatic && strcmp(signature, "mapWindow(_)") == 0)          return C_mapWindow;
            if (!isStatic && strcmp(signature, "closeDisplay()") == 0)        return C_closeDisplay;
            if (!isStatic && strcmp(signature, "nextEvent(_)") == 0)          return C_nextEvent;
            if (!isStatic && strcmp(signature, "storeName(_,_)") == 0)        return C_storeName;
            if (!isStatic && strcmp(signature, "flush()") == 0)               return C_flush;
            if (!isStatic && strcmp(signature, "internAtom(_,_)") == 0)       return C_internAtom;
            if (!isStatic && strcmp(signature, "setWMProtocols(_,_,_)") == 0) return C_setWMProtocols;
            if (!isStatic && strcmp(signature, "sendEvent(_,_,_,_)") == 0)    return C_sendEvent;
            if (!isStatic && strcmp(signature, "destroyWindow(_)") == 0)      return C_destroyWindow;
            if (!isStatic && strcmp(signature, "createSimpleWindow(_,_,_,_,_,_,_,_)") == 0) return C_createSimpleWindow;
            if (!isStatic && strcmp(signature, "drawString(_,_,_,_,_,_)") == 0) return C_drawString;
        } else if (strcmp(className, "X") == 0) {
            if (isStatic && strcmp(signature, "lookupKeysym(_,_)") == 0)       return C_lookupKeysym;
            if (isStatic && strcmp(signature, "lookupString(_,_,_,_,_)") == 0) return C_lookupString;
        }
    }
    return NULL;
}

static void writeFn(WrenVM* vm, const char* text) {
    printf("%s", text);
}

void errorFn(WrenVM* vm, WrenErrorType errorType, const char* module, const int line, const char* msg) {
    switch (errorType) {
        case WREN_ERROR_COMPILE:
            printf("[%s line %d] [Error] %s\n", module, line, msg);
            break;
        case WREN_ERROR_STACK_TRACE:
            printf("[%s line %d] in %s\n", module, line, msg);
            break;
        case WREN_ERROR_RUNTIME:
            printf("[Runtime Error] %s\n", msg);
            break;
    }
}

char *readFile(const char *fileName) {
    FILE *f = fopen(fileName, "r");
    fseek(f, 0, SEEK_END);
    long fsize = ftell(f);
    rewind(f);
    char *script = malloc(fsize + 1);
    fread(script, 1, fsize, f);
    fclose(f);
    script[fsize] = 0;
    return script;
}

int main(int argc, char **argv) {
    WrenConfiguration config;
    wrenInitConfiguration(&config);
    config.writeFn = &writeFn;
    config.errorFn = &errorFn;
    config.bindForeignClassFn = &bindForeignClass;
    config.bindForeignMethodFn = &bindForeignMethod;
    WrenVM* vm = wrenNewVM(&config);
    const char* module = "main";
    const char* fileName = "Simulate_input_Keyboard.wren";
    char *script = readFile(fileName);
    WrenInterpretResult result = wrenInterpret(vm, module, script);
    switch (result) {
        case WREN_RESULT_COMPILE_ERROR:
            printf("Compile Error!\n");
            break;
        case WREN_RESULT_RUNTIME_ERROR:
            printf("Runtime Error!\n");
            break;
        case WREN_RESULT_SUCCESS:
            break;
    }
    wrenFreeVM(vm);
    free(script);
    return 0;
}
Cookies help us deliver our services. By using our services, you agree to our use of cookies.