Simulate input/Keyboard: Difference between revisions

{{omit from|Retro}}

{{omit from|SmileBASIC}}

{{omit from|zkl}}

 

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).

 

=={{header|AutoHotkey}}==

Target may be externally created.

WinWait, ahk_class ConsoleWindowClass

 

=={{header|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.

WinWaitActive("Untitled - Notepad")

 

It takes user input in variable using "input box"

and displays that in "message box"

$name = InputBox("Name","Your name please ?",$name)

 

=={{header|C}}==

gcc -o simkeypress -L/usr/X11R6/lib -lX11 simkeypress.c

 

#include <stdlib.h>

#include <X11/Xlib.h>

XCloseDisplay(dpy);

return 1;

 

=={{header|Clojure}}==

{{trans|Java}}

(import java.awt.event.KeyEvent)

(defn keytype [str]

(doto robot

(.keyPress (int upCh))

 

=={{header|Go}}==

 

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

 

import (

log.Fatal(err)

}

 

=={{header|GUISS}}==

 

 

=={{header|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.

public static void type(String str){

Robot robot = new Robot();

}

}

 

=={{header|Kotlin}}==

 

import java.awt.Robot

fun main(args: Array<String>) {

sendChars("dir") // runs 'dir' command

 

=={{header|LabVIEW}}==

This example implements limited capability of simulating input/Keyboard on Windows using standard library only. For better Windows support we can use [https://github.com/khchen/winim Winim] and [https://github.com/juancarlospaco/nim-xdo xdo] for Linux.

Current example will simulate keyboard input of typing Hello world to the current focused window.

import winlean

else:

 

main()

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

<pre>nim c -r ourfile.nim</pre>

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

 

 

let () =

(* close connection to server *)

xCloseDisplay d;

 

=={{header|Oz}}==

 

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

[QTk] = {Module.link ['x-oz://system/wp/QTk.ozf']}

Entry

{Delay 100}

{Tk.send event(generate Entry Key)}

 

This only works with internal windows.

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

 

### How to get the correct value for $TIOCSTI is discussed here : http://www.perlmonks.org/?node_id=10920

$TIOCSTI = 0x5412 ;

sleep(2);

foreach $a ( @c ) { ioctl(TTY,$TIOCSTI,$a); select(undef,undef,undef,0.1);} ;

 

 

Target may be externally created.

 

 

=={{header|PicoLisp}}==

in the following example. Keyboard input is simulated with the function 'enter'

to fill the login form's name and password fields.

 

# Connect to the demo app at http://7fach.de/8080

(click "Spare Part") # Click on "Spare Part" article

(prinl (value 8)) # Print the price (12.50)

{{out}}

<pre>12.50</pre>

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

[Microsoft.VisualBasic.Interaction]::AppActivate(“Calc”)

[System.Windows.Forms.SendKeys]::SendWait(“2{ADD}2=”)

 

=={{header|PureBasic}}==

{{libheader|AutoWin}}

 

AW_SendKeys("123+3=")

 

=={{header|Python}}==

{{libheader|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)

 

{{works with|Python|2.5+}}

Target may be externally created.

 

>>> 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('left') # press the left arrow key

>>> pyautogui.keyUp('shift') # release the shift key

 

=={{header|Racket}}==

 

(define frame (new frame%

(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)

 

=={{header|Raku}}==

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

 

 

my $xdo = Xdo.new;

sleep 1;

 

 

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

$xdo.activate-window($w);

say "Window name: ", $xdo.get-window-name( $w );

sleep .25;

$xdo.send-sequence($w, 'Tab');

sleep .5;

$xdo.send-sequence($w, 'Return');

 

=={{header|REXX}}==

{{works with|Personal REXX}}

Note: &nbsp; this REXX program &nbsp; ''only'' &nbsp; works with the above two REXXes.

 

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).*/

 

=={{header|Rust}}==

{{libheader|AutoPilot}}

 

fn main() {

autopilot::key::type_string("Hello, world!", None, None, &[]);

 

=={{header|Scala}}==

{{libheader|Scala}}

import java.awt.event.KeyEvent

 

}

keystroke(args(0))

 

=={{header|Tcl}}==

This only works with windows created by Tk;

it sends a single key "x" to the given window.

To send multiple keys, call repeatedly in order.

Alphabetic keys can be used directly as events, " " has to be mapped to "<space>".

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#Tcl|keyboard macros]]

illustrates a very closely related method.

 

=={{header|VBScript}}==

The keystrokes are sent to the active window.

 

Set WshShell = WScript.CreateObject("WScript.Shell")

WshShell.SendKeys "{Down}{F2}"

WScript.Sleep 1000 ' one-second delay