53d46aa3 |
1 | package main |
03519b4f |
2 | |
73f250ed |
3 | import( |
4 | "fmt" |
73f250ed |
5 | "os" |
6 | |
08ff4e7b |
7 | "strings" |
8 | "strconv" |
9 | "bufio" |
10 | |
11 | "net/http" |
12 | |
73f250ed |
13 | "github.com/wsxiaoys/terminal/color" |
14 | ) |
15 | |
16 | /* holds our palette, or 16 ANSI colors (8 normal colors + bright complements) |
17 | and two foreground/background colors. colors are 3 byte arrays (RGB) */ |
18 | type ktPalette struct { |
19 | |
20 | black [3]byte |
21 | bblack [3]byte |
22 | |
23 | red [3]byte |
24 | bred [3]byte |
25 | |
26 | green [3]byte |
27 | bgreen [3]byte |
28 | |
29 | yellow [3]byte |
30 | byellow [3]byte |
31 | |
32 | blue [3]byte |
33 | bblue [3]byte |
34 | |
35 | purple [3]byte |
36 | bpurple [3]byte |
37 | |
38 | cyan [3]byte |
39 | bcyan [3]byte |
40 | |
41 | white [3]byte |
42 | bwhite [3]byte |
43 | |
44 | fg [3]byte |
45 | bg [3]byte |
46 | } |
47 | |
48 | /* the default "control" ANSI color set (boring) */ |
49 | var ansiColors = ktPalette { |
50 | |
51 | black : [3]byte {0,0,0}, |
52 | bblack : [3]byte {128,128,128}, |
53 | |
54 | red : [3]byte {128,0,0}, |
55 | bred : [3]byte {255,0,0}, |
56 | |
57 | green : [3]byte {0,128,0}, |
58 | bgreen : [3]byte {0,255,0}, |
59 | |
60 | yellow : [3]byte {128,128,0}, |
61 | byellow : [3]byte {255,255,0}, |
62 | |
63 | blue : [3]byte {0,0,128}, |
64 | bblue : [3]byte {0,0,255}, |
65 | |
66 | purple : [3]byte {128,0,128}, |
67 | bpurple : [3]byte {255,0,255}, |
68 | |
69 | cyan : [3]byte {0,128,128}, |
70 | bcyan : [3]byte {0,255,255}, |
71 | |
72 | white : [3]byte {128,128,128}, |
73 | bwhite : [3]byte {255,255,255}, |
74 | |
75 | fg : [3]byte {0,0,0}, |
76 | bg : [3]byte {255,255,255}, |
77 | } |
78 | |
08ff4e7b |
79 | /* lets get our money's worth out of this utf-8 crap */ |
80 | var checkM = "✓" |
81 | var xM = "✗" |
82 | |
73f250ed |
83 | /* parses a colorfile, returns palette struct. given a nil file pointer, |
84 | returns standard ANSI color set (our "control") */ |
85 | func parseColors(colorfile *os.File) (pal ktPalette, err error) { |
86 | |
08ff4e7b |
87 | if colorfile == nil { return ansiColors, nil } |
88 | |
89 | ret := ktPalette {} |
90 | var e errConsumer |
91 | |
92 | scanner := bufio.NewScanner(colorfile) |
93 | for scanner.Scan() { |
94 | |
95 | if strings.Contains(scanner.Text(), "color") && |
96 | !strings.Contains(scanner.Text(), "!") { |
97 | |
98 | /* i am so sorry */ |
99 | cur := strings.Replace(scanner.Text(), " ", "", -1) |
100 | split := strings.Split(cur, ":") |
101 | hexColor := strings.Replace(split[1], "#", "", -1) |
102 | coNumStr := strings.Replace(split[0], "URxvt*color", "", -1) |
103 | |
104 | r, err := strconv.ParseUint(hexColor[0:2], 16, 8); e.Consume(err) |
105 | g, err := strconv.ParseUint(hexColor[2:4], 16, 8); e.Consume(err) |
106 | b, err := strconv.ParseUint(hexColor[4:], 16, 8); e.Consume(err) |
107 | |
108 | colorNo, err := strconv.Atoi(coNumStr); e.Consume(err) |
109 | |
110 | if e.err != nil { |
111 | return ktPalette{}, e.err |
112 | } |
113 | |
114 | switch(colorNo) { |
115 | case 0: ret.black[0] = byte(r); ret.black[1] = byte(g); ret.black[2] = byte(b) |
116 | case 1: ret.red[0] = byte(r); ret.red[1] = byte(g); ret.red[2] = byte(b) |
117 | case 2: ret.green[0] = byte(r); ret.green[1] = byte(g); ret.green[2] = byte(b) |
118 | case 3: ret.yellow[0] = byte(r); ret.yellow[1] = byte(g); ret.yellow[2] = byte(b) |
119 | case 4: ret.blue[0] = byte(r); ret.blue[1] = byte(g); ret.blue[2] = byte(b) |
120 | case 5: ret.purple[0] = byte(r); ret.purple[1] = byte(g); ret.purple[2] = byte(b) |
121 | case 6: ret.cyan[0] = byte(r); ret.cyan[1] = byte(g); ret.cyan[2] = byte(b) |
122 | case 7: ret.white[0] = byte(r); ret.white[1] = byte(g); ret.white[2] = byte(b) |
123 | case 8: ret.bblack[0] = byte(r); ret.bblack[1] = byte(g); ret.bblack[2] = byte(b) |
124 | case 9: ret.bred[0] = byte(r); ret.bred[1] = byte(g); ret.bred[2] = byte(b) |
125 | case 10: ret.bgreen[0] = byte(r); ret.bgreen[1] = byte(g); ret.bgreen[2] = byte(b) |
126 | case 11: ret.byellow[0] = byte(r); ret.byellow[1] = byte(g); ret.byellow[2] = byte(b) |
127 | case 12: ret.bblue[0] = byte(r); ret.bblue[1] = byte(g); ret.bblue[2] = byte(b) |
128 | case 13: ret.bpurple[0] = byte(r); ret.bpurple[1] = byte(g); ret.bpurple[2] = byte(b) |
129 | case 14: ret.bcyan[0] = byte(r); ret.bcyan[1] = byte(g); ret.bcyan[2] = byte(b) |
130 | case 15: ret.bwhite[0] = byte(r); ret.bwhite[1] = byte(g); ret.bwhite[2] = byte(b) |
131 | } |
132 | |
133 | } else if strings.Contains(scanner.Text(), "background") { |
134 | |
135 | hex := strings.Split(scanner.Text(), "#") |
136 | het := hex[1] |
137 | |
138 | r, err := strconv.ParseUint(het[0:2], 16, 8); e.Consume(err) |
139 | g, err := strconv.ParseUint(het[2:4], 16, 8); e.Consume(err) |
140 | b, err := strconv.ParseUint(het[4:], 16, 8); e.Consume(err) |
141 | |
142 | if e.err != nil { |
143 | return ktPalette{}, e.err |
144 | } |
145 | |
146 | ret.bg[0] = byte(r) |
147 | ret.bg[1] = byte(g) |
148 | ret.bg[2] = byte(b) |
149 | |
150 | } else if strings.Contains(scanner.Text(), "foreground") { |
151 | |
152 | hex := strings.Split(scanner.Text(), "#") |
153 | het := hex[1] |
154 | |
155 | r, err := strconv.ParseUint(het[0:2], 16, 8); e.Consume(err) |
156 | g, err := strconv.ParseUint(het[2:4], 16, 8); e.Consume(err) |
157 | b, err := strconv.ParseUint(het[4:], 16, 8); e.Consume(err) |
158 | |
159 | if e.err != nil { |
160 | return ktPalette{}, e.err |
161 | } |
162 | |
163 | ret.fg[0] = byte(r) |
164 | ret.fg[1] = byte(g) |
165 | ret.fg[2] = byte(b) |
166 | } |
167 | } |
168 | |
169 | return ret, e.err |
73f250ed |
170 | } |
171 | |
172 | func ktInit(dirPrepend string, port int, colorfilePath string) error { |
173 | |
174 | color.Print("@yparsing colorfile :: @{|}") |
175 | file, err := os.Open(colorfilePath) |
176 | if err != nil { |
177 | color.Printf("@r[%s]@{|} - bad colorfile path\n", xM) |
178 | return fmt.Errorf("%s\n", "bad colorfile path") |
179 | } |
180 | |
181 | pal, err := parseColors(file) |
73f250ed |
182 | |
183 | if err != nil { |
08ff4e7b |
184 | color.Printf("@r[%s]@{|} - malformed colorfile [%s]\n", xM, err) |
73f250ed |
185 | return fmt.Errorf("%s\n", "malformed colorfile") |
186 | } |
187 | |
188 | color.Printf("@g[%s]@{|}\n", checkM) |
189 | |
08ff4e7b |
190 | if pal == ansiColors {} |
191 | |
73f250ed |
192 | color.Printf("@ystarting httpd on port @b%d@{|} :: ", port) |
193 | |
08ff4e7b |
194 | |
73f250ed |
195 | return nil |
196 | } |
03519b4f |
197 | |
198 | func main() { |
199 | |
08ff4e7b |
200 | err := ktInit("kolors", 999, "/home/kremlin/.Xresources") |
73f250ed |
201 | |
53d46aa3 |
202 | /* make sure to close() anything you need to (you need to) */ |
08ff4e7b |
203 | _, err = http.Get("http://kremlin.cc") |
53d46aa3 |
204 | |
205 | if err != nil {} |
03519b4f |
206 | } |
73f250ed |
207 | |
08ff4e7b |
208 | type errConsumer struct { |
209 | err error |
210 | } |
211 | |
212 | func (e *errConsumer) Consume(err error) { |
213 | if e.err == nil && err != nil { |
214 | e.err = err |
215 | } |
216 | } |
73f250ed |
217 | |