package vt10x
import (
"fmt"
"math"
"regexp"
"strconv"
"strings"
)
type strEscape struct {
typ rune
buf []rune
args []string
}
func (s *strEscape ) reset () {
s .typ = 0
s .buf = s .buf [:0 ]
s .args = nil
}
func (s *strEscape ) put (c rune ) {
if len (s .buf ) < 256 {
s .buf = append (s .buf , c )
}
}
func (s *strEscape ) parse () {
s .args = strings .Split (string (s .buf ), ";" )
}
func (s *strEscape ) arg (i , def int ) int {
if i >= len (s .args ) || i < 0 {
return def
}
i , err := strconv .Atoi (s .args [i ])
if err != nil {
return def
}
return i
}
func (s *strEscape ) argString (i int , def string ) string {
if i >= len (s .args ) || i < 0 {
return def
}
return s .args [i ]
}
func (t *State ) handleSTR () {
s := &t .str
s .parse ()
switch s .typ {
case ']' :
var p *string
switch d := s .arg (0 , 0 ); d {
case 0 , 1 , 2 :
title := s .argString (1 , "" )
if title != "" {
t .setTitle (title )
}
case 10 :
if len (s .args ) < 2 {
break
}
c := s .argString (1 , "" )
p := &c
if p != nil && *p == "?" {
t .oscColorResponse (int (DefaultFG ), 10 )
} else if err := t .setColorName (int (DefaultFG ), p ); err != nil {
t .logf ("invalid foreground color: %s\n" , maybe (p ))
} else {
}
case 11 :
if len (s .args ) < 2 {
break
}
c := s .argString (1 , "" )
p := &c
if p != nil && *p == "?" {
t .oscColorResponse (int (DefaultBG ), 11 )
} else if err := t .setColorName (int (DefaultBG ), p ); err != nil {
t .logf ("invalid cursor color: %s\n" , maybe (p ))
} else {
}
case 4 :
if len (s .args ) < 3 {
break
}
c := s .argString (2 , "" )
p = &c
fallthrough
case 104 :
j := -1
if len (s .args ) > 1 {
j = s .arg (1 , 0 )
}
if p != nil && *p == "?" {
t .osc4ColorResponse (j )
} else if err := t .setColorName (j , p ); err != nil {
if !(d == 104 && len (s .args ) <= 1 ) {
t .logf ("invalid color j=%d, p=%s\n" , j , maybe (p ))
}
} else {
}
default :
t .logf ("unknown OSC command %d\n" , d )
}
case 'k' :
title := s .argString (0 , "" )
if title != "" {
t .setTitle (title )
}
default :
t .logf ("unhandled STR sequence '%c'\n" , s .typ )
}
}
func (t *State ) setColorName (j int , p *string ) error {
if !between (j , 0 , 1 <<24 ) {
return fmt .Errorf ("invalid color value %d" , j )
}
if p == nil {
delete (t .colorOverride , Color (j ))
} else {
r , g , b , err := parseColor (*p )
if err != nil {
return err
}
t .colorOverride [Color (j )] = Color (r <<16 | g <<8 | b )
}
return nil
}
func (t *State ) oscColorResponse (j , num int ) {
if j < 0 {
t .logf ("failed to fetch osc color %d\n" , j )
return
}
k , ok := t .colorOverride [Color (j )]
if ok {
j = int (k )
}
r , g , b := rgb (j )
t .w .Write ([]byte (fmt .Sprintf ("\033]%d;rgb:%02x%02x/%02x%02x/%02x%02x\007" , num , r , r , g , g , b , b )))
}
func (t *State ) osc4ColorResponse (j int ) {
if j < 0 {
t .logf ("failed to fetch osc4 color %d\n" , j )
return
}
k , ok := t .colorOverride [Color (j )]
if ok {
j = int (k )
}
r , g , b := rgb (j )
t .w .Write ([]byte (fmt .Sprintf ("\033]4;%d;rgb:%02x%02x/%02x%02x/%02x%02x\007" , j , r , r , g , g , b , b )))
}
func rgb(j int ) (r , g , b int ) {
return (j >> 16 ) & 0xff , (j >> 8 ) & 0xff , j & 0xff
}
var (
RGBPattern = regexp .MustCompile (`^([\da-f]{1})\/([\da-f]{1})\/([\da-f]{1})$|^([\da-f]{2})\/([\da-f]{2})\/([\da-f]{2})$|^([\da-f]{3})\/([\da-f]{3})\/([\da-f]{3})$|^([\da-f]{4})\/([\da-f]{4})\/([\da-f]{4})$` )
HashPattern = regexp .MustCompile (`[\da-f]` )
)
func parseColor(p string ) (r , g , b int , err error ) {
if len (p ) == 0 {
err = fmt .Errorf ("empty color spec" )
return
}
low := strings .ToLower (p )
if strings .HasPrefix (low , "rgb:" ) {
low = low [4 :]
sm := RGBPattern .FindAllStringSubmatch (low , -1 )
if len (sm ) != 1 || len (sm [0 ]) == 0 {
err = fmt .Errorf ("invalid rgb color spec: %s" , p )
return
}
m := sm [0 ]
var base float64
if len (m [1 ]) > 0 {
base = 15
} else if len (m [4 ]) > 0 {
base = 255
} else if len (m [7 ]) > 0 {
base = 4095
} else {
base = 65535
}
r64 , err := strconv .ParseInt (firstNonEmpty (m [1 ], m [4 ], m [7 ], m [10 ]), 16 , 0 )
if err != nil {
return r , g , b , err
}
g64 , err := strconv .ParseInt (firstNonEmpty (m [2 ], m [5 ], m [8 ], m [11 ]), 16 , 0 )
if err != nil {
return r , g , b , err
}
b64 , err := strconv .ParseInt (firstNonEmpty (m [3 ], m [6 ], m [9 ], m [12 ]), 16 , 0 )
if err != nil {
return r , g , b , err
}
r = int (math .Round (float64 (r64 ) / base * 255 ))
g = int (math .Round (float64 (g64 ) / base * 255 ))
b = int (math .Round (float64 (b64 ) / base * 255 ))
return r , g , b , nil
} else if strings .HasPrefix (low , "#" ) {
low = low [1 :]
m := HashPattern .FindAllString (low , -1 )
if !oneOf (len (m ), []int {3 , 6 , 9 , 12 }) {
err = fmt .Errorf ("invalid hash color spec: %s" , p )
return
}
adv := len (low ) / 3
for i := 0 ; i < 3 ; i ++ {
c , err := strconv .ParseInt (low [adv *i :adv *i +adv ], 16 , 0 )
if err != nil {
return r , g , b , err
}
var v int64
switch adv {
case 1 :
v = c << 4
case 2 :
v = c
case 3 :
v = c >> 4
default :
v = c >> 8
}
switch i {
case 0 :
r = int (v )
case 1 :
g = int (v )
case 2 :
b = int (v )
}
}
return
} else {
err = fmt .Errorf ("invalid color spec: %s" , p )
return
}
}
func maybe(p *string ) string {
if p == nil {
return "<nil>"
}
return *p
}
func firstNonEmpty(strs ...string ) string {
if len (strs ) == 0 {
return ""
}
for _ , str := range strs {
if len (str ) > 0 {
return str
}
}
return strs [len (strs )-1 ]
}
func oneOf(v int , is []int ) bool {
for _ , i := range is {
if v == i {
return true
}
}
return false
}
The pages are generated with Golds v0.8.7 . (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu .
PR and bug reports are welcome and can be submitted to the issue list .
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds .