Terminal control/Inverse video

From Rosetta Code
Task
Terminal control/Inverse video
You are encouraged to solve this task according to the task description, using any language you may know.
Task

Display a word in inverse video   (or reverse video)   followed by a word in normal video.

11l[edit]

Translation of: Python
print("\033[7mReversed\033[m Normal")

6502 Assembly[edit]

Works with: [VICE]

This example has been written for the C64 and uses the STROUT BASIC routine. Compile with the Turbo Macro Pro cross assembler:

tmpx -i inverse-video.s -o inverse-video.prg

Run with:

SYS680
; C64 - Terminal control: Inverse Video

; *** labels ***

strout          = $ab1e

; *** main ***

                *=$02a8         ; sys 680
                
                lda #<str       ; Address of the message to print - low byte
                ldy #>str       ; Address high byte
                jsr strout      ; Print a null terminated string.
                rts    
                
; *** data ***

str             .byte $12       ; the REVERSE ON control code
                                ; see https://en.wikipedia.org/wiki/PETSCII
                .text "reversed"
                .byte $92       ; the REVERSE OFF control code
                .null " normal" ; null terminated string

Action![edit]

PROC PrintInv(CHAR ARRAY a)
  BYTE i

  IF a(0)>0 THEN
    FOR i=1 TO a(0)
    DO
      Put(a(i)%$80)
    OD
  FI
RETURN

PROC Main()
  Position(2,2)

  PrintInv("Inverse")
  Print(" video")
RETURN
Output:

Screenshot from Atari 8-bit computer

Ada[edit]

with Ada.Text_IO; use  Ada.Text_IO;

procedure Reverse_Video is 

   Rev_Video  : String := Ascii.ESC & "[7m";
   Norm_Video : String := Ascii.ESC & "[m";

begin
   Put (Rev_Video & "Reversed");
   Put (Norm_Video & " Normal");
end Reverse_Video;

ARM Assembly[edit]

Works with: [Game Boy Advance]

This is a slightly different take on the age-old XOR technique to flip the colors of a monochrome graphic. While the Game Boy Advance uses 16 bits per pixel, we'll use a monochrome bitmap font, where each bit that's a 1 is an instruction to fill in a pixel and each bit that's a 0 is an instruction to leave it blank. By flipping the bits of the font itself, we can create the "inverse video" effect. The ARM's EOR instruction can't be used to write to memory directly; you would have to load from memory into a register first, apply the EOR operation with the desired value, and write back. Our method of flipping the bits of the font will save time.

The Game Boy Advance's video memory is very simple, a two-dimensional array of 16-bit values ranging from memory locations 0x06000000 to 0x06012BFF represents each pixel of the screen. Write a 15-bit hex color value to an element of the array to turn the corresponding pixel to that color value.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	
; Program Start

	.equ ramarea, 0x02000000
	.equ CursorX,ramarea		
	.equ CursorY,ramarea+1

	
ProgramStart:
	mov sp,#0x03000000			;Init Stack Pointer
	
	mov r4,#0x04000000  		        ;DISPCNT -LCD Control
	mov r2,#0x403    			;4= Layer 2 on / 3= ScreenMode 3
	str r2,[r4]         	
	bl ResetTextCursors			;set text cursors to top left of screen
		
	adr r1,HelloWorld
	mov r2,#0x7FFF
	mov r11,#1
	bl PrintString
	
	adr r1,HelloWorld
	mov r2,#0x7FFF
	mov r11,#0
	bl PrintString
	

forever:
	b forever
BitmapFont:
        .include "M:\SrcAll\BitmapFont.asm"
	
HelloWorld:
	.byte "HELLO",255
	.align 4
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
PrintString:					;Print 255 terminated string 
	STMFD sp!,{r0-r12, lr}
PrintStringAgain:
		ldrB r0,[r1],#1
		cmp r0,#255
		beq PrintStringDone		;Repeat until 255
		bl printchar 			;Print Char
		b PrintStringAgain
PrintStringDone:
	LDMFD sp!,{r0-r12, lr}
	bx lr
	
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
PrintChar:
	;input: R1 = ADDR OF TEXT
	;	R2 = DESIRED COLOR (ABBBBBGGGGGRRRRR   A=Alpha)
	;	CursorX = X POS OF WHERE TO DRAW
	;	CursorY = Y POS OF WHERE TO DRAW
        ;       R11 = 1 FOR INVERTED TEXT, 0 FOR NORMAL TEXT

	STMFD sp!,{r4-r12, lr}

		mov r4,#0
		mov r5,#0
		
		mov r3,#CursorX
		ldrB r4,[r3]			;X pos
		mov r3,#CursorY
		ldrB r5,[r3]			;Y pos
		
		mov r3,#0x06000000 		;VRAM base
		
		mov r6,r4,lsl #4		;Xpos, 2 bytes per pixel, 8 bytes per char
		add r3,r3,r6
		
	;Ypos, 240 pixels per line,2 bytes per pixel, 8 lines per char
		
		mov r4,r5,lsl #4		
		mov r5,r5,lsl #8
		sub r6,r5,r4
		mov r6,r6,lsl #4		;ypos * 240 * 8 * 2 = ((((ypos << 8)-(ypos << 4)) << 3)<< 1
		add r3,r3,r6
		
		adr r4,BitmapFont 		;Font source
		
		subs r0,r0,#32			;First Char is 32 (space)
		beq LineDone			;if it's a space, just move the cursor without actually writing anything
		add r4,r4,r0,asl #3		;8 bytes per char
		
		mov r6,#8			;8 lines 
DrawLine:
		mov r7,#8 			;8 pixels per line
		ldrb r8,[r4],#1			;Load this piece of the letter
		cmp r11,#1			;does r11 = 1?
		mvneq r8,r8			;if so, flip the bits of r8 before printing.
		mov r9,#0b100000000		;Bit Mask for testing whether to fill
				
DrawPixel:
		tst r8,r9			;Is bit 1?
		strneh r2,[r3]			;Yes? then fill pixel (HalfWord)
		add r3,r3,#2
		mov r9,r9,ror #1		;Bitshift Mask
		subs r7,r7,#1
		bne DrawPixel			;Next Hpixel
		
		add r3,r3,#480-16	        ;Move Down a line (240 pixels * 2 bytes) 
		subs r6,r6,#1			;-1 char (16 px)
		bne DrawLine			;Next Vline
		
LineDone:	
		mov r3,#CursorX
		ldrB r0,[r3]	
		add r0,r0,#1			;Move across screen
		strB r0,[r3]	
		mov r10,#30
		cmp r0,r10
		bleq NewLine
	LDMFD sp!,{r4-r12, lr}
	bx lr
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
NewLine:
	STMFD sp!,{r0-r12, lr}
		mov r3,#CursorX
		mov r0,#0
		strB r0,[r3]
		mov r4,#CursorY
		ldrB r0,[r4]
		add r0,r0,#1
		strB r0,[r4]
	LDMFD sp!,{r0-r12, pc}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ResetTextCursors:
	STMFD sp!,{r4-r6,lr}
		mov r4,#0
		mov r5,#CursorX
		mov r6,#CursorY
		strB r4,[r5]
		strB r4,[r6]
	LDMFD sp!,{r4-r6,lr}
	bx lr
Output:

Picture of output text

AutoHotkey[edit]

Call SetConsoleTextAttribute() to change foreground and background colors.

DllCall( "AllocConsole" ) ; create a console if not launched from one
hConsole := DllCall( "GetStdHandle", int, STDOUT := -11 )

