Terminal control/Hiding the cursor

Terminal control/Hiding the cursor
You are encouraged to solve this task according to the task description, using any language you may know.

The task is to hide the cursor and show it again.

Action!

PROC Wait(BYTE frames)
  BYTE RTCLOK=$14
  frames==+RTCLOK
  WHILE frames#RTCLOK DO OD
RETURN

PROC Main()
  BYTE CRSINH=$02F0 ;Controls visibility of cursor

  Print("Hiding the cursor...")
  Wait(50)
  CRSINH=1 PutE() ;put the new line character to force hide the cursor
  Wait(50)

  Print("Showing the cursor...")
  Wait(50)
  CRSINH=0 PutE() ;put the new line character to force show the cursor
  Wait(50)
RETURN

Output:

Screenshot from Atari 8-bit computer

Ada

Library: ANSIAda

with Ada.Text_Io;

with Ansi;

procedure Hiding is
   use Ada.Text_Io;
begin
   Put ("Hiding the cursor for 2.0 seconds...");
   delay 0.500;
   Put (Ansi.Hide);
   delay 2.000;
   Put ("And showing again.");
   delay 0.500;
   Put (Ansi.Show);
   delay 2.000;
   New_Line;
end Hiding;

Arturo

cursor false
print "hiding the cursor"

pause 2000

cursor true
print "showing the cursor"

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

BaCon

' Hiding the cursor for an ANSI compliant terminal
CURSOR OFF
CURSOR ON

BASIC

Works with: QBasic

Works with: FreeBASIC

'hide the cursor:
LOCATE , , 0
'wait for a keypress...
SLEEP
'show the cursor:
LOCATE , , 1

Applesoft BASIC

WAIT 49152,128

BBC BASIC

32-bit BBC BASICs:

      OFF : REM Hide the cursor
      WAIT 400
      ON  : REM Show the cursor again

All BBC BASICs:

      VDU 23,1,0;0;0;0; : REM Hide the cursor
      T%=TIME+400:REPEAT UNTIL TIME>T%
      VDU 23,1,1;0;0;0; : REM Show the cursor again

True BASIC

SET CURSOR "off"
PAUSE 2                    !Pause 2 seconds
SET CURSOR "on"
END

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#

Works with: Mono version 1.2

Works with: Visual C# version 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);
}

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
}

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)

ncurses

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

(defun hide-show-cursor ()
  (with-screen (scr :input-echoing nil :input-blocking t)
    (setf (cursor-visible-p scr) nil)
    (format scr "cursor-visible-p: ~A~%" (cursor-visible-p scr))
    (refresh scr)
    ;; wait for a keypress
    (get-char scr)
    (setf (cursor-visible-p scr) t)
    (format scr "cursor-visible-p: ~A" (cursor-visible-p scr))
    (refresh scr)
    (get-char scr)))

FunL

import time.*
import console.*

hide()
sleep( 2 Second )
show()

Furor

Hide:

cursoroff

Show:

cursoron

Peri

Hide:

###sysinclude system.uh
cursoroff

Show:

###sysinclude system.uh
cursoron

FreeBASIC

Locate , , 0    'Hide the cursor

Sleep 500       'waiting half second or a keypress...

Locate , , 1    'Show the cursor again

Sleep

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

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

jq

Works with: jq

Also works with gojq, the Go implementation.

Invocation: jq -nrR -f hiding-the-cursor.jq

# Be busy for at least the given number of seconds,
# and emit the actual number of seconds that have elapsed.
def sleep($seconds):
  now
  | . as $now
  | until( .  - $now >= $seconds; now)
  | . - $now ;

def demo:
  def ESC: "\u001B";
  def reset: "\(ESC)[0H\(ESC)[0J\(ESC)[?25h";

  reset,
  "Now you see it ...",
  (sleep(2) | empty),
  "\(ESC)[?25l",                       # hide the cursor
  "... now you don't.",
  "Press RETURN to reset the screen and cursor.",
  (first(inputs) | empty),
  reset;

demo

Julia

Translation of: 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 version 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/Wolfram Language

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

Phix

cursor(NO_CURSOR)
sleep(1)
cursor(UNDERLINE_CURSOR)

PHP

#!/usr/bin/php
<?php
echo "\e[?25l"; // Cursor hide escape sequence
sleep(5);
echo "\e[?25h"; // Cursor show escape sequence
sleep(5);

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

With print:

print("\x1b[?25l") # hidden
print("\x1b[?25h") # shown

With curses:

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()

Quackery

Translation of: Python

On some platforms the cursor visibility will not change until the output buffer is flushed by for example a cr/lf.

  [ $ &print("\x1b[?25l",end='')& python ] is hide ( --> )

  [ $ &print("\x1b[?25h",end='')& python ] is show  ( --> )

R

Translation of: Python

cat("\x1b[?25l") # Hide
Sys.sleep(2)
cat("\x1b[?25h") # Show

Racket

#lang racket
(void (system "tput civis")) (sleep 2) (void (system "tput cvvis"))

Raku

(formerly Perl 6)

say 'Hiding the cursor for 5 seconds...';
run 'tput', 'civis';
sleep 5;
run '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 cursorVisibility {{state normal}} {
    switch -- $state {
	invisible {set op civis}
	visible   {set op cvvis}
	normal    {set op cnorm}
    }
    exec -- >@stdout tput $op
}

Demo:

foreach x {visible invisible normal} {
    cursorVisibility $x
    puts -nonewline "$x cursor -> "
    flush stdout
    after 3000
    puts {}
}

UNIX Shell

tput civis    # Hide the cursor
sleep 5       # Sleep for 5 seconds
tput cnorm    # Show the cursor

Wren

Translation of: Go

import "timer" for Timer

System.print("\e[?25l")
Timer.sleep(3000)
System.print("\e[?25h")
Timer.sleep(3000)

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

Translation of: Go

Hide the cursor for three seconds on an ANSI terminal

print("\e[?25l");
Atomic.sleep(3);
print("\e[?25h");