Terminal control/Cursor movement: Difference between revisions

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program cursorMove64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

 

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

BYTE RTCLOK=$14

frames==+RTCLOK

 

Wait(d)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Cursor_movement.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

{{libheader|ANSIAda}}

 

with Ansi;

delay 2.000;

Put (Ansi.Restore);

 

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

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

bx lr @ return

 

 

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

 

' Default number of positions, if not specified, is 1.

 

' Bottom right

R = ROWS

 

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

==={{header|ncurses}}===

To interface the ncurses C library from Lisp, the ''croatoan'' library is used.

(with-screen (scr :input-blocking t :input-echoing nil :cursor-visible t)

;; display the screen and wait for a keypress

(move scr (1- (height scr)) (1- (width scr))) (refresh scr) (get-char scr)

;; top left corner

 

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

 

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

{{trans|Kotlin}}

const moves = Dict( "left" => "[1D", "right" => "[1C", "up" => "[1A", "down" => "[1B",

"linestart" => "[9D", "topleft" => "[H", "bottomright" => "[24;79H")

println()

println()

 

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

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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

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

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

 

=={{header|Nim}}==

 

echo "Press the return key to go to next step."

# Move cursor to the bottom right corner.

setCursorPos(width - 1, height - 1)

 

=={{header|Perl}}==

{{trans|Raku}}

system "tput cuf1"; sleep 1; # one position to the right

system "tput cuu1"; sleep 1; # up one line

 

system "tput cup $rows $cols"; # bottom right corner

 

=={{header|Phix}}==

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\Cursor_movement.exw

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>

 

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

(formerly Perl 6)

shell "tput cuf1"; # one position to the right

shell "tput cuu1"; # up one line

 

shell "tput hpa $cols"; # end of line

 

=={{header|REXX}}==

 

This version &nbsp; ''only'' &nbsp; works with PC/REXX or 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|Wren}}==

import "io" for Stdout

 

Stdout.flush()

Timer.sleep(2000)

 

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