SetConsoleTextAttribute(hConsole, 0x70) ; gray background, black foreground
FileAppend, Reversed`n, CONOUT$ ; print to stdout

SetConsoleTextAttribute(hConsole, 0x07) ; black background, gray foreground
FileAppend, Normal, CONOUT$

MsgBox

SetConsoleTextAttribute(hConsole, Attributes){
	return DllCall( "SetConsoleTextAttribute", UPtr, hConsole, UShort, Attributes)
}

AWK[edit]

BEGIN {
system ("tput rev")
print "foo"
system ("tput sgr0")
print "bar"
}

Axe[edit]

A delay is added because the screen redraws with the normal font after the program exits.

Fix 3
Disp "INVERTED"
Fix 2
Disp "REGULAR",i
Pause 4500

BaCon[edit]

COLOR INVERSE
PRINT "a word"
COLOR RESET
PRINT "a word"

BASIC[edit]

Applesoft BASIC[edit]

INVERSE:?"ROSETTA";:NORMAL:?" CODE"

BBC BASIC[edit]

      COLOUR 128        : REM Black background
      COLOUR 15         : REM White foreground
      PRINT "Inverse";
      COLOUR 128+15     : REM White background
      COLOUR 0          : REM Black foreground
      PRINT " video"

Alternative method using 'VDU code' strings:

      inverse$ = CHR$(17)+CHR$(128)+CHR$(17)+CHR$(15)
      normal$ = CHR$(17)+CHR$(128+15)+CHR$(17)+CHR$(0)
      PRINT inverse$ + "Inverse" + normal$ + " video"

Commodore BASIC[edit]

Commodore computers have defined a "reverse" character set in character ROM. This can be accessed through control characters reserved in the ASCII (PETSCII) character table. To enable reverse characters, print CHR$(18) ("Reverse On"). Reverse characters will continue until a "Reverse Off" CHR$(146) is printed, or until a newline (carriage return CHR$(13)) which may also occur at the end of a print statement.

5 rem inverse video
10 print chr$(18);"reverse on";chr$(146);" reverse off"
20 print
25 rem newline (cr) also terminates reverse mode
30 print chr$(18);"this is reversed... ";:print "so is this."
40 print
50 print chr$(18);"this is reversed... ":print "this is not."
60 print 
70 print chr$(18);"this is reversed... ";chr$(13);"this is not."


FreeBASIC[edit]

Color 0, 15 ' usa los colores blanco (fondo) y negro (primer plano)
Locate 2, 2 : Print "Video inverso"
Color 15, 0 ' usa los colores negro (fondo) y blanco (primer plano)
Locate 3, 2 : Print "Video normal"
Sleep


Locomotive Basic[edit]

The firmware routine at &bb9c (TXT INVERSE) swaps the current Locomotive BASIC PEN and PAPER colors:

10 CALL &bb9c:PRINT "inverse";
20 CALL &bb9c:PRINT "normal"

PureBasic[edit]

If OpenConsole()
  ConsoleColor(0, 15) ;use the colors black (background) and white (forground)
  PrintN("Inverse Video")
  ConsoleColor(15, 0) ;use the colors white (background) and black (forground)
  PrintN("Normal Video")
  
  Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
  CloseConsole()
EndIf

Run BASIC[edit]

' ---------- foo is reverse --------------
x$ = shell$("tput mr
echo 'foo'")

' ---------- bar is normal --------------
x$ = shell$("tput me     
echo 'bar'")
wait

Sinclair ZX81 BASIC[edit]

Inverse video is available from the keyboard (accessed with SHIFT9), so the normal way to do this would be just

PRINT "FOOBAR"

but with the 'foo' in inverse video and the 'bar' in normal video.

If this won't work (say, if we may want to use inverse video with string variables rather than string literals), we can use a small subroutine—relying on the fact that the ZX81 character set uses the high bit of each character code to select normal or inverse video.

10 LET S$="FOO"
20 GOSUB 50
30 PRINT S$;"BAR"
40 STOP
50 FOR I=1 TO LEN S$
60 LET S$(I)=CHR$ (128+CODE S$(I))
70 NEXT I
80 RETURN

Note that this subroutine assumes the source string is not already in inverse video: if it could be, you will need to test each character before you attempt to convert it.


Yabasic[edit]

print color("black","white") "Video inverso"
// o también
print reverse "Video inverso"

print color("white","black") "Video normal"

ZX Spectrum Basic[edit]

10 INVERSE 1
20 PRINT "FOO";
30 INVERSE 0
40 PRINT "BAR"

Befunge[edit]

Assuming a terminal with support for ANSI escape sequences.

0"lamroNm["39*"esrevnIm7["39*>:#,_$@

C[edit]

#include <stdio.h>

int main()
{
	printf("\033[7mReversed\033[m Normal\n");

	return 0;
}

COBOL[edit]

       IDENTIFICATION DIVISION.
       PROGRAM-ID. terminal-reverse-video.

       PROCEDURE DIVISION.
           DISPLAY "Reverse-Video" WITH REVERSE-VIDEO
           DISPLAY "Normal"

           GOBACK
           .

Common Lisp[edit]

ncurses[edit]

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

(defun reverse-attribute ()
  (with-screen (scr :input-blocking t :input-echoing nil :cursor-visible nil)
    (add-string scr "Reverse" :attributes '(:reverse))
    (add-string scr " Normal" :attributes '())
    (refresh scr)
    (get-char scr)))

Forth[edit]

Developed with Gforth 0.7.9

: Reverse          #27  emit "[7m" type ; 
: Normal           #27 emit "[m" type ; 

: test cr Reverse ."   Reverse " cr  Normal ."  Normal  " ; 
test

FunL[edit]

import console.*

println( "${REVERSED}This is reversed.$RESET This is normal." )

Go[edit]

External command[edit]

package main

import (
    "fmt"
    "os"
    "os/exec"
)

func main() {
    tput("rev")
    fmt.Print("Rosetta")
    tput("sgr0")
    fmt.Println(" Code")
}

func tput(arg string) error {
    cmd := exec.Command("tput", arg)
    cmd.Stdout = os.Stdout
    return cmd.Run()
}

ANSI escape codes[edit]

package main

import "fmt"

func main() {
    fmt.Println("\033[7mRosetta\033[m Code")
}

Ncurses[edit]

Library: Curses
package main

import (
    "log"

    gc "code.google.com/p/goncurses"
)

func main() {
    s, err := gc.Init()
    if err != nil {
        log.Fatal("init:", err)
    }
    defer gc.End()
    s.AttrOn(gc.A_REVERSE)
    s.Print("Rosetta")
    s.AttrOff(gc.A_REVERSE)
    s.Println(" Code")
    s.GetChar()
}

J[edit]

Use the definitions given in Terminal_control/Coloured_text#J

   ;:';:,#.*."3,(C.A.)/\/&.:;:' NB. some output beforehand
   attributes REVERSEVIDEO      NB. does as it says
   2 o.^:a:0                    NB. solve the fixed point equation cos(x) == x
   attributes OFF               NB. no more blinky flashy
   parseFrench=:;:,#.*."3,(C.A.)/\/&.:;:  NB. just kidding!  More output.

Julia[edit]

Use within the Julia REPL command line.

using Crayons.Box

println(WHITE_FG, BLACK_BG, "Normal")
println(WHITE_BG, BLACK_FG, "Reversed")
println(WHITE_FG, BLACK_BG, "Normal")

Kotlin[edit]

Works with: Ubuntu version 14.04
// version 1.1.2

fun main(args: Array<String>) {
    println("\u001B[7mInverse\u001B[m Normal")
}

Lasso[edit]

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

stdout( #esc + '[7m Reversed Video ' + #esc + '[0m Normal Video ')

Mathematica/Wolfram Language[edit]

Run["tput mr"]
Run["echo foo"] (* is displayed in reverse mode *)
Run["tput me"]
Run["echo bar"]

Nim[edit]

import terminal

stdout.styledWrite("normal ", styleReverse, "inverse", resetStyle, " normal\n")

OCaml[edit]

Using the library ANSITerminal in the interactive loop:

$ ocaml unix.cma -I +ANSITerminal ANSITerminal.cma

# open ANSITerminal ;;
# print_string [Inverse] "Hello\n" ;;
Hello
- : unit = ()

Pascal[edit]

Works with: Free_Pascal
Library: Curses

Using Free Pascal and ncurses. On some systems linking to the libtinfo library may be necessary.

program InverseVideo;
{$LINKLIB tinfo}
uses
  ncurses;
begin
  initscr;
  attron(A_REVERSE);
  printw('reversed');
  attroff(A_REVERSE);
  printw(' normal');
  refresh;
  getch;
  endwin;
end.

Perl[edit]

Like Raku.

print "normal\n";
system "tput rev";
print "reversed\n";
system "tput sgr0";
print "normal\n";

Phix[edit]

--
-- demo\rosetta\Inverse_Video.exw
-- ================================
--
with javascript_semantics
text_color(BLACK)
bk_color(WHITE)
printf(1,"Inverse")
text_color(WHITE)
bk_color(BLACK)
printf(1," Video")
printf(1,"\n\npress enter to exit")
{} = wait_key()

PicoLisp[edit]

(prin "abc")
(call "tput" "rev")
(prin "def")  # These three chars are displayed in reverse video
(call "tput" "sgr0")
(prinl "ghi")

Python[edit]

#!/usr/bin/env python

print "\033[7mReversed\033[m Normal"

Quackery[edit]

  [ $ 'print("\033[7m", end="")' python ] is inversetext ( --> )

  [ $ 'print("\033[m", end="")' python ]  is regulartext ( --> )

  inversetext say "inverse video" 
  regulartext say " normal text"


Racket[edit]

#lang racket
(require (planet neil/charterm:3:0))
 
(with-charterm
 (charterm-clear-screen)
 (charterm-cursor 0 0)
 (charterm-inverse)
 (charterm-display "Hello")
 (charterm-normal)
 (charterm-display "World"))

Raku[edit]

(formerly Perl 6)

say "normal";
run "tput", "rev";
say "reversed";
run "tput", "sgr0";
say "normal";

REXX[edit]

This version only works with PC/REXX and Personal Rexx.

/*REXX program demonstrates the showing of  reverse  video  to the display terminal.    */
@day   = 'day'
@night = 'night'

call scrwrite , 1, @day, , , 7                   /*display to terminal:  white on black.*/
call scrwrite , 1+length(@day), @night, , , 112  /*   "     "     "      black  " white.*/

exit 0                                           /*stick a fork in it,  we're all done. */


Ring[edit]

nverse = char(17)+char(128)+char(17)+char(15)
normal = char(17)+char(128+15)+char(17)+char(0)
see  inverse + " inverse " + normal + " video"

Ruby[edit]

Works with: Ubuntu version 14.04
puts "\033[7mReversed\033[m Normal"

Scala[edit]

Works with: Ubuntu version 14.04
object Main extends App {
    println("\u001B[7mInverse\u001B[m Normal")
}

Standard ML[edit]

val () = print "\^[[7mReversed\^[[m Normal\n"

Tcl[edit]

This only works on Unix terminals.

# Get how the terminal wants to do things...
set videoSeq(reverse) [exec tput rev]
set videoSeq(normal) [exec tput rmso]
proc reverseVideo str {
    global videoSeq
    return "$videoSeq(reverse)${str}$videoSeq(normal)"
}

# The things to print
set inReverse "foo"
set inNormal "bar"

# Print those words
puts "[reverseVideo $inReverse] $inNormal"

TPP[edit]

--revon
This is inverse
--revoff
This is normal

UNIX Shell[edit]

Use the tput(1) utility to write the escape sequences that enable or disable reverse video.

Works with: Bourne Shell
#!/bin/sh
tput mr     # foo is reversed
echo 'foo'
tput me     # bar is normal video
echo 'bar'

If the system supports terminfo, then tput rev and tput sgr0 also work. (All recent systems have terminfo, except NetBSD, but NetBSD 6 will have terminfo.) The shorter names mr and me are the backward-compatible names from termcap.

If the terminal cannot do reverse video, then tput will fail with a message to standard error.

$ TERM=dumb tput mr
tput: Unknown terminfo capability `mr'

