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. <lang AutoHotkey>run, cmd /k WinWait, ahk_class ConsoleWindowClass controlsend, ,hello console, ahk_class ConsoleWindowClass</lang>
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. <lang AutoIt>Run("notepad") WinWaitActive("Untitled - Notepad") Send("The answer is 42")</lang>
It takes user input in variable using "input box" and displays that in "message box" <lang AutoIt>$name="type your name here" $name = InputBox("Name","Your name please ?",$name) MsgBox(0,"Name","Your name is: "&$name)</lang>
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. <lang basic> 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 </lang>
- 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. <lang basic>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</lang>
- Output:
NAME? MARK HELLO, MARK! READY.
C
Compile with:
gcc -o simkeypress -L/usr/X11R6/lib -lX11 simkeypress.c
<lang 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;
}</lang>
Clojure
<lang Clojure>(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))))))))</lang>
Go
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. <lang go>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) }
}</lang>
GUISS
<lang guiss>Start,Programs,Accessories,Notepad,Textbox,Type:Hello World[pling]</lang>
Java
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. <lang java5>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); } }
}</lang>
Kotlin
<lang scala>// 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
}</lang>
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. <lang nim>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() </lang> Compile and run it by (assuming we have GNU C compiler):
nim c -r ourfile.nim
OCaml
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
<lang ocaml>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;
- </lang>
Oz
Oz' default GUI toolkit is based on Tk. So we can do the same thing as in Tcl: <lang oz>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</lang>
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.
<lang perl>$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";</lang>
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.
<lang perl>SendKeys("Hello, how are you?\n");</lang>
Phix
-- -- 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. <lang PicoLisp>(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</lang>
- 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. <lang PowerShell> 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=”) </lang>
PureBasic
<lang PureBasic>If AW_WinActivate("Calc")
AW_SendKeys("123+3=")
EndIf</lang>
Python
<lang Python>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)</lang>
Target may be externally created.
<lang Python>>>> 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')</lang>
Racket
<lang 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</lang>
Raku
(formerly Perl 6)
Use libxdo bindings to send text / keystrokes to any application that will accept keystrokes from X11.
<lang perl6>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');
}</lang>
REXX
Note: this REXX program only works with the above two REXXes. <lang rexx>/*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. */</lang>
Rust
<lang Rust>extern crate autopilot; fn main() {
autopilot::key::type_string("Hello, world!", None, None, &[]);
}</lang>
Scala
<lang 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))
}</lang>
Tcl
This only works with windows created by Tk; it sends a single key "x" to the given window. <lang tcl>set key "x" event generate $target <Key-$key></lang> To send multiple keys, call repeatedly in order. Alphabetic keys can be used directly as events, " " has to be mapped to "<space>". <lang Tcl>package require Tk pack [text .t] focus -force .t foreach c [split "hello world" ""] {
event generate .t [expr {$c eq " "?"<space>": $c}]
}</lang> Note also that the task on keyboard macros illustrates a very closely related method.
On Windows simulate pressing the Escape, Backspace etc keys <lang tcl>package require twapi twapi::send_keys ({Esc})</lang>
VBScript
The keystrokes are sent to the active window.
<lang vbscript>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</lang>
Wren
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.
<lang ecmascript>/* 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()</lang>
We now embed this Wren script in the following C program, compile and run it.
<lang c>#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;
}</lang>
- Programming Tasks
- GUI
- Testing
- ACL2/Omit
- Batch File/Omit
- Brainf***/Omit
- Maxima/Omit
- Modula-3/Omit
- PARI/GP/Omit
- PHP/Omit
- PostScript/Omit
- R/Omit
- Retro/Omit
- SmileBASIC/Omit
- TI-83 BASIC/Omit
- TI-89 BASIC/Omit
- Zkl/Omit
- AutoHotkey
- AutoIt
- BASIC
- Applesoft BASIC
- Commodore BASIC
- C
- Xlib
- Clojure
- Go
- Keybd event
- GUISS
- Java
- AWT
- Kotlin
- LabVIEW
- Nim
- OCaml
- OCaml-Xlib
- Oz
- Tk
- Perl
- Phix
- Phix/pGUI
- PicoLisp
- PowerShell
- PureBasic
- AutoWin
- Python
- AutoPy
- PyAutoGUI
- Racket
- Raku
- REXX
- Rust
- AutoPilot
- Scala
- Tcl
- VBScript
- Wren