Terminal control/Inverse video: Difference between revisions

Content added Content deleted

Inline

Revision as of 10:07, 5 September 2021

Task

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

Call SetConsoleTextAttribute() to change foreground and background colors. <lang AHK>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) }</lang>

AWK

<lang awk>BEGIN { system ("tput rev") print "foo" system ("tput sgr0") print "bar" }</lang>

Axe

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

<lang axe>Fix 3 Disp "INVERTED" Fix 2 Disp "REGULAR",i Pause 4500</lang>

BaCon

<lang freebasic>COLOR INVERSE PRINT "a word" COLOR RESET PRINT "a word"</lang>

BASIC

Applesoft BASIC

<lang ApplesoftBasic>INVERSE:?"ROSETTA";:NORMAL:?" CODE"</lang>

BBC BASIC

<lang bbcbasic> 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"</lang>

Alternative method using 'VDU code' strings: <lang bbcbasic> inverse$ = CHR$(17)+CHR$(128)+CHR$(17)+CHR$(15)

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

Commodore BASIC

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.

<lang gwbasic>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."</lang>

FreeBASIC

<lang freebasic>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</lang>

Locomotive Basic

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

<lang locobasic>10 CALL &bb9c:PRINT "inverse"; 20 CALL &bb9c:PRINT "normal"</lang>

PureBasic

<lang PureBasic>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</lang>

Run BASIC

<lang runbasic>' ---------- foo is reverse -------------- x$ = shell$("tput mr echo 'foo'")

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

Sinclair ZX81 BASIC

Inverse video is available from the keyboard (accessed with SHIFT9), so the normal way to do this would be just <lang basic>PRINT "FOOBAR"</lang> 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. <lang basic>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</lang> 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

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

print color("white","black") "Video normal"</lang>

ZX Spectrum Basic

<lang basic>10 INVERSE 1 20 PRINT "FOO"; 30 INVERSE 0 40 PRINT "BAR"</lang>

Befunge

Assuming a terminal with support for ANSI escape sequences. <lang befunge>0"lamroNm["39*"esrevnIm7["39*>:#,_$@</lang>

C

<lang C>#include <stdio.h>

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

return 0; }</lang>

COBOL

<lang cobol> IDENTIFICATION DIVISION.

      PROGRAM-ID. terminal-reverse-video.

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

          GOBACK
          .</lang>

Common Lisp

ncurses

To interface the ncurses C library from Lisp, the croatoan library is used. <lang lisp>(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)))</lang>

Forth

Developed with Gforth 0.7.9 <lang forth>: Reverse #27 emit "[7m" type ;

Normal #27 emit "[m" type ;

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

test </lang>

FunL

<lang funl>import console.*

println( "${REVERSED}This is reversed.$RESET This is normal." )</lang>

Go

External command

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

}</lang>

ANSI escape codes

<lang go>package main

import "fmt"

func main() {

   fmt.Println("\033[7mRosetta\033[m Code")

}</lang>

Ncurses

Library: Curses

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

}</lang>

J

Use the definitions given in Terminal_control/Coloured_text#J <lang 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.

</lang>

Julia

Use within the Julia REPL command line. <lang julia>using Crayons.Box

println(WHITE_FG, BLACK_BG, "Normal") println(WHITE_BG, BLACK_FG, "Reversed") println(WHITE_FG, BLACK_BG, "Normal") </lang>

Kotlin

Works with: Ubuntu version 14.04

<lang scala>// version 1.1.2

fun main(args: Array<String>) {

   println("\u001B[7mInverse\u001B[m Normal")

}</lang>

Lasso

<lang Lasso>local(esc = decode_base64('Gw=='))

stdout( #esc + '[7m Reversed Video ' + #esc + '[0m Normal Video ')</lang>

Mathematica/Wolfram Language

<lang Mathematica>Run["tput mr"] Run["echo foo"] (* is displayed in reverse mode *) Run["tput me"] Run["echo bar"]</lang>

Nim

<lang nim>import terminal

stdout.styledWrite("normal ", styleReverse, "inverse", resetStyle, " normal\n")</lang>

OCaml

Using the library ANSITerminal in the interactive loop:

<lang ocaml>$ ocaml unix.cma -I +ANSITerminal ANSITerminal.cma

open ANSITerminal ;;
print_string [Inverse] "Hello\n" ;;

Hello - : unit = ()</lang>

Pascal

Works with: Free_Pascal

Library: Curses

Using Free Pascal and ncurses. On some systems linking to the libtinfo library may be necessary. <lang pascal>program InverseVideo; {$LINKLIB tinfo} uses

 ncurses;

begin

 initscr;
 attron(A_REVERSE);
 printw('reversed');
 attroff(A_REVERSE);
 printw(' normal');
 refresh;
 getch;
 endwin;

end. </lang>

Perl

Like Raku. <lang perl>print "normal\n"; system "tput rev"; print "reversed\n"; system "tput sgr0"; print "normal\n";</lang>

Phix

<lang Phix>-- -- demo\rosetta\Inverse_Video.exw -- ================================ -- 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() </lang>

PicoLisp

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

Python

<lang Python>#!/usr/bin/env python

print "\033[7mReversed\033[m Normal"</lang>

Quackery

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

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

 inversetext say "inverse video" 
 regulartext say " normal text"</lang>

Racket

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

</lang>

Raku

(formerly Perl 6) <lang perl6>say "normal"; run "tput", "rev"; say "reversed"; run "tput", "sgr0"; say "normal";</lang>

REXX

This version only works with PC/REXX and Personal Rexx. <lang 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. */</lang>

Ring

<lang ring> nverse = char(17)+char(128)+char(17)+char(15) normal = char(17)+char(128+15)+char(17)+char(0) see inverse + " inverse " + normal + " video" </lang>

Ruby

Works with: Ubuntu version 14.04

<lang ruby>puts "\033[7mReversed\033[m Normal"</lang>

Scala

Works with: Ubuntu version 14.04

<lang scala>object Main extends App {

   println("\u001B[7mInverse\u001B[m Normal")

}</lang>

Standard ML

<lang sml>val () = print "\^[[7mReversed\^[[m Normal\n"</lang>

Tcl

This only works on Unix terminals. <lang tcl># 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"</lang>

TPP

<lang tpp>--revon This is inverse --revoff This is normal</lang>

UNIX Shell

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

Works with: Bourne Shell

<lang bash>#!/bin/sh tput mr # foo is reversed echo 'foo' tput me # bar is normal video echo 'bar'</lang>

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.

<lang bash>$ TERM=dumb tput mr tput: Unknown terminfo capability `mr'</lang>

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

<lang bash>tput so # enter standout mode echo 'foo' tput se # exit standout mode echo 'bar'</lang>

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