Terminal control/Coloured text: Difference between revisions

* How to cause blinking or flashing (if supported by the terminal)

<br><br>

 

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

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

bx lr @ return

 

 

=={{header|Arturo}}==

 

 

 

=={{header|AutoHotkey}}==

[[Image:AutoHotkey_terminal_control_coloured_text.jpeg|thumb|right]]

AutoHotkey is not written for the command line, so we need to use the WinAPI directly. For simplicity, this example demonstrates only the foreground colours.

hConsole := DllCall( "GetStdHandle", int, STDOUT := -11 )

Loop 15

return out

return 0

 

=={{header|BASIC}}==

{{works with|QBasic}}

 

COLOR n

PRINT "Rosetta Code"

 

==={{header|Commodore BASIC}}===

Eight (8) colors available.

 

20 for i=0 to 7

30 poke 646,i:print "rosetta code!"

40 next i

 

====Commodore 64====

Sixteen (16) colors available. This program also works on the rare Commodore CBM-II P500, which featured the same VIC-II video chip as the Commodore 64. Simply change the memory address from 646 to 236.

 

20 for i=0 to 15

30 poke 646,i:print "rosetta code!"

40 next

 

====Commodore 128====

Outputs 16 colors to both the 80-column and 40-column displays, however the palette between the two displays is not exactly the same.

 

20 for i=0 to 15

30 color 5,i:print "rosetta code!"

70 color 5,i:print "rosetta code!"

80 next i

 

====Commodore Plus/4====

This machine is capable of 8 luminance values for 15 colors, plus black, yielding a total of 121 unique colors.

 

20 for c=1 to 16

30 for b=0 to 7

40 color 1,c,b:print "rosetta code!"

50 next b:next c

 

=={{header|BBC BASIC}}==

COLOUR col% : REM foreground

COLOUR 128+(15-col%) : REM background

PRINT "Rosetta Code"

[[File:coloured_text_bbc.gif]]

 

=={{header|Befunge}}==

Assuming a terminal with support for ANSI escape sequences, this displays the words ''Red'', ''Green'', ''Blue'', ''Magenta'', ''Cyan'' and ''Yellow'', using the corresponding text colour and a "complementary" background colour.

 

=={{header|C}}==

On a terminal that understands ANSI escape sequences, such as color xterm, this shows you some annoyingly huge, annoyingly colorful tables.

 

void table(const char *title, const char *mode)

table("inverted ( ESC[7m )", "7;");

return 0;

 

