559 lines
13 KiB
Go
559 lines
13 KiB
Go
//
|
||
// Copyright (c) 2016-2020 The Aurora Authors. All rights reserved.
|
||
// This program is free software. It comes without any warranty,
|
||
// to the extent permitted by applicable law. You can redistribute
|
||
// it and/or modify it under the terms of the Unlicense. See LICENSE
|
||
// file for more details or see below.
|
||
//
|
||
|
||
//
|
||
// This is free and unencumbered software released into the public domain.
|
||
//
|
||
// Anyone is free to copy, modify, publish, use, compile, sell, or
|
||
// distribute this software, either in source code form or as a compiled
|
||
// binary, for any purpose, commercial or non-commercial, and by any
|
||
// means.
|
||
//
|
||
// In jurisdictions that recognize copyright laws, the author or authors
|
||
// of this software dedicate any and all copyright interest in the
|
||
// software to the public domain. We make this dedication for the benefit
|
||
// of the public at large and to the detriment of our heirs and
|
||
// successors. We intend this dedication to be an overt act of
|
||
// relinquishment in perpetuity of all present and future rights to this
|
||
// software under copyright law.
|
||
//
|
||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||
// IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||
// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||
// OTHER DEALINGS IN THE SOFTWARE.
|
||
//
|
||
// For more information, please refer to <http://unlicense.org/>
|
||
//
|
||
|
||
package aurora
|
||
|
||
// Colorize wraps given value into Value with
|
||
// given colors. For example
|
||
//
|
||
// s := Colorize("some", BlueFg|GreenBg|BoldFm)
|
||
//
|
||
// returns a Value with blue foreground, green
|
||
// background and bold. Unlike functions like
|
||
// Red/BgBlue/Bold etc. This function clears
|
||
// all previous colors and formats. Thus
|
||
//
|
||
// s := Colorize(Red("some"), BgBlue)
|
||
//
|
||
// clears red color from value
|
||
func Colorize(arg interface{}, color Color) Value {
|
||
if val, ok := arg.(value); ok {
|
||
val.color = color
|
||
return val
|
||
}
|
||
return value{arg, color, 0}
|
||
}
|
||
|
||
// Reset wraps given argument returning Value
|
||
// without formats and colors.
|
||
func Reset(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.Reset()
|
||
}
|
||
return value{value: arg}
|
||
}
|
||
|
||
//
|
||
// Formats
|
||
//
|
||
|
||
// Bold or increased intensity (1).
|
||
func Bold(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.Bold()
|
||
}
|
||
return value{value: arg, color: BoldFm}
|
||
}
|
||
|
||
// Faint decreases intensity (2).
|
||
// The Faint rejects the Bold.
|
||
func Faint(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.Faint()
|
||
}
|
||
return value{value: arg, color: FaintFm}
|
||
}
|
||
|
||
// DoublyUnderline or Bold off, double-underline
|
||
// per ECMA-48 (21).
|
||
func DoublyUnderline(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.DoublyUnderline()
|
||
}
|
||
return value{value: arg, color: DoublyUnderlineFm}
|
||
}
|
||
|
||
// Fraktur is rarely supported (20).
|
||
func Fraktur(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.Fraktur()
|
||
}
|
||
return value{value: arg, color: FrakturFm}
|
||
}
|
||
|
||
// Italic is not widely supported, sometimes
|
||
// treated as inverse (3).
|
||
func Italic(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.Italic()
|
||
}
|
||
return value{value: arg, color: ItalicFm}
|
||
}
|
||
|
||
// Underline (4).
|
||
func Underline(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.Underline()
|
||
}
|
||
return value{value: arg, color: UnderlineFm}
|
||
}
|
||
|
||
// SlowBlink makes text blink less than
|
||
// 150 per minute (5).
|
||
func SlowBlink(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.SlowBlink()
|
||
}
|
||
return value{value: arg, color: SlowBlinkFm}
|
||
}
|
||
|
||
// RapidBlink makes text blink 150+ per
|
||
// minute. It is not widely supported (6).
|
||
func RapidBlink(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.RapidBlink()
|
||
}
|
||
return value{value: arg, color: RapidBlinkFm}
|
||
}
|
||
|
||
// Blink is alias for the SlowBlink.
|
||
func Blink(arg interface{}) Value {
|
||
return SlowBlink(arg)
|
||
}
|
||
|
||
// Reverse video, swap foreground and
|
||
// background colors (7).
|
||
func Reverse(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.Reverse()
|
||
}
|
||
return value{value: arg, color: ReverseFm}
|
||
}
|
||
|
||
// Inverse is alias for the Reverse
|
||
func Inverse(arg interface{}) Value {
|
||
return Reverse(arg)
|
||
}
|
||
|
||
// Conceal hides text, preserving an ability to select
|
||
// the text and copy it. It is not widely supported (8).
|
||
func Conceal(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.Conceal()
|
||
}
|
||
return value{value: arg, color: ConcealFm}
|
||
}
|
||
|
||
// Hidden is alias for the Conceal
|
||
func Hidden(arg interface{}) Value {
|
||
return Conceal(arg)
|
||
}
|
||
|
||
// CrossedOut makes characters legible, but
|
||
// marked for deletion (9).
|
||
func CrossedOut(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.CrossedOut()
|
||
}
|
||
return value{value: arg, color: CrossedOutFm}
|
||
}
|
||
|
||
// StrikeThrough is alias for the CrossedOut.
|
||
func StrikeThrough(arg interface{}) Value {
|
||
return CrossedOut(arg)
|
||
}
|
||
|
||
// Framed (51).
|
||
func Framed(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.Framed()
|
||
}
|
||
return value{value: arg, color: FramedFm}
|
||
}
|
||
|
||
// Encircled (52).
|
||
func Encircled(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.Encircled()
|
||
}
|
||
return value{value: arg, color: EncircledFm}
|
||
}
|
||
|
||
// Overlined (53).
|
||
func Overlined(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.Overlined()
|
||
}
|
||
return value{value: arg, color: OverlinedFm}
|
||
}
|
||
|
||
//
|
||
// Foreground colors
|
||
//
|
||
//
|
||
|
||
// Black foreground color (30)
|
||
func Black(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.Black()
|
||
}
|
||
return value{value: arg, color: BlackFg}
|
||
}
|
||
|
||
// Red foreground color (31)
|
||
func Red(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.Red()
|
||
}
|
||
return value{value: arg, color: RedFg}
|
||
}
|
||
|
||
// Green foreground color (32)
|
||
func Green(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.Green()
|
||
}
|
||
return value{value: arg, color: GreenFg}
|
||
}
|
||
|
||
// Yellow foreground color (33)
|
||
func Yellow(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.Yellow()
|
||
}
|
||
return value{value: arg, color: YellowFg}
|
||
}
|
||
|
||
// Brown foreground color (33)
|
||
//
|
||
// Deprecated: use Yellow instead, following specification
|
||
func Brown(arg interface{}) Value {
|
||
return Yellow(arg)
|
||
}
|
||
|
||
// Blue foreground color (34)
|
||
func Blue(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.Blue()
|
||
}
|
||
return value{value: arg, color: BlueFg}
|
||
}
|
||
|
||
// Magenta foreground color (35)
|
||
func Magenta(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.Magenta()
|
||
}
|
||
return value{value: arg, color: MagentaFg}
|
||
}
|
||
|
||
// Cyan foreground color (36)
|
||
func Cyan(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.Cyan()
|
||
}
|
||
return value{value: arg, color: CyanFg}
|
||
}
|
||
|
||
// White foreground color (37)
|
||
func White(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.White()
|
||
}
|
||
return value{value: arg, color: WhiteFg}
|
||
}
|
||
|
||
//
|
||
// Bright foreground colors
|
||
//
|
||
|
||
// BrightBlack foreground color (90)
|
||
func BrightBlack(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BrightBlack()
|
||
}
|
||
return value{value: arg, color: BrightFg | BlackFg}
|
||
}
|
||
|
||
// BrightRed foreground color (91)
|
||
func BrightRed(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BrightRed()
|
||
}
|
||
return value{value: arg, color: BrightFg | RedFg}
|
||
}
|
||
|
||
// BrightGreen foreground color (92)
|
||
func BrightGreen(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BrightGreen()
|
||
}
|
||
return value{value: arg, color: BrightFg | GreenFg}
|
||
}
|
||
|
||
// BrightYellow foreground color (93)
|
||
func BrightYellow(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BrightYellow()
|
||
}
|
||
return value{value: arg, color: BrightFg | YellowFg}
|
||
}
|
||
|
||
// BrightBlue foreground color (94)
|
||
func BrightBlue(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BrightBlue()
|
||
}
|
||
return value{value: arg, color: BrightFg | BlueFg}
|
||
}
|
||
|
||
// BrightMagenta foreground color (95)
|
||
func BrightMagenta(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BrightMagenta()
|
||
}
|
||
return value{value: arg, color: BrightFg | MagentaFg}
|
||
}
|
||
|
||
// BrightCyan foreground color (96)
|
||
func BrightCyan(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BrightCyan()
|
||
}
|
||
return value{value: arg, color: BrightFg | CyanFg}
|
||
}
|
||
|
||
// BrightWhite foreground color (97)
|
||
func BrightWhite(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BrightWhite()
|
||
}
|
||
return value{value: arg, color: BrightFg | WhiteFg}
|
||
}
|
||
|
||
//
|
||
// Other
|
||
//
|
||
|
||
// Index of pre-defined 8-bit foreground color
|
||
// from 0 to 255 (38;5;n).
|
||
//
|
||
// 0- 7: standard colors (as in ESC [ 30–37 m)
|
||
// 8- 15: high intensity colors (as in ESC [ 90–97 m)
|
||
// 16-231: 6 × 6 × 6 cube (216 colors): 16 + 36 × r + 6 × g + b (0 ≤ r, g, b ≤ 5)
|
||
// 232-255: grayscale from black to white in 24 steps
|
||
//
|
||
func Index(n uint8, arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.Index(n)
|
||
}
|
||
return value{value: arg, color: (Color(n) << shiftFg) | flagFg}
|
||
}
|
||
|
||
// Gray from 0 to 24.
|
||
func Gray(n uint8, arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.Gray(n)
|
||
}
|
||
if n > 23 {
|
||
n = 23
|
||
}
|
||
return value{value: arg, color: (Color(232+n) << shiftFg) | flagFg}
|
||
}
|
||
|
||
//
|
||
// Background colors
|
||
//
|
||
//
|
||
|
||
// BgBlack background color (40)
|
||
func BgBlack(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BgBlack()
|
||
}
|
||
return value{value: arg, color: BlackBg}
|
||
}
|
||
|
||
// BgRed background color (41)
|
||
func BgRed(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BgRed()
|
||
}
|
||
return value{value: arg, color: RedBg}
|
||
}
|
||
|
||
// BgGreen background color (42)
|
||
func BgGreen(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BgGreen()
|
||
}
|
||
return value{value: arg, color: GreenBg}
|
||
}
|
||
|
||
// BgYellow background color (43)
|
||
func BgYellow(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BgYellow()
|
||
}
|
||
return value{value: arg, color: YellowBg}
|
||
}
|
||
|
||
// BgBrown background color (43)
|
||
//
|
||
// Deprecated: use BgYellow instead, following specification
|
||
func BgBrown(arg interface{}) Value {
|
||
return BgYellow(arg)
|
||
}
|
||
|
||
// BgBlue background color (44)
|
||
func BgBlue(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BgBlue()
|
||
}
|
||
return value{value: arg, color: BlueBg}
|
||
}
|
||
|
||
// BgMagenta background color (45)
|
||
func BgMagenta(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BgMagenta()
|
||
}
|
||
return value{value: arg, color: MagentaBg}
|
||
}
|
||
|
||
// BgCyan background color (46)
|
||
func BgCyan(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BgCyan()
|
||
}
|
||
return value{value: arg, color: CyanBg}
|
||
}
|
||
|
||
// BgWhite background color (47)
|
||
func BgWhite(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BgWhite()
|
||
}
|
||
return value{value: arg, color: WhiteBg}
|
||
}
|
||
|
||
//
|
||
// Bright background colors
|
||
//
|
||
|
||
// BgBrightBlack background color (100)
|
||
func BgBrightBlack(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BgBrightBlack()
|
||
}
|
||
return value{value: arg, color: BrightBg | BlackBg}
|
||
}
|
||
|
||
// BgBrightRed background color (101)
|
||
func BgBrightRed(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BgBrightRed()
|
||
}
|
||
return value{value: arg, color: BrightBg | RedBg}
|
||
}
|
||
|
||
// BgBrightGreen background color (102)
|
||
func BgBrightGreen(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BgBrightGreen()
|
||
}
|
||
return value{value: arg, color: BrightBg | GreenBg}
|
||
}
|
||
|
||
// BgBrightYellow background color (103)
|
||
func BgBrightYellow(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BgBrightYellow()
|
||
}
|
||
return value{value: arg, color: BrightBg | YellowBg}
|
||
}
|
||
|
||
// BgBrightBlue background color (104)
|
||
func BgBrightBlue(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BgBrightBlue()
|
||
}
|
||
return value{value: arg, color: BrightBg | BlueBg}
|
||
}
|
||
|
||
// BgBrightMagenta background color (105)
|
||
func BgBrightMagenta(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BgBrightMagenta()
|
||
}
|
||
return value{value: arg, color: BrightBg | MagentaBg}
|
||
}
|
||
|
||
// BgBrightCyan background color (106)
|
||
func BgBrightCyan(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BgBrightCyan()
|
||
}
|
||
return value{value: arg, color: BrightBg | CyanBg}
|
||
}
|
||
|
||
// BgBrightWhite background color (107)
|
||
func BgBrightWhite(arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BgBrightWhite()
|
||
}
|
||
return value{value: arg, color: BrightBg | WhiteBg}
|
||
}
|
||
|
||
//
|
||
// Other
|
||
//
|
||
|
||
// BgIndex of 8-bit pre-defined background color
|
||
// from 0 to 255 (48;5;n).
|
||
//
|
||
// 0- 7: standard colors (as in ESC [ 40–47 m)
|
||
// 8- 15: high intensity colors (as in ESC [100–107 m)
|
||
// 16-231: 6 × 6 × 6 cube (216 colors): 16 + 36 × r + 6 × g + b (0 ≤ r, g, b ≤ 5)
|
||
// 232-255: grayscale from black to white in 24 steps
|
||
//
|
||
func BgIndex(n uint8, arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BgIndex(n)
|
||
}
|
||
return value{value: arg, color: (Color(n) << shiftBg) | flagBg}
|
||
}
|
||
|
||
// BgGray from 0 to 24.
|
||
func BgGray(n uint8, arg interface{}) Value {
|
||
if val, ok := arg.(Value); ok {
|
||
return val.BgGray(n)
|
||
}
|
||
if n > 23 {
|
||
n = 23
|
||
}
|
||
return value{value: arg, color: (Color(n+232) << shiftBg) | flagBg}
|
||
}
|