Terminal control/Cursor movement: Difference between revisions

This task has no specific requirements to trap or correct cursor movement beyond the terminal boundaries, so the implementer should decide what behavior fits best in terms of the chosen language.   Explanatory notes may be added to clarify how an out of bounds action would behave and the generation of error messages relating to an out of bounds cursor position is permitted.

<br><br>

 

=={{header|AutoHotkey}}==

 

hConsole:=DllCall("GetConsoleWindow","UPtr")

Stdout:=FileOpen(DllCall("GetStdHandle", "int", -11, "ptr"), "h `n")

bufferheight:=NumGet(&struct,2,"UShort")

return 1

 

=={{header|Axe}}==

Axe does not allow relative movement of the cursor. However, if the current position is known in the X and Y variables, the behavior can be simulated.

Output(X+1,Y)

Output(X,Y-1)

Output(15,Y)

Output(0,0)

 

=={{header|BASIC}}==

{{works with|QBasic}}

 

20 LOCATE , POS(0) - 1

30 'move right

140 LOCATE 1, 1

150 'bottom right corner; requires knowledge of screen dimensions (80x25 here)

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

80-Column Text Card: Applesoft Control Codes

Apple II Family Identification

http://www.umich.edu/~archive/apple2/technotes/tn/misc/TN.MISC.007

100 DATA56,32,31,254,160,0

110 DATA176,1,136,140,13,3,96

430 HTAB PEEK(33)

440 GET A$

 

=={{header|BBC BASIC}}==

VDU 9 : REM Move one position to the right

VDU 11 : REM Move up one line

VDU 13,8,10 : REM Move to the end of the line

VDU 30,8 : REM Move to the bottom right corner

 

=={{header|Befunge}}==

The conio.h header file in Borland's Turbo C makes keyboard interaction very simple. The following is an interactive program which has been tested with Turbo C, the delay function takes milliseconds and has been used to animate the involved cases.

 

#include<conio.h>

#include<dos.h>

return 0;

}

 

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

{{works with|Mono|1.2}}

{{works with|Visual C sharp|Visual C#|2003}}

{

//There will be a 3 second pause between each cursor movement.

System.Threading.Thread.Sleep(3000);

}

 

=={{header|Forth}}==

 

The following example assumes we are using a terminal that accepts ANSI escape codes. It defines the ANSI codes as Forth words with a markup language look. With this code compiled into the Forth system, the commands are used like native Forth commands.

DECIMAL

 

27 CONSTANT ESC

: <##> ( n -- ) ( sends n, radix 10, no spaces)

 

: ESC[ ( -- ) ESC EMIT ." [" ;

: <CUF> ( col --) ESC[ <##> ." C" ;

: <CUB> ( col --) ESC[ <##> ." D" ;

: <CHA> ( n --) ESC[ <##> ." G" ;

: <EL> ( -- ) ESC[ ." K" ;

( Define ANSI Forth names for these functions using our markup words)

: AT-XY ( col row -- ) SWAP <CUP> ;

Rosetta Task

( move the cursor one position to the right) 1 <CUF>

( move the cursor up one line ) 1 <CUU>

( move the cursor to the top left corner of the screen) 1 1 <CUP>

( move the cursor to the bottom right corner of the screen) 80 24 <CUP>

 

=={{header|Go}}==

===External commands===

 

import (

cmd.Stdout = os.Stdout

return cmd.Run()

===ANSI escape codes===

Not meeting all task requirements. Some of the movements are awkward with ANSI escape codes alone and are best done with one of the other techniques shown.

 

import (

fmt.Print("\033[;H") // top left

time.Sleep(1 * time.Second)

===Ncurses===

{{libheader|curses}}

 

import (

s.Refresh()

s.GetChar()

 

=={{header|Kotlin}}==

{{Works with|Ubuntu|14.04}}

 

const val ESC = "\u001B" // escape code

Thread.sleep(3000)

println()

 

=={{header|Lasso}}==

 

local(esc = decode_base64('Gw=='))

// move the cursor to the bottom right corner of the screen

stdout(#esc + '[500;500H')

 

Run["tput cuf1" ] (* one position to the right *)

Run["tput cuu1" ] (* up one line *)

Run["tput cr"] (* beginning of line *)

Run["tput home"] (* top left corner *)

 

WIDTH=RunThrough["tput cols", ""];

Run["tput hpa "<>WIDTH] (* end of line *)

 

 

 

 

 

 

 

 

 

=={{header|PicoLisp}}==

(call 'tput "cuf1") # one position to the right

(call 'tput "cuu1") # up one line

(call 'tput "hpa" (sys "COLUMNS")) # end of the line

(call 'tput "home") # top left corner

 

=={{header|Python}}==

{{libheader|curses}}

 

scr = curses.initscr()

y,x = scr.getmaxyx()

curses.move(y,x)

 

=={{header|Racket}}==

#lang racket

(require (planet neil/charterm:3:0))

(when continue?

(loop (on-key (charterm-read-key))))))

 

 

=={{header|REXX}}==

{{works with|PC/REXX}}

{{works with|Personal REXX}}

 

parse value scrsize() with sd sw /*find the display screen size. */

call cursor sd,sw /*move cursor to bot right corner*/

 

 

=={{header|Scala}}==

{{Works with|Ubuntu|14.04}}

val ESC = "\u001B" // escape code

 

}

 

=={{header|Tcl}}==

{{trans|UNIX Shell}}

proc tput args {

exec tput {*}$args >@stdout <@stdin

 

tput hpa $width; # end of line

 

=={{header|UNIX Shell}}==

tput cuf1 # one position to the right

tput cuu1 # up one line

 

tput hpa $WIDTH # end of line

 

=={{header|XPL0}}==

int I, X, Y, W, H;

[Cursor(10, 13); \set cursor to arbitrary location on screen

Cursor(W-1, H-1); \move to bottom right corner

I:= ChIn(1);

 

Moving the cursor position beyond the terminal boundaries simply makes

{{trans|Go}}

zkl doesn't know anything about terminals but can print Ansi terminal codes:

Atomic.sleep(1); // pause to let cursor blink

print("\e[D"); // left

Atomic.sleep(1);

print("\e[;H"); // top left

 

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

 

20 PRINT CHR$(9);:REM cursor one position right

30 GO SUB 500: REM get cursor position

610 POKE 23688,33-cc

620 POKE 23689,24-cr