=={{header|C sharp|C#}}==

 

Visual Studios Intellisense will list all available colours.

static void Main(string[] args)

{

Console.ReadKey();

}

 

=={{header|COBOL}}==

{{works with|OpenCOBOL}}

<!-- I couldn't find a way to upload a picture of the output. The 'Upload File' option isn't there for me. Would someone else mind uploading it? -->

IDENTIFICATION DIVISION.

PROGRAM-ID. coloured-text.

 

GOBACK

 

=={{header|D}}==

 

For terminals that understand color escape sequences:

std.conv,

std.stdio;

"Hello, world!".color(c).writeln;

}

 

=={{header|F_Sharp|F#}}==

{{trans|C#}}

 

Console.ForegroundColor <- ConsoleColor.Red

Console.ResetColor()

Console.WriteLine("Back to normal")

 

=={{header|Forth}}==

ANS/ISO Forth does not specify how screen color is handled. This demonstration creates a set of commands for an ANSI terminal that give the programmer control of text color.

DECIMAL

( support routines)

: TEXT ( color ) 30 + ATTR ; ( use: YELLOW TEXT )

: BACKGROUND ( color ) 40 + ATTR ; ( use: BLUE BACKGROUND )

With the code loaded into Forth, color control is a part of the language

BLUE TEXT BOLD ATTR ok

 

=={{header|Fortran}}==

! and ANSI supporting terminal (tested Linux, various terminals).

program coloured_terminal_text

 

write(ERROR_UNIT, '(a)') background_green // 'Bonus Round' // reset

 

===Intel Fortran on Windows===

Using Windows API functions, see for instance '''[https://msdn.microsoft.com/en-us/library/ms686047.aspx SetConsoleTextAttribute]''' in MSDN. On can set foreground and background colors, available attributes are [https://msdn.microsoft.com/en-us/library/ms682088.aspx here]. It's not possible to cause blinking without using a thread to change attributes at time intervals. The program reverts the console attributes to the preceding values. Failing to do that, it is still possible to reset console colors with the '''color''' command, without arguments.

 

use kernel32

implicit none

print "(A)", "This is a red string."

q = SetConsoleTextAttribute(hConsole, csbi%wAttributes)

 

=={{header|FunL}}==

 

bold()

reset()

 

 

=={{header|Go}}==

===External command===

 

import (

cmd.Stdout = os.Stdout

cmd.Run()

Optional tasks

 

import (

cmd.Stdout = os.Stdout

return cmd.Run()

===ANSI escape codes===

 

import "fmt"

fmt.Println("\033[32mGreen")

fmt.Println("\033[34mBlue")

Optional tasks

 

import "fmt"

fmt.Println(" Blinking Red ")

fmt.Print("\033[25;40m") // blink off, black background

===Ncurses===

{{libheader|Curses}}

 

import (

s.Println("Blue")

s.GetChar()

Optional tasks

 

import (

s.Print(" Blinking Red ")

s.GetChar()

 

=={{header|Golo}}==

----

This module demonstrates terminal colours.

}

println("")

 

=={{header|Haskell}}==

{{Works with|ansi-terminal|0.5.5.1}}

 

 

import System.Console.ANSI

colorStrLn Vivid Green Dull Black "This is green on black."

colorStrLn Vivid Yellow Dull Black "This is yellow on black."

 

=={{header|J}}==

<!--WARNING-->

Quite different from the fixed c solution, we flexibly construct character vectors that combine various functions. This code constructs two such sequences, DB is useful to write vertical text, and the noun J output to the terminal draws to the extent of my artistic ability the J icon at the relative position.

 

CSI=: 27 91 { a.

J=: J , (backward 5),'\____/'

smoutput(color BLACK),(clear 2),(move 8 22),J,(WHITE color BLACK),(downward 2)

 

=={{header|Julia}}==

Julia has rudimentary color terminal support built-in. Slightly more elaborate color and effect support is available with the <code>AnsiColor</code> package.

using AnsiColor

 

println("This terminal appears not to support color.")

end

 

{{out}}

=={{header|Kotlin}}==

{{Works with|Ubuntu|14.04}}

 

const val ESC = "\u001B"

}

println(WHITE) // set foreground color to normal white

 

=={{header|Lasso}}==

 

define ec(code::string) => {

stdoutnl('So this is the Rosetta Code!')

stdout( ec('normal'))

 

=={{header|Locomotive Basic}}==

 

20 print "Mode 1 (4 colors):"

30 for y=0 to 3

330 print "*End of color demo*"

340 locate 1,25:print "<Press any key>";:call &bb06

 

Delegating to tput on terminal enabled OS(Mac Os, Linux)

Run["tput setaf 2"]; Print["Coloured Text"];

[[File:colouredtextmma.png]]

 

=={{header|Nim}}==

setForegroundColor(fgRed)

echo "FATAL ERROR! Cannot write to /boot/vmlinuz-3.2.0-33-generic"

 

setForegroundColor(fgMagenta)

 

=={{header|OCaml}}==

Using the library [http://forge.ocamlcore.org/projects/ansiterminal/ ANSITerminal] in the interactive loop:

 

 

# open ANSITerminal ;;

# print_string [cyan; on_blue] "Hello\n" ;;

Hello

 

=={{header|ooRexx}}==

This program is based on the shell script in the Bash Prompt HowTo at

http://www.tldp.org/, by Giles Orr. It uses object-oriented features of Open Object Rexx.

#!/usr/bin/rexx

/*.----------------------------------------------------------------------.*/

end

return

This is what the output looks like:

 

=={{header|PARI/GP}}==

 

 

=={{header|Pascal}}==

The CRT unit allows us to play with the console window, since at least the old Turbo Pascal days. We can clear the screen and specify colors by number or by name, among other tricks.

 

 

uses CRT;

TextBackground(White);

TextColor(Black);

 

=={{header|Perl}}==

red => "\e[1;31m",

green => "\e[1;32m",

say colored('MAGENTA', 'bold magenta');

say colored('CYAN ON RED', 'bold cyan on_red');

 

=={{header|Phix}}==

{{trans|PureBasic}}

The following builtin constants (0..15) may be used:

Output matches PureBasic

 

=={{header|PicoLisp}}==

{{trans|UNIX Shell}}

(quit "This application requires a colour terminal") )

 

 

(call 'tput 'sgr0) # reset

 

=={{header|PowerShell}}==

foreach ($color in [enum]::GetValues([System.ConsoleColor])) {Write-Host "$color color." -ForegroundColor $color}

 

=={{header|PureBasic}}==

PrintN("Background color# 00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15")

PrintN(" -----------------------------------------------")

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

[[Image:terminal_control,colored_text.png]]

 

=={{header|Python}}==

{{libheader|colorama}}

from colorama import init, Fore, Back, Style

init(autoreset=True)

print Fore.MAGENTA + "Rosetta Code!"

print Back.YELLOW + Fore.BLUE + Style.BRIGHT + " " * 40 + " == Good Bye!"

 

 

This is a windows only solution without colorama

from ctypes import *

 

color(7)

raw_input("holding cmd")

 

=={{header|Racket}}==

{{trans|Tcl}}

#lang racket

 

(reset))

(displayln "Steady only"))

 

=={{header|Raku}}==

(formerly Perl 6)

 

say colored('RED ON WHITE', 'bold red on_white');

say colored('MAGENTA', 'bold magenta');

say colored('CYAN ON RED', 'bold cyan on_red');

 

=={{header|REXX}}==

<br><br>The program displays 16 lines, each of a different color with text stating the color of the text.

<br>(The black text, of course, is essentially invisible as the background is also black.)

parse arg !; if !all() then exit /*exit if documentation specified*/

if \!dos & \!os2 then exit /*if this isn't DOS, then exit. */

!rex:parse upper version !ver !vernum !verdate .;!brexx='BY'==!vernum;!kexx='KEXX'==!ver;!pcrexx='REXX/PERSONAL'==!ver|'REXX/PC'==!ver;!r4='REXX-R4'==!ver;!regina='REXX-REGINA'==left(!ver,11);!roo='REXX-ROO'==!ver;call !env;return

!sys:!cms=!sys=='CMS';!os2=!sys=='OS2';!tso=!sys=='TSO'|!sys=='MVS';!vse=!sys=='VSE';!dos=pos('DOS',!sys)\==0|pos('WIN',!sys)\==0|!sys=='CMD';call !rex;return

 

=={{header|Ring}}==

# Project : Terminal control/Coloured text

 

cc_print(forecolor | CC_BG_WHITE, "Rosetta Code" + nl)

next

Output image:

 

{{libheader|colored}}

 

require 'rubygems'

require 'colored'

puts 'white on green'.white_on_green

puts 'white on magenta'.white_on_magenta

 

[[File:Colored-text-ruby.png]]

 

=={{header|Scala}}==

===Scala idiom (Functional Programming)===

{{Works with|Ubuntu|14.04}}

val ESC = "\u001B"

val (normal, bold, blink, black, white) =

println(white) // set foreground color to normal white

}

 

=={{header|Sidef}}==

{{trans|Raku}}

 

say a.colored('RED ON WHITE', 'bold red on_white');

say a.colored('MAGENTA', 'bold magenta');

say a.colored('CYAN ON RED', 'bold cyan on_red');

 

=={{header|Tcl}}==

This only works on Unix terminals as it delegates to the system <tt>tput</tt> command.

proc capability cap {expr {![catch {exec tput -S << $cap}]}}

proc colorterm {} {expr {[capability setaf] && [capability setab]}}

} else {

puts "Steady only"

 

This is red

--color green

This is magenta

--color yellow

 

# Check if the terminal supports colour

 

echo "Flashing text"

 

 

=={{header|XPL0}}==

PCs and by simulators, such as DOSBox, on other computers.

 

def Black, Blue, Green, Cyan, Red, Magenta, Brown, White, \attribute colors

Gray, LBlue, LGreen, LCyan, LRed, LMagenta, Yellow, BWhite; \EGA palette

Attrib(Cyan<<4+Black); \black on cyan

ChOut(6,^r);

 

=={{header|zkl}}==

{{trans|C}}

Terminal window on Linux, prints tables of colored glyphs.

println("\n\e[1m%s\e[m\n bg\t fg".fmt(title));

foreach b in ([40..48].chain([100..107])){

table("underline ( ESC[4m ), support varies", "4;");

table("blink ( ESC[5m )", "5;");

 

The ZX Spectrum will always output colour. However if the television is black and white, these will show as various levels of luminence corresponding to the numerical colour value.

20 READ c$: REM get our text for display

30 INK l: REM set the text colour

110 STOP

 

 

{{omit from|Axe}}