Brings in changes like support for Solaris/FreeBSD.master
Harshavardhana
9 years ago
parent
acb44e294c
commit
781540081d
@ -1,6 +1,6 @@ |
||||
The MIT License (MIT) |
||||
|
||||
Copyright (c) [2014] [shiena] |
||||
Copyright (c) 2016 Yasuhiro Matsumoto |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy |
||||
of this software and associated documentation files (the "Software"), to deal |
||||
@ -0,0 +1,43 @@ |
||||
# go-colorable |
||||
|
||||
Colorable writer for windows. |
||||
|
||||
For example, most of logger packages doesn't show colors on windows. (I know we can do it with ansicon. But I don't want.) |
||||
This package is possible to handle escape sequence for ansi color on windows. |
||||
|
||||
## Too Bad! |
||||
|
||||
 |
||||
|
||||
|
||||
## So Good! |
||||
|
||||
 |
||||
|
||||
## Usage |
||||
|
||||
```go |
||||
logrus.SetFormatter(&logrus.TextFormatter{ForceColors: true}) |
||||
logrus.SetOutput(colorable.NewColorableStdout()) |
||||
|
||||
logrus.Info("succeeded") |
||||
logrus.Warn("not correct") |
||||
logrus.Error("something error") |
||||
logrus.Fatal("panic") |
||||
``` |
||||
|
||||
You can compile above code on non-windows OSs. |
||||
|
||||
## Installation |
||||
|
||||
``` |
||||
$ go get github.com/mattn/go-colorable |
||||
``` |
||||
|
||||
# License |
||||
|
||||
MIT |
||||
|
||||
# Author |
||||
|
||||
Yasuhiro Matsumoto (a.k.a mattn) |
||||
@ -0,0 +1,24 @@ |
||||
// +build !windows
|
||||
|
||||
package colorable |
||||
|
||||
import ( |
||||
"io" |
||||
"os" |
||||
) |
||||
|
||||
func NewColorable(file *os.File) io.Writer { |
||||
if file == nil { |
||||
panic("nil passed instead of *os.File to NewColorable()") |
||||
} |
||||
|
||||
return file |
||||
} |
||||
|
||||
func NewColorableStdout() io.Writer { |
||||
return os.Stdout |
||||
} |
||||
|
||||
func NewColorableStderr() io.Writer { |
||||
return os.Stderr |
||||
} |
||||
@ -0,0 +1,783 @@ |
||||
package colorable |
||||
|
||||
import ( |
||||
"bytes" |
||||
"fmt" |
||||
"io" |
||||
"math" |
||||
"os" |
||||
"strconv" |
||||
"strings" |
||||
"syscall" |
||||
"unsafe" |
||||
|
||||
"github.com/mattn/go-isatty" |
||||
) |
||||
|
||||
const ( |
||||
foregroundBlue = 0x1 |
||||
foregroundGreen = 0x2 |
||||
foregroundRed = 0x4 |
||||
foregroundIntensity = 0x8 |
||||
foregroundMask = (foregroundRed | foregroundBlue | foregroundGreen | foregroundIntensity) |
||||
backgroundBlue = 0x10 |
||||
backgroundGreen = 0x20 |
||||
backgroundRed = 0x40 |
||||
backgroundIntensity = 0x80 |
||||
backgroundMask = (backgroundRed | backgroundBlue | backgroundGreen | backgroundIntensity) |
||||
) |
||||
|
||||
type wchar uint16 |
||||
type short int16 |
||||
type dword uint32 |
||||
type word uint16 |
||||
|
||||
type coord struct { |
||||
x short |
||||
y short |
||||
} |
||||
|
||||
type smallRect struct { |
||||
left short |
||||
top short |
||||
right short |
||||
bottom short |
||||
} |
||||
|
||||
type consoleScreenBufferInfo struct { |
||||
size coord |
||||
cursorPosition coord |
||||
attributes word |
||||
window smallRect |
||||
maximumWindowSize coord |
||||
} |
||||
|
||||
var ( |
||||
kernel32 = syscall.NewLazyDLL("kernel32.dll") |
||||
procGetConsoleScreenBufferInfo = kernel32.NewProc("GetConsoleScreenBufferInfo") |
||||
procSetConsoleTextAttribute = kernel32.NewProc("SetConsoleTextAttribute") |
||||
procSetConsoleCursorPosition = kernel32.NewProc("SetConsoleCursorPosition") |
||||
procFillConsoleOutputCharacter = kernel32.NewProc("FillConsoleOutputCharacterW") |
||||
procFillConsoleOutputAttribute = kernel32.NewProc("FillConsoleOutputAttribute") |
||||
) |
||||
|
||||
type Writer struct { |
||||
out io.Writer |
||||
handle syscall.Handle |
||||
lastbuf bytes.Buffer |
||||
oldattr word |
||||
} |
||||
|
||||
func NewColorable(file *os.File) io.Writer { |
||||
if file == nil { |
||||
panic("nil passed instead of *os.File to NewColorable()") |
||||
} |
||||
|
||||
if isatty.IsTerminal(file.Fd()) { |
||||
var csbi consoleScreenBufferInfo |
||||
handle := syscall.Handle(file.Fd()) |
||||
procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi))) |
||||
return &Writer{out: file, handle: handle, oldattr: csbi.attributes} |
||||
} else { |
||||
return file |
||||
} |
||||
} |
||||
|
||||
func NewColorableStdout() io.Writer { |
||||
return NewColorable(os.Stdout) |
||||
} |
||||
|
||||
func NewColorableStderr() io.Writer { |
||||
return NewColorable(os.Stderr) |
||||
} |
||||
|
||||
var color256 = map[int]int{ |
||||
0: 0x000000, |
||||
1: 0x800000, |
||||
2: 0x008000, |
||||
3: 0x808000, |
||||
4: 0x000080, |
||||
5: 0x800080, |
||||
6: 0x008080, |
||||
7: 0xc0c0c0, |
||||
8: 0x808080, |
||||
9: 0xff0000, |
||||
10: 0x00ff00, |
||||
11: 0xffff00, |
||||
12: 0x0000ff, |
||||
13: 0xff00ff, |
||||
14: 0x00ffff, |
||||
15: 0xffffff, |
||||
16: 0x000000, |
||||
17: 0x00005f, |
||||
18: 0x000087, |
||||
19: 0x0000af, |
||||
20: 0x0000d7, |
||||
21: 0x0000ff, |
||||
22: 0x005f00, |
||||
23: 0x005f5f, |
||||
24: 0x005f87, |
||||
25: 0x005faf, |
||||
26: 0x005fd7, |
||||
27: 0x005fff, |
||||
28: 0x008700, |
||||
29: 0x00875f, |
||||
30: 0x008787, |
||||
31: 0x0087af, |
||||
32: 0x0087d7, |
||||
33: 0x0087ff, |
||||
34: 0x00af00, |
||||
35: 0x00af5f, |
||||
36: 0x00af87, |
||||
37: 0x00afaf, |
||||
38: 0x00afd7, |
||||
39: 0x00afff, |
||||
40: 0x00d700, |
||||
41: 0x00d75f, |
||||
42: 0x00d787, |
||||
43: 0x00d7af, |
||||
44: 0x00d7d7, |
||||
45: 0x00d7ff, |
||||
46: 0x00ff00, |
||||
47: 0x00ff5f, |
||||
48: 0x00ff87, |
||||
49: 0x00ffaf, |
||||
50: 0x00ffd7, |
||||
51: 0x00ffff, |
||||
52: 0x5f0000, |
||||
53: 0x5f005f, |
||||
54: 0x5f0087, |
||||
55: 0x5f00af, |
||||
56: 0x5f00d7, |
||||
57: 0x5f00ff, |
||||
58: 0x5f5f00, |
||||
59: 0x5f5f5f, |
||||
60: 0x5f5f87, |
||||
61: 0x5f5faf, |
||||
62: 0x5f5fd7, |
||||
63: 0x5f5fff, |
||||
64: 0x5f8700, |
||||
65: 0x5f875f, |
||||
66: 0x5f8787, |
||||
67: 0x5f87af, |
||||
68: 0x5f87d7, |
||||
69: 0x5f87ff, |
||||
70: 0x5faf00, |
||||
71: 0x5faf5f, |
||||
72: 0x5faf87, |
||||
73: 0x5fafaf, |
||||
74: 0x5fafd7, |
||||
75: 0x5fafff, |
||||
76: 0x5fd700, |
||||
77: 0x5fd75f, |
||||
78: 0x5fd787, |
||||
79: 0x5fd7af, |
||||
80: 0x5fd7d7, |
||||
81: 0x5fd7ff, |
||||
82: 0x5fff00, |
||||
83: 0x5fff5f, |
||||
84: 0x5fff87, |
||||
85: 0x5fffaf, |
||||
86: 0x5fffd7, |
||||
87: 0x5fffff, |
||||
88: 0x870000, |
||||
89: 0x87005f, |
||||
90: 0x870087, |
||||
91: 0x8700af, |
||||
92: 0x8700d7, |
||||
93: 0x8700ff, |
||||
94: 0x875f00, |
||||
95: 0x875f5f, |
||||
96: 0x875f87, |
||||
97: 0x875faf, |
||||
98: 0x875fd7, |
||||
99: 0x875fff, |
||||
100: 0x878700, |
||||
101: 0x87875f, |
||||
102: 0x878787, |
||||
103: 0x8787af, |
||||
104: 0x8787d7, |
||||
105: 0x8787ff, |
||||
106: 0x87af00, |
||||
107: 0x87af5f, |
||||
108: 0x87af87, |
||||
109: 0x87afaf, |
||||
110: 0x87afd7, |
||||
111: 0x87afff, |
||||
112: 0x87d700, |
||||
113: 0x87d75f, |
||||
114: 0x87d787, |
||||
115: 0x87d7af, |
||||
116: 0x87d7d7, |
||||
117: 0x87d7ff, |
||||
118: 0x87ff00, |
||||
119: 0x87ff5f, |
||||
120: 0x87ff87, |
||||
121: 0x87ffaf, |
||||
122: 0x87ffd7, |
||||
123: 0x87ffff, |
||||
124: 0xaf0000, |
||||
125: 0xaf005f, |
||||
126: 0xaf0087, |
||||
127: 0xaf00af, |
||||
128: 0xaf00d7, |
||||
129: 0xaf00ff, |
||||
130: 0xaf5f00, |
||||
131: 0xaf5f5f, |
||||
132: 0xaf5f87, |
||||
133: 0xaf5faf, |
||||
134: 0xaf5fd7, |
||||
135: 0xaf5fff, |
||||
136: 0xaf8700, |
||||
137: 0xaf875f, |
||||
138: 0xaf8787, |
||||
139: 0xaf87af, |
||||
140: 0xaf87d7, |
||||
141: 0xaf87ff, |
||||
142: 0xafaf00, |
||||
143: 0xafaf5f, |
||||
144: 0xafaf87, |
||||
145: 0xafafaf, |
||||
146: 0xafafd7, |
||||
147: 0xafafff, |
||||
148: 0xafd700, |
||||
149: 0xafd75f, |
||||
150: 0xafd787, |
||||
151: 0xafd7af, |
||||
152: 0xafd7d7, |
||||
153: 0xafd7ff, |
||||
154: 0xafff00, |
||||
155: 0xafff5f, |
||||
156: 0xafff87, |
||||
157: 0xafffaf, |
||||
158: 0xafffd7, |
||||
159: 0xafffff, |
||||
160: 0xd70000, |
||||
161: 0xd7005f, |
||||
162: 0xd70087, |
||||
163: 0xd700af, |
||||
164: 0xd700d7, |
||||
165: 0xd700ff, |
||||
166: 0xd75f00, |
||||
167: 0xd75f5f, |
||||
168: 0xd75f87, |
||||
169: 0xd75faf, |
||||
170: 0xd75fd7, |
||||
171: 0xd75fff, |
||||
172: 0xd78700, |
||||
173: 0xd7875f, |
||||
174: 0xd78787, |
||||
175: 0xd787af, |
||||
176: 0xd787d7, |
||||
177: 0xd787ff, |
||||
178: 0xd7af00, |
||||
179: 0xd7af5f, |
||||
180: 0xd7af87, |
||||
181: 0xd7afaf, |
||||
182: 0xd7afd7, |
||||
183: 0xd7afff, |
||||
184: 0xd7d700, |
||||
185: 0xd7d75f, |
||||
186: 0xd7d787, |
||||
187: 0xd7d7af, |
||||
188: 0xd7d7d7, |
||||
189: 0xd7d7ff, |
||||
190: 0xd7ff00, |
||||
191: 0xd7ff5f, |
||||
192: 0xd7ff87, |
||||
193: 0xd7ffaf, |
||||
194: 0xd7ffd7, |
||||
195: 0xd7ffff, |
||||
196: 0xff0000, |
||||
197: 0xff005f, |
||||
198: 0xff0087, |
||||
199: 0xff00af, |
||||
200: 0xff00d7, |
||||
201: 0xff00ff, |
||||
202: 0xff5f00, |
||||
203: 0xff5f5f, |
||||
204: 0xff5f87, |
||||
205: 0xff5faf, |
||||
206: 0xff5fd7, |
||||
207: 0xff5fff, |
||||
208: 0xff8700, |
||||
209: 0xff875f, |
||||
210: 0xff8787, |
||||
211: 0xff87af, |
||||
212: 0xff87d7, |
||||
213: 0xff87ff, |
||||
214: 0xffaf00, |
||||
215: 0xffaf5f, |
||||
216: 0xffaf87, |
||||
217: 0xffafaf, |
||||
218: 0xffafd7, |
||||
219: 0xffafff, |
||||
220: 0xffd700, |
||||
221: 0xffd75f, |
||||
222: 0xffd787, |
||||
223: 0xffd7af, |
||||
224: 0xffd7d7, |
||||
225: 0xffd7ff, |
||||
226: 0xffff00, |
||||
227: 0xffff5f, |
||||
228: 0xffff87, |
||||
229: 0xffffaf, |
||||
230: 0xffffd7, |
||||
231: 0xffffff, |
||||
232: 0x080808, |
||||
233: 0x121212, |
||||
234: 0x1c1c1c, |
||||
235: 0x262626, |
||||
236: 0x303030, |
||||
237: 0x3a3a3a, |
||||
238: 0x444444, |
||||
239: 0x4e4e4e, |
||||
240: 0x585858, |
||||
241: 0x626262, |
||||
242: 0x6c6c6c, |
||||
243: 0x767676, |
||||
244: 0x808080, |
||||
245: 0x8a8a8a, |
||||
246: 0x949494, |
||||
247: 0x9e9e9e, |
||||
248: 0xa8a8a8, |
||||
249: 0xb2b2b2, |
||||
250: 0xbcbcbc, |
||||
251: 0xc6c6c6, |
||||
252: 0xd0d0d0, |
||||
253: 0xdadada, |
||||
254: 0xe4e4e4, |
||||
255: 0xeeeeee, |
||||
} |
||||
|
||||
func (w *Writer) Write(data []byte) (n int, err error) { |
||||
var csbi consoleScreenBufferInfo |
||||
procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi))) |
||||
|
||||
er := bytes.NewBuffer(data) |
||||
loop: |
||||
for { |
||||
r1, _, err := procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi))) |
||||
if r1 == 0 { |
||||
break loop |
||||
} |
||||
|
||||
c1, _, err := er.ReadRune() |
||||
if err != nil { |
||||
break loop |
||||
} |
||||
if c1 != 0x1b { |
||||
fmt.Fprint(w.out, string(c1)) |
||||
continue |
||||
} |
||||
c2, _, err := er.ReadRune() |
||||
if err != nil { |
||||
w.lastbuf.WriteRune(c1) |
||||
break loop |
||||
} |
||||
if c2 != 0x5b { |
||||
w.lastbuf.WriteRune(c1) |
||||
w.lastbuf.WriteRune(c2) |
||||
continue |
||||
} |
||||
|
||||
var buf bytes.Buffer |
||||
var m rune |
||||
for { |
||||
c, _, err := er.ReadRune() |
||||
if err != nil { |
||||
w.lastbuf.WriteRune(c1) |
||||
w.lastbuf.WriteRune(c2) |
||||
w.lastbuf.Write(buf.Bytes()) |
||||
break loop |
||||
} |
||||
if ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '@' { |
||||
m = c |
||||
break |
||||
} |
||||
buf.Write([]byte(string(c))) |
||||
} |
||||
|
||||
var csbi consoleScreenBufferInfo |
||||
switch m { |
||||
case 'A': |
||||
n, err = strconv.Atoi(buf.String()) |
||||
if err != nil { |
||||
continue |
||||
} |
||||
procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi))) |
||||
csbi.cursorPosition.y -= short(n) |
||||
procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition))) |
||||
case 'B': |
||||
n, err = strconv.Atoi(buf.String()) |
||||
if err != nil { |
||||
continue |
||||
} |
||||
procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi))) |
||||
csbi.cursorPosition.y += short(n) |
||||
procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition))) |
||||
case 'C': |
||||
n, err = strconv.Atoi(buf.String()) |
||||
if err != nil { |
||||
continue |
||||
} |
||||
procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi))) |
||||
csbi.cursorPosition.x -= short(n) |
||||
procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition))) |
||||
case 'D': |
||||
n, err = strconv.Atoi(buf.String()) |
||||
if err != nil { |
||||
continue |
||||
} |
||||
if n, err = strconv.Atoi(buf.String()); err == nil { |
||||
var csbi consoleScreenBufferInfo |
||||
procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi))) |
||||
csbi.cursorPosition.x += short(n) |
||||
procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition))) |
||||
} |
||||
case 'E': |
||||
n, err = strconv.Atoi(buf.String()) |
||||
if err != nil { |
||||
continue |
||||
} |
||||
procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi))) |
||||
csbi.cursorPosition.x = 0 |
||||
csbi.cursorPosition.y += short(n) |
||||
procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition))) |
||||
case 'F': |
||||
n, err = strconv.Atoi(buf.String()) |
||||
if err != nil { |
||||
continue |
||||
} |
||||
procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi))) |
||||
csbi.cursorPosition.x = 0 |
||||
csbi.cursorPosition.y -= short(n) |
||||
procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition))) |
||||
case 'G': |
||||
n, err = strconv.Atoi(buf.String()) |
||||
if err != nil { |
||||
continue |
||||
} |
||||
procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi))) |
||||
csbi.cursorPosition.x = short(n) |
||||
procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition))) |
||||
case 'H': |
||||
token := strings.Split(buf.String(), ";") |
||||
if len(token) != 2 { |
||||
continue |
||||
} |
||||
n1, err := strconv.Atoi(token[0]) |
||||
if err != nil { |
||||
continue |
||||
} |
||||
n2, err := strconv.Atoi(token[1]) |
||||
if err != nil { |
||||
continue |
||||
} |
||||
csbi.cursorPosition.x = short(n2) |
||||
csbi.cursorPosition.x = short(n1) |
||||
procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition))) |
||||
case 'J': |
||||
n, err := strconv.Atoi(buf.String()) |
||||
if err != nil { |
||||
continue |
||||
} |
||||
var cursor coord |
||||
switch n { |
||||
case 0: |
||||
cursor = coord{x: csbi.cursorPosition.x, y: csbi.cursorPosition.y} |
||||
case 1: |
||||
cursor = coord{x: csbi.window.left, y: csbi.window.top} |
||||
case 2: |
||||
cursor = coord{x: csbi.window.left, y: csbi.window.top} |
||||
} |
||||
var count, written dword |
||||
count = dword(csbi.size.x - csbi.cursorPosition.x + (csbi.size.y-csbi.cursorPosition.y)*csbi.size.x) |
||||
procFillConsoleOutputCharacter.Call(uintptr(w.handle), uintptr(' '), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written))) |
||||
procFillConsoleOutputAttribute.Call(uintptr(w.handle), uintptr(csbi.attributes), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written))) |
||||
case 'K': |
||||
n, err := strconv.Atoi(buf.String()) |
||||
if err != nil { |
||||
continue |
||||
} |
||||
var cursor coord |
||||
switch n { |
||||
case 0: |
||||
cursor = coord{x: csbi.cursorPosition.x, y: csbi.cursorPosition.y} |
||||
case 1: |
||||
cursor = coord{x: csbi.window.left, y: csbi.window.top + csbi.cursorPosition.y} |
||||
case 2: |
||||
cursor = coord{x: csbi.window.left, y: csbi.window.top + csbi.cursorPosition.y} |
||||
} |
||||
var count, written dword |
||||
count = dword(csbi.size.x - csbi.cursorPosition.x) |
||||
procFillConsoleOutputCharacter.Call(uintptr(w.handle), uintptr(' '), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written))) |
||||
procFillConsoleOutputAttribute.Call(uintptr(w.handle), uintptr(csbi.attributes), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written))) |
||||
case 'm': |
||||
attr := csbi.attributes |
||||
cs := buf.String() |
||||
if cs == "" { |
||||
procSetConsoleTextAttribute.Call(uintptr(w.handle), uintptr(w.oldattr)) |
||||
continue |
||||
} |
||||
token := strings.Split(cs, ";") |
||||
for i := 0; i < len(token); i += 1 { |
||||
ns := token[i] |
||||
if n, err = strconv.Atoi(ns); err == nil { |
||||
switch { |
||||
case n == 0 || n == 100: |
||||
attr = w.oldattr |
||||
case 1 <= n && n <= 5: |
||||
attr |= foregroundIntensity |
||||
case n == 7: |
||||
attr = ((attr & foregroundMask) << 4) | ((attr & backgroundMask) >> 4) |
||||
case 22 == n || n == 25 || n == 25: |
||||
attr |= foregroundIntensity |
||||
case n == 27: |
||||
attr = ((attr & foregroundMask) << 4) | ((attr & backgroundMask) >> 4) |
||||
case 30 <= n && n <= 37: |
||||
attr = (attr & backgroundMask) |
||||
if (n-30)&1 != 0 { |
||||
attr |= foregroundRed |
||||
} |
||||
if (n-30)&2 != 0 { |
||||
attr |= foregroundGreen |
||||
} |
||||
if (n-30)&4 != 0 { |
||||
attr |= foregroundBlue |
||||
} |
||||
case n == 38: // set foreground color.
|
||||
if i < len(token)-2 && (token[i+1] == "5" || token[i+1] == "05") { |
||||
if n256, err := strconv.Atoi(token[i+2]); err == nil { |
||||
if n256foreAttr == nil { |
||||
n256setup() |
||||
} |
||||
attr &= backgroundMask |
||||
attr |= n256foreAttr[n256] |
||||
i += 2 |
||||
} |
||||
} else { |
||||
attr = attr & (w.oldattr & backgroundMask) |
||||
} |
||||
case n == 39: // reset foreground color.
|
||||
attr &= backgroundMask |
||||
attr |= w.oldattr & foregroundMask |
||||
case 40 <= n && n <= 47: |
||||
attr = (attr & foregroundMask) |
||||
if (n-40)&1 != 0 { |
||||
attr |= backgroundRed |
||||
} |
||||
if (n-40)&2 != 0 { |
||||
attr |= backgroundGreen |
||||
} |
||||
if (n-40)&4 != 0 { |
||||
attr |= backgroundBlue |
||||
} |
||||
case n == 48: // set background color.
|
||||
if i < len(token)-2 && token[i+1] == "5" { |
||||
if n256, err := strconv.Atoi(token[i+2]); err == nil { |
||||
if n256backAttr == nil { |
||||
n256setup() |
||||
} |
||||
attr &= foregroundMask |
||||
attr |= n256backAttr[n256] |
||||
i += 2 |
||||
} |
||||
} else { |
||||
attr = attr & (w.oldattr & foregroundMask) |
||||
} |
||||
case n == 49: // reset foreground color.
|
||||
attr &= foregroundMask |
||||
attr |= w.oldattr & backgroundMask |
||||
case 90 <= n && n <= 97: |
||||
attr = (attr & backgroundMask) |
||||
attr |= foregroundIntensity |
||||
if (n-90)&1 != 0 { |
||||
attr |= foregroundRed |
||||
} |
||||
if (n-90)&2 != 0 { |
||||
attr |= foregroundGreen |
||||
} |
||||
if (n-90)&4 != 0 { |
||||
attr |= foregroundBlue |
||||
} |
||||
case 100 <= n && n <= 107: |
||||
attr = (attr & foregroundMask) |
||||
attr |= backgroundIntensity |
||||
if (n-100)&1 != 0 { |
||||
attr |= backgroundRed |
||||
} |
||||
if (n-100)&2 != 0 { |
||||
attr |= backgroundGreen |
||||
} |
||||
if (n-100)&4 != 0 { |
||||
attr |= backgroundBlue |
||||
} |
||||
} |
||||
procSetConsoleTextAttribute.Call(uintptr(w.handle), uintptr(attr)) |
||||
} |
||||
} |
||||
} |
||||
} |
||||
return len(data) - w.lastbuf.Len(), nil |
||||
} |
||||
|
||||
type consoleColor struct { |
||||
rgb int |
||||
red bool |
||||
green bool |
||||
blue bool |
||||
intensity bool |
||||
} |
||||
|
||||
func (c consoleColor) foregroundAttr() (attr word) { |
||||
if c.red { |
||||
attr |= foregroundRed |
||||
} |
||||
if c.green { |
||||
attr |= foregroundGreen |
||||
} |
||||
if c.blue { |
||||
attr |= foregroundBlue |
||||
} |
||||
if c.intensity { |
||||
attr |= foregroundIntensity |
||||
} |
||||
return |
||||
} |
||||
|
||||
func (c consoleColor) backgroundAttr() (attr word) { |
||||
if c.red { |
||||
attr |= backgroundRed |
||||
} |
||||
if c.green { |
||||
attr |= backgroundGreen |
||||
} |
||||
if c.blue { |
||||
attr |= backgroundBlue |
||||
} |
||||
if c.intensity { |
||||
attr |= backgroundIntensity |
||||
} |
||||
return |
||||
} |
||||
|
||||
var color16 = []consoleColor{ |
||||
consoleColor{0x000000, false, false, false, false}, |
||||
consoleColor{0x000080, false, false, true, false}, |
||||
consoleColor{0x008000, false, true, false, false}, |
||||
consoleColor{0x008080, false, true, true, false}, |
||||
consoleColor{0x800000, true, false, false, false}, |
||||
consoleColor{0x800080, true, false, true, false}, |
||||
consoleColor{0x808000, true, true, false, false}, |
||||
consoleColor{0xc0c0c0, true, true, true, false}, |
||||
consoleColor{0x808080, false, false, false, true}, |
||||
consoleColor{0x0000ff, false, false, true, true}, |
||||
consoleColor{0x00ff00, false, true, false, true}, |
||||
consoleColor{0x00ffff, false, true, true, true}, |
||||
consoleColor{0xff0000, true, false, false, true}, |
||||
consoleColor{0xff00ff, true, false, true, true}, |
||||
consoleColor{0xffff00, true, true, false, true}, |
||||
consoleColor{0xffffff, true, true, true, true}, |
||||
} |
||||
|
||||
type hsv struct { |
||||
h, s, v float32 |
||||
} |
||||
|
||||
func (a hsv) dist(b hsv) float32 { |
||||
dh := a.h - b.h |
||||
switch { |
||||
case dh > 0.5: |
||||
dh = 1 - dh |
||||
case dh < -0.5: |
||||
dh = -1 - dh |
||||
} |
||||
ds := a.s - b.s |
||||
dv := a.v - b.v |
||||
return float32(math.Sqrt(float64(dh*dh + ds*ds + dv*dv))) |
||||
} |
||||
|
||||
func toHSV(rgb int) hsv { |
||||
r, g, b := float32((rgb&0xFF0000)>>16)/256.0, |
||||
float32((rgb&0x00FF00)>>8)/256.0, |
||||
float32(rgb&0x0000FF)/256.0 |
||||
min, max := minmax3f(r, g, b) |
||||
h := max - min |
||||
if h > 0 { |
||||
if max == r { |
||||
h = (g - b) / h |
||||
if h < 0 { |
||||
h += 6 |
||||
} |
||||
} else if max == g { |
||||
h = 2 + (b-r)/h |
||||
} else { |
||||
h = 4 + (r-g)/h |
||||
} |
||||
} |
||||
h /= 6.0 |
||||
s := max - min |
||||
if max != 0 { |
||||
s /= max |
||||
} |
||||
v := max |
||||
return hsv{h: h, s: s, v: v} |
||||
} |
||||
|
||||
type hsvTable []hsv |
||||
|
||||
func toHSVTable(rgbTable []consoleColor) hsvTable { |
||||
t := make(hsvTable, len(rgbTable)) |
||||
for i, c := range rgbTable { |
||||
t[i] = toHSV(c.rgb) |
||||
} |
||||
return t |
||||
} |
||||
|
||||
func (t hsvTable) find(rgb int) consoleColor { |
||||
hsv := toHSV(rgb) |
||||
n := 7 |
||||
l := float32(5.0) |
||||
for i, p := range t { |
||||
d := hsv.dist(p) |
||||
if d < l { |
||||
l, n = d, i |
||||
} |
||||
} |
||||
return color16[n] |
||||
} |
||||
|
||||
func minmax3f(a, b, c float32) (min, max float32) { |
||||
if a < b { |
||||
if b < c { |
||||
return a, c |
||||
} else if a < c { |
||||
return a, b |
||||
} else { |
||||
return c, b |
||||
} |
||||
} else { |
||||
if a < c { |
||||
return b, c |
||||
} else if b < c { |
||||
return b, a |
||||
} else { |
||||
return c, a |
||||
} |
||||
} |
||||
} |
||||
|
||||
var n256foreAttr []word |
||||
var n256backAttr []word |
||||
|
||||
func n256setup() { |
||||
n256foreAttr = make([]word, 256) |
||||
n256backAttr = make([]word, 256) |
||||
t := toHSVTable(color16) |
||||
for i, rgb := range color256 { |
||||
c := t.find(rgb) |
||||
n256foreAttr[i] = c.foregroundAttr() |
||||
n256backAttr[i] = c.backgroundAttr() |
||||
} |
||||
} |
||||
@ -1,100 +0,0 @@ |
||||
[](https://godoc.org/github.com/shiena/ansicolor) |
||||
|
||||
# ansicolor |
||||
|
||||
Ansicolor library provides color console in Windows as ANSICON for Golang. |
||||
|
||||
## Features |
||||
|
||||
|Escape sequence|Text attributes| |
||||
|---------------|----| |
||||
|\x1b[0m|All attributes off(color at startup)| |
||||
|\x1b[1m|Bold on(enable foreground intensity)| |
||||
|\x1b[4m|Underline on| |
||||
|\x1b[5m|Blink on(enable background intensity)| |
||||
|\x1b[21m|Bold off(disable foreground intensity)| |
||||
|\x1b[24m|Underline off| |
||||
|\x1b[25m|Blink off(disable background intensity)| |
||||
|
||||
|Escape sequence|Foreground colors| |
||||
|---------------|----| |
||||
|\x1b[30m|Black| |
||||
|\x1b[31m|Red| |
||||
|\x1b[32m|Green| |
||||
|\x1b[33m|Yellow| |
||||
|\x1b[34m|Blue| |
||||
|\x1b[35m|Magenta| |
||||
|\x1b[36m|Cyan| |
||||
|\x1b[37m|White| |
||||
|\x1b[39m|Default(foreground color at startup)| |
||||
|\x1b[90m|Light Gray| |
||||
|\x1b[91m|Light Red| |
||||
|\x1b[92m|Light Green| |
||||
|\x1b[93m|Light Yellow| |
||||
|\x1b[94m|Light Blue| |
||||
|\x1b[95m|Light Magenta| |
||||
|\x1b[96m|Light Cyan| |
||||
|\x1b[97m|Light White| |
||||
|
||||
|Escape sequence|Background colors| |
||||
|---------------|----| |
||||
|\x1b[40m|Black| |
||||
|\x1b[41m|Red| |
||||
|\x1b[42m|Green| |
||||
|\x1b[43m|Yellow| |
||||
|\x1b[44m|Blue| |
||||
|\x1b[45m|Magenta| |
||||
|\x1b[46m|Cyan| |
||||
|\x1b[47m|White| |
||||
|\x1b[49m|Default(background color at startup)| |
||||
|\x1b[100m|Light Gray| |
||||
|\x1b[101m|Light Red| |
||||
|\x1b[102m|Light Green| |
||||
|\x1b[103m|Light Yellow| |
||||
|\x1b[104m|Light Blue| |
||||
|\x1b[105m|Light Magenta| |
||||
|\x1b[106m|Light Cyan| |
||||
|\x1b[107m|Light White| |
||||
|
||||
## Example |
||||
|
||||
```go |
||||
package main |
||||
|
||||
import ( |
||||
"fmt" |
||||
"os" |
||||
|
||||
"github.com/shiena/ansicolor" |
||||
) |
||||
|
||||
func main() { |
||||
w := ansicolor.NewAnsiColorWriter(os.Stdout) |
||||
text := "%sforeground %sbold%s %sbackground%s\n" |
||||
fmt.Fprintf(w, text, "\x1b[31m", "\x1b[1m", "\x1b[21m", "\x1b[41;32m", "\x1b[0m") |
||||
fmt.Fprintf(w, text, "\x1b[32m", "\x1b[1m", "\x1b[21m", "\x1b[42;31m", "\x1b[0m") |
||||
fmt.Fprintf(w, text, "\x1b[33m", "\x1b[1m", "\x1b[21m", "\x1b[43;34m", "\x1b[0m") |
||||
fmt.Fprintf(w, text, "\x1b[34m", "\x1b[1m", "\x1b[21m", "\x1b[44;33m", "\x1b[0m") |
||||
fmt.Fprintf(w, text, "\x1b[35m", "\x1b[1m", "\x1b[21m", "\x1b[45;36m", "\x1b[0m") |
||||
fmt.Fprintf(w, text, "\x1b[36m", "\x1b[1m", "\x1b[21m", "\x1b[46;35m", "\x1b[0m") |
||||
fmt.Fprintf(w, text, "\x1b[37m", "\x1b[1m", "\x1b[21m", "\x1b[47;30m", "\x1b[0m") |
||||
} |
||||
``` |
||||
|
||||
 |
||||
|
||||
## See also: |
||||
|
||||
- https://github.com/daviddengcn/go-colortext |
||||
- https://github.com/adoxa/ansicon |
||||
- https://github.com/aslakhellesoy/wac |
||||
- https://github.com/wsxiaoys/terminal |
||||
|
||||
## Contributing |
||||
|
||||
1. Fork it |
||||
2. Create your feature branch (`git checkout -b my-new-feature`) |
||||
3. Commit your changes (`git commit -am 'Add some feature'`) |
||||
4. Push to the branch (`git push origin my-new-feature`) |
||||
5. Create new Pull Request |
||||
|
||||
@ -1,20 +0,0 @@ |
||||
// Copyright 2014 shiena Authors. All rights reserved.
|
||||
// Use of this source code is governed by a MIT-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Package ansicolor provides color console in Windows as ANSICON.
|
||||
package ansicolor |
||||
|
||||
import "io" |
||||
|
||||
// NewAnsiColorWriter creates and initializes a new ansiColorWriter
|
||||
// using io.Writer w as its initial contents.
|
||||
// In the console of Windows, which change the foreground and background
|
||||
// colors of the text by the escape sequence.
|
||||
// In the console of other systems, which writes to w all text.
|
||||
func NewAnsiColorWriter(w io.Writer) io.Writer { |
||||
if _, ok := w.(*ansiColorWriter); !ok { |
||||
return &ansiColorWriter{w: w} |
||||
} |
||||
return w |
||||
} |
||||
@ -1,17 +0,0 @@ |
||||
// Copyright 2014 shiena Authors. All rights reserved.
|
||||
// Use of this source code is governed by a MIT-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// +build !windows
|
||||
|
||||
package ansicolor |
||||
|
||||
import "io" |
||||
|
||||
type ansiColorWriter struct { |
||||
w io.Writer |
||||
} |
||||
|
||||
func (cw *ansiColorWriter) Write(p []byte) (int, error) { |
||||
return cw.w.Write(p) |
||||
} |
||||
@ -1,351 +0,0 @@ |
||||
// Copyright 2014 shiena Authors. All rights reserved.
|
||||
// Use of this source code is governed by a MIT-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// +build windows
|
||||
|
||||
package ansicolor |
||||
|
||||
import ( |
||||
"bytes" |
||||
"io" |
||||
"strings" |
||||
"syscall" |
||||
"unsafe" |
||||
) |
||||
|
||||
type csiState int |
||||
|
||||
const ( |
||||
outsideCsiCode csiState = iota |
||||
firstCsiCode |
||||
secondCsiCode |
||||
) |
||||
|
||||
type ansiColorWriter struct { |
||||
w io.Writer |
||||
state csiState |
||||
paramBuf bytes.Buffer |
||||
} |
||||
|
||||
const ( |
||||
firstCsiChar byte = '\x1b' |
||||
secondeCsiChar byte = '[' |
||||
separatorChar byte = ';' |
||||
sgrCode byte = 'm' |
||||
) |
||||
|
||||
const ( |
||||
foregroundBlue = uint16(0x0001) |
||||
foregroundGreen = uint16(0x0002) |
||||
foregroundRed = uint16(0x0004) |
||||
foregroundIntensity = uint16(0x0008) |
||||
backgroundBlue = uint16(0x0010) |
||||
backgroundGreen = uint16(0x0020) |
||||
backgroundRed = uint16(0x0040) |
||||
backgroundIntensity = uint16(0x0080) |
||||
underscore = uint16(0x8000) |
||||
|
||||
foregroundMask = foregroundBlue | foregroundGreen | foregroundRed | foregroundIntensity |
||||
backgroundMask = backgroundBlue | backgroundGreen | backgroundRed | backgroundIntensity |
||||
) |
||||
|
||||
const ( |
||||
ansiReset = "0" |
||||
ansiIntensityOn = "1" |
||||
ansiIntensityOff = "21" |
||||
ansiUnderlineOn = "4" |
||||
ansiUnderlineOff = "24" |
||||
ansiBlinkOn = "5" |
||||
ansiBlinkOff = "25" |
||||
|
||||
ansiForegroundBlack = "30" |
||||
ansiForegroundRed = "31" |
||||
ansiForegroundGreen = "32" |
||||
ansiForegroundYellow = "33" |
||||
ansiForegroundBlue = "34" |
||||
ansiForegroundMagenta = "35" |
||||
ansiForegroundCyan = "36" |
||||
ansiForegroundWhite = "37" |
||||
ansiForegroundDefault = "39" |
||||
|
||||
ansiBackgroundBlack = "40" |
||||
ansiBackgroundRed = "41" |
||||
ansiBackgroundGreen = "42" |
||||
ansiBackgroundYellow = "43" |
||||
ansiBackgroundBlue = "44" |
||||
ansiBackgroundMagenta = "45" |
||||
ansiBackgroundCyan = "46" |
||||
ansiBackgroundWhite = "47" |
||||
ansiBackgroundDefault = "49" |
||||
|
||||
ansiLightForegroundGray = "90" |
||||
ansiLightForegroundRed = "91" |
||||
ansiLightForegroundGreen = "92" |
||||
ansiLightForegroundYellow = "93" |
||||
ansiLightForegroundBlue = "94" |
||||
ansiLightForegroundMagenta = "95" |
||||
ansiLightForegroundCyan = "96" |
||||
ansiLightForegroundWhite = "97" |
||||
|
||||
ansiLightBackgroundGray = "100" |
||||
ansiLightBackgroundRed = "101" |
||||
ansiLightBackgroundGreen = "102" |
||||
ansiLightBackgroundYellow = "103" |
||||
ansiLightBackgroundBlue = "104" |
||||
ansiLightBackgroundMagenta = "105" |
||||
ansiLightBackgroundCyan = "106" |
||||
ansiLightBackgroundWhite = "107" |
||||
) |
||||
|
||||
type drawType int |
||||
|
||||
const ( |
||||
foreground drawType = iota |
||||
background |
||||
) |
||||
|
||||
type winColor struct { |
||||
code uint16 |
||||
drawType drawType |
||||
} |
||||
|
||||
var colorMap = map[string]winColor{ |
||||
ansiForegroundBlack: {0, foreground}, |
||||
ansiForegroundRed: {foregroundRed, foreground}, |
||||
ansiForegroundGreen: {foregroundGreen, foreground}, |
||||
ansiForegroundYellow: {foregroundRed | foregroundGreen, foreground}, |
||||
ansiForegroundBlue: {foregroundBlue, foreground}, |
||||
ansiForegroundMagenta: {foregroundRed | foregroundBlue, foreground}, |
||||
ansiForegroundCyan: {foregroundGreen | foregroundBlue, foreground}, |
||||
ansiForegroundWhite: {foregroundRed | foregroundGreen | foregroundBlue, foreground}, |
||||
ansiForegroundDefault: {foregroundRed | foregroundGreen | foregroundBlue, foreground}, |
||||
|
||||
ansiBackgroundBlack: {0, background}, |
||||
ansiBackgroundRed: {backgroundRed, background}, |
||||
ansiBackgroundGreen: {backgroundGreen, background}, |
||||
ansiBackgroundYellow: {backgroundRed | backgroundGreen, background}, |
||||
ansiBackgroundBlue: {backgroundBlue, background}, |
||||
ansiBackgroundMagenta: {backgroundRed | backgroundBlue, background}, |
||||
ansiBackgroundCyan: {backgroundGreen | backgroundBlue, background}, |
||||
ansiBackgroundWhite: {backgroundRed | backgroundGreen | backgroundBlue, background}, |
||||
ansiBackgroundDefault: {0, background}, |
||||
|
||||
ansiLightForegroundGray: {foregroundIntensity, foreground}, |
||||
ansiLightForegroundRed: {foregroundIntensity | foregroundRed, foreground}, |
||||
ansiLightForegroundGreen: {foregroundIntensity | foregroundGreen, foreground}, |
||||
ansiLightForegroundYellow: {foregroundIntensity | foregroundRed | foregroundGreen, foreground}, |
||||
ansiLightForegroundBlue: {foregroundIntensity | foregroundBlue, foreground}, |
||||
ansiLightForegroundMagenta: {foregroundIntensity | foregroundRed | foregroundBlue, foreground}, |
||||
ansiLightForegroundCyan: {foregroundIntensity | foregroundGreen | foregroundBlue, foreground}, |
||||
ansiLightForegroundWhite: {foregroundIntensity | foregroundRed | foregroundGreen | foregroundBlue, foreground}, |
||||
|
||||
ansiLightBackgroundGray: {backgroundIntensity, background}, |
||||
ansiLightBackgroundRed: {backgroundIntensity | backgroundRed, background}, |
||||
ansiLightBackgroundGreen: {backgroundIntensity | backgroundGreen, background}, |
||||
ansiLightBackgroundYellow: {backgroundIntensity | backgroundRed | backgroundGreen, background}, |
||||
ansiLightBackgroundBlue: {backgroundIntensity | backgroundBlue, background}, |
||||
ansiLightBackgroundMagenta: {backgroundIntensity | backgroundRed | backgroundBlue, background}, |
||||
ansiLightBackgroundCyan: {backgroundIntensity | backgroundGreen | backgroundBlue, background}, |
||||
ansiLightBackgroundWhite: {backgroundIntensity | backgroundRed | backgroundGreen | backgroundBlue, background}, |
||||
} |
||||
|
||||
var ( |
||||
kernel32 = syscall.NewLazyDLL("kernel32.dll") |
||||
procSetConsoleTextAttribute = kernel32.NewProc("SetConsoleTextAttribute") |
||||
procGetConsoleScreenBufferInfo = kernel32.NewProc("GetConsoleScreenBufferInfo") |
||||
defaultAttr *textAttributes |
||||
) |
||||
|
||||
func init() { |
||||
screenInfo := getConsoleScreenBufferInfo(uintptr(syscall.Stdout)) |
||||
if screenInfo != nil { |
||||
colorMap[ansiForegroundDefault] = winColor{ |
||||
screenInfo.WAttributes & (foregroundRed | foregroundGreen | foregroundBlue), |
||||
foreground, |
||||
} |
||||
colorMap[ansiBackgroundDefault] = winColor{ |
||||
screenInfo.WAttributes & (backgroundRed | backgroundGreen | backgroundBlue), |
||||
background, |
||||
} |
||||
defaultAttr = convertTextAttr(screenInfo.WAttributes) |
||||
} |
||||
} |
||||
|
||||
type coord struct { |
||||
X, Y int16 |
||||
} |
||||
|
||||
type smallRect struct { |
||||
Left, Top, Right, Bottom int16 |
||||
} |
||||
|
||||
type consoleScreenBufferInfo struct { |
||||
DwSize coord |
||||
DwCursorPosition coord |
||||
WAttributes uint16 |
||||
SrWindow smallRect |
||||
DwMaximumWindowSize coord |
||||
} |
||||
|
||||
func getConsoleScreenBufferInfo(hConsoleOutput uintptr) *consoleScreenBufferInfo { |
||||
var csbi consoleScreenBufferInfo |
||||
ret, _, _ := procGetConsoleScreenBufferInfo.Call( |
||||
hConsoleOutput, |
||||
uintptr(unsafe.Pointer(&csbi))) |
||||
if ret == 0 { |
||||
return nil |
||||
} |
||||
return &csbi |
||||
} |
||||
|
||||
func setConsoleTextAttribute(hConsoleOutput uintptr, wAttributes uint16) bool { |
||||
ret, _, _ := procSetConsoleTextAttribute.Call( |
||||
hConsoleOutput, |
||||
uintptr(wAttributes)) |
||||
return ret != 0 |
||||
} |
||||
|
||||
type textAttributes struct { |
||||
foregroundColor uint16 |
||||
backgroundColor uint16 |
||||
foregroundIntensity uint16 |
||||
backgroundIntensity uint16 |
||||
underscore uint16 |
||||
otherAttributes uint16 |
||||
} |
||||
|
||||
func convertTextAttr(winAttr uint16) *textAttributes { |
||||
fgColor := winAttr & (foregroundRed | foregroundGreen | foregroundBlue) |
||||
bgColor := winAttr & (backgroundRed | backgroundGreen | backgroundBlue) |
||||
fgIntensity := winAttr & foregroundIntensity |
||||
bgIntensity := winAttr & backgroundIntensity |
||||
underline := winAttr & underscore |
||||
otherAttributes := winAttr &^ (foregroundMask | backgroundMask | underscore) |
||||
return &textAttributes{fgColor, bgColor, fgIntensity, bgIntensity, underline, otherAttributes} |
||||
} |
||||
|
||||
func convertWinAttr(textAttr *textAttributes) uint16 { |
||||
var winAttr uint16 = 0 |
||||
winAttr |= textAttr.foregroundColor |
||||
winAttr |= textAttr.backgroundColor |
||||
winAttr |= textAttr.foregroundIntensity |
||||
winAttr |= textAttr.backgroundIntensity |
||||
winAttr |= textAttr.underscore |
||||
winAttr |= textAttr.otherAttributes |
||||
return winAttr |
||||
} |
||||
|
||||
func changeColor(param []byte) { |
||||
if defaultAttr == nil { |
||||
return |
||||
} |
||||
|
||||
screenInfo := getConsoleScreenBufferInfo(uintptr(syscall.Stdout)) |
||||
if screenInfo == nil { |
||||
return |
||||
} |
||||
|
||||
winAttr := convertTextAttr(screenInfo.WAttributes) |
||||
strParam := string(param) |
||||
if len(strParam) <= 0 { |
||||
strParam = "0" |
||||
} |
||||
csiParam := strings.Split(strParam, string(separatorChar)) |
||||
for _, p := range csiParam { |
||||
c, ok := colorMap[p] |
||||
switch { |
||||
case !ok: |
||||
switch p { |
||||
case ansiReset: |
||||
winAttr.foregroundColor = defaultAttr.foregroundColor |
||||
winAttr.backgroundColor = defaultAttr.backgroundColor |
||||
winAttr.foregroundIntensity = defaultAttr.foregroundIntensity |
||||
winAttr.backgroundIntensity = defaultAttr.backgroundIntensity |
||||
winAttr.underscore = 0 |
||||
winAttr.otherAttributes = 0 |
||||
case ansiIntensityOn: |
||||
winAttr.foregroundIntensity = foregroundIntensity |
||||
case ansiIntensityOff: |
||||
winAttr.foregroundIntensity = 0 |
||||
case ansiUnderlineOn: |
||||
winAttr.underscore = underscore |
||||
case ansiUnderlineOff: |
||||
winAttr.underscore = 0 |
||||
case ansiBlinkOn: |
||||
winAttr.backgroundIntensity = backgroundIntensity |
||||
case ansiBlinkOff: |
||||
winAttr.backgroundIntensity = 0 |
||||
default: |
||||
// unknown code
|
||||
} |
||||
case c.drawType == foreground: |
||||
winAttr.foregroundColor = c.code |
||||
case c.drawType == background: |
||||
winAttr.backgroundColor = c.code |
||||
} |
||||
} |
||||
winTextAttribute := convertWinAttr(winAttr) |
||||
setConsoleTextAttribute(uintptr(syscall.Stdout), winTextAttribute) |
||||
} |
||||
|
||||
func parseEscapeSequence(command byte, param []byte) { |
||||
switch command { |
||||
case sgrCode: |
||||
changeColor(param) |
||||
} |
||||
} |
||||
|
||||
func isParameterChar(b byte) bool { |
||||
return ('0' <= b && b <= '9') || b == separatorChar |
||||
} |
||||
|
||||
func (cw *ansiColorWriter) Write(p []byte) (int, error) { |
||||
r, nw, nc, first, last := 0, 0, 0, 0, 0 |
||||
var err error |
||||
for i, ch := range p { |
||||
switch cw.state { |
||||
case outsideCsiCode: |
||||
if ch == firstCsiChar { |
||||
nc++ |
||||
cw.state = firstCsiCode |
||||
} |
||||
case firstCsiCode: |
||||
switch ch { |
||||
case firstCsiChar: |
||||
nc++ |
||||
break |
||||
case secondeCsiChar: |
||||
nc++ |
||||
cw.state = secondCsiCode |
||||
last = i - 1 |
||||
default: |
||||
cw.state = outsideCsiCode |
||||
} |
||||
case secondCsiCode: |
||||
nc++ |
||||
if isParameterChar(ch) { |
||||
cw.paramBuf.WriteByte(ch) |
||||
} else { |
||||
nw, err = cw.w.Write(p[first:last]) |
||||
r += nw |
||||
if err != nil { |
||||
return r, err |
||||
} |
||||
first = i + 1 |
||||
param := cw.paramBuf.Bytes() |
||||
cw.paramBuf.Reset() |
||||
parseEscapeSequence(ch, param) |
||||
cw.state = outsideCsiCode |
||||
} |
||||
default: |
||||
cw.state = outsideCsiCode |
||||
} |
||||
} |
||||
|
||||
if cw.state == outsideCsiCode { |
||||
nw, err = cw.w.Write(p[first:len(p)]) |
||||
} |
||||
|
||||
return r + nw + nc, err |
||||
} |
||||
Loading…
Reference in new issue