Keyboard input/Keypress check: Difference between revisions
m
Use inputReady instead of the deprecated function keypress
m (→{{header|J}}) |
m (Use inputReady instead of the deprecated function keypress) |
||
(6 intermediate revisions by 4 users not shown) | |||
Line 9:
{{works with|https://skilldrick.github.io/easy6502/ Easy6502}}
Easy6502 uses zero page address FF as a memory-mapped port for keyboard input. The ASCII value of the last key you pressed is stored in this address, independent of the program's current execution state.
<
main:
Line 28:
dex
bne delay
rts</
{{out}}
<pre>
Line 39:
=={{header|Action!}}==
The KEY variable returns the key code, or 255 if no key was pressed.
<
Byte KEY,k=764
KEY=K
Return</
=={{header|Ada}}==
<
Available : Boolean;
Ada.Text_IO.Get_Immediate (Ch, Available);</
If key was pressed, Available is set to True and Ch contains the value.
Line 56:
=={{header|Amazing Hopper}}==
Version: hopper-FLOW!
<syntaxhighlight lang="amazing hopper">
#include <flow.h>
Line 71:
PRNL( "Last key pressed: ", c )
END
</syntaxhighlight>
{{out}}
<pre>
Line 84:
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* Programme assembleur ARM Raspberry */
Line 481:
bx lr @return
</syntaxhighlight>
=={{header|AutoHotkey}}==
Waits for the user to type a string (not supported on Windows 9x: it does nothing).
<
Input, KeyPressed, L1 T2 ; Length = 1, Timeout = 2 seconds</
Checks if a keyboard key or mouse/joystick button is down or up. Also retrieves joystick status.
<
GetKeyState, State, RButton ; Right mouse button.</
Function version of GetKeyState.
<
State := GetKeyState("RButton", "P") ; Right mouse button. P = Physical state.</
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: TAWK -f KEYBOARD_INPUT_KEYPRESS_CHECK.AWK
BEGIN {
Line 519:
exit(0)
}
</syntaxhighlight>
{{out}}
<pre>
Line 529:
=={{header|Axe}}==
Note that while the syntax for getting the most recent keypress is identical to [[#TI-83_BASIC|TI-83 BASIC]], the keycodes themselves are different.
<syntaxhighlight lang
=={{header|BASIC}}==
==={{header|Applesoft BASIC}}===
<
==={{header|BaCon}}===
<
PRINT "Press <escape> to exit now..."
key = GETKEY
IF key = 27 THEN
END
END IF</
==={{header|BASIC256}}===
<
k$ = key
until k$ <> ""
Line 553:
else
print "An extended key was pressed"
end if</
==={{header|BBC BASIC}}===
<
If there was no keypress an empty string is returned. Alternatively a numeric key-code may be obtained; if there was no keypress -1 is returned:
<
==={{header|IS-BASIC}}===
<
or
<syntaxhighlight lang
==={{header|QBasic}}===
<
PRINT k$</
==={{header|Yabasic}}===
Line 575:
<code>inkey$</code> may only be used, if <code>clear screen</code> has been called at least once.
<
k$ = inkey$</
==={{header|ZX Spectrum Basic}}===
{{works with|Locomotive Basic}}
<
20 LET k$ = INKEY$</
=={{header|C}}==
For POSIX systems. Ctrl-C to stop:<
#include <termios.h> /* general terminal interface: tcgetattr, tcsetattr, tcflush */
#include <unistd.h> /* synchronous I/O multiplexing: select, FD_CLR, FD_ISSET, FD_SET, FD_ZERO */
Line 634:
printf("key %d\n", c);
}
}</
=={{header|Common Lisp}}==
==={{header|ncurses}}===
To interface the ncurses C library from Lisp, the ''croatoan'' library is used.
<
(with-screen (scr :input-echoing nil :input-blocking nil :input-buffering nil :enable-function-keys t)
(loop
Line 655:
(refresh scr)
;; we wait anyway to spare the CPU.
(sleep 0.15))))))</
=={{header|C sharp|C#}}==
<
if(Console.KeyAvailable)
chr = Console.ReadKey().Key.ToString();</
=={{header|Clojure}}==
Line 669:
<pre>$ lein trampoline run</pre>
<
(ns keypress.core
(:import jline.Terminal)
Line 686:
(prompt)
(shutdown-agents))
</syntaxhighlight>
=={{header|D}}==
<
void _STI_conio();
void _STD_conio();
Line 704:
_STD_conio();
}</
=={{header|Delphi}}==
This is valid for a GUI application!
<
interface
Line 735:
end;
end.</
=={{header|Elena}}==
{{trans|C#}}
ELENA 4.x :
<
public program()
Line 749:
chr := console.readChar()
}
}</
=={{header|ERRE}}==
<syntaxhighlight lang="erre">
!$KEY
.........
GET(K$)
.........
</syntaxhighlight>
Note: If no key was pressed K$ is empty string "".
=={{header|Euphoria}}==
<
key = get_key() -- if key was not pressed get_key() returns -1</
=={{header|F_Sharp|F#}}==
{{trans|C#}}
<
let chr = if Console.KeyAvailable then Console.ReadKey().Key.ToString() else String.Empty</
=={{header|Forth}}==
<
: check key? if key last-key ! then ;</
=={{header|FreeBASIC}}==
<
Dim k As String
Line 788:
End If
Sleep</
Sample input/output
Line 796:
The key pressed was A (ascii 65)
</pre>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
_window = 1
void local fn BuildWindow
subclass window _window, @"Keyboard input/Keypress check"
text,24
print %(180,190)@"Press any key"
end fn
void local fn DoDialog( ev as long, tag as long )
select ( ev )
case _windowKeyDown
select ( tag )
case _window
cls : printf %(180,190)@"\"%@\" key pressed",fn EventCharacters
DialogEventSetBool( YES )// we handled
end select
end select
end fn
fn BuildWindow
on dialog fn DoDialog
HandleEvents
</syntaxhighlight>
=={{header|Gambas}}==
<
'Requires a TextBox or similar on the Form to work
Print Key.Text;
End</
Output:
<pre>
Line 811 ⟶ 839:
=={{header|Go}}==
{{libheader|Curses}}
<
import (
Line 833 ⟶ 861:
s.Refresh()
time.Sleep(500 * time.Millisecond)
}</
s.Println()
Line 853 ⟶ 881:
s.GetChar()
You don't need external dependencies to achieve this. You can use a channel and set a timeout on it.
::<
// stackoverflow.com/questions/43965556/how-to-read-a-key-in-go-but-continue-application-if-no-key-pressed-within-x-seco
import (
Line 883 ⟶ 911:
fmt.Println("Time out!")
}
}</
=={{header|Haskell}}==
<
import Control.Monad
import Data.Maybe
Line 905 ⟶ 933:
else putStrLn "Awaiting char.." >>
threadDelay 500000 >> wait c
</syntaxhighlight>
Output:
<pre>
Line 916 ⟶ 944:
=={{header|Icon}} and {{header|Unicon}}==
<
delay(1000) # give user a chance to input
if kbhit() then # test for input
Line 922 ⟶ 950:
else # use getche for echo
write("No input waiting")
end</
=={{header|J}}==
(Note that keypress handling depends on the host. Here, we illustrate jqt.)<
p_c_char=: {{variable=: sysdata}}</
=={{header|Java}}==
{{works with|java|8}}
<
import javax.swing.*;
Line 953 ⟶ 981:
});
}
}</
=={{header|JavaScript}}==
<syntaxhighlight lang="javascript">
let thePressedKey;
Line 965 ⟶ 993:
document.addEventListener('keydown', handleKey);
</syntaxhighlight>
=={{header|Julia}}==
<
function keypresswindow()
Line 989 ⟶ 1,017:
keypresswindow()
</syntaxhighlight>
=={{header|Kotlin}}==
Translated from the Java entry but then modified so as to quit the program when the Enter key is pressed:
<
import java.awt.event.KeyAdapter
Line 1,023 ⟶ 1,051:
f.isVisible = true
}
}</
=={{header|Lingo}}==
<
-- event handler
Line 1,032 ⟶ 1,060:
pressedKey = _key.key
put "A key was pressed:" && pressedKey
end</
=={{header|LiveCode}}==
Line 1,038 ⟶ 1,066:
Example
<
-- exit loop if "." or the escapeKey is pressed
if 46 is in the keysDown or 65307 is in the keysdown then
Line 1,047 ⟶ 1,075:
wait 200 millisec
end if
end repeat</
Example of event message handling (at stack, card or control level)
<
-- do stuff, keycode is held in k
if k is not 46 then pass keyDown // will be trapped if "." is pressed, others will be passed on through the message path
end keyDown</
You can substitute keyUp, rawKeyUp, rawKeyDown for keyUp in above. The non-raw handlers do not readily cope with special key presses, and they have their own handlers such as escapeKey, enterKey, altkey, commandKey... look up "key" in the LC dictionary to find more.
=={{header|Logo}}==
<
=={{header|M2000 Interpreter}}==
===Without delay===
<syntaxhighlight lang="m2000 interpreter">
k$=inkey$
</syntaxhighlight>
===Using delay===
<syntaxhighlight lang="m2000 interpreter">
K$=""
If Inkey(2000)<>-1 then k$=Key$
Print k$
</syntaxhighlight>
===Check specific key===
<syntaxhighlight lang="m2000 interpreter">
k$=""
If keypress(32) then k$=" "
</syntaxhighlight>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
This will create a little panel, once the panel has focus the keys are captured and displayed inside the panel.
<
EventHandler[Panel[Dynamic[i],
ImageSize -> {300, 300}], {"KeyDown" :>
AppendTo[i, CurrentValue["EventKey"]]}]</
=={{header|MiniScript}}==
{{works with|Mini Micro}}
<
=={{header|Nim}}==
Line 1,092 ⟶ 1,120:
Using https://github.com/johnnovak/illwill
<
illwillInit(fullscreen=false)
Line 1,107 ⟶ 1,135:
sleep(1000)
</syntaxhighlight>
=={{header|Oforth}}==
<
: checkKey
Line 1,116 ⟶ 1,144:
System.Console receiveTimeout(2000000) ->key // Wait a key pressed for 2 seconds
key ifNotNull: [ System.Out "Key pressed : " << key << cr ]
"Done" println ; </
Other options :
<
System.Console receiveChar ->aChar // Wait until a character is pressed. All other keys are ignored
System.Console receiveTimeout(0) ->key // Check if a key is pressed and return immediatly</
=={{header|Perl}}==
<
use strict;
use warnings;
Line 1,135 ⟶ 1,163:
}
print "got key '$key'\n";
ReadMode('restore');</
In many cases one does not want to wait for each step end. In this case you can use two parallel processes:
<
use strict;
use warnings;
Line 1,187 ⟶ 1,215:
}
ReadMode('restore');
}</
This code prints <code>"doing something"</code> 10 times and then ends. Parallelly another process prints every key you type in.
=={{header|Phix}}==
<!--<
<span style="color: #004080;">integer</span> <span style="color: #000000;">key</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">get_key</span><span style="color: #0000FF;">()</span> <span style="color: #000080;font-style:italic;">-- if key was not pressed get_key() returns -1</span>
<!--</
=={{header|PicoLisp}}==
<syntaxhighlight lang
=={{header|Plain English}}==
Print the numeric value of any key pressed without waiting.
<
Start up.
Handle any events.
Line 1,218 ⟶ 1,246:
Put the event's key into a key.
Write "" then the key to the console.
If the key is the escape key, relinquish control.</
=={{header|PowerShell}}==
The following uses the special <code>$Host</code> variable which points to an instance of the PowerShell host application. Since the host's capabilities may vary this may not work in all PowerShell hosts. In particular, this works in the console host, but not in the PowerShell ISE.
<
$key = $Host.UI.RawUI.ReadKey()
}</
=={{header|PureBasic}}==
Line 1,230 ⟶ 1,258:
If special keys (non-ASCII) have to be handled, RawKey() should be called after Inkey().
<
=={{header|Python}}==
<
# -*- coding: utf-8 -*-
from __future__ import absolute_import, division, unicode_literals, print_function
Line 1,284 ⟶ 1,312:
if __name__ == "__main__":
main()
</syntaxhighlight>
=={{header|Racket}}==
Line 1,290 ⟶ 1,318:
Using <tt>stty</tt> to get the terminal into raw mode.
<
#lang racket
(define-syntax-rule (with-raw body ...)
Line 1,306 ⟶ 1,334:
(printf "You pressed ~a\n" (read-char))
(printf "You didn't press a key\n")))
</syntaxhighlight>
=={{header|Raku}}==
Line 1,312 ⟶ 1,340:
{{works with|Rakudo|2018.10}}
<syntaxhighlight lang="raku"
react {
Line 1,321 ⟶ 1,349:
}
}
}</
=={{header|REXX}}==
Line 1,329 ⟶ 1,357:
:::* PC/REXX
:::* Personal REXX
<
∙
Line 1,337 ⟶ 1,365:
∙
∙
∙</
=={{header|Ring}}==
<
if getchar() see "A key was pressed" + nl
else see "No key was pressed" + nl ok
</syntaxhighlight>
=={{header|Robotic}}==
<
: "loop"
if "KEY_PRESSED" != 0 then "#store"
Line 1,355 ⟶ 1,383:
set "storedKey" to "KEY_PRESSED"
goto "#return"
</syntaxhighlight>
=={{header|RPL}}==
≪ '''IF''' KEY '''THEN''' 'Entry' STO '''END''' ≫
If no key is pressed and the <code>Entry</code> variable does not exist yet, it won't be created.
=={{header|Ruby}}==
<
begin
check = STDIN.read_nonblock(1)
Line 1,366 ⟶ 1,398:
puts check if check
</syntaxhighlight>
Test in unix shell:
<
% ruby keypress_check.rb
% echo -n y | ruby keypress_check.rb
y
</syntaxhighlight>
=={{header|Scala}}==
<
import javax.swing.{JFrame, SwingUtilities}
Line 1,407 ⟶ 1,439:
foo()
})
}</
=={{header|Seed7}}==
The library [http://seed7.sourceforge.net/libraries/keybd.htm keybd.s7i] defines
the file [http://seed7.sourceforge.net/libraries/keybd.htm#KEYBOARD KEYBOARD] and
the function [http://seed7.sourceforge.net/libraries/keybd.htm#
which can be used to determine if a key has been pressed.
<
writeln("A key was pressed");
else
writeln("No key was pressed");
end if;</
=={{header|Tcl}}==
There are two ways to handle listening for a key from the terminal. The first is to put the channel connected to the terminal into non-blocking mode and do a <code>read</code> on it:
<
set ch [read stdin 1]
fconfigure stdin -blocking 1
Line 1,430 ⟶ 1,462:
} else {
# Got the character $ch
}</
The second method is to set up an event listener to perform callbacks when there is at least one character available:
<
proc GetChar {} {
set ch [read stdin 1]
Line 1,441 ⟶ 1,473:
}
vwait forever; # run the event loop if necessary</
Note that in both cases, if you want to get characters as users actually type them then you have to [http://wiki.tcl.tk/14693 put the terminal in raw mode]. That's formally independent of the actual reading of a character.
=={{header|TI-83 BASIC}}==
TI-83 BASIC has a built in getKey function.
<
:getKey→G
</syntaxhighlight>
This returns the key code of the key pressed which is the row number followed by the column number. The left up and down arrow keys are grouped with row 2 as 24, 25, and 26, and the down arrow key is grouped with row 3 as 34.
=={{header|Wee Basic}}==
This returns the key code of the key pressed.
<
print 1 "Press any key and its key code will appear."
while keycode=0
Line 1,459 ⟶ 1,491:
wend
print 1 keycode
end</
=={{header|Wren}}==
<
import "timer" for Timer
import "io" for Stdin, Stdout
Line 1,483 ⟶ 1,515:
}
Stdin.isRaw = false</
{{out}}
Line 1,493 ⟶ 1,525:
=={{header|XPL0}}==
<
int K, N;
[N:= 0;
Line 1,500 ⟶ 1,532:
N:= N+1;
until K;
]</
{{omit from|ACL2}}
|