Keyboard input/Keypress check: Difference between revisions

{{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:

dex

bne delay

{{out}}

<pre>

=={{header|Action!}}==

The KEY variable returns the key code, or 255 if no key was pressed.

Byte KEY,k=764

KEY=K

=={{header|Ada}}==

Available : Boolean;

If key was pressed, Available is set to True and Ch contains the value.

=={{header|Amazing Hopper}}==

Version: hopper-FLOW!

#include <flow.h>

PRNL( "Last key pressed: ", c )

END

{{out}}

<pre>

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* Programme assembleur ARM Raspberry */

bx lr @return

=={{header|AutoHotkey}}==

Waits for the user to type a string (not supported on Windows 9x: it does nothing).

Checks if a keyboard key or mouse/joystick button is down or up. Also retrieves joystick status.

Function version of GetKeyState.

=={{header|AWK}}==

# syntax: TAWK -f KEYBOARD_INPUT_KEYPRESS_CHECK.AWK

BEGIN {

exit(0)

}

{{out}}

<pre>

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

=={{header|BASIC}}==

==={{header|Applesoft BASIC}}===

==={{header|BaCon}}===

PRINT "Press <escape> to exit now..."

key = GETKEY

IF key = 27 THEN

END

==={{header|BASIC256}}===

k$ = key

until k$ <> ""

else

print "An extended key was pressed"

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

==={{header|QBasic}}===

==={{header|Yabasic}}===

<code>inkey$</code> may only be used, if <code>clear screen</code> has been called at least once.

==={{header|ZX Spectrum Basic}}===

{{works with|Locomotive Basic}}

=={{header|C}}==

#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 */

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

(refresh scr)

;; we wait anyway to spare the CPU.

=={{header|C sharp|C#}}==

if(Console.KeyAvailable)

=={{header|Clojure}}==

<pre>$ lein trampoline run</pre>

(ns keypress.core

(:import jline.Terminal)

(prompt)

(shutdown-agents))

=={{header|D}}==

void _STI_conio();

void _STD_conio();

_STD_conio();

=={{header|Delphi}}==

This is valid for a GUI application!

interface

end;

=={{header|Elena}}==

{{trans|C#}}

ELENA 4.x :

public program()

chr := console.readChar()

}

=={{header|ERRE}}==

!$KEY

.........

GET(K$)

.........

Note: If no key was pressed K$ is empty string "".

=={{header|Euphoria}}==

=={{header|F_Sharp|F#}}==

{{trans|C#}}

=={{header|Forth}}==

=={{header|FreeBASIC}}==

Dim k As String

End If

Sample input/output

=={{header|Gambas}}==

'Requires a TextBox or similar on the Form to work

Print Key.Text;

Output:

<pre>

=={{header|Go}}==

{{libheader|Curses}}

import (

s.Refresh()

time.Sleep(500 * time.Millisecond)

s.Println()

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 (

fmt.Println("Time out!")

}

=={{header|Haskell}}==

import Control.Monad

import Data.Maybe

else putStrLn "Awaiting char.." >>

threadDelay 500000 >> wait c

Output:

<pre>

=={{header|Icon}} and {{header|Unicon}}==

delay(1000) # give user a chance to input

if kbhit() then # test for input

else # use getche for echo

write("No input waiting")

=={{header|J}}==

=={{header|Java}}==

{{works with|java|8}}

import javax.swing.*;

});

}

=={{header|JavaScript}}==

let thePressedKey;

document.addEventListener('keydown', handleKey);

=={{header|Julia}}==

function keypresswindow()

keypresswindow()

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

f.isVisible = true

}

=={{header|Lingo}}==

-- event handler

pressedKey = _key.key

put "A key was pressed:" && pressedKey

=={{header|LiveCode}}==

Example

-- exit loop if "." or the escapeKey is pressed

if 46 is in the keysDown or 65307 is in the keysdown then

wait 200 millisec

end if

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

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===

k$=inkey$

===Using delay===

K$=""

If Inkey(2000)<>-1 then k$=Key$

Print k$

===Check specific key===

k$=""

If keypress(32) then k$=" "

=={{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" :>

=={{header|MiniScript}}==

{{works with|Mini Micro}}

=={{header|Nim}}==

Using https://github.com/johnnovak/illwill

illwillInit(fullscreen=false)

sleep(1000)

=={{header|Oforth}}==

: checkKey

System.Console receiveTimeout(2000000) ->key // Wait a key pressed for 2 seconds

key ifNotNull: [ System.Out "Key pressed : " << key << cr ]

Other options :

System.Console receiveChar ->aChar // Wait until a character is pressed. All other keys are ignored

=={{header|Perl}}==

use strict;

use warnings;

}

print "got key '$key'\n";

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;

}

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}}==

=={{header|Plain English}}==

Print the numeric value of any key pressed without waiting.

Start up.

Handle any events.

Put the event's key into a key.

Write "" then the key to the console.

=={{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}}==

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

if __name__ == "__main__":

main()

=={{header|Racket}}==

Using <tt>stty</tt> to get the terminal into raw mode.

#lang racket

(define-syntax-rule (with-raw body ...)

(printf "You pressed ~a\n" (read-char))

(printf "You didn't press a key\n")))

=={{header|Raku}}==

{{works with|Rakudo|2018.10}}

react {

}

}

=={{header|REXX}}==

:::* PC/REXX

:::* Personal REXX

∙

∙

∙

=={{header|Ring}}==

if getchar() see "A key was pressed" + nl

else see "No key was pressed" + nl ok

=={{header|Robotic}}==

: "loop"

if "KEY_PRESSED" != 0 then "#store"

set "storedKey" to "KEY_PRESSED"

goto "#return"

=={{header|Ruby}}==

begin

check = STDIN.read_nonblock(1)

puts check if check

Test in unix shell:

% ruby keypress_check.rb

% echo -n y | ruby keypress_check.rb

y

=={{header|Scala}}==

import javax.swing.{JFrame, SwingUtilities}

foo()

})

=={{header|Seed7}}==

the function [http://seed7.sourceforge.net/libraries/keybd.htm#keypressed%28in_keyboard_file%29 keypressed],

which can be used to determine if a key has been pressed.

writeln("A key was pressed");

else

writeln("No key was pressed");

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

} 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]

}

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

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

wend

print 1 keycode

=={{header|Wren}}==

import "timer" for Timer

import "io" for Stdin, Stdout

}

{{out}}

=={{header|XPL0}}==

int K, N;

[N:= 0;

N:= N+1;

until K;

{{omit from|ACL2}}