Some programs use the standout mode, which might look exactly like reverse video. (The escape sequences might be identical!)

tput so     # enter standout mode
echo 'foo'
tput se     # exit standout mode
echo 'bar'

If the system supports terminfo, then tput smso and tput rmso also work.

C Shell[edit]

tput mr
echo 'foo'
tput me
echo 'bar'

Wren[edit]

System.print("\e[7mInverse")
System.print("\e[0mNormal")

XPL0[edit]

Output device 6 is similar to the normal console screen (device 0), but it provides many combinations of foreground and background colors.

include c:\cxpl\codes;
[Attrib($70);
Text(6, "Inverse");
Attrib($07);
Text(6, " Video");
CrLf(6);
]

Z80 Assembly[edit]

Translation of: Locomotive Basic
.org &8000
PrintChar equ &BB5A
InvertTextColors equ &BB9C


;main

call InvertTextColors

ld hl, HelloAddr
call PrintString

call InvertTextColors

ld hl,HelloAddr
jp PrintString      ;and return to basic after that.


HelloAddr: byte "Hello",0

PrintString:
ld a,(hl)
or a
ret z
call PrintChar
inc hl
jp PrintString


zkl[edit]

There is no explicit support for terminals/video. But, assuming an ANSI terminal:

println("\e[7mReversed\e[m Normal");