⚠️ Warning: This is a draft ⚠️
This means it might contain formatting issues, incorrect code, conceptual problems, or other severe issues.
If you want to help to improve and eventually enable this page, please fork RosettaGit's repository and open a merge request on GitHub.
{{task|Terminal control}}[[Category:Terminal control]]
The task is to hide the cursor and show it again.
AutoHotkey
Keep in mind that AHK is not built for the command line, so we must call the WinAPI directly.
DllCall("AllocConsole") ; Create a console if not launched from one
hConsole := DllCall("GetStdHandle", UInt, STDOUT := -11)
VarSetCapacity(cci, 8) ; CONSOLE_CURSOR_INFO structure
DllCall("GetConsoleCursorInfo", UPtr, hConsole, UPtr, &cci)
NumPut(0, cci, 4)
DllCall("SetConsoleCursorInfo", UPtr, hConsole, UPtr, &cci)
FileAppend, Cursor hidden for 3 seconds..., CONOUT$ ; Prints to stdout
Sleep 3000
NumPut(1, cci, 4)
DllCall("SetConsoleCursorInfo", UPtr, hConsole, UPtr, &cci)
FileAppend, `nCursor shown, CONOUT$
MsgBox
BASIC
{{works with|QBasic}}
'hide the cursor:
LOCATE , , 0
'wait for a keypress...
SLEEP
'show the cursor:
LOCATE , , 1
=
Applesoft BASIC
=
WAIT 49152,128
BBC BASIC
OFF : REM Hide the cursor (caret)
WAIT 400
ON : REM Show the cursor again
Befunge
Assuming a terminal with support for ANSI escape sequences, this hides the cursor, waits for the user to press ''Enter'', and then shows the cursor again.
"l52?["39*,,,,,, >v
"retnE sserP">:#,_v>
"h52?["39*,,,,,,@ >~
C
/* Please note that curs_set is terminal dependent. */ #include<curses.h> #include<stdio.h> int main () { printf ("At the end of this line you will see the cursor, process will sleep for 5 seconds."); napms (5000); curs_set (0); printf ("\nAt the end of this line you will NOT see the cursor, process will again sleep for 5 seconds."); napms (5000); printf ("\nGoodbye."); return 0; }
C++
#include <Windows.h> int main() { bool showCursor = false; HANDLE std_out = GetStdHandle(STD_OUTPUT_HANDLE); // Get standard output CONSOLE_CURSOR_INFO cursorInfo; // GetConsoleCursorInfo(out, &cursorInfo); // Get cursorinfo from output cursorInfo.bVisible = showCursor; // Set flag visible. SetConsoleCursorInfo(out, &cursorInfo); // Apply changes }
C#
{{works with|Mono|1.2}} {{works with|Visual C sharp|Visual C#|2003}}
static void Main(string[] args) { Console.Write("At the end of this line you will see the cursor, process will sleep for 5 seconds."); System.Threading.Thread.Sleep(5000); Console.CursorVisible = false; Console.WriteLine(); Console.Write("At the end of this line you will not see the cursor, process will sleep for 5 seconds."); System.Threading.Thread.Sleep(5000); }
Common Lisp
(defun sh (cmd) #+clisp (shell cmd) #+ecl (si:system cmd) #+sbcl (sb-ext:run-program "/bin/sh" (list "-c" cmd) :input nil :output *standard-output*) #+clozure (ccl:run-program "/bin/sh" (list "-c" cmd) :input nil :output *standard-output*)) (defun show-cursor (x) (if x (sh "tput cvvis") (sh "tput civis"))) (show-cursor nil) (sleep 3) (show-cursor t) (sleep 3)
FunL
import time.*
import console.*
hide()
sleep( 2 Second )
show()
Go
External command
package main import ( "os" "os/exec" "time" ) func main() { tput("civis") // hide time.Sleep(3 * time.Second) tput("cvvis") // show time.Sleep(3 * time.Second) } func tput(arg string) error { cmd := exec.Command("tput", arg) cmd.Stdout = os.Stdout return cmd.Run() }
Escape code
(Not sure if this is ANSI, but it worked for me.)
package main import ( "fmt" "time" ) func main() { fmt.Print("\033[?25l") time.Sleep(3 * time.Second) fmt.Print("\033[?25h") time.Sleep(3 * time.Second) }
Ncurses
{{libheader|Curses}}
package main import ( "log" "time" gc "code.google.com/p/goncurses" ) func main() { s, err := gc.Init() if err != nil { log.Fatal("init:", err) } defer gc.End() gc.Cursor(0) time.Sleep(3 * time.Second) gc.Cursor(1) s.GetChar() }
J
With the definitions of [[Terminal_control/Coloured_text#J]]
smoutput HIDECURSOR
usleep(4e6) NB. wait 4 seconds
smoutput SHOWCURSOR
Julia
{{trans|Perl}}
const ESC = "\u001B" # escape code print("$ESC[?25l") # hide the cursor print("Enter anything, press RETURN: ") # prompt shown input = readline() # but no cursor print("$ESC[0H$ESC[0J$ESC[?25h") # reset, visible again sleep(3) println()
Kotlin
{{Works with|Ubuntu|14.04}}
// version 1.1.2 fun main(args: Array<String>) { print("\u001B[?25l") // hide cursor Thread.sleep(2000) // wait 2 seconds before redisplaying cursor print("\u001B[?25h") // display cursor Thread.sleep(2000) // wait 2 more seconds before exiting }
Lasso
#!/usr/bin/lasso9
local(
esc = decode_base64('Gw==')
)
// hide the cursor
stdout(#esc + '[?25l')
// wait for 4 seconds to give time discover the cursor is gone
sleep(4000)
// show the cursor
stdout(#esc + '[?25h')
// wait for 4 seconds to give time discover the cursor is back
sleep(4000)
Locomotive Basic
10 CURSOR 0: REM hide cursor
20 FOR l = 1 TO 2000: REM delay
30 NEXT l
40 CURSOR 1: REM show cursor
Mathematica
Run["tput civis"] (* Cursor hidden *)
Pause[2]
Run["tput cvvis"] (* Cursor Visible *)
Nemerle
using System.Console;
using System.Threading.Thread;
module CursorVisibility
{
Main() : void
{
repeat(3) {
CursorVisible = !CursorVisible;
Sleep(5000);
}
}
}
Nim
import terminal echo "Cursor hidden. Press a key to show the cursor and exit." stdout.hideCursor() discard getCh() stdout.showCursor()
Perl
print "\e[?25l"; # hide the cursor print "Enter anything, press RETURN: "; # prompt shown $input = <>; # but no cursor print "\e[0H\e[0J\e[?25h"; # reset, visible again
Perl 6
say 'Hiding the cursor for 5 seconds...';
run 'tput', 'civis';
sleep 5;
run 'tput', 'cvvis';
Phix
cursor(NO_CURSOR)
sleep(1)
cursor(UNDERLINE_CURSOR)
PicoLisp
(call "tput" "civis") # Invisible
(wait 1000)
(call "tput" "cvvis") # Visible
PureBasic
#cursorSize = 10 ;use a full sized cursor
If OpenConsole()
Print("Press any key to toggle cursor: ")
EnableGraphicalConsole(1)
height = #cursorSize
ConsoleCursor(height)
Repeat
If Inkey()
height ! #cursorSize
ConsoleCursor(height)
EndIf
ForEver
EndIf
Tested with PB v5.60
Procedure HideCursor ()
ConsoleCursor(0)
EndProcedure
Procedure ShowCursor (CursorHeight.b = 1)
If CursorHeight > 10 : CursorHeight = 10 : EndIf
If CursorHeight < 1 : CursorHeight = 1 : EndIf
ConsoleCursor(CursorHeight)
EndProcedure
Procedure NL (NoL.b = 1)
For i = 1 To NoL : PrintN("") : Next
EndProcedure
If OpenConsole()
EnableGraphicalConsole(1)
Print(" full cursor > ")
ShowCursor(11) : Delay(4000) : NL()
Print(" hidden cursor > ")
HideCursor() : Delay(4000) : NL()
Print("minimal cursor > ")
ShowCursor(-0.5)
Print("press [Enter] to continue ... ") : Input()
EndIf
Python
import curses import time stdscr = curses.initscr() curses.curs_set(1) # visible time.sleep(2) curses.curs_set(0) # invisible time.sleep(2) curses.curs_set(1) # visible time.sleep(2) curses.endwin()
Racket
#lang racket
(void (system "tput civis")) (sleep 2) (void (system "tput cvvis"))
REXX
{{works with|Regina REXX}}
/*REXX pgm calls a function in a shared library (regutil) to hide/show cursor.*/
z=rxfuncadd('sysloadfuncs', "regutil", 'sysloadfuncs') /*add a function lib.*/
if z\==0 then do /*test the return cod*/
say 'return code' z "from rxfuncadd" /*tell about bad RC. */
exit z /*exit this program. */
end
call sysloadfuncs /*load the functions.*/
/* [↓] call a particular function. */
call syscurstate 'off' /*hide the displaying of the cursor. */
say 'showing of the cursor is now off' /*inform that the cursor is now hidden.*/
/* ··· and perform some stuff here ··· */
say 'sleeping for three seconds ...' /*inform the user of what we're doing. */
call sleep 3 /*might as well sleep for three seconds*/
call syscurstate 'on' /*(unhide) the displaying of the cursor*/
say 'showing of the cursor is now on' /*inform that the cursor is now showing*/
/*stick a fork in it, we're all done. */
'''output'''
showing of the cursor is now off
sleeping for three seconds ...
showing of the cursor is now on
Ring
# Project : Terminal control/Hiding the cursor
load "stdlib.ring"
# Linux
? "Hide Cursor using tput utility"
system("tput civis") # Invisible
sleep(10)
? "Show Cursor using tput utility"
system("tput cnorm") # Normal
Ruby
require "curses" include Curses init_screen begin curs_set(1) #visible cursor sleep 3 curs_set(0) #invisible cursor sleep 3 curs_set(1) #visible cursor sleep 3 ensure close_screen end
Scala
object Main extends App { print("\u001B[?25l") // hide cursor Thread.sleep(2000) // wait 2 seconds before redisplaying cursor print("\u001B[?25h") // display cursor Thread.sleep(2000) // wait 2 more seconds before exiting }
Tcl
proc cursor {{state "normal"}} { switch -- $state { "normal" {set op "cnorm"} "invisible" {set op "civis"} "visible" {set op "cvvis"} } # Should be just: “exec tput $op” but it's not actually supported on my terminal... exec sh -c "tput $op || true" }
Demonstration code:
cursor normal puts "normal cursor" after 3000 cursor invisible puts "invisible cursor" after 3000 cursor visible puts "very visible cursor" after 3000 cursor normal puts "back to normal" after 1000
UNIX Shell
tput civis # Hide the cursor sleep 5 # Sleep for 5 seconds tput cnorm # Show the cursor
XPL0
include c:\cxpl\codes; \intrinsic 'code' declarations
proc ShowCur(On); \Turn flashing cursor on or off
int On; \true = cursor on; false = cursor off
int CpuReg;
[CpuReg:= GetReg; \access CPU registers
CpuReg(0):= $0100; \AX:= $0100
CpuReg(2):= if On then $0007 else $2000;
SoftInt($10); \Call BIOS interrupt $10
]; \ShowCur
[ShowCur(false); \turn off flashing cursor
if ChIn(1) then []; \wait for keystroke
ShowCur(true); \turn on flashing cursor
]
zkl
{{trans|Go}} Hide the cursor for three seconds on an ANSI terminal
print("\e[?25l");
Atomic.sleep(3);
print("\e[?25h");
{{omit from|ACL2}} {{omit from|GUISS}} {{omit from|Maxima}} {{omit from|ZX Spectrum Basic|The cursor appears in a separate area, and does not appear unless input is required}}