├── .gitignore
├── AUTHORS
├── LICENSE
├── README.md
├── _examples
├── Mark.Twain-Tom.Sawyer.txt
├── active.go
├── bufs.go
├── colors.go
├── colors256.go
├── demo.go
├── dynamic.go
├── flow_layout.go
├── goroutine.go
├── hello.go
├── layout.go
├── mask.go
├── mouse.go
├── ontop.go
├── overlap.go
├── size.go
├── stdin.go
├── title.go
├── widgets.go
└── wrap.go
├── attribute.go
├── doc.go
├── edit.go
├── escape.go
├── go.mod
├── go.sum
├── gui.go
├── keybinding.go
└── view.go
/.gitignore:
--------------------------------------------------------------------------------
1 | *.swp
2 |
--------------------------------------------------------------------------------
/AUTHORS:
--------------------------------------------------------------------------------
1 | # This is the official list of gocui authors for copyright purposes.
2 |
3 | # Names should be added to this file as
4 | # Name or Organization <email address> contribution
5 | # Contribution
6 | # The email address is not required for organizations.
7 |
8 | Roi Martin <jroi.martin@gmail.com>
9 | Main developer
10 |
11 | Ryan Sullivan <kayoticsully@gmail.com>
12 | Toggleable view frames
13 |
14 | Matthieu Rakotojaona <matthieu.rakotojaona@gmail.com>
15 | Wrapped views
16 |
17 | Harry Lawrence <hazbo@gmx.com>
18 | Basic mouse support
19 |
20 | Danny Tylman <dtylman@gmail.com>
21 | Masked views
22 |
23 | Frederik Deweerdt <frederik.deweerdt@gmail.com>
24 | Colored fonts
25 |
26 | Henri Koski <henri.t.koski@gmail.com>
27 | Custom current view color
28 |
29 | Dustin Willis Webber <dustin.webber@gmail.com>
30 | 256-colors output mode support
31 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2014 The gocui Authors. All rights reserved.
2 |
3 | Redistribution and use in source and binary forms, with or without
4 | modification, are permitted provided that the following conditions are met:
5 | * Redistributions of source code must retain the above copyright
6 | notice, this list of conditions and the following disclaimer.
7 | * Redistributions in binary form must reproduce the above copyright
8 | notice, this list of conditions and the following disclaimer in the
9 | documentation and/or other materials provided with the distribution.
10 | * Neither the name of the gocui Authors nor the names of its contributors
11 | may be used to endorse or promote products derived from this software
12 | without specific prior written permission.
13 |
14 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
15 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
16 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
18 | ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
19 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
20 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
21 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
23 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # GOCUI - Go Console User Interface
2 |
3 | [](https://pkg.go.dev/github.com/jroimartin/gocui)
4 |
5 | Minimalist Go package aimed at creating Console User Interfaces.
6 |
7 | ## Features
8 |
9 | * Minimalist API.
10 | * Views (the "windows" in the GUI) implement the interface io.ReadWriter.
11 | * Support for overlapping views.
12 | * The GUI can be modified at runtime (concurrent-safe).
13 | * Global and view-level keybindings.
14 | * Mouse support.
15 | * Colored text.
16 | * Customizable edition mode.
17 | * Easy to build reusable widgets, complex layouts...
18 |
19 | ## Installation
20 |
21 | Execute:
22 |
23 | ```sh
24 | go get github.com/jroimartin/gocui
25 | ```
26 |
27 | ## Documentation
28 |
29 | Execute:
30 |
31 | ```sh
32 | go doc github.com/jroimartin/gocui
33 | ```
34 |
35 | Or visit [pkg.go.dev](https://pkg.go.dev/github.com/jroimartin/gocui) to read
36 | it online.
37 |
38 | ## Example
39 |
40 | ```go
41 | package main
42 |
43 | import (
44 | "fmt"
45 | "log"
46 |
47 | "github.com/jroimartin/gocui"
48 | )
49 |
50 | func main() {
51 | g, err := gocui.NewGui(gocui.OutputNormal)
52 | if err != nil {
53 | log.Panicln(err)
54 | }
55 | defer g.Close()
56 |
57 | g.SetManagerFunc(layout)
58 |
59 | if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
60 | log.Panicln(err)
61 | }
62 |
63 | if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
64 | log.Panicln(err)
65 | }
66 | }
67 |
68 | func layout(g *gocui.Gui) error {
69 | maxX, maxY := g.Size()
70 | if v, err := g.SetView("hello", maxX/2-7, maxY/2, maxX/2+7, maxY/2+2); err != nil {
71 | if err != gocui.ErrUnknownView {
72 | return err
73 | }
74 | fmt.Fprintln(v, "Hello world!")
75 | }
76 | return nil
77 | }
78 |
79 | func quit(g *gocui.Gui, v *gocui.View) error {
80 | return gocui.ErrQuit
81 | }
82 | ```
83 |
84 | ## Screenshots
85 |
86 | 
87 |
88 | 
89 |
90 | 
91 |
--------------------------------------------------------------------------------
/_examples/Mark.Twain-Tom.Sawyer.txt:
--------------------------------------------------------------------------------
1 | The Project Gutenberg EBook of The Adventures of Tom Sawyer, Complete
2 | by Mark Twain (Samuel Clemens)
3 |
4 | This eBook is for the use of anyone anywhere at no cost and with
5 | almost no restrictions whatsoever. You may copy it, give it away or
6 | re-use it under the terms of the Project Gutenberg License included
7 | with this eBook or online at www.gutenberg.net
8 |
9 |
10 | Title: The Adventures of Tom Sawyer, Complete
11 |
12 | Author: Mark Twain (Samuel Clemens)
13 |
14 | Release Date: August 20, 2006 [EBook #74]
15 | [Last updated: May 3, 2011]
16 |
17 | Language: English
18 |
19 |
20 | *** START OF THIS PROJECT GUTENBERG EBOOK TOM SAWYER ***
21 |
22 |
23 |
24 |
25 | Produced by David Widger. The previous edition was updated by Jose
26 | Menendez.
27 |
28 |
29 |
30 |
31 |
32 | THE ADVENTURES OF TOM SAWYER
33 | BY
34 | MARK TWAIN
35 | (Samuel Langhorne Clemens)
36 |
37 |
38 |
39 |
40 | P R E F A C E
41 |
42 | MOST of the adventures recorded in this book really occurred; one or
43 | two were experiences of my own, the rest those of boys who were
44 | schoolmates of mine. Huck Finn is drawn from life; Tom Sawyer also, but
45 | not from an individual--he is a combination of the characteristics of
46 | three boys whom I knew, and therefore belongs to the composite order of
47 | architecture.
48 |
49 | The odd superstitions touched upon were all prevalent among children
50 | and slaves in the West at the period of this story--that is to say,
51 | thirty or forty years ago.
52 |
53 | Although my book is intended mainly for the entertainment of boys and
54 | girls, I hope it will not be shunned by men and women on that account,
55 | for part of my plan has been to try to pleasantly remind adults of what
56 | they once were themselves, and of how they felt and thought and talked,
57 | and what queer enterprises they sometimes engaged in.
58 |
59 | THE AUTHOR.
60 |
61 | HARTFORD, 1876.
62 |
63 |
64 |
65 | T O M S A W Y E R
66 |
67 |
68 |
69 | CHAPTER I
70 |
71 | "TOM!"
72 |
73 | No answer.
74 |
75 | "TOM!"
76 |
77 | No answer.
78 |
79 | "What's gone with that boy, I wonder? You TOM!"
80 |
81 | No answer.
82 |
83 | The old lady pulled her spectacles down and looked over them about the
84 | room; then she put them up and looked out under them. She seldom or
85 | never looked THROUGH them for so small a thing as a boy; they were her
86 | state pair, the pride of her heart, and were built for "style," not
87 | service--she could have seen through a pair of stove-lids just as well.
88 | She looked perplexed for a moment, and then said, not fiercely, but
89 | still loud enough for the furniture to hear:
90 |
91 | "Well, I lay if I get hold of you I'll--"
92 |
93 | She did not finish, for by this time she was bending down and punching
94 | under the bed with the broom, and so she needed breath to punctuate the
95 | punches with. She resurrected nothing but the cat.
96 |
97 | "I never did see the beat of that boy!"
98 |
99 | She went to the open door and stood in it and looked out among the
100 | tomato vines and "jimpson" weeds that constituted the garden. No Tom.
101 | So she lifted up her voice at an angle calculated for distance and
102 | shouted:
103 |
104 | "Y-o-u-u TOM!"
105 |
106 | There was a slight noise behind her and she turned just in time to
107 | seize a small boy by the slack of his roundabout and arrest his flight.
108 |
109 | "There! I might 'a' thought of that closet. What you been doing in
110 | there?"
111 |
112 | "Nothing."
113 |
114 | "Nothing! Look at your hands. And look at your mouth. What IS that
115 | truck?"
116 |
117 | "I don't know, aunt."
118 |
119 | "Well, I know. It's jam--that's what it is. Forty times I've said if
120 | you didn't let that jam alone I'd skin you. Hand me that switch."
121 |
122 | The switch hovered in the air--the peril was desperate--
123 |
124 | "My! Look behind you, aunt!"
125 |
126 | The old lady whirled round, and snatched her skirts out of danger. The
127 | lad fled on the instant, scrambled up the high board-fence, and
128 | disappeared over it.
129 |
130 | His aunt Polly stood surprised a moment, and then broke into a gentle
131 | laugh.
132 |
133 | "Hang the boy, can't I never learn anything? Ain't he played me tricks
134 | enough like that for me to be looking out for him by this time? But old
135 | fools is the biggest fools there is. Can't learn an old dog new tricks,
136 | as the saying is. But my goodness, he never plays them alike, two days,
137 | and how is a body to know what's coming? He 'pears to know just how
138 | long he can torment me before I get my dander up, and he knows if he
139 | can make out to put me off for a minute or make me laugh, it's all down
140 | again and I can't hit him a lick. I ain't doing my duty by that boy,
141 | and that's the Lord's truth, goodness knows. Spare the rod and spile
142 | the child, as the Good Book says. I'm a laying up sin and suffering for
143 | us both, I know. He's full of the Old Scratch, but laws-a-me! he's my
144 | own dead sister's boy, poor thing, and I ain't got the heart to lash
145 | him, somehow. Every time I let him off, my conscience does hurt me so,
146 | and every time I hit him my old heart most breaks. Well-a-well, man
147 | that is born of woman is of few days and full of trouble, as the
148 | Scripture says, and I reckon it's so. He'll play hookey this evening, *
149 | and [* Southwestern for "afternoon"] I'll just be obleeged to make him
150 | work, to-morrow, to punish him. It's mighty hard to make him work
151 | Saturdays, when all the boys is having holiday, but he hates work more
152 | than he hates anything else, and I've GOT to do some of my duty by him,
153 | or I'll be the ruination of the child."
154 |
155 | Tom did play hookey, and he had a very good time. He got back home
156 | barely in season to help Jim, the small colored boy, saw next-day's
157 | wood and split the kindlings before supper--at least he was there in
158 | time to tell his adventures to Jim while Jim did three-fourths of the
159 | work. Tom's younger brother (or rather half-brother) Sid was already
160 | through with his part of the work (picking up chips), for he was a
161 | quiet boy, and had no adventurous, troublesome ways.
162 |
163 | While Tom was eating his supper, and stealing sugar as opportunity
164 | offered, Aunt Polly asked him questions that were full of guile, and
165 | very deep--for she wanted to trap him into damaging revealments. Like
166 | many other simple-hearted souls, it was her pet vanity to believe she
167 | was endowed with a talent for dark and mysterious diplomacy, and she
168 | loved to contemplate her most transparent devices as marvels of low
169 | cunning. Said she:
170 |
171 | "Tom, it was middling warm in school, warn't it?"
172 |
173 | "Yes'm."
174 |
175 | "Powerful warm, warn't it?"
176 |
177 | "Yes'm."
178 |
179 | "Didn't you want to go in a-swimming, Tom?"
180 |
181 | A bit of a scare shot through Tom--a touch of uncomfortable suspicion.
182 | He searched Aunt Polly's face, but it told him nothing. So he said:
183 |
184 | "No'm--well, not very much."
185 |
186 | The old lady reached out her hand and felt Tom's shirt, and said:
187 |
188 | "But you ain't too warm now, though." And it flattered her to reflect
189 | that she had discovered that the shirt was dry without anybody knowing
190 | that that was what she had in her mind. But in spite of her, Tom knew
191 | where the wind lay, now. So he forestalled what might be the next move:
192 |
193 | "Some of us pumped on our heads--mine's damp yet. See?"
194 |
195 | Aunt Polly was vexed to think she had overlooked that bit of
196 | circumstantial evidence, and missed a trick. Then she had a new
197 | inspiration:
198 |
199 | "Tom, you didn't have to undo your shirt collar where I sewed it, to
200 | pump on your head, did you? Unbutton your jacket!"
201 |
202 | The trouble vanished out of Tom's face. He opened his jacket. His
203 | shirt collar was securely sewed.
204 |
205 | "Bother! Well, go 'long with you. I'd made sure you'd played hookey
206 | and been a-swimming. But I forgive ye, Tom. I reckon you're a kind of a
207 | singed cat, as the saying is--better'n you look. THIS time."
208 |
209 | She was half sorry her sagacity had miscarried, and half glad that Tom
210 | had stumbled into obedient conduct for once.
211 |
212 | But Sidney said:
213 |
214 | "Well, now, if I didn't think you sewed his collar with white thread,
215 | but it's black."
216 |
217 | "Why, I did sew it with white! Tom!"
218 |
219 | But Tom did not wait for the rest. As he went out at the door he said:
220 |
221 | "Siddy, I'll lick you for that."
222 |
223 | In a safe place Tom examined two large needles which were thrust into
224 | the lapels of his jacket, and had thread bound about them--one needle
225 | carried white thread and the other black. He said:
226 |
227 | "She'd never noticed if it hadn't been for Sid. Confound it! sometimes
228 | she sews it with white, and sometimes she sews it with black. I wish to
229 | geeminy she'd stick to one or t'other--I can't keep the run of 'em. But
230 | I bet you I'll lam Sid for that. I'll learn him!"
231 |
232 | He was not the Model Boy of the village. He knew the model boy very
233 | well though--and loathed him.
234 |
235 | Within two minutes, or even less, he had forgotten all his troubles.
236 | Not because his troubles were one whit less heavy and bitter to him
237 | than a man's are to a man, but because a new and powerful interest bore
238 | them down and drove them out of his mind for the time--just as men's
239 | misfortunes are forgotten in the excitement of new enterprises. This
240 | new interest was a valued novelty in whistling, which he had just
241 | acquired from a negro, and he was suffering to practise it undisturbed.
242 | It consisted in a peculiar bird-like turn, a sort of liquid warble,
243 | produced by touching the tongue to the roof of the mouth at short
244 | intervals in the midst of the music--the reader probably remembers how
245 | to do it, if he has ever been a boy. Diligence and attention soon gave
246 | him the knack of it, and he strode down the street with his mouth full
247 | of harmony and his soul full of gratitude. He felt much as an
248 | astronomer feels who has discovered a new planet--no doubt, as far as
249 | strong, deep, unalloyed pleasure is concerned, the advantage was with
250 | the boy, not the astronomer.
251 |
252 | The summer evenings were long. It was not dark, yet. Presently Tom
253 | checked his whistle. A stranger was before him--a boy a shade larger
254 | than himself. A new-comer of any age or either sex was an impressive
255 | curiosity in the poor little shabby village of St. Petersburg. This boy
256 | was well dressed, too--well dressed on a week-day. This was simply
257 | astounding. His cap was a dainty thing, his close-buttoned blue cloth
258 | roundabout was new and natty, and so were his pantaloons. He had shoes
259 | on--and it was only Friday. He even wore a necktie, a bright bit of
260 | ribbon. He had a citified air about him that ate into Tom's vitals. The
261 | more Tom stared at the splendid marvel, the higher he turned up his
262 | nose at his finery and the shabbier and shabbier his own outfit seemed
263 | to him to grow. Neither boy spoke. If one moved, the other moved--but
264 | only sidewise, in a circle; they kept face to face and eye to eye all
265 | the time. Finally Tom said:
266 |
267 | "I can lick you!"
268 |
269 | "I'd like to see you try it."
270 |
271 | "Well, I can do it."
272 |
273 | "No you can't, either."
274 |
275 | "Yes I can."
276 |
277 | "No you can't."
278 |
279 | "I can."
280 |
281 | "You can't."
282 |
283 | "Can!"
284 |
285 | "Can't!"
286 |
287 | An uncomfortable pause. Then Tom said:
288 |
289 | "What's your name?"
290 |
291 | "'Tisn't any of your business, maybe."
292 |
293 | "Well I 'low I'll MAKE it my business."
294 |
295 | "Well why don't you?"
296 |
297 | "If you say much, I will."
298 |
299 | "Much--much--MUCH. There now."
300 |
301 | "Oh, you think you're mighty smart, DON'T you? I could lick you with
302 | one hand tied behind me, if I wanted to."
303 |
304 | "Well why don't you DO it? You SAY you can do it."
305 |
306 | "Well I WILL, if you fool with me."
307 |
308 | "Oh yes--I've seen whole families in the same fix."
309 |
310 | "Smarty! You think you're SOME, now, DON'T you? Oh, what a hat!"
311 |
312 | "You can lump that hat if you don't like it. I dare you to knock it
313 | off--and anybody that'll take a dare will suck eggs."
314 |
315 | "You're a liar!"
316 |
317 | "You're another."
318 |
319 | "You're a fighting liar and dasn't take it up."
320 |
321 | "Aw--take a walk!"
322 |
323 | "Say--if you give me much more of your sass I'll take and bounce a
324 | rock off'n your head."
325 |
326 | "Oh, of COURSE you will."
327 |
328 | "Well I WILL."
329 |
330 | "Well why don't you DO it then? What do you keep SAYING you will for?
331 | Why don't you DO it? It's because you're afraid."
332 |
333 | "I AIN'T afraid."
334 |
335 | "You are."
336 |
337 | "I ain't."
338 |
339 | "You are."
340 |
341 | Another pause, and more eying and sidling around each other. Presently
342 | they were shoulder to shoulder. Tom said:
343 |
344 | "Get away from here!"
345 |
346 | "Go away yourself!"
347 |
348 | "I won't."
349 |
350 | "I won't either."
351 |
352 | So they stood, each with a foot placed at an angle as a brace, and
353 | both shoving with might and main, and glowering at each other with
354 | hate. But neither could get an advantage. After struggling till both
355 | were hot and flushed, each relaxed his strain with watchful caution,
356 | and Tom said:
357 |
358 | "You're a coward and a pup. I'll tell my big brother on you, and he
359 | can thrash you with his little finger, and I'll make him do it, too."
360 |
361 | "What do I care for your big brother? I've got a brother that's bigger
362 | than he is--and what's more, he can throw him over that fence, too."
363 | [Both brothers were imaginary.]
364 |
365 | "That's a lie."
366 |
367 | "YOUR saying so don't make it so."
368 |
369 | Tom drew a line in the dust with his big toe, and said:
370 |
371 | "I dare you to step over that, and I'll lick you till you can't stand
372 | up. Anybody that'll take a dare will steal sheep."
373 |
374 | The new boy stepped over promptly, and said:
375 |
376 | "Now you said you'd do it, now let's see you do it."
377 |
378 | "Don't you crowd me now; you better look out."
379 |
380 | "Well, you SAID you'd do it--why don't you do it?"
381 |
382 | "By jingo! for two cents I WILL do it."
383 |
384 | The new boy took two broad coppers out of his pocket and held them out
385 | with derision. Tom struck them to the ground. In an instant both boys
386 | were rolling and tumbling in the dirt, gripped together like cats; and
387 | for the space of a minute they tugged and tore at each other's hair and
388 | clothes, punched and scratched each other's nose, and covered
389 | themselves with dust and glory. Presently the confusion took form, and
390 | through the fog of battle Tom appeared, seated astride the new boy, and
391 | pounding him with his fists. "Holler 'nuff!" said he.
392 |
393 | The boy only struggled to free himself. He was crying--mainly from rage.
394 |
395 | "Holler 'nuff!"--and the pounding went on.
396 |
397 | At last the stranger got out a smothered "'Nuff!" and Tom let him up
398 | and said:
399 |
400 | "Now that'll learn you. Better look out who you're fooling with next
401 | time."
402 |
403 | The new boy went off brushing the dust from his clothes, sobbing,
404 | snuffling, and occasionally looking back and shaking his head and
405 | threatening what he would do to Tom the "next time he caught him out."
406 | To which Tom responded with jeers, and started off in high feather, and
407 | as soon as his back was turned the new boy snatched up a stone, threw
408 | it and hit him between the shoulders and then turned tail and ran like
409 | an antelope. Tom chased the traitor home, and thus found out where he
410 | lived. He then held a position at the gate for some time, daring the
411 | enemy to come outside, but the enemy only made faces at him through the
412 | window and declined. At last the enemy's mother appeared, and called
413 | Tom a bad, vicious, vulgar child, and ordered him away. So he went
414 | away; but he said he "'lowed" to "lay" for that boy.
415 |
416 | He got home pretty late that night, and when he climbed cautiously in
417 | at the window, he uncovered an ambuscade, in the person of his aunt;
418 | and when she saw the state his clothes were in her resolution to turn
419 | his Saturday holiday into captivity at hard labor became adamantine in
420 | its firmness.
421 |
--------------------------------------------------------------------------------
/_examples/active.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package main
6 |
7 | import (
8 | "fmt"
9 | "log"
10 |
11 | "github.com/jroimartin/gocui"
12 | )
13 |
14 | var (
15 | viewArr = []string{"v1", "v2", "v3", "v4"}
16 | active = 0
17 | )
18 |
19 | func setCurrentViewOnTop(g *gocui.Gui, name string) (*gocui.View, error) {
20 | if _, err := g.SetCurrentView(name); err != nil {
21 | return nil, err
22 | }
23 | return g.SetViewOnTop(name)
24 | }
25 |
26 | func nextView(g *gocui.Gui, v *gocui.View) error {
27 | nextIndex := (active + 1) % len(viewArr)
28 | name := viewArr[nextIndex]
29 |
30 | out, err := g.View("v2")
31 | if err != nil {
32 | return err
33 | }
34 | fmt.Fprintln(out, "Going from view "+v.Name()+" to "+name)
35 |
36 | if _, err := setCurrentViewOnTop(g, name); err != nil {
37 | return err
38 | }
39 |
40 | if nextIndex == 0 || nextIndex == 3 {
41 | g.Cursor = true
42 | } else {
43 | g.Cursor = false
44 | }
45 |
46 | active = nextIndex
47 | return nil
48 | }
49 |
50 | func layout(g *gocui.Gui) error {
51 | maxX, maxY := g.Size()
52 | if v, err := g.SetView("v1", 0, 0, maxX/2-1, maxY/2-1); err != nil {
53 | if err != gocui.ErrUnknownView {
54 | return err
55 | }
56 | v.Title = "v1 (editable)"
57 | v.Editable = true
58 | v.Wrap = true
59 |
60 | if _, err = setCurrentViewOnTop(g, "v1"); err != nil {
61 | return err
62 | }
63 | }
64 |
65 | if v, err := g.SetView("v2", maxX/2-1, 0, maxX-1, maxY/2-1); err != nil {
66 | if err != gocui.ErrUnknownView {
67 | return err
68 | }
69 | v.Title = "v2"
70 | v.Wrap = true
71 | v.Autoscroll = true
72 | }
73 | if v, err := g.SetView("v3", 0, maxY/2-1, maxX/2-1, maxY-1); err != nil {
74 | if err != gocui.ErrUnknownView {
75 | return err
76 | }
77 | v.Title = "v3"
78 | v.Wrap = true
79 | v.Autoscroll = true
80 | fmt.Fprint(v, "Press TAB to change current view")
81 | }
82 | if v, err := g.SetView("v4", maxX/2, maxY/2, maxX-1, maxY-1); err != nil {
83 | if err != gocui.ErrUnknownView {
84 | return err
85 | }
86 | v.Title = "v4 (editable)"
87 | v.Editable = true
88 | }
89 | return nil
90 | }
91 |
92 | func quit(g *gocui.Gui, v *gocui.View) error {
93 | return gocui.ErrQuit
94 | }
95 |
96 | func main() {
97 | g, err := gocui.NewGui(gocui.OutputNormal)
98 | if err != nil {
99 | log.Panicln(err)
100 | }
101 | defer g.Close()
102 |
103 | g.Highlight = true
104 | g.Cursor = true
105 | g.SelFgColor = gocui.ColorGreen
106 |
107 | g.SetManagerFunc(layout)
108 |
109 | if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
110 | log.Panicln(err)
111 | }
112 | if err := g.SetKeybinding("", gocui.KeyTab, gocui.ModNone, nextView); err != nil {
113 | log.Panicln(err)
114 | }
115 |
116 | if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
117 | log.Panicln(err)
118 | }
119 | }
120 |
--------------------------------------------------------------------------------
/_examples/bufs.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // WARNING: tricky code just for testing purposes, do not use as reference.
6 |
7 | package main
8 |
9 | import (
10 | "fmt"
11 | "log"
12 |
13 | "github.com/jroimartin/gocui"
14 | )
15 |
16 | var vbuf, buf string
17 |
18 | func quit(g *gocui.Gui, v *gocui.View) error {
19 | vbuf = v.ViewBuffer()
20 | buf = v.Buffer()
21 | return gocui.ErrQuit
22 | }
23 |
24 | func overwrite(g *gocui.Gui, v *gocui.View) error {
25 | v.Overwrite = !v.Overwrite
26 | return nil
27 | }
28 |
29 | func layout(g *gocui.Gui) error {
30 | _, maxY := g.Size()
31 | if v, err := g.SetView("main", 0, 0, 20, maxY-1); err != nil {
32 | if err != gocui.ErrUnknownView {
33 | return err
34 | }
35 | v.Editable = true
36 | v.Wrap = true
37 | if _, err := g.SetCurrentView("main"); err != nil {
38 | return err
39 | }
40 | }
41 | return nil
42 | }
43 |
44 | func main() {
45 | g, err := gocui.NewGui(gocui.OutputNormal)
46 | if err != nil {
47 | log.Panicln(err)
48 | }
49 |
50 | g.Cursor = true
51 | g.Mouse = true
52 |
53 | g.SetManagerFunc(layout)
54 |
55 | if err := g.SetKeybinding("main", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
56 | log.Panicln(err)
57 | }
58 | if err := g.SetKeybinding("main", gocui.KeyCtrlI, gocui.ModNone, overwrite); err != nil {
59 | log.Panicln(err)
60 | }
61 |
62 | if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
63 | log.Panicln(err)
64 | }
65 |
66 | g.Close()
67 |
68 | fmt.Printf("VBUF:\n%s\n", vbuf)
69 | fmt.Printf("BUF:\n%s\n", buf)
70 | }
71 |
--------------------------------------------------------------------------------
/_examples/colors.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package main
6 |
7 | import (
8 | "fmt"
9 | "log"
10 |
11 | "github.com/jroimartin/gocui"
12 | )
13 |
14 | func main() {
15 | g, err := gocui.NewGui(gocui.OutputNormal)
16 | if err != nil {
17 | log.Panicln(err)
18 | }
19 | defer g.Close()
20 |
21 | g.SetManagerFunc(layout)
22 |
23 | if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
24 | log.Panicln(err)
25 | }
26 |
27 | if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
28 | log.Panicln(err)
29 | }
30 | }
31 |
32 | func layout(g *gocui.Gui) error {
33 | maxX, maxY := g.Size()
34 | if v, err := g.SetView("colors", maxX/2-7, maxY/2-12, maxX/2+7, maxY/2+13); err != nil {
35 | if err != gocui.ErrUnknownView {
36 | return err
37 | }
38 | for i := 0; i <= 7; i++ {
39 | for _, j := range []int{1, 4, 7} {
40 | fmt.Fprintf(v, "Hello \033[3%d;%dmcolors!\033[0m\n", i, j)
41 | }
42 | }
43 | }
44 | return nil
45 | }
46 |
47 | func quit(g *gocui.Gui, v *gocui.View) error {
48 | return gocui.ErrQuit
49 | }
50 |
--------------------------------------------------------------------------------
/_examples/colors256.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package main
6 |
7 | import (
8 | "fmt"
9 | "log"
10 |
11 | "github.com/jroimartin/gocui"
12 | )
13 |
14 | func main() {
15 | g, err := gocui.NewGui(gocui.Output256)
16 |
17 | if err != nil {
18 | log.Panicln(err)
19 | }
20 | defer g.Close()
21 |
22 | g.SetManagerFunc(layout)
23 |
24 | if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
25 | log.Panicln(err)
26 | }
27 |
28 | if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
29 | log.Panicln(err)
30 | }
31 | }
32 |
33 | func layout(g *gocui.Gui) error {
34 | maxX, maxY := g.Size()
35 | if v, err := g.SetView("colors", -1, -1, maxX, maxY); err != nil {
36 | if err != gocui.ErrUnknownView {
37 | return err
38 | }
39 |
40 | // 256-colors escape codes
41 | for i := 0; i < 256; i++ {
42 | str := fmt.Sprintf("\x1b[48;5;%dm\x1b[30m%3d\x1b[0m ", i, i)
43 | str += fmt.Sprintf("\x1b[38;5;%dm%3d\x1b[0m ", i, i)
44 |
45 | if (i+1)%10 == 0 {
46 | str += "\n"
47 | }
48 |
49 | fmt.Fprint(v, str)
50 | }
51 |
52 | fmt.Fprint(v, "\n\n")
53 |
54 | // 8-colors escape codes
55 | ctr := 0
56 | for i := 0; i <= 7; i++ {
57 | for _, j := range []int{1, 4, 7} {
58 | str := fmt.Sprintf("\x1b[3%d;%dm%d:%d\x1b[0m ", i, j, i, j)
59 | if (ctr+1)%20 == 0 {
60 | str += "\n"
61 | }
62 |
63 | fmt.Fprint(v, str)
64 |
65 | ctr++
66 | }
67 | }
68 | }
69 | return nil
70 | }
71 |
72 | func quit(g *gocui.Gui, v *gocui.View) error {
73 | return gocui.ErrQuit
74 | }
75 |
--------------------------------------------------------------------------------
/_examples/demo.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package main
6 |
7 | import (
8 | "fmt"
9 | "io"
10 | "io/ioutil"
11 | "log"
12 | "strings"
13 |
14 | "github.com/jroimartin/gocui"
15 | )
16 |
17 | func nextView(g *gocui.Gui, v *gocui.View) error {
18 | if v == nil || v.Name() == "side" {
19 | _, err := g.SetCurrentView("main")
20 | return err
21 | }
22 | _, err := g.SetCurrentView("side")
23 | return err
24 | }
25 |
26 | func cursorDown(g *gocui.Gui, v *gocui.View) error {
27 | if v != nil {
28 | cx, cy := v.Cursor()
29 | if err := v.SetCursor(cx, cy+1); err != nil {
30 | ox, oy := v.Origin()
31 | if err := v.SetOrigin(ox, oy+1); err != nil {
32 | return err
33 | }
34 | }
35 | }
36 | return nil
37 | }
38 |
39 | func cursorUp(g *gocui.Gui, v *gocui.View) error {
40 | if v != nil {
41 | ox, oy := v.Origin()
42 | cx, cy := v.Cursor()
43 | if err := v.SetCursor(cx, cy-1); err != nil && oy > 0 {
44 | if err := v.SetOrigin(ox, oy-1); err != nil {
45 | return err
46 | }
47 | }
48 | }
49 | return nil
50 | }
51 |
52 | func getLine(g *gocui.Gui, v *gocui.View) error {
53 | var l string
54 | var err error
55 |
56 | _, cy := v.Cursor()
57 | if l, err = v.Line(cy); err != nil {
58 | l = ""
59 | }
60 |
61 | maxX, maxY := g.Size()
62 | if v, err := g.SetView("msg", maxX/2-30, maxY/2, maxX/2+30, maxY/2+2); err != nil {
63 | if err != gocui.ErrUnknownView {
64 | return err
65 | }
66 | fmt.Fprintln(v, l)
67 | if _, err := g.SetCurrentView("msg"); err != nil {
68 | return err
69 | }
70 | }
71 | return nil
72 | }
73 |
74 | func delMsg(g *gocui.Gui, v *gocui.View) error {
75 | if err := g.DeleteView("msg"); err != nil {
76 | return err
77 | }
78 | if _, err := g.SetCurrentView("side"); err != nil {
79 | return err
80 | }
81 | return nil
82 | }
83 |
84 | func quit(g *gocui.Gui, v *gocui.View) error {
85 | return gocui.ErrQuit
86 | }
87 |
88 | func keybindings(g *gocui.Gui) error {
89 | if err := g.SetKeybinding("side", gocui.KeyCtrlSpace, gocui.ModNone, nextView); err != nil {
90 | return err
91 | }
92 | if err := g.SetKeybinding("main", gocui.KeyCtrlSpace, gocui.ModNone, nextView); err != nil {
93 | return err
94 | }
95 | if err := g.SetKeybinding("side", gocui.KeyArrowDown, gocui.ModNone, cursorDown); err != nil {
96 | return err
97 | }
98 | if err := g.SetKeybinding("side", gocui.KeyArrowUp, gocui.ModNone, cursorUp); err != nil {
99 | return err
100 | }
101 | if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
102 | return err
103 | }
104 | if err := g.SetKeybinding("side", gocui.KeyEnter, gocui.ModNone, getLine); err != nil {
105 | return err
106 | }
107 | if err := g.SetKeybinding("msg", gocui.KeyEnter, gocui.ModNone, delMsg); err != nil {
108 | return err
109 | }
110 |
111 | if err := g.SetKeybinding("main", gocui.KeyCtrlS, gocui.ModNone, saveMain); err != nil {
112 | return err
113 | }
114 | if err := g.SetKeybinding("main", gocui.KeyCtrlW, gocui.ModNone, saveVisualMain); err != nil {
115 | return err
116 | }
117 | return nil
118 | }
119 |
120 | func saveMain(g *gocui.Gui, v *gocui.View) error {
121 | f, err := ioutil.TempFile("", "gocui_demo_")
122 | if err != nil {
123 | return err
124 | }
125 | defer f.Close()
126 |
127 | p := make([]byte, 5)
128 | v.Rewind()
129 | for {
130 | n, err := v.Read(p)
131 | if n > 0 {
132 | if _, err := f.Write(p[:n]); err != nil {
133 | return err
134 | }
135 | }
136 | if err == io.EOF {
137 | break
138 | }
139 | if err != nil {
140 | return err
141 | }
142 | }
143 | return nil
144 | }
145 |
146 | func saveVisualMain(g *gocui.Gui, v *gocui.View) error {
147 | f, err := ioutil.TempFile("", "gocui_demo_")
148 | if err != nil {
149 | return err
150 | }
151 | defer f.Close()
152 |
153 | vb := v.ViewBuffer()
154 | if _, err := io.Copy(f, strings.NewReader(vb)); err != nil {
155 | return err
156 | }
157 | return nil
158 | }
159 |
160 | func layout(g *gocui.Gui) error {
161 | maxX, maxY := g.Size()
162 | if v, err := g.SetView("side", -1, -1, 30, maxY); err != nil {
163 | if err != gocui.ErrUnknownView {
164 | return err
165 | }
166 | v.Highlight = true
167 | v.SelBgColor = gocui.ColorGreen
168 | v.SelFgColor = gocui.ColorBlack
169 | fmt.Fprintln(v, "Item 1")
170 | fmt.Fprintln(v, "Item 2")
171 | fmt.Fprintln(v, "Item 3")
172 | fmt.Fprint(v, "\rWill be")
173 | fmt.Fprint(v, "deleted\rItem 4\nItem 5")
174 | }
175 | if v, err := g.SetView("main", 30, -1, maxX, maxY); err != nil {
176 | if err != gocui.ErrUnknownView {
177 | return err
178 | }
179 | b, err := ioutil.ReadFile("Mark.Twain-Tom.Sawyer.txt")
180 | if err != nil {
181 | panic(err)
182 | }
183 | fmt.Fprintf(v, "%s", b)
184 | v.Editable = true
185 | v.Wrap = true
186 | if _, err := g.SetCurrentView("main"); err != nil {
187 | return err
188 | }
189 | }
190 | return nil
191 | }
192 |
193 | func main() {
194 | g, err := gocui.NewGui(gocui.OutputNormal)
195 | if err != nil {
196 | log.Panicln(err)
197 | }
198 | defer g.Close()
199 |
200 | g.Cursor = true
201 |
202 | g.SetManagerFunc(layout)
203 |
204 | if err := keybindings(g); err != nil {
205 | log.Panicln(err)
206 | }
207 |
208 | if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
209 | log.Panicln(err)
210 | }
211 | }
212 |
--------------------------------------------------------------------------------
/_examples/dynamic.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package main
6 |
7 | import (
8 | "fmt"
9 | "log"
10 | "strings"
11 |
12 | "github.com/jroimartin/gocui"
13 | )
14 |
15 | const delta = 1
16 |
17 | var (
18 | views = []string{}
19 | curView = -1
20 | idxView = 0
21 | )
22 |
23 | func main() {
24 | g, err := gocui.NewGui(gocui.OutputNormal)
25 | if err != nil {
26 | log.Panicln(err)
27 | }
28 | defer g.Close()
29 |
30 | g.Highlight = true
31 | g.SelFgColor = gocui.ColorRed
32 |
33 | g.SetManagerFunc(layout)
34 |
35 | if err := initKeybindings(g); err != nil {
36 | log.Panicln(err)
37 | }
38 | if err := newView(g); err != nil {
39 | log.Panicln(err)
40 | }
41 |
42 | if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
43 | log.Panicln(err)
44 | }
45 | }
46 |
47 | func layout(g *gocui.Gui) error {
48 | maxX, _ := g.Size()
49 | v, err := g.SetView("help", maxX-25, 0, maxX-1, 9)
50 | if err != nil {
51 | if err != gocui.ErrUnknownView {
52 | return err
53 | }
54 | fmt.Fprintln(v, "KEYBINDINGS")
55 | fmt.Fprintln(v, "Space: New View")
56 | fmt.Fprintln(v, "Tab: Next View")
57 | fmt.Fprintln(v, "← ↑ → ↓: Move View")
58 | fmt.Fprintln(v, "Backspace: Delete View")
59 | fmt.Fprintln(v, "t: Set view on top")
60 | fmt.Fprintln(v, "b: Set view on bottom")
61 | fmt.Fprintln(v, "^C: Exit")
62 | }
63 | return nil
64 | }
65 |
66 | func initKeybindings(g *gocui.Gui) error {
67 | if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone,
68 | func(g *gocui.Gui, v *gocui.View) error {
69 | return gocui.ErrQuit
70 | }); err != nil {
71 | return err
72 | }
73 | if err := g.SetKeybinding("", gocui.KeySpace, gocui.ModNone,
74 | func(g *gocui.Gui, v *gocui.View) error {
75 | return newView(g)
76 | }); err != nil {
77 | return err
78 | }
79 | if err := g.SetKeybinding("", gocui.KeyBackspace2, gocui.ModNone,
80 | func(g *gocui.Gui, v *gocui.View) error {
81 | return delView(g)
82 | }); err != nil {
83 | return err
84 | }
85 | if err := g.SetKeybinding("", gocui.KeyTab, gocui.ModNone,
86 | func(g *gocui.Gui, v *gocui.View) error {
87 | return nextView(g, true)
88 | }); err != nil {
89 | return err
90 | }
91 | if err := g.SetKeybinding("", gocui.KeyArrowLeft, gocui.ModNone,
92 | func(g *gocui.Gui, v *gocui.View) error {
93 | return moveView(g, v, -delta, 0)
94 | }); err != nil {
95 | return err
96 | }
97 | if err := g.SetKeybinding("", gocui.KeyArrowRight, gocui.ModNone,
98 | func(g *gocui.Gui, v *gocui.View) error {
99 | return moveView(g, v, delta, 0)
100 | }); err != nil {
101 | return err
102 | }
103 | if err := g.SetKeybinding("", gocui.KeyArrowDown, gocui.ModNone,
104 | func(g *gocui.Gui, v *gocui.View) error {
105 | return moveView(g, v, 0, delta)
106 | }); err != nil {
107 | return err
108 | }
109 | if err := g.SetKeybinding("", gocui.KeyArrowUp, gocui.ModNone,
110 | func(g *gocui.Gui, v *gocui.View) error {
111 | return moveView(g, v, 0, -delta)
112 | }); err != nil {
113 | return err
114 | }
115 | if err := g.SetKeybinding("", 't', gocui.ModNone,
116 | func(g *gocui.Gui, v *gocui.View) error {
117 | _, err := g.SetViewOnTop(views[curView])
118 | return err
119 | }); err != nil {
120 | return err
121 | }
122 | if err := g.SetKeybinding("", 'b', gocui.ModNone,
123 | func(g *gocui.Gui, v *gocui.View) error {
124 | _, err := g.SetViewOnBottom(views[curView])
125 | return err
126 | }); err != nil {
127 | return err
128 | }
129 | return nil
130 | }
131 |
132 | func newView(g *gocui.Gui) error {
133 | maxX, maxY := g.Size()
134 | name := fmt.Sprintf("v%v", idxView)
135 | v, err := g.SetView(name, maxX/2-5, maxY/2-5, maxX/2+5, maxY/2+5)
136 | if err != nil {
137 | if err != gocui.ErrUnknownView {
138 | return err
139 | }
140 | v.Wrap = true
141 | fmt.Fprintln(v, strings.Repeat(name+" ", 30))
142 | }
143 | if _, err := g.SetCurrentView(name); err != nil {
144 | return err
145 | }
146 |
147 | views = append(views, name)
148 | curView = len(views) - 1
149 | idxView += 1
150 | return nil
151 | }
152 |
153 | func delView(g *gocui.Gui) error {
154 | if len(views) <= 1 {
155 | return nil
156 | }
157 |
158 | if err := g.DeleteView(views[curView]); err != nil {
159 | return err
160 | }
161 | views = append(views[:curView], views[curView+1:]...)
162 |
163 | return nextView(g, false)
164 | }
165 |
166 | func nextView(g *gocui.Gui, disableCurrent bool) error {
167 | next := curView + 1
168 | if next > len(views)-1 {
169 | next = 0
170 | }
171 |
172 | if _, err := g.SetCurrentView(views[next]); err != nil {
173 | return err
174 | }
175 |
176 | curView = next
177 | return nil
178 | }
179 |
180 | func moveView(g *gocui.Gui, v *gocui.View, dx, dy int) error {
181 | name := v.Name()
182 | x0, y0, x1, y1, err := g.ViewPosition(name)
183 | if err != nil {
184 | return err
185 | }
186 | if _, err := g.SetView(name, x0+dx, y0+dy, x1+dx, y1+dy); err != nil {
187 | return err
188 | }
189 | return nil
190 | }
191 |
--------------------------------------------------------------------------------
/_examples/flow_layout.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package main
6 |
7 | import (
8 | "fmt"
9 | "log"
10 | "strings"
11 |
12 | "github.com/jroimartin/gocui"
13 | )
14 |
15 | type Label struct {
16 | name string
17 | w, h int
18 | body string
19 | }
20 |
21 | func NewLabel(name string, body string) *Label {
22 | lines := strings.Split(body, "\n")
23 |
24 | w := 0
25 | for _, l := range lines {
26 | if len(l) > w {
27 | w = len(l)
28 | }
29 | }
30 | h := len(lines) + 1
31 | w = w + 1
32 |
33 | return &Label{name: name, w: w, h: h, body: body}
34 | }
35 |
36 | func (w *Label) Layout(g *gocui.Gui) error {
37 | v, err := g.SetView(w.name, 0, 0, w.w, w.h)
38 | if err != nil {
39 | if err != gocui.ErrUnknownView {
40 | return err
41 | }
42 | fmt.Fprint(v, w.body)
43 | }
44 | return nil
45 | }
46 |
47 | func flowLayout(g *gocui.Gui) error {
48 | views := g.Views()
49 | x := 0
50 | for _, v := range views {
51 | w, h := v.Size()
52 | _, err := g.SetView(v.Name(), x, 0, x+w+1, h+1)
53 | if err != nil && err != gocui.ErrUnknownView {
54 | return err
55 | }
56 | x += w + 2
57 | }
58 | return nil
59 | }
60 |
61 | func main() {
62 | g, err := gocui.NewGui(gocui.OutputNormal)
63 | if err != nil {
64 | log.Panicln(err)
65 | }
66 | defer g.Close()
67 |
68 | l1 := NewLabel("l1", "This")
69 | l2 := NewLabel("l2", "is")
70 | l3 := NewLabel("l3", "a")
71 | l4 := NewLabel("l4", "flow\nlayout")
72 | l5 := NewLabel("l5", "!")
73 | fl := gocui.ManagerFunc(flowLayout)
74 | g.SetManager(l1, l2, l3, l4, l5, fl)
75 |
76 | if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
77 | log.Panicln(err)
78 | }
79 |
80 | if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
81 | log.Panicln(err)
82 | }
83 | }
84 |
85 | func quit(g *gocui.Gui, v *gocui.View) error {
86 | return gocui.ErrQuit
87 | }
88 |
--------------------------------------------------------------------------------
/_examples/goroutine.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package main
6 |
7 | import (
8 | "fmt"
9 | "log"
10 | "sync"
11 | "time"
12 |
13 | "github.com/jroimartin/gocui"
14 | )
15 |
16 | const NumGoroutines = 10
17 |
18 | var (
19 | done = make(chan struct{})
20 | wg sync.WaitGroup
21 |
22 | mu sync.Mutex // protects ctr
23 | ctr = 0
24 | )
25 |
26 | func main() {
27 | g, err := gocui.NewGui(gocui.OutputNormal)
28 | if err != nil {
29 | log.Panicln(err)
30 | }
31 | defer g.Close()
32 |
33 | g.SetManagerFunc(layout)
34 |
35 | if err := keybindings(g); err != nil {
36 | log.Panicln(err)
37 | }
38 |
39 | for i := 0; i < NumGoroutines; i++ {
40 | wg.Add(1)
41 | go counter(g)
42 | }
43 |
44 | if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
45 | log.Panicln(err)
46 | }
47 |
48 | wg.Wait()
49 | }
50 |
51 | func layout(g *gocui.Gui) error {
52 | if v, err := g.SetView("ctr", 2, 2, 12, 4); err != nil {
53 | if err != gocui.ErrUnknownView {
54 | return err
55 | }
56 | fmt.Fprintln(v, "0")
57 | }
58 | return nil
59 | }
60 |
61 | func keybindings(g *gocui.Gui) error {
62 | if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
63 | return err
64 | }
65 | return nil
66 | }
67 |
68 | func quit(g *gocui.Gui, v *gocui.View) error {
69 | close(done)
70 | return gocui.ErrQuit
71 | }
72 |
73 | func counter(g *gocui.Gui) {
74 | defer wg.Done()
75 |
76 | for {
77 | select {
78 | case <-done:
79 | return
80 | case <-time.After(500 * time.Millisecond):
81 | mu.Lock()
82 | n := ctr
83 | ctr++
84 | mu.Unlock()
85 |
86 | g.Update(func(g *gocui.Gui) error {
87 | v, err := g.View("ctr")
88 | if err != nil {
89 | return err
90 | }
91 | v.Clear()
92 | fmt.Fprintln(v, n)
93 | return nil
94 | })
95 | }
96 | }
97 | }
98 |
--------------------------------------------------------------------------------
/_examples/hello.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package main
6 |
7 | import (
8 | "fmt"
9 | "log"
10 |
11 | "github.com/jroimartin/gocui"
12 | )
13 |
14 | func main() {
15 | g, err := gocui.NewGui(gocui.OutputNormal)
16 | if err != nil {
17 | log.Panicln(err)
18 | }
19 | defer g.Close()
20 |
21 | g.SetManagerFunc(layout)
22 |
23 | if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
24 | log.Panicln(err)
25 | }
26 |
27 | if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
28 | log.Panicln(err)
29 | }
30 | }
31 |
32 | func layout(g *gocui.Gui) error {
33 | maxX, maxY := g.Size()
34 | if v, err := g.SetView("hello", maxX/2-7, maxY/2, maxX/2+7, maxY/2+2); err != nil {
35 | if err != gocui.ErrUnknownView {
36 | return err
37 | }
38 | fmt.Fprintln(v, "Hello world!")
39 | }
40 | return nil
41 | }
42 |
43 | func quit(g *gocui.Gui, v *gocui.View) error {
44 | return gocui.ErrQuit
45 | }
46 |
--------------------------------------------------------------------------------
/_examples/layout.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package main
6 |
7 | import (
8 | "log"
9 |
10 | "github.com/jroimartin/gocui"
11 | )
12 |
13 | func layout(g *gocui.Gui) error {
14 | maxX, maxY := g.Size()
15 | if _, err := g.SetView("side", -1, -1, int(0.2*float32(maxX)), maxY-5); err != nil &&
16 | err != gocui.ErrUnknownView {
17 | return err
18 | }
19 | if _, err := g.SetView("main", int(0.2*float32(maxX)), -1, maxX, maxY-5); err != nil &&
20 | err != gocui.ErrUnknownView {
21 | return err
22 | }
23 | if _, err := g.SetView("cmdline", -1, maxY-5, maxX, maxY); err != nil &&
24 | err != gocui.ErrUnknownView {
25 | return err
26 | }
27 | return nil
28 | }
29 |
30 | func quit(g *gocui.Gui, v *gocui.View) error {
31 | return gocui.ErrQuit
32 | }
33 |
34 | func main() {
35 | g, err := gocui.NewGui(gocui.OutputNormal)
36 | if err != nil {
37 | log.Panicln(err)
38 | }
39 | defer g.Close()
40 |
41 | g.SetManagerFunc(layout)
42 |
43 | if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
44 | log.Panicln(err)
45 | }
46 |
47 | if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
48 | log.Panicln(err)
49 | }
50 | }
51 |
--------------------------------------------------------------------------------
/_examples/mask.go:
--------------------------------------------------------------------------------
1 | // Copyright 2015 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package main
6 |
7 | import (
8 | "fmt"
9 | "log"
10 |
11 | "github.com/jroimartin/gocui"
12 | )
13 |
14 | func main() {
15 | g, err := gocui.NewGui(gocui.OutputNormal)
16 | if err != nil {
17 | log.Fatalln(err)
18 | }
19 | defer g.Close()
20 |
21 | g.Cursor = true
22 |
23 | g.SetManagerFunc(layout)
24 |
25 | if err := initKeybindings(g); err != nil {
26 | log.Fatalln(err)
27 | }
28 |
29 | if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
30 | log.Fatalln(err)
31 | }
32 | }
33 |
34 | func layout(g *gocui.Gui) error {
35 | maxX, maxY := g.Size()
36 |
37 | if v, err := g.SetView("help", maxX-23, 0, maxX-1, 3); err != nil {
38 | if err != gocui.ErrUnknownView {
39 | return err
40 | }
41 | v.Title = "Keybindings"
42 | fmt.Fprintln(v, "^a: Set mask")
43 | fmt.Fprintln(v, "^c: Exit")
44 | }
45 |
46 | if v, err := g.SetView("input", 0, 0, maxX-24, maxY-1); err != nil {
47 | if err != gocui.ErrUnknownView {
48 | return err
49 | }
50 | if _, err := g.SetCurrentView("input"); err != nil {
51 | return err
52 | }
53 | v.Editable = true
54 | v.Wrap = true
55 | }
56 |
57 | return nil
58 | }
59 |
60 | func initKeybindings(g *gocui.Gui) error {
61 | if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone,
62 | func(g *gocui.Gui, v *gocui.View) error {
63 | return gocui.ErrQuit
64 | }); err != nil {
65 | return err
66 | }
67 | if err := g.SetKeybinding("input", gocui.KeyCtrlA, gocui.ModNone,
68 | func(g *gocui.Gui, v *gocui.View) error {
69 | v.Mask ^= '*'
70 | return nil
71 | }); err != nil {
72 | return err
73 | }
74 | return nil
75 | }
76 |
--------------------------------------------------------------------------------
/_examples/mouse.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package main
6 |
7 | import (
8 | "fmt"
9 | "log"
10 |
11 | "github.com/jroimartin/gocui"
12 | )
13 |
14 | func main() {
15 | g, err := gocui.NewGui(gocui.OutputNormal)
16 | if err != nil {
17 | log.Panicln(err)
18 | }
19 | defer g.Close()
20 |
21 | g.Cursor = true
22 | g.Mouse = true
23 |
24 | g.SetManagerFunc(layout)
25 |
26 | if err := keybindings(g); err != nil {
27 | log.Panicln(err)
28 | }
29 |
30 | if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
31 | log.Panicln(err)
32 | }
33 | }
34 |
35 | func layout(g *gocui.Gui) error {
36 | if v, err := g.SetView("but1", 2, 2, 22, 7); err != nil {
37 | if err != gocui.ErrUnknownView {
38 | return err
39 | }
40 | v.Highlight = true
41 | v.SelBgColor = gocui.ColorGreen
42 | v.SelFgColor = gocui.ColorBlack
43 | fmt.Fprintln(v, "Button 1 - line 1")
44 | fmt.Fprintln(v, "Button 1 - line 2")
45 | fmt.Fprintln(v, "Button 1 - line 3")
46 | fmt.Fprintln(v, "Button 1 - line 4")
47 | }
48 | if v, err := g.SetView("but2", 24, 2, 44, 4); err != nil {
49 | if err != gocui.ErrUnknownView {
50 | return err
51 | }
52 | v.Highlight = true
53 | v.SelBgColor = gocui.ColorGreen
54 | v.SelFgColor = gocui.ColorBlack
55 | fmt.Fprintln(v, "Button 2 - line 1")
56 | }
57 | return nil
58 | }
59 |
60 | func keybindings(g *gocui.Gui) error {
61 | if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
62 | return err
63 | }
64 | for _, n := range []string{"but1", "but2"} {
65 | if err := g.SetKeybinding(n, gocui.MouseLeft, gocui.ModNone, showMsg); err != nil {
66 | return err
67 | }
68 | }
69 | if err := g.SetKeybinding("msg", gocui.MouseLeft, gocui.ModNone, delMsg); err != nil {
70 | return err
71 | }
72 | return nil
73 | }
74 |
75 | func quit(g *gocui.Gui, v *gocui.View) error {
76 | return gocui.ErrQuit
77 | }
78 |
79 | func showMsg(g *gocui.Gui, v *gocui.View) error {
80 | var l string
81 | var err error
82 |
83 | if _, err := g.SetCurrentView(v.Name()); err != nil {
84 | return err
85 | }
86 |
87 | _, cy := v.Cursor()
88 | if l, err = v.Line(cy); err != nil {
89 | l = ""
90 | }
91 |
92 | maxX, maxY := g.Size()
93 | if v, err := g.SetView("msg", maxX/2-10, maxY/2, maxX/2+10, maxY/2+2); err != nil {
94 | if err != gocui.ErrUnknownView {
95 | return err
96 | }
97 | fmt.Fprintln(v, l)
98 | }
99 | return nil
100 | }
101 |
102 | func delMsg(g *gocui.Gui, v *gocui.View) error {
103 | if err := g.DeleteView("msg"); err != nil {
104 | return err
105 | }
106 | return nil
107 | }
108 |
--------------------------------------------------------------------------------
/_examples/ontop.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package main
6 |
7 | import (
8 | "fmt"
9 | "log"
10 |
11 | "github.com/jroimartin/gocui"
12 | )
13 |
14 | func main() {
15 | g, err := gocui.NewGui(gocui.OutputNormal)
16 | if err != nil {
17 | log.Panicln(err)
18 | }
19 | defer g.Close()
20 |
21 | g.SetManagerFunc(layout)
22 |
23 | if err := keybindings(g); err != nil {
24 | log.Panicln(err)
25 | }
26 |
27 | if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
28 | log.Panicln(err)
29 | }
30 | }
31 |
32 | func layout(g *gocui.Gui) error {
33 | if v, err := g.SetView("v1", 10, 2, 30, 6); err != nil {
34 | if err != gocui.ErrUnknownView {
35 | return err
36 | }
37 | fmt.Fprintln(v, "View #1")
38 | }
39 | if v, err := g.SetView("v2", 20, 4, 40, 8); err != nil {
40 | if err != gocui.ErrUnknownView {
41 | return err
42 | }
43 | fmt.Fprintln(v, "View #2")
44 | }
45 | if v, err := g.SetView("v3", 30, 6, 50, 10); err != nil {
46 | if err != gocui.ErrUnknownView {
47 | return err
48 | }
49 | fmt.Fprintln(v, "View #3")
50 | }
51 |
52 | return nil
53 | }
54 |
55 | func keybindings(g *gocui.Gui) error {
56 | err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, func(g *gocui.Gui, v *gocui.View) error {
57 | return gocui.ErrQuit
58 | })
59 | if err != nil {
60 | return err
61 | }
62 |
63 | err = g.SetKeybinding("", '1', gocui.ModNone, func(g *gocui.Gui, v *gocui.View) error {
64 | _, err := g.SetViewOnTop("v1")
65 | return err
66 | })
67 | if err != nil {
68 | return err
69 | }
70 |
71 | err = g.SetKeybinding("", '2', gocui.ModNone, func(g *gocui.Gui, v *gocui.View) error {
72 | _, err := g.SetViewOnTop("v2")
73 | return err
74 | })
75 | if err != nil {
76 | return err
77 | }
78 |
79 | err = g.SetKeybinding("", '3', gocui.ModNone, func(g *gocui.Gui, v *gocui.View) error {
80 | _, err := g.SetViewOnTop("v3")
81 | return err
82 | })
83 | if err != nil {
84 | return err
85 | }
86 |
87 | return nil
88 | }
89 |
--------------------------------------------------------------------------------
/_examples/overlap.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package main
6 |
7 | import (
8 | "log"
9 |
10 | "github.com/jroimartin/gocui"
11 | )
12 |
13 | func layout(g *gocui.Gui) error {
14 | maxX, maxY := g.Size()
15 | if _, err := g.SetView("v1", -1, -1, 10, 10); err != nil &&
16 | err != gocui.ErrUnknownView {
17 | return err
18 | }
19 | if _, err := g.SetView("v2", maxX-10, -1, maxX, 10); err != nil &&
20 | err != gocui.ErrUnknownView {
21 | return err
22 | }
23 | if _, err := g.SetView("v3", maxX/2-5, -1, maxX/2+5, 10); err != nil &&
24 | err != gocui.ErrUnknownView {
25 | return err
26 | }
27 | if _, err := g.SetView("v4", -1, maxY/2-5, 10, maxY/2+5); err != nil &&
28 | err != gocui.ErrUnknownView {
29 | return err
30 | }
31 | if _, err := g.SetView("v5", maxX-10, maxY/2-5, maxX, maxY/2+5); err != nil &&
32 | err != gocui.ErrUnknownView {
33 | return err
34 | }
35 | if _, err := g.SetView("v6", -1, maxY-10, 10, maxY); err != nil &&
36 | err != gocui.ErrUnknownView {
37 | return err
38 | }
39 | if _, err := g.SetView("v7", maxX-10, maxY-10, maxX, maxY); err != nil &&
40 | err != gocui.ErrUnknownView {
41 | return err
42 | }
43 | if _, err := g.SetView("v8", maxX/2-5, maxY-10, maxX/2+5, maxY); err != nil &&
44 | err != gocui.ErrUnknownView {
45 | return err
46 | }
47 | if _, err := g.SetView("v9", maxX/2-5, maxY/2-5, maxX/2+5, maxY/2+5); err != nil &&
48 | err != gocui.ErrUnknownView {
49 | return err
50 | }
51 | return nil
52 | }
53 |
54 | func quit(g *gocui.Gui, v *gocui.View) error {
55 | return gocui.ErrQuit
56 | }
57 |
58 | func main() {
59 | g, err := gocui.NewGui(gocui.OutputNormal)
60 | if err != nil {
61 | log.Panicln(err)
62 | }
63 | defer g.Close()
64 |
65 | g.SetManagerFunc(layout)
66 |
67 | if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
68 | log.Panicln(err)
69 | }
70 |
71 | if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
72 | log.Panicln(err)
73 | }
74 | }
75 |
--------------------------------------------------------------------------------
/_examples/size.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package main
6 |
7 | import (
8 | "fmt"
9 | "log"
10 |
11 | "github.com/jroimartin/gocui"
12 | )
13 |
14 | func main() {
15 | g, err := gocui.NewGui(gocui.OutputNormal)
16 | if err != nil {
17 | log.Panicln(err)
18 | }
19 | defer g.Close()
20 |
21 | g.SetManagerFunc(layout)
22 |
23 | if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
24 | log.Panicln(err)
25 | }
26 |
27 | if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
28 | log.Panicln(err)
29 | }
30 | }
31 |
32 | func layout(g *gocui.Gui) error {
33 | maxX, maxY := g.Size()
34 | v, err := g.SetView("size", maxX/2-7, maxY/2, maxX/2+7, maxY/2+2)
35 | if err != nil && err != gocui.ErrUnknownView {
36 | return err
37 | }
38 | v.Clear()
39 | fmt.Fprintf(v, "%d, %d", maxX, maxY)
40 | return nil
41 | }
42 |
43 | func quit(g *gocui.Gui, v *gocui.View) error {
44 | return gocui.ErrQuit
45 | }
46 |
--------------------------------------------------------------------------------
/_examples/stdin.go:
--------------------------------------------------------------------------------
1 | // Copyright 2015 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package main
6 |
7 | import (
8 | "encoding/hex"
9 | "fmt"
10 | "io"
11 | "log"
12 | "os"
13 |
14 | "github.com/jroimartin/gocui"
15 | )
16 |
17 | func main() {
18 | g, err := gocui.NewGui(gocui.OutputNormal)
19 | if err != nil {
20 | log.Fatalln(err)
21 | }
22 | defer g.Close()
23 |
24 | g.Cursor = true
25 |
26 | g.SetManagerFunc(layout)
27 |
28 | if err := initKeybindings(g); err != nil {
29 | log.Fatalln(err)
30 | }
31 |
32 | if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
33 | log.Fatalln(err)
34 | }
35 | }
36 |
37 | func layout(g *gocui.Gui) error {
38 | maxX, _ := g.Size()
39 |
40 | if v, err := g.SetView("help", maxX-23, 0, maxX-1, 5); err != nil {
41 | if err != gocui.ErrUnknownView {
42 | return err
43 | }
44 | fmt.Fprintln(v, "KEYBINDINGS")
45 | fmt.Fprintln(v, "↑ ↓: Seek input")
46 | fmt.Fprintln(v, "a: Enable autoscroll")
47 | fmt.Fprintln(v, "^C: Exit")
48 | }
49 |
50 | if v, err := g.SetView("stdin", 0, 0, 80, 35); err != nil {
51 | if err != gocui.ErrUnknownView {
52 | return err
53 | }
54 | if _, err := g.SetCurrentView("stdin"); err != nil {
55 | return err
56 | }
57 | dumper := hex.Dumper(v)
58 | if _, err := io.Copy(dumper, os.Stdin); err != nil {
59 | return err
60 | }
61 | v.Wrap = true
62 | }
63 |
64 | return nil
65 | }
66 |
67 | func initKeybindings(g *gocui.Gui) error {
68 | if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
69 | return err
70 | }
71 | if err := g.SetKeybinding("stdin", 'a', gocui.ModNone, autoscroll); err != nil {
72 | return err
73 | }
74 | if err := g.SetKeybinding("stdin", gocui.KeyArrowUp, gocui.ModNone,
75 | func(g *gocui.Gui, v *gocui.View) error {
76 | scrollView(v, -1)
77 | return nil
78 | }); err != nil {
79 | return err
80 | }
81 | if err := g.SetKeybinding("stdin", gocui.KeyArrowDown, gocui.ModNone,
82 | func(g *gocui.Gui, v *gocui.View) error {
83 | scrollView(v, 1)
84 | return nil
85 | }); err != nil {
86 | return err
87 | }
88 | return nil
89 | }
90 |
91 | func quit(g *gocui.Gui, v *gocui.View) error {
92 | return gocui.ErrQuit
93 | }
94 |
95 | func autoscroll(g *gocui.Gui, v *gocui.View) error {
96 | v.Autoscroll = true
97 | return nil
98 | }
99 |
100 | func scrollView(v *gocui.View, dy int) error {
101 | if v != nil {
102 | v.Autoscroll = false
103 | ox, oy := v.Origin()
104 | if err := v.SetOrigin(ox, oy+dy); err != nil {
105 | return err
106 | }
107 | }
108 | return nil
109 | }
110 |
--------------------------------------------------------------------------------
/_examples/title.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package main
6 |
7 | import (
8 | "log"
9 |
10 | "github.com/jroimartin/gocui"
11 | )
12 |
13 | func main() {
14 | g, err := gocui.NewGui(gocui.OutputNormal)
15 | if err != nil {
16 | log.Panicln(err)
17 | }
18 | defer g.Close()
19 |
20 | g.SetManagerFunc(layout)
21 |
22 | if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
23 | log.Panicln(err)
24 | }
25 |
26 | if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
27 | log.Panicln(err)
28 | }
29 | }
30 |
31 | func quit(g *gocui.Gui, v *gocui.View) error {
32 | return gocui.ErrQuit
33 | }
34 |
35 | func layout(g *gocui.Gui) error {
36 | maxX, maxY := g.Size()
37 |
38 | // Overlap (front)
39 | if v, err := g.SetView("v1", 10, 2, 30, 6); err != nil {
40 | if err != gocui.ErrUnknownView {
41 | return err
42 | }
43 | v.Title = "Regular title"
44 | }
45 | if v, err := g.SetView("v2", 20, 4, 40, 8); err != nil {
46 | if err != gocui.ErrUnknownView {
47 | return err
48 | }
49 | v.Title = "Regular title"
50 | }
51 |
52 | // Overlap (back)
53 | if v, err := g.SetView("v3", 60, 4, 80, 8); err != nil {
54 | if err != gocui.ErrUnknownView {
55 | return err
56 | }
57 | v.Title = "Regular title"
58 | }
59 | if v, err := g.SetView("v4", 50, 2, 70, 6); err != nil {
60 | if err != gocui.ErrUnknownView {
61 | return err
62 | }
63 | v.Title = "Regular title"
64 | }
65 |
66 | // Overlap (frame)
67 | if v, err := g.SetView("v15", 90, 2, 110, 5); err != nil {
68 | if err != gocui.ErrUnknownView {
69 | return err
70 | }
71 | v.Title = "Regular title"
72 | }
73 | if v, err := g.SetView("v16", 100, 5, 120, 8); err != nil {
74 | if err != gocui.ErrUnknownView {
75 | return err
76 | }
77 | v.Title = "Regular title"
78 | }
79 | if v, err := g.SetView("v17", 140, 5, 160, 8); err != nil {
80 | if err != gocui.ErrUnknownView {
81 | return err
82 | }
83 | v.Title = "Regular title"
84 | }
85 | if v, err := g.SetView("v18", 130, 2, 150, 5); err != nil {
86 | if err != gocui.ErrUnknownView {
87 | return err
88 | }
89 | v.Title = "Regular title"
90 | }
91 |
92 | // Long title
93 | if v, err := g.SetView("v5", 10, 12, 30, 16); err != nil {
94 | if err != gocui.ErrUnknownView {
95 | return err
96 | }
97 | v.Title = "Long long long long title"
98 | }
99 |
100 | // No title
101 | if v, err := g.SetView("v6", 35, 12, 55, 16); err != nil {
102 | if err != gocui.ErrUnknownView {
103 | return err
104 | }
105 | v.Title = ""
106 | }
107 | if _, err := g.SetView("v7", 60, 12, 80, 16); err != nil {
108 | if err != gocui.ErrUnknownView {
109 | return err
110 | }
111 | }
112 |
113 | // Small view
114 | if v, err := g.SetView("v8", 85, 12, 88, 16); err != nil {
115 | if err != gocui.ErrUnknownView {
116 | return err
117 | }
118 | v.Title = "Regular title"
119 | }
120 |
121 | // Screen borders
122 | if v, err := g.SetView("v9", -10, 20, 10, 24); err != nil {
123 | if err != gocui.ErrUnknownView {
124 | return err
125 | }
126 | v.Title = "Regular title"
127 | }
128 | if v, err := g.SetView("v10", maxX-10, 20, maxX+10, 24); err != nil {
129 | if err != gocui.ErrUnknownView {
130 | return err
131 | }
132 | v.Title = "Regular title"
133 | }
134 |
135 | // Out of screen
136 | if v, err := g.SetView("v11", -21, 28, -1, 32); err != nil {
137 | if err != gocui.ErrUnknownView {
138 | return err
139 | }
140 | v.Title = "Regular title"
141 | }
142 | if v, err := g.SetView("v12", maxX, 28, maxX+20, 32); err != nil {
143 | if err != gocui.ErrUnknownView {
144 | return err
145 | }
146 | v.Title = "Regular title"
147 | }
148 | if v, err := g.SetView("v13", 10, -7, 30, -1); err != nil {
149 | if err != gocui.ErrUnknownView {
150 | return err
151 | }
152 | v.Title = "Regular title"
153 | }
154 | if v, err := g.SetView("v14", 10, maxY, 30, maxY+6); err != nil {
155 | if err != gocui.ErrUnknownView {
156 | return err
157 | }
158 | v.Title = "Regular title"
159 | }
160 |
161 | return nil
162 | }
163 |
--------------------------------------------------------------------------------
/_examples/widgets.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package main
6 |
7 | import (
8 | "errors"
9 | "fmt"
10 | "log"
11 | "strings"
12 |
13 | "github.com/jroimartin/gocui"
14 | )
15 |
16 | const delta = 0.2
17 |
18 | type HelpWidget struct {
19 | name string
20 | x, y int
21 | w, h int
22 | body string
23 | }
24 |
25 | func NewHelpWidget(name string, x, y int, body string) *HelpWidget {
26 | lines := strings.Split(body, "\n")
27 |
28 | w := 0
29 | for _, l := range lines {
30 | if len(l) > w {
31 | w = len(l)
32 | }
33 | }
34 | h := len(lines) + 1
35 | w = w + 1
36 |
37 | return &HelpWidget{name: name, x: x, y: y, w: w, h: h, body: body}
38 | }
39 |
40 | func (w *HelpWidget) Layout(g *gocui.Gui) error {
41 | v, err := g.SetView(w.name, w.x, w.y, w.x+w.w, w.y+w.h)
42 | if err != nil {
43 | if err != gocui.ErrUnknownView {
44 | return err
45 | }
46 | fmt.Fprint(v, w.body)
47 | }
48 | return nil
49 | }
50 |
51 | type StatusbarWidget struct {
52 | name string
53 | x, y int
54 | w int
55 | val float64
56 | }
57 |
58 | func NewStatusbarWidget(name string, x, y, w int) *StatusbarWidget {
59 | return &StatusbarWidget{name: name, x: x, y: y, w: w}
60 | }
61 |
62 | func (w *StatusbarWidget) SetVal(val float64) error {
63 | if val < 0 || val > 1 {
64 | return errors.New("invalid value")
65 | }
66 | w.val = val
67 | return nil
68 | }
69 |
70 | func (w *StatusbarWidget) Val() float64 {
71 | return w.val
72 | }
73 |
74 | func (w *StatusbarWidget) Layout(g *gocui.Gui) error {
75 | v, err := g.SetView(w.name, w.x, w.y, w.x+w.w, w.y+2)
76 | if err != nil && err != gocui.ErrUnknownView {
77 | return err
78 | }
79 | v.Clear()
80 |
81 | rep := int(w.val * float64(w.w-1))
82 | fmt.Fprint(v, strings.Repeat("▒", rep))
83 | return nil
84 | }
85 |
86 | type ButtonWidget struct {
87 | name string
88 | x, y int
89 | w int
90 | label string
91 | handler func(g *gocui.Gui, v *gocui.View) error
92 | }
93 |
94 | func NewButtonWidget(name string, x, y int, label string, handler func(g *gocui.Gui, v *gocui.View) error) *ButtonWidget {
95 | return &ButtonWidget{name: name, x: x, y: y, w: len(label) + 1, label: label, handler: handler}
96 | }
97 |
98 | func (w *ButtonWidget) Layout(g *gocui.Gui) error {
99 | v, err := g.SetView(w.name, w.x, w.y, w.x+w.w, w.y+2)
100 | if err != nil {
101 | if err != gocui.ErrUnknownView {
102 | return err
103 | }
104 | if _, err := g.SetCurrentView(w.name); err != nil {
105 | return err
106 | }
107 | if err := g.SetKeybinding(w.name, gocui.KeyEnter, gocui.ModNone, w.handler); err != nil {
108 | return err
109 | }
110 | fmt.Fprint(v, w.label)
111 | }
112 | return nil
113 | }
114 |
115 | func main() {
116 | g, err := gocui.NewGui(gocui.OutputNormal)
117 | if err != nil {
118 | log.Panicln(err)
119 | }
120 | defer g.Close()
121 |
122 | g.Highlight = true
123 | g.SelFgColor = gocui.ColorRed
124 |
125 | help := NewHelpWidget("help", 1, 1, helpText)
126 | status := NewStatusbarWidget("status", 1, 7, 50)
127 | butdown := NewButtonWidget("butdown", 52, 7, "DOWN", statusDown(status))
128 | butup := NewButtonWidget("butup", 58, 7, "UP", statusUp(status))
129 | g.SetManager(help, status, butdown, butup)
130 |
131 | if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
132 | log.Panicln(err)
133 | }
134 | if err := g.SetKeybinding("", gocui.KeyTab, gocui.ModNone, toggleButton); err != nil {
135 | log.Panicln(err)
136 | }
137 |
138 | if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
139 | log.Panicln(err)
140 | }
141 | }
142 |
143 | func quit(g *gocui.Gui, v *gocui.View) error {
144 | return gocui.ErrQuit
145 | }
146 |
147 | func toggleButton(g *gocui.Gui, v *gocui.View) error {
148 | nextview := "butdown"
149 | if v != nil && v.Name() == "butdown" {
150 | nextview = "butup"
151 | }
152 | _, err := g.SetCurrentView(nextview)
153 | return err
154 | }
155 |
156 | func statusUp(status *StatusbarWidget) func(g *gocui.Gui, v *gocui.View) error {
157 | return func(g *gocui.Gui, v *gocui.View) error {
158 | return statusSet(status, delta)
159 | }
160 | }
161 |
162 | func statusDown(status *StatusbarWidget) func(g *gocui.Gui, v *gocui.View) error {
163 | return func(g *gocui.Gui, v *gocui.View) error {
164 | return statusSet(status, -delta)
165 | }
166 | }
167 |
168 | func statusSet(sw *StatusbarWidget, inc float64) error {
169 | val := sw.Val() + inc
170 | if val < 0 || val > 1 {
171 | return nil
172 | }
173 | return sw.SetVal(val)
174 | }
175 |
176 | const helpText = `KEYBINDINGS
177 | Tab: Move between buttons
178 | Enter: Push button
179 | ^C: Exit`
180 |
--------------------------------------------------------------------------------
/_examples/wrap.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package main
6 |
7 | import (
8 | "fmt"
9 | "log"
10 | "strings"
11 |
12 | "github.com/jroimartin/gocui"
13 | )
14 |
15 | func layout(g *gocui.Gui) error {
16 | maxX, maxY := g.Size()
17 | if v, err := g.SetView("main", 1, 1, maxX-1, maxY-1); err != nil {
18 | if err != gocui.ErrUnknownView {
19 | return err
20 | }
21 | v.Wrap = true
22 |
23 | line := strings.Repeat("This is a long line -- ", 10)
24 | fmt.Fprintf(v, "%s\n\n", line)
25 | fmt.Fprintln(v, "Short")
26 | }
27 | return nil
28 | }
29 |
30 | func quit(g *gocui.Gui, v *gocui.View) error {
31 | return gocui.ErrQuit
32 | }
33 |
34 | func main() {
35 | g, err := gocui.NewGui(gocui.OutputNormal)
36 | if err != nil {
37 | log.Panicln(err)
38 | }
39 | defer g.Close()
40 |
41 | g.SetManagerFunc(layout)
42 |
43 | if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
44 | log.Panicln(err)
45 | }
46 |
47 | if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
48 | log.Panicln(err)
49 | }
50 | }
51 |
--------------------------------------------------------------------------------
/attribute.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package gocui
6 |
7 | import "github.com/nsf/termbox-go"
8 |
9 | // Attribute represents a terminal attribute, like color, font style, etc. They
10 | // can be combined using bitwise OR (|). Note that it is not possible to
11 | // combine multiple color attributes.
12 | type Attribute termbox.Attribute
13 |
14 | // Color attributes.
15 | const (
16 | ColorDefault Attribute = Attribute(termbox.ColorDefault)
17 | ColorBlack = Attribute(termbox.ColorBlack)
18 | ColorRed = Attribute(termbox.ColorRed)
19 | ColorGreen = Attribute(termbox.ColorGreen)
20 | ColorYellow = Attribute(termbox.ColorYellow)
21 | ColorBlue = Attribute(termbox.ColorBlue)
22 | ColorMagenta = Attribute(termbox.ColorMagenta)
23 | ColorCyan = Attribute(termbox.ColorCyan)
24 | ColorWhite = Attribute(termbox.ColorWhite)
25 | )
26 |
27 | // Text style attributes.
28 | const (
29 | AttrBold Attribute = Attribute(termbox.AttrBold)
30 | AttrUnderline = Attribute(termbox.AttrUnderline)
31 | AttrReverse = Attribute(termbox.AttrReverse)
32 | )
33 |
--------------------------------------------------------------------------------
/doc.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | /*
6 | Package gocui allows to create console user interfaces.
7 |
8 | Create a new GUI:
9 |
10 | g, err := gocui.NewGui(gocui.OutputNormal)
11 | if err != nil {
12 | // handle error
13 | }
14 | defer g.Close()
15 |
16 | // Set GUI managers and key bindings
17 | // ...
18 |
19 | if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
20 | // handle error
21 | }
22 |
23 | Set GUI managers:
24 |
25 | g.SetManager(mgr1, mgr2)
26 |
27 | Managers are in charge of GUI's layout and can be used to build widgets. On
28 | each iteration of the GUI's main loop, the Layout function of each configured
29 | manager is executed. Managers are used to set-up and update the application's
30 | main views, being possible to freely change them during execution. Also, it is
31 | important to mention that a main loop iteration is executed on each reported
32 | event (key-press, mouse event, window resize, etc).
33 |
34 | GUIs are composed by Views, you can think of it as buffers. Views implement the
35 | io.ReadWriter interface, so you can just write to them if you want to modify
36 | their content. The same is valid for reading.
37 |
38 | Create and initialize a view with absolute coordinates:
39 |
40 | if v, err := g.SetView("viewname", 2, 2, 22, 7); err != nil {
41 | if err != gocui.ErrUnknownView {
42 | // handle error
43 | }
44 | fmt.Fprintln(v, "This is a new view")
45 | // ...
46 | }
47 |
48 | Views can also be created using relative coordinates:
49 |
50 | maxX, maxY := g.Size()
51 | if v, err := g.SetView("viewname", maxX/2-30, maxY/2, maxX/2+30, maxY/2+2); err != nil {
52 | // ...
53 | }
54 |
55 | Configure keybindings:
56 |
57 | if err := g.SetKeybinding("viewname", gocui.KeyEnter, gocui.ModNone, fcn); err != nil {
58 | // handle error
59 | }
60 |
61 | gocui implements full mouse support that can be enabled with:
62 |
63 | g.Mouse = true
64 |
65 | Mouse events are handled like any other keybinding:
66 |
67 | if err := g.SetKeybinding("viewname", gocui.MouseLeft, gocui.ModNone, fcn); err != nil {
68 | // handle error
69 | }
70 |
71 | IMPORTANT: Views can only be created, destroyed or updated in three ways: from
72 | the Layout function within managers, from keybinding callbacks or via
73 | *Gui.Update(). The reason for this is that it allows gocui to be
74 | concurrent-safe. So, if you want to update your GUI from a goroutine, you must
75 | use *Gui.Update(). For example:
76 |
77 | g.Update(func(g *gocui.Gui) error {
78 | v, err := g.View("viewname")
79 | if err != nil {
80 | // handle error
81 | }
82 | v.Clear()
83 | fmt.Fprintln(v, "Writing from different goroutines")
84 | return nil
85 | })
86 |
87 | By default, gocui provides a basic edition mode. This mode can be extended
88 | and customized creating a new Editor and assigning it to *View.Editor:
89 |
90 | type Editor interface {
91 | Edit(v *View, key Key, ch rune, mod Modifier)
92 | }
93 |
94 | DefaultEditor can be taken as example to create your own custom Editor:
95 |
96 | var DefaultEditor Editor = EditorFunc(simpleEditor)
97 |
98 | func simpleEditor(v *View, key Key, ch rune, mod Modifier) {
99 | switch {
100 | case ch != 0 && mod == 0:
101 | v.EditWrite(ch)
102 | case key == KeySpace:
103 | v.EditWrite(' ')
104 | case key == KeyBackspace || key == KeyBackspace2:
105 | v.EditDelete(true)
106 | // ...
107 | }
108 | }
109 |
110 | Colored text:
111 |
112 | Views allow to add colored text using ANSI colors. For example:
113 |
114 | fmt.Fprintln(v, "\x1b[0;31mHello world")
115 |
116 | For more information, see the examples in folder "_examples/".
117 | */
118 | package gocui
119 |
--------------------------------------------------------------------------------
/edit.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package gocui
6 |
7 | import "errors"
8 |
9 | const maxInt = int(^uint(0) >> 1)
10 |
11 | // Editor interface must be satisfied by gocui editors.
12 | type Editor interface {
13 | Edit(v *View, key Key, ch rune, mod Modifier)
14 | }
15 |
16 | // The EditorFunc type is an adapter to allow the use of ordinary functions as
17 | // Editors. If f is a function with the appropriate signature, EditorFunc(f)
18 | // is an Editor object that calls f.
19 | type EditorFunc func(v *View, key Key, ch rune, mod Modifier)
20 |
21 | // Edit calls f(v, key, ch, mod)
22 | func (f EditorFunc) Edit(v *View, key Key, ch rune, mod Modifier) {
23 | f(v, key, ch, mod)
24 | }
25 |
26 | // DefaultEditor is the default editor.
27 | var DefaultEditor Editor = EditorFunc(simpleEditor)
28 |
29 | // simpleEditor is used as the default gocui editor.
30 | func simpleEditor(v *View, key Key, ch rune, mod Modifier) {
31 | switch {
32 | case ch != 0 && mod == 0:
33 | v.EditWrite(ch)
34 | case key == KeySpace:
35 | v.EditWrite(' ')
36 | case key == KeyBackspace || key == KeyBackspace2:
37 | v.EditDelete(true)
38 | case key == KeyDelete:
39 | v.EditDelete(false)
40 | case key == KeyInsert:
41 | v.Overwrite = !v.Overwrite
42 | case key == KeyEnter:
43 | v.EditNewLine()
44 | case key == KeyArrowDown:
45 | v.MoveCursor(0, 1, false)
46 | case key == KeyArrowUp:
47 | v.MoveCursor(0, -1, false)
48 | case key == KeyArrowLeft:
49 | v.MoveCursor(-1, 0, false)
50 | case key == KeyArrowRight:
51 | v.MoveCursor(1, 0, false)
52 | }
53 | }
54 |
55 | // EditWrite writes a rune at the cursor position.
56 | func (v *View) EditWrite(ch rune) {
57 | v.writeRune(v.cx, v.cy, ch)
58 | v.MoveCursor(1, 0, true)
59 | }
60 |
61 | // EditDelete deletes a rune at the cursor position. back determines the
62 | // direction.
63 | func (v *View) EditDelete(back bool) {
64 | x, y := v.ox+v.cx, v.oy+v.cy
65 | if y < 0 {
66 | return
67 | } else if y >= len(v.viewLines) {
68 | v.MoveCursor(-1, 0, true)
69 | return
70 | }
71 |
72 | maxX, _ := v.Size()
73 | if back {
74 | if x == 0 { // start of the line
75 | if y < 1 {
76 | return
77 | }
78 |
79 | var maxPrevWidth int
80 | if v.Wrap {
81 | maxPrevWidth = maxX
82 | } else {
83 | maxPrevWidth = maxInt
84 | }
85 |
86 | if v.viewLines[y].linesX == 0 { // regular line
87 | v.mergeLines(v.cy - 1)
88 | if len(v.viewLines[y-1].line) < maxPrevWidth {
89 | v.MoveCursor(-1, 0, true)
90 | }
91 | } else { // wrapped line
92 | v.deleteRune(len(v.viewLines[y-1].line)-1, v.cy-1)
93 | v.MoveCursor(-1, 0, true)
94 | }
95 | } else { // middle/end of the line
96 | v.deleteRune(v.cx-1, v.cy)
97 | v.MoveCursor(-1, 0, true)
98 | }
99 | } else {
100 | if x == len(v.viewLines[y].line) { // end of the line
101 | v.mergeLines(v.cy)
102 | } else { // start/middle of the line
103 | v.deleteRune(v.cx, v.cy)
104 | }
105 | }
106 | }
107 |
108 | // EditNewLine inserts a new line under the cursor.
109 | func (v *View) EditNewLine() {
110 | v.breakLine(v.cx, v.cy)
111 | v.ox = 0
112 | v.cx = 0
113 | v.MoveCursor(0, 1, true)
114 | }
115 |
116 | // MoveCursor moves the cursor taking into account the width of the line/view,
117 | // displacing the origin if necessary.
118 | func (v *View) MoveCursor(dx, dy int, writeMode bool) {
119 | maxX, maxY := v.Size()
120 | cx, cy := v.cx+dx, v.cy+dy
121 | x, y := v.ox+cx, v.oy+cy
122 |
123 | var curLineWidth, prevLineWidth int
124 | // get the width of the current line
125 | if writeMode {
126 | if v.Wrap {
127 | curLineWidth = maxX - 1
128 | } else {
129 | curLineWidth = maxInt
130 | }
131 | } else {
132 | if y >= 0 && y < len(v.viewLines) {
133 | curLineWidth = len(v.viewLines[y].line)
134 | if v.Wrap && curLineWidth >= maxX {
135 | curLineWidth = maxX - 1
136 | }
137 | } else {
138 | curLineWidth = 0
139 | }
140 | }
141 | // get the width of the previous line
142 | if y-1 >= 0 && y-1 < len(v.viewLines) {
143 | prevLineWidth = len(v.viewLines[y-1].line)
144 | } else {
145 | prevLineWidth = 0
146 | }
147 |
148 | // adjust cursor's x position and view's x origin
149 | if x > curLineWidth { // move to next line
150 | if dx > 0 { // horizontal movement
151 | cy++
152 | if writeMode || v.oy+cy < len(v.viewLines) {
153 | if !v.Wrap {
154 | v.ox = 0
155 | }
156 | v.cx = 0
157 | }
158 | } else { // vertical movement
159 | if curLineWidth > 0 { // move cursor to the EOL
160 | if v.Wrap {
161 | v.cx = curLineWidth
162 | } else {
163 | ncx := curLineWidth - v.ox
164 | if ncx < 0 {
165 | v.ox += ncx
166 | if v.ox < 0 {
167 | v.ox = 0
168 | }
169 | v.cx = 0
170 | } else {
171 | v.cx = ncx
172 | }
173 | }
174 | } else {
175 | if writeMode || v.oy+cy < len(v.viewLines) {
176 | if !v.Wrap {
177 | v.ox = 0
178 | }
179 | v.cx = 0
180 | }
181 | }
182 | }
183 | } else if cx < 0 {
184 | if !v.Wrap && v.ox > 0 { // move origin to the left
185 | v.ox += cx
186 | v.cx = 0
187 | } else { // move to previous line
188 | cy--
189 | if prevLineWidth > 0 {
190 | if !v.Wrap { // set origin so the EOL is visible
191 | nox := prevLineWidth - maxX + 1
192 | if nox < 0 {
193 | v.ox = 0
194 | } else {
195 | v.ox = nox
196 | }
197 | }
198 | v.cx = prevLineWidth
199 | } else {
200 | if !v.Wrap {
201 | v.ox = 0
202 | }
203 | v.cx = 0
204 | }
205 | }
206 | } else { // stay on the same line
207 | if v.Wrap {
208 | v.cx = cx
209 | } else {
210 | if cx >= maxX {
211 | v.ox += cx - maxX + 1
212 | v.cx = maxX
213 | } else {
214 | v.cx = cx
215 | }
216 | }
217 | }
218 |
219 | // adjust cursor's y position and view's y origin
220 | if cy < 0 {
221 | if v.oy > 0 {
222 | v.oy--
223 | }
224 | } else if writeMode || v.oy+cy < len(v.viewLines) {
225 | if cy >= maxY {
226 | v.oy++
227 | } else {
228 | v.cy = cy
229 | }
230 | }
231 | }
232 |
233 | // writeRune writes a rune into the view's internal buffer, at the
234 | // position corresponding to the point (x, y). The length of the internal
235 | // buffer is increased if the point is out of bounds. Overwrite mode is
236 | // governed by the value of View.overwrite.
237 | func (v *View) writeRune(x, y int, ch rune) error {
238 | v.tainted = true
239 |
240 | x, y, err := v.realPosition(x, y)
241 | if err != nil {
242 | return err
243 | }
244 |
245 | if x < 0 || y < 0 {
246 | return errors.New("invalid point")
247 | }
248 |
249 | if y >= len(v.lines) {
250 | s := make([][]cell, y-len(v.lines)+1)
251 | v.lines = append(v.lines, s...)
252 | }
253 |
254 | olen := len(v.lines[y])
255 |
256 | var s []cell
257 | if x >= len(v.lines[y]) {
258 | s = make([]cell, x-len(v.lines[y])+1)
259 | } else if !v.Overwrite {
260 | s = make([]cell, 1)
261 | }
262 | v.lines[y] = append(v.lines[y], s...)
263 |
264 | if !v.Overwrite || (v.Overwrite && x >= olen-1) {
265 | copy(v.lines[y][x+1:], v.lines[y][x:])
266 | }
267 | v.lines[y][x] = cell{
268 | fgColor: v.FgColor,
269 | bgColor: v.BgColor,
270 | chr: ch,
271 | }
272 |
273 | return nil
274 | }
275 |
276 | // deleteRune removes a rune from the view's internal buffer, at the
277 | // position corresponding to the point (x, y).
278 | func (v *View) deleteRune(x, y int) error {
279 | v.tainted = true
280 |
281 | x, y, err := v.realPosition(x, y)
282 | if err != nil {
283 | return err
284 | }
285 |
286 | if x < 0 || y < 0 || y >= len(v.lines) || x >= len(v.lines[y]) {
287 | return errors.New("invalid point")
288 | }
289 | v.lines[y] = append(v.lines[y][:x], v.lines[y][x+1:]...)
290 | return nil
291 | }
292 |
293 | // mergeLines merges the lines "y" and "y+1" if possible.
294 | func (v *View) mergeLines(y int) error {
295 | v.tainted = true
296 |
297 | _, y, err := v.realPosition(0, y)
298 | if err != nil {
299 | return err
300 | }
301 |
302 | if y < 0 || y >= len(v.lines) {
303 | return errors.New("invalid point")
304 | }
305 |
306 | if y < len(v.lines)-1 { // otherwise we don't need to merge anything
307 | v.lines[y] = append(v.lines[y], v.lines[y+1]...)
308 | v.lines = append(v.lines[:y+1], v.lines[y+2:]...)
309 | }
310 | return nil
311 | }
312 |
313 | // breakLine breaks a line of the internal buffer at the position corresponding
314 | // to the point (x, y).
315 | func (v *View) breakLine(x, y int) error {
316 | v.tainted = true
317 |
318 | x, y, err := v.realPosition(x, y)
319 | if err != nil {
320 | return err
321 | }
322 |
323 | if y < 0 || y >= len(v.lines) {
324 | return errors.New("invalid point")
325 | }
326 |
327 | var left, right []cell
328 | if x < len(v.lines[y]) { // break line
329 | left = make([]cell, len(v.lines[y][:x]))
330 | copy(left, v.lines[y][:x])
331 | right = make([]cell, len(v.lines[y][x:]))
332 | copy(right, v.lines[y][x:])
333 | } else { // new empty line
334 | left = v.lines[y]
335 | }
336 |
337 | lines := make([][]cell, len(v.lines)+1)
338 | lines[y] = left
339 | lines[y+1] = right
340 | copy(lines, v.lines[:y])
341 | copy(lines[y+2:], v.lines[y+1:])
342 | v.lines = lines
343 | return nil
344 | }
345 |
--------------------------------------------------------------------------------
/escape.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package gocui
6 |
7 | import (
8 | "errors"
9 | "strconv"
10 | )
11 |
12 | type escapeInterpreter struct {
13 | state escapeState
14 | curch rune
15 | csiParam []string
16 | curFgColor, curBgColor Attribute
17 | mode OutputMode
18 | }
19 |
20 | type escapeState int
21 |
22 | const (
23 | stateNone escapeState = iota
24 | stateEscape
25 | stateCSI
26 | stateParams
27 | )
28 |
29 | var (
30 | errNotCSI = errors.New("Not a CSI escape sequence")
31 | errCSIParseError = errors.New("CSI escape sequence parsing error")
32 | errCSITooLong = errors.New("CSI escape sequence is too long")
33 | )
34 |
35 | // runes in case of error will output the non-parsed runes as a string.
36 | func (ei *escapeInterpreter) runes() []rune {
37 | switch ei.state {
38 | case stateNone:
39 | return []rune{0x1b}
40 | case stateEscape:
41 | return []rune{0x1b, ei.curch}
42 | case stateCSI:
43 | return []rune{0x1b, '[', ei.curch}
44 | case stateParams:
45 | ret := []rune{0x1b, '['}
46 | for _, s := range ei.csiParam {
47 | ret = append(ret, []rune(s)...)
48 | ret = append(ret, ';')
49 | }
50 | return append(ret, ei.curch)
51 | }
52 | return nil
53 | }
54 |
55 | // newEscapeInterpreter returns an escapeInterpreter that will be able to parse
56 | // terminal escape sequences.
57 | func newEscapeInterpreter(mode OutputMode) *escapeInterpreter {
58 | ei := &escapeInterpreter{
59 | state: stateNone,
60 | curFgColor: ColorDefault,
61 | curBgColor: ColorDefault,
62 | mode: mode,
63 | }
64 | return ei
65 | }
66 |
67 | // reset sets the escapeInterpreter in initial state.
68 | func (ei *escapeInterpreter) reset() {
69 | ei.state = stateNone
70 | ei.curFgColor = ColorDefault
71 | ei.curBgColor = ColorDefault
72 | ei.csiParam = nil
73 | }
74 |
75 | // parseOne parses a rune. If isEscape is true, it means that the rune is part
76 | // of an escape sequence, and as such should not be printed verbatim. Otherwise,
77 | // it's not an escape sequence.
78 | func (ei *escapeInterpreter) parseOne(ch rune) (isEscape bool, err error) {
79 | // Sanity checks
80 | if len(ei.csiParam) > 20 {
81 | return false, errCSITooLong
82 | }
83 | if len(ei.csiParam) > 0 && len(ei.csiParam[len(ei.csiParam)-1]) > 255 {
84 | return false, errCSITooLong
85 | }
86 |
87 | ei.curch = ch
88 |
89 | switch ei.state {
90 | case stateNone:
91 | if ch == 0x1b {
92 | ei.state = stateEscape
93 | return true, nil
94 | }
95 | return false, nil
96 | case stateEscape:
97 | if ch == '[' {
98 | ei.state = stateCSI
99 | return true, nil
100 | }
101 | return false, errNotCSI
102 | case stateCSI:
103 | switch {
104 | case ch >= '0' && ch <= '9':
105 | ei.csiParam = append(ei.csiParam, "")
106 | case ch == 'm':
107 | ei.csiParam = append(ei.csiParam, "0")
108 | default:
109 | return false, errCSIParseError
110 | }
111 | ei.state = stateParams
112 | fallthrough
113 | case stateParams:
114 | switch {
115 | case ch >= '0' && ch <= '9':
116 | ei.csiParam[len(ei.csiParam)-1] += string(ch)
117 | return true, nil
118 | case ch == ';':
119 | ei.csiParam = append(ei.csiParam, "")
120 | return true, nil
121 | case ch == 'm':
122 | var err error
123 | switch ei.mode {
124 | case OutputNormal:
125 | err = ei.outputNormal()
126 | case Output256:
127 | err = ei.output256()
128 | }
129 | if err != nil {
130 | return false, errCSIParseError
131 | }
132 |
133 | ei.state = stateNone
134 | ei.csiParam = nil
135 | return true, nil
136 | default:
137 | return false, errCSIParseError
138 | }
139 | }
140 | return false, nil
141 | }
142 |
143 | // outputNormal provides 8 different colors:
144 | // black, red, green, yellow, blue, magenta, cyan, white
145 | func (ei *escapeInterpreter) outputNormal() error {
146 | for _, param := range ei.csiParam {
147 | p, err := strconv.Atoi(param)
148 | if err != nil {
149 | return errCSIParseError
150 | }
151 |
152 | switch {
153 | case p >= 30 && p <= 37:
154 | ei.curFgColor = Attribute(p - 30 + 1)
155 | case p == 39:
156 | ei.curFgColor = ColorDefault
157 | case p >= 40 && p <= 47:
158 | ei.curBgColor = Attribute(p - 40 + 1)
159 | case p == 49:
160 | ei.curBgColor = ColorDefault
161 | case p == 1:
162 | ei.curFgColor |= AttrBold
163 | case p == 4:
164 | ei.curFgColor |= AttrUnderline
165 | case p == 7:
166 | ei.curFgColor |= AttrReverse
167 | case p == 0:
168 | ei.curFgColor = ColorDefault
169 | ei.curBgColor = ColorDefault
170 | }
171 | }
172 |
173 | return nil
174 | }
175 |
176 | // output256 allows you to leverage the 256-colors terminal mode:
177 | // 0x01 - 0x08: the 8 colors as in OutputNormal
178 | // 0x09 - 0x10: Color* | AttrBold
179 | // 0x11 - 0xe8: 216 different colors
180 | // 0xe9 - 0x1ff: 24 different shades of grey
181 | func (ei *escapeInterpreter) output256() error {
182 | if len(ei.csiParam) < 3 {
183 | return ei.outputNormal()
184 | }
185 |
186 | mode, err := strconv.Atoi(ei.csiParam[1])
187 | if err != nil {
188 | return errCSIParseError
189 | }
190 | if mode != 5 {
191 | return ei.outputNormal()
192 | }
193 |
194 | fgbg, err := strconv.Atoi(ei.csiParam[0])
195 | if err != nil {
196 | return errCSIParseError
197 | }
198 | color, err := strconv.Atoi(ei.csiParam[2])
199 | if err != nil {
200 | return errCSIParseError
201 | }
202 |
203 | switch fgbg {
204 | case 38:
205 | ei.curFgColor = Attribute(color + 1)
206 |
207 | for _, param := range ei.csiParam[3:] {
208 | p, err := strconv.Atoi(param)
209 | if err != nil {
210 | return errCSIParseError
211 | }
212 |
213 | switch {
214 | case p == 1:
215 | ei.curFgColor |= AttrBold
216 | case p == 4:
217 | ei.curFgColor |= AttrUnderline
218 | case p == 7:
219 | ei.curFgColor |= AttrReverse
220 | }
221 | }
222 | case 48:
223 | ei.curBgColor = Attribute(color + 1)
224 | default:
225 | return errCSIParseError
226 | }
227 |
228 | return nil
229 | }
230 |
--------------------------------------------------------------------------------
/go.mod:
--------------------------------------------------------------------------------
1 | module github.com/jroimartin/gocui
2 |
3 | go 1.16
4 |
5 | require github.com/nsf/termbox-go v1.1.1
6 |
--------------------------------------------------------------------------------
/go.sum:
--------------------------------------------------------------------------------
1 | github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
2 | github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
3 | github.com/nsf/termbox-go v1.1.1 h1:nksUPLCb73Q++DwbYUBEglYBRPZyoXJdrj5L+TkjyZY=
4 | github.com/nsf/termbox-go v1.1.1/go.mod h1:T0cTdVuOwf7pHQNtfhnEbzHbcNyCEcVU4YPpouCbVxo=
5 |
--------------------------------------------------------------------------------
/gui.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package gocui
6 |
7 | import (
8 | "errors"
9 |
10 | "github.com/nsf/termbox-go"
11 | )
12 |
13 | var (
14 | // ErrQuit is used to decide if the MainLoop finished successfully.
15 | ErrQuit = errors.New("quit")
16 |
17 | // ErrUnknownView allows to assert if a View must be initialized.
18 | ErrUnknownView = errors.New("unknown view")
19 | )
20 |
21 | // OutputMode represents the terminal's output mode (8 or 256 colors).
22 | type OutputMode termbox.OutputMode
23 |
24 | const (
25 | // OutputNormal provides 8-colors terminal mode.
26 | OutputNormal = OutputMode(termbox.OutputNormal)
27 |
28 | // Output256 provides 256-colors terminal mode.
29 | Output256 = OutputMode(termbox.Output256)
30 | )
31 |
32 | // Gui represents the whole User Interface, including the views, layouts
33 | // and keybindings.
34 | type Gui struct {
35 | tbEvents chan termbox.Event
36 | userEvents chan userEvent
37 | views []*View
38 | currentView *View
39 | managers []Manager
40 | keybindings []*keybinding
41 | maxX, maxY int
42 | outputMode OutputMode
43 |
44 | // BgColor and FgColor allow to configure the background and foreground
45 | // colors of the GUI.
46 | BgColor, FgColor Attribute
47 |
48 | // SelBgColor and SelFgColor allow to configure the background and
49 | // foreground colors of the frame of the current view.
50 | SelBgColor, SelFgColor Attribute
51 |
52 | // If Highlight is true, Sel{Bg,Fg}Colors will be used to draw the
53 | // frame of the current view.
54 | Highlight bool
55 |
56 | // If Cursor is true then the cursor is enabled.
57 | Cursor bool
58 |
59 | // If Mouse is true then mouse events will be enabled.
60 | Mouse bool
61 |
62 | // If InputEsc is true, when ESC sequence is in the buffer and it doesn't
63 | // match any known sequence, ESC means KeyEsc.
64 | InputEsc bool
65 |
66 | // If ASCII is true then use ASCII instead of unicode to draw the
67 | // interface. Using ASCII is more portable.
68 | ASCII bool
69 | }
70 |
71 | // NewGui returns a new Gui object with a given output mode.
72 | func NewGui(mode OutputMode) (*Gui, error) {
73 | if err := termbox.Init(); err != nil {
74 | return nil, err
75 | }
76 |
77 | g := &Gui{}
78 |
79 | g.outputMode = mode
80 | termbox.SetOutputMode(termbox.OutputMode(mode))
81 |
82 | g.tbEvents = make(chan termbox.Event, 20)
83 | g.userEvents = make(chan userEvent, 20)
84 |
85 | g.maxX, g.maxY = termbox.Size()
86 |
87 | g.BgColor, g.FgColor = ColorDefault, ColorDefault
88 | g.SelBgColor, g.SelFgColor = ColorDefault, ColorDefault
89 |
90 | return g, nil
91 | }
92 |
93 | // Close finalizes the library. It should be called after a successful
94 | // initialization and when gocui is not needed anymore.
95 | func (g *Gui) Close() {
96 | termbox.Close()
97 | }
98 |
99 | // Size returns the terminal's size.
100 | func (g *Gui) Size() (x, y int) {
101 | return g.maxX, g.maxY
102 | }
103 |
104 | // SetRune writes a rune at the given point, relative to the top-left
105 | // corner of the terminal. It checks if the position is valid and applies
106 | // the given colors.
107 | func (g *Gui) SetRune(x, y int, ch rune, fgColor, bgColor Attribute) error {
108 | if x < 0 || y < 0 || x >= g.maxX || y >= g.maxY {
109 | return errors.New("invalid point")
110 | }
111 | termbox.SetCell(x, y, ch, termbox.Attribute(fgColor), termbox.Attribute(bgColor))
112 | return nil
113 | }
114 |
115 | // Rune returns the rune contained in the cell at the given position.
116 | // It checks if the position is valid.
117 | func (g *Gui) Rune(x, y int) (rune, error) {
118 | if x < 0 || y < 0 || x >= g.maxX || y >= g.maxY {
119 | return ' ', errors.New("invalid point")
120 | }
121 | c := termbox.CellBuffer()[y*g.maxX+x]
122 | return c.Ch, nil
123 | }
124 |
125 | // SetView creates a new view with its top-left corner at (x0, y0)
126 | // and the bottom-right one at (x1, y1). If a view with the same name
127 | // already exists, its dimensions are updated; otherwise, the error
128 | // ErrUnknownView is returned, which allows to assert if the View must
129 | // be initialized. It checks if the position is valid.
130 | func (g *Gui) SetView(name string, x0, y0, x1, y1 int) (*View, error) {
131 | if x0 >= x1 || y0 >= y1 {
132 | return nil, errors.New("invalid dimensions")
133 | }
134 | if name == "" {
135 | return nil, errors.New("invalid name")
136 | }
137 |
138 | if v, err := g.View(name); err == nil {
139 | v.x0 = x0
140 | v.y0 = y0
141 | v.x1 = x1
142 | v.y1 = y1
143 | v.tainted = true
144 | return v, nil
145 | }
146 |
147 | v := newView(name, x0, y0, x1, y1, g.outputMode)
148 | v.BgColor, v.FgColor = g.BgColor, g.FgColor
149 | v.SelBgColor, v.SelFgColor = g.SelBgColor, g.SelFgColor
150 | g.views = append(g.views, v)
151 | return v, ErrUnknownView
152 | }
153 |
154 | // SetViewOnTop sets the given view on top of the existing ones.
155 | func (g *Gui) SetViewOnTop(name string) (*View, error) {
156 | for i, v := range g.views {
157 | if v.name == name {
158 | s := append(g.views[:i], g.views[i+1:]...)
159 | g.views = append(s, v)
160 | return v, nil
161 | }
162 | }
163 | return nil, ErrUnknownView
164 | }
165 |
166 | // SetViewOnBottom sets the given view on bottom of the existing ones.
167 | func (g *Gui) SetViewOnBottom(name string) (*View, error) {
168 | for i, v := range g.views {
169 | if v.name == name {
170 | s := append(g.views[:i], g.views[i+1:]...)
171 | g.views = append([]*View{v}, s...)
172 | return v, nil
173 | }
174 | }
175 | return nil, ErrUnknownView
176 | }
177 |
178 | // Views returns all the views in the GUI.
179 | func (g *Gui) Views() []*View {
180 | return g.views
181 | }
182 |
183 | // View returns a pointer to the view with the given name, or error
184 | // ErrUnknownView if a view with that name does not exist.
185 | func (g *Gui) View(name string) (*View, error) {
186 | for _, v := range g.views {
187 | if v.name == name {
188 | return v, nil
189 | }
190 | }
191 | return nil, ErrUnknownView
192 | }
193 |
194 | // ViewByPosition returns a pointer to a view matching the given position, or
195 | // error ErrUnknownView if a view in that position does not exist.
196 | func (g *Gui) ViewByPosition(x, y int) (*View, error) {
197 | // traverse views in reverse order checking top views first
198 | for i := len(g.views); i > 0; i-- {
199 | v := g.views[i-1]
200 | if x > v.x0 && x < v.x1 && y > v.y0 && y < v.y1 {
201 | return v, nil
202 | }
203 | }
204 | return nil, ErrUnknownView
205 | }
206 |
207 | // ViewPosition returns the coordinates of the view with the given name, or
208 | // error ErrUnknownView if a view with that name does not exist.
209 | func (g *Gui) ViewPosition(name string) (x0, y0, x1, y1 int, err error) {
210 | for _, v := range g.views {
211 | if v.name == name {
212 | return v.x0, v.y0, v.x1, v.y1, nil
213 | }
214 | }
215 | return 0, 0, 0, 0, ErrUnknownView
216 | }
217 |
218 | // DeleteView deletes a view by name.
219 | func (g *Gui) DeleteView(name string) error {
220 | for i, v := range g.views {
221 | if v.name == name {
222 | g.views = append(g.views[:i], g.views[i+1:]...)
223 | return nil
224 | }
225 | }
226 | return ErrUnknownView
227 | }
228 |
229 | // SetCurrentView gives the focus to a given view.
230 | func (g *Gui) SetCurrentView(name string) (*View, error) {
231 | for _, v := range g.views {
232 | if v.name == name {
233 | g.currentView = v
234 | return v, nil
235 | }
236 | }
237 | return nil, ErrUnknownView
238 | }
239 |
240 | // CurrentView returns the currently focused view, or nil if no view
241 | // owns the focus.
242 | func (g *Gui) CurrentView() *View {
243 | return g.currentView
244 | }
245 |
246 | // SetKeybinding creates a new keybinding. If viewname equals to ""
247 | // (empty string) then the keybinding will apply to all views. key must
248 | // be a rune or a Key.
249 | func (g *Gui) SetKeybinding(viewname string, key interface{}, mod Modifier, handler func(*Gui, *View) error) error {
250 | var kb *keybinding
251 |
252 | k, ch, err := getKey(key)
253 | if err != nil {
254 | return err
255 | }
256 | kb = newKeybinding(viewname, k, ch, mod, handler)
257 | g.keybindings = append(g.keybindings, kb)
258 | return nil
259 | }
260 |
261 | // DeleteKeybinding deletes a keybinding.
262 | func (g *Gui) DeleteKeybinding(viewname string, key interface{}, mod Modifier) error {
263 | k, ch, err := getKey(key)
264 | if err != nil {
265 | return err
266 | }
267 |
268 | for i, kb := range g.keybindings {
269 | if kb.viewName == viewname && kb.ch == ch && kb.key == k && kb.mod == mod {
270 | g.keybindings = append(g.keybindings[:i], g.keybindings[i+1:]...)
271 | return nil
272 | }
273 | }
274 | return errors.New("keybinding not found")
275 | }
276 |
277 | // DeleteKeybindings deletes all keybindings of view.
278 | func (g *Gui) DeleteKeybindings(viewname string) {
279 | var s []*keybinding
280 | for _, kb := range g.keybindings {
281 | if kb.viewName != viewname {
282 | s = append(s, kb)
283 | }
284 | }
285 | g.keybindings = s
286 | }
287 |
288 | // getKey takes an empty interface with a key and returns the corresponding
289 | // typed Key or rune.
290 | func getKey(key interface{}) (Key, rune, error) {
291 | switch t := key.(type) {
292 | case Key:
293 | return t, 0, nil
294 | case rune:
295 | return 0, t, nil
296 | default:
297 | return 0, 0, errors.New("unknown type")
298 | }
299 | }
300 |
301 | // userEvent represents an event triggered by the user.
302 | type userEvent struct {
303 | f func(*Gui) error
304 | }
305 |
306 | // Update executes the passed function. This method can be called safely from a
307 | // goroutine in order to update the GUI. It is important to note that the
308 | // passed function won't be executed immediately, instead it will be added to
309 | // the user events queue. Given that Update spawns a goroutine, the order in
310 | // which the user events will be handled is not guaranteed.
311 | func (g *Gui) Update(f func(*Gui) error) {
312 | go func() { g.userEvents <- userEvent{f: f} }()
313 | }
314 |
315 | // A Manager is in charge of GUI's layout and can be used to build widgets.
316 | type Manager interface {
317 | // Layout is called every time the GUI is redrawn, it must contain the
318 | // base views and its initializations.
319 | Layout(*Gui) error
320 | }
321 |
322 | // The ManagerFunc type is an adapter to allow the use of ordinary functions as
323 | // Managers. If f is a function with the appropriate signature, ManagerFunc(f)
324 | // is an Manager object that calls f.
325 | type ManagerFunc func(*Gui) error
326 |
327 | // Layout calls f(g)
328 | func (f ManagerFunc) Layout(g *Gui) error {
329 | return f(g)
330 | }
331 |
332 | // SetManager sets the given GUI managers. It deletes all views and
333 | // keybindings.
334 | func (g *Gui) SetManager(managers ...Manager) {
335 | g.managers = managers
336 | g.currentView = nil
337 | g.views = nil
338 | g.keybindings = nil
339 |
340 | go func() { g.tbEvents <- termbox.Event{Type: termbox.EventResize} }()
341 | }
342 |
343 | // SetManagerFunc sets the given manager function. It deletes all views and
344 | // keybindings.
345 | func (g *Gui) SetManagerFunc(manager func(*Gui) error) {
346 | g.SetManager(ManagerFunc(manager))
347 | }
348 |
349 | // MainLoop runs the main loop until an error is returned. A successful
350 | // finish should return ErrQuit.
351 | func (g *Gui) MainLoop() error {
352 | go func() {
353 | for {
354 | g.tbEvents <- termbox.PollEvent()
355 | }
356 | }()
357 |
358 | inputMode := termbox.InputAlt
359 | if g.InputEsc {
360 | inputMode = termbox.InputEsc
361 | }
362 | if g.Mouse {
363 | inputMode |= termbox.InputMouse
364 | }
365 | termbox.SetInputMode(inputMode)
366 |
367 | if err := g.flush(); err != nil {
368 | return err
369 | }
370 | for {
371 | select {
372 | case ev := <-g.tbEvents:
373 | if err := g.handleEvent(&ev); err != nil {
374 | return err
375 | }
376 | case ev := <-g.userEvents:
377 | if err := ev.f(g); err != nil {
378 | return err
379 | }
380 | }
381 | if err := g.consumeevents(); err != nil {
382 | return err
383 | }
384 | if err := g.flush(); err != nil {
385 | return err
386 | }
387 | }
388 | }
389 |
390 | // consumeevents handles the remaining events in the events pool.
391 | func (g *Gui) consumeevents() error {
392 | for {
393 | select {
394 | case ev := <-g.tbEvents:
395 | if err := g.handleEvent(&ev); err != nil {
396 | return err
397 | }
398 | case ev := <-g.userEvents:
399 | if err := ev.f(g); err != nil {
400 | return err
401 | }
402 | default:
403 | return nil
404 | }
405 | }
406 | }
407 |
408 | // handleEvent handles an event, based on its type (key-press, error,
409 | // etc.)
410 | func (g *Gui) handleEvent(ev *termbox.Event) error {
411 | switch ev.Type {
412 | case termbox.EventKey, termbox.EventMouse:
413 | return g.onKey(ev)
414 | case termbox.EventError:
415 | return ev.Err
416 | default:
417 | return nil
418 | }
419 | }
420 |
421 | // flush updates the gui, re-drawing frames and buffers.
422 | func (g *Gui) flush() error {
423 | termbox.Clear(termbox.Attribute(g.FgColor), termbox.Attribute(g.BgColor))
424 |
425 | maxX, maxY := termbox.Size()
426 | // if GUI's size has changed, we need to redraw all views
427 | if maxX != g.maxX || maxY != g.maxY {
428 | for _, v := range g.views {
429 | v.tainted = true
430 | }
431 | }
432 | g.maxX, g.maxY = maxX, maxY
433 |
434 | for _, m := range g.managers {
435 | if err := m.Layout(g); err != nil {
436 | return err
437 | }
438 | }
439 | for _, v := range g.views {
440 | if v.Frame {
441 | var fgColor, bgColor Attribute
442 | if g.Highlight && v == g.currentView {
443 | fgColor = g.SelFgColor
444 | bgColor = g.SelBgColor
445 | } else {
446 | fgColor = g.FgColor
447 | bgColor = g.BgColor
448 | }
449 |
450 | if err := g.drawFrameEdges(v, fgColor, bgColor); err != nil {
451 | return err
452 | }
453 | if err := g.drawFrameCorners(v, fgColor, bgColor); err != nil {
454 | return err
455 | }
456 | if v.Title != "" {
457 | if err := g.drawTitle(v, fgColor, bgColor); err != nil {
458 | return err
459 | }
460 | }
461 | }
462 | if err := g.draw(v); err != nil {
463 | return err
464 | }
465 | }
466 | termbox.Flush()
467 | return nil
468 | }
469 |
470 | // drawFrameEdges draws the horizontal and vertical edges of a view.
471 | func (g *Gui) drawFrameEdges(v *View, fgColor, bgColor Attribute) error {
472 | runeH, runeV := '─', '│'
473 | if g.ASCII {
474 | runeH, runeV = '-', '|'
475 | }
476 |
477 | for x := v.x0 + 1; x < v.x1 && x < g.maxX; x++ {
478 | if x < 0 {
479 | continue
480 | }
481 | if v.y0 > -1 && v.y0 < g.maxY {
482 | if err := g.SetRune(x, v.y0, runeH, fgColor, bgColor); err != nil {
483 | return err
484 | }
485 | }
486 | if v.y1 > -1 && v.y1 < g.maxY {
487 | if err := g.SetRune(x, v.y1, runeH, fgColor, bgColor); err != nil {
488 | return err
489 | }
490 | }
491 | }
492 | for y := v.y0 + 1; y < v.y1 && y < g.maxY; y++ {
493 | if y < 0 {
494 | continue
495 | }
496 | if v.x0 > -1 && v.x0 < g.maxX {
497 | if err := g.SetRune(v.x0, y, runeV, fgColor, bgColor); err != nil {
498 | return err
499 | }
500 | }
501 | if v.x1 > -1 && v.x1 < g.maxX {
502 | if err := g.SetRune(v.x1, y, runeV, fgColor, bgColor); err != nil {
503 | return err
504 | }
505 | }
506 | }
507 | return nil
508 | }
509 |
510 | // drawFrameCorners draws the corners of the view.
511 | func (g *Gui) drawFrameCorners(v *View, fgColor, bgColor Attribute) error {
512 | runeTL, runeTR, runeBL, runeBR := '┌', '┐', '└', '┘'
513 | if g.ASCII {
514 | runeTL, runeTR, runeBL, runeBR = '+', '+', '+', '+'
515 | }
516 |
517 | corners := []struct {
518 | x, y int
519 | ch rune
520 | }{{v.x0, v.y0, runeTL}, {v.x1, v.y0, runeTR}, {v.x0, v.y1, runeBL}, {v.x1, v.y1, runeBR}}
521 |
522 | for _, c := range corners {
523 | if c.x >= 0 && c.y >= 0 && c.x < g.maxX && c.y < g.maxY {
524 | if err := g.SetRune(c.x, c.y, c.ch, fgColor, bgColor); err != nil {
525 | return err
526 | }
527 | }
528 | }
529 | return nil
530 | }
531 |
532 | // drawTitle draws the title of the view.
533 | func (g *Gui) drawTitle(v *View, fgColor, bgColor Attribute) error {
534 | if v.y0 < 0 || v.y0 >= g.maxY {
535 | return nil
536 | }
537 |
538 | for i, ch := range v.Title {
539 | x := v.x0 + i + 2
540 | if x < 0 {
541 | continue
542 | } else if x > v.x1-2 || x >= g.maxX {
543 | break
544 | }
545 | if err := g.SetRune(x, v.y0, ch, fgColor, bgColor); err != nil {
546 | return err
547 | }
548 | }
549 | return nil
550 | }
551 |
552 | // draw manages the cursor and calls the draw function of a view.
553 | func (g *Gui) draw(v *View) error {
554 | if g.Cursor {
555 | if curview := g.currentView; curview != nil {
556 | vMaxX, vMaxY := curview.Size()
557 | if curview.cx < 0 {
558 | curview.cx = 0
559 | } else if curview.cx >= vMaxX {
560 | curview.cx = vMaxX - 1
561 | }
562 | if curview.cy < 0 {
563 | curview.cy = 0
564 | } else if curview.cy >= vMaxY {
565 | curview.cy = vMaxY - 1
566 | }
567 |
568 | gMaxX, gMaxY := g.Size()
569 | cx, cy := curview.x0+curview.cx+1, curview.y0+curview.cy+1
570 | if cx >= 0 && cx < gMaxX && cy >= 0 && cy < gMaxY {
571 | termbox.SetCursor(cx, cy)
572 | } else {
573 | termbox.HideCursor()
574 | }
575 | }
576 | } else {
577 | termbox.HideCursor()
578 | }
579 |
580 | v.clearRunes()
581 | if err := v.draw(); err != nil {
582 | return err
583 | }
584 | return nil
585 | }
586 |
587 | // onKey manages key-press events. A keybinding handler is called when
588 | // a key-press or mouse event satisfies a configured keybinding. Furthermore,
589 | // currentView's internal buffer is modified if currentView.Editable is true.
590 | func (g *Gui) onKey(ev *termbox.Event) error {
591 | switch ev.Type {
592 | case termbox.EventKey:
593 | matched, err := g.execKeybindings(g.currentView, ev)
594 | if err != nil {
595 | return err
596 | }
597 | if matched {
598 | break
599 | }
600 | if g.currentView != nil && g.currentView.Editable && g.currentView.Editor != nil {
601 | g.currentView.Editor.Edit(g.currentView, Key(ev.Key), ev.Ch, Modifier(ev.Mod))
602 | }
603 | case termbox.EventMouse:
604 | mx, my := ev.MouseX, ev.MouseY
605 | v, err := g.ViewByPosition(mx, my)
606 | if err != nil {
607 | break
608 | }
609 | if err := v.SetCursor(mx-v.x0-1, my-v.y0-1); err != nil {
610 | return err
611 | }
612 | if _, err := g.execKeybindings(v, ev); err != nil {
613 | return err
614 | }
615 | }
616 |
617 | return nil
618 | }
619 |
620 | // execKeybindings executes the keybinding handlers that match the passed view
621 | // and event. The value of matched is true if there is a match and no errors.
622 | func (g *Gui) execKeybindings(v *View, ev *termbox.Event) (matched bool, err error) {
623 | matched = false
624 | for _, kb := range g.keybindings {
625 | if kb.handler == nil {
626 | continue
627 | }
628 | if kb.matchKeypress(Key(ev.Key), ev.Ch, Modifier(ev.Mod)) && kb.matchView(v) {
629 | if err := kb.handler(g, v); err != nil {
630 | return false, err
631 | }
632 | matched = true
633 | }
634 | }
635 | return matched, nil
636 | }
637 |
--------------------------------------------------------------------------------
/keybinding.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package gocui
6 |
7 | import "github.com/nsf/termbox-go"
8 |
9 | // Keybidings are used to link a given key-press event with a handler.
10 | type keybinding struct {
11 | viewName string
12 | key Key
13 | ch rune
14 | mod Modifier
15 | handler func(*Gui, *View) error
16 | }
17 |
18 | // newKeybinding returns a new Keybinding object.
19 | func newKeybinding(viewname string, key Key, ch rune, mod Modifier, handler func(*Gui, *View) error) (kb *keybinding) {
20 | kb = &keybinding{
21 | viewName: viewname,
22 | key: key,
23 | ch: ch,
24 | mod: mod,
25 | handler: handler,
26 | }
27 | return kb
28 | }
29 |
30 | // matchKeypress returns if the keybinding matches the keypress.
31 | func (kb *keybinding) matchKeypress(key Key, ch rune, mod Modifier) bool {
32 | return kb.key == key && kb.ch == ch && kb.mod == mod
33 | }
34 |
35 | // matchView returns if the keybinding matches the current view.
36 | func (kb *keybinding) matchView(v *View) bool {
37 | if kb.viewName == "" {
38 | return true
39 | }
40 | return v != nil && kb.viewName == v.name
41 | }
42 |
43 | // Key represents special keys or keys combinations.
44 | type Key termbox.Key
45 |
46 | // Special keys.
47 | const (
48 | KeyF1 Key = Key(termbox.KeyF1)
49 | KeyF2 = Key(termbox.KeyF2)
50 | KeyF3 = Key(termbox.KeyF3)
51 | KeyF4 = Key(termbox.KeyF4)
52 | KeyF5 = Key(termbox.KeyF5)
53 | KeyF6 = Key(termbox.KeyF6)
54 | KeyF7 = Key(termbox.KeyF7)
55 | KeyF8 = Key(termbox.KeyF8)
56 | KeyF9 = Key(termbox.KeyF9)
57 | KeyF10 = Key(termbox.KeyF10)
58 | KeyF11 = Key(termbox.KeyF11)
59 | KeyF12 = Key(termbox.KeyF12)
60 | KeyInsert = Key(termbox.KeyInsert)
61 | KeyDelete = Key(termbox.KeyDelete)
62 | KeyHome = Key(termbox.KeyHome)
63 | KeyEnd = Key(termbox.KeyEnd)
64 | KeyPgup = Key(termbox.KeyPgup)
65 | KeyPgdn = Key(termbox.KeyPgdn)
66 | KeyArrowUp = Key(termbox.KeyArrowUp)
67 | KeyArrowDown = Key(termbox.KeyArrowDown)
68 | KeyArrowLeft = Key(termbox.KeyArrowLeft)
69 | KeyArrowRight = Key(termbox.KeyArrowRight)
70 |
71 | MouseLeft = Key(termbox.MouseLeft)
72 | MouseMiddle = Key(termbox.MouseMiddle)
73 | MouseRight = Key(termbox.MouseRight)
74 | MouseRelease = Key(termbox.MouseRelease)
75 | MouseWheelUp = Key(termbox.MouseWheelUp)
76 | MouseWheelDown = Key(termbox.MouseWheelDown)
77 | )
78 |
79 | // Keys combinations.
80 | const (
81 | KeyCtrlTilde Key = Key(termbox.KeyCtrlTilde)
82 | KeyCtrl2 = Key(termbox.KeyCtrl2)
83 | KeyCtrlSpace = Key(termbox.KeyCtrlSpace)
84 | KeyCtrlA = Key(termbox.KeyCtrlA)
85 | KeyCtrlB = Key(termbox.KeyCtrlB)
86 | KeyCtrlC = Key(termbox.KeyCtrlC)
87 | KeyCtrlD = Key(termbox.KeyCtrlD)
88 | KeyCtrlE = Key(termbox.KeyCtrlE)
89 | KeyCtrlF = Key(termbox.KeyCtrlF)
90 | KeyCtrlG = Key(termbox.KeyCtrlG)
91 | KeyBackspace = Key(termbox.KeyBackspace)
92 | KeyCtrlH = Key(termbox.KeyCtrlH)
93 | KeyTab = Key(termbox.KeyTab)
94 | KeyCtrlI = Key(termbox.KeyCtrlI)
95 | KeyCtrlJ = Key(termbox.KeyCtrlJ)
96 | KeyCtrlK = Key(termbox.KeyCtrlK)
97 | KeyCtrlL = Key(termbox.KeyCtrlL)
98 | KeyEnter = Key(termbox.KeyEnter)
99 | KeyCtrlM = Key(termbox.KeyCtrlM)
100 | KeyCtrlN = Key(termbox.KeyCtrlN)
101 | KeyCtrlO = Key(termbox.KeyCtrlO)
102 | KeyCtrlP = Key(termbox.KeyCtrlP)
103 | KeyCtrlQ = Key(termbox.KeyCtrlQ)
104 | KeyCtrlR = Key(termbox.KeyCtrlR)
105 | KeyCtrlS = Key(termbox.KeyCtrlS)
106 | KeyCtrlT = Key(termbox.KeyCtrlT)
107 | KeyCtrlU = Key(termbox.KeyCtrlU)
108 | KeyCtrlV = Key(termbox.KeyCtrlV)
109 | KeyCtrlW = Key(termbox.KeyCtrlW)
110 | KeyCtrlX = Key(termbox.KeyCtrlX)
111 | KeyCtrlY = Key(termbox.KeyCtrlY)
112 | KeyCtrlZ = Key(termbox.KeyCtrlZ)
113 | KeyEsc = Key(termbox.KeyEsc)
114 | KeyCtrlLsqBracket = Key(termbox.KeyCtrlLsqBracket)
115 | KeyCtrl3 = Key(termbox.KeyCtrl3)
116 | KeyCtrl4 = Key(termbox.KeyCtrl4)
117 | KeyCtrlBackslash = Key(termbox.KeyCtrlBackslash)
118 | KeyCtrl5 = Key(termbox.KeyCtrl5)
119 | KeyCtrlRsqBracket = Key(termbox.KeyCtrlRsqBracket)
120 | KeyCtrl6 = Key(termbox.KeyCtrl6)
121 | KeyCtrl7 = Key(termbox.KeyCtrl7)
122 | KeyCtrlSlash = Key(termbox.KeyCtrlSlash)
123 | KeyCtrlUnderscore = Key(termbox.KeyCtrlUnderscore)
124 | KeySpace = Key(termbox.KeySpace)
125 | KeyBackspace2 = Key(termbox.KeyBackspace2)
126 | KeyCtrl8 = Key(termbox.KeyCtrl8)
127 | )
128 |
129 | // Modifier allows to define special keys combinations. They can be used
130 | // in combination with Keys or Runes when a new keybinding is defined.
131 | type Modifier termbox.Modifier
132 |
133 | // Modifiers.
134 | const (
135 | ModNone Modifier = Modifier(0)
136 | ModAlt = Modifier(termbox.ModAlt)
137 | )
138 |
--------------------------------------------------------------------------------
/view.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The gocui Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package gocui
6 |
7 | import (
8 | "bytes"
9 | "errors"
10 | "io"
11 | "strings"
12 |
13 | "github.com/nsf/termbox-go"
14 | )
15 |
16 | // A View is a window. It maintains its own internal buffer and cursor
17 | // position.
18 | type View struct {
19 | name string
20 | x0, y0, x1, y1 int
21 | ox, oy int
22 | cx, cy int
23 | lines [][]cell
24 | readOffset int
25 | readCache string
26 |
27 | tainted bool // marks if the viewBuffer must be updated
28 | viewLines []viewLine // internal representation of the view's buffer
29 |
30 | ei *escapeInterpreter // used to decode ESC sequences on Write
31 |
32 | // BgColor and FgColor allow to configure the background and foreground
33 | // colors of the View.
34 | BgColor, FgColor Attribute
35 |
36 | // SelBgColor and SelFgColor are used to configure the background and
37 | // foreground colors of the selected line, when it is highlighted.
38 | SelBgColor, SelFgColor Attribute
39 |
40 | // If Editable is true, keystrokes will be added to the view's internal
41 | // buffer at the cursor position.
42 | Editable bool
43 |
44 | // Editor allows to define the editor that manages the edition mode,
45 | // including keybindings or cursor behaviour. DefaultEditor is used by
46 | // default.
47 | Editor Editor
48 |
49 | // Overwrite enables or disables the overwrite mode of the view.
50 | Overwrite bool
51 |
52 | // If Highlight is true, Sel{Bg,Fg}Colors will be used
53 | // for the line under the cursor position.
54 | Highlight bool
55 |
56 | // If Frame is true, a border will be drawn around the view.
57 | Frame bool
58 |
59 | // If Wrap is true, the content that is written to this View is
60 | // automatically wrapped when it is longer than its width. If true the
61 | // view's x-origin will be ignored.
62 | Wrap bool
63 |
64 | // If Autoscroll is true, the View will automatically scroll down when the
65 | // text overflows. If true the view's y-origin will be ignored.
66 | Autoscroll bool
67 |
68 | // If Frame is true, Title allows to configure a title for the view.
69 | Title string
70 |
71 | // If Mask is true, the View will display the mask instead of the real
72 | // content
73 | Mask rune
74 | }
75 |
76 | type viewLine struct {
77 | linesX, linesY int // coordinates relative to v.lines
78 | line []cell
79 | }
80 |
81 | type cell struct {
82 | chr rune
83 | bgColor, fgColor Attribute
84 | }
85 |
86 | type lineType []cell
87 |
88 | // String returns a string from a given cell slice.
89 | func (l lineType) String() string {
90 | str := ""
91 | for _, c := range l {
92 | str += string(c.chr)
93 | }
94 | return str
95 | }
96 |
97 | // newView returns a new View object.
98 | func newView(name string, x0, y0, x1, y1 int, mode OutputMode) *View {
99 | v := &View{
100 | name: name,
101 | x0: x0,
102 | y0: y0,
103 | x1: x1,
104 | y1: y1,
105 | Frame: true,
106 | Editor: DefaultEditor,
107 | tainted: true,
108 | ei: newEscapeInterpreter(mode),
109 | }
110 | return v
111 | }
112 |
113 | // Size returns the number of visible columns and rows in the View.
114 | func (v *View) Size() (x, y int) {
115 | return v.x1 - v.x0 - 1, v.y1 - v.y0 - 1
116 | }
117 |
118 | // Name returns the name of the view.
119 | func (v *View) Name() string {
120 | return v.name
121 | }
122 |
123 | // setRune sets a rune at the given point relative to the view. It applies the
124 | // specified colors, taking into account if the cell must be highlighted. Also,
125 | // it checks if the position is valid.
126 | func (v *View) setRune(x, y int, ch rune, fgColor, bgColor Attribute) error {
127 | maxX, maxY := v.Size()
128 | if x < 0 || x >= maxX || y < 0 || y >= maxY {
129 | return errors.New("invalid point")
130 | }
131 |
132 | var (
133 | ry, rcy int
134 | err error
135 | )
136 | if v.Highlight {
137 | _, ry, err = v.realPosition(x, y)
138 | if err != nil {
139 | return err
140 | }
141 | _, rcy, err = v.realPosition(v.cx, v.cy)
142 | if err != nil {
143 | return err
144 | }
145 | }
146 |
147 | if v.Mask != 0 {
148 | fgColor = v.FgColor
149 | bgColor = v.BgColor
150 | ch = v.Mask
151 | } else if v.Highlight && ry == rcy {
152 | fgColor = v.SelFgColor
153 | bgColor = v.SelBgColor
154 | }
155 |
156 | termbox.SetCell(v.x0+x+1, v.y0+y+1, ch,
157 | termbox.Attribute(fgColor), termbox.Attribute(bgColor))
158 |
159 | return nil
160 | }
161 |
162 | // SetCursor sets the cursor position of the view at the given point,
163 | // relative to the view. It checks if the position is valid.
164 | func (v *View) SetCursor(x, y int) error {
165 | maxX, maxY := v.Size()
166 | if x < 0 || x >= maxX || y < 0 || y >= maxY {
167 | return errors.New("invalid point")
168 | }
169 | v.cx = x
170 | v.cy = y
171 | return nil
172 | }
173 |
174 | // Cursor returns the cursor position of the view.
175 | func (v *View) Cursor() (x, y int) {
176 | return v.cx, v.cy
177 | }
178 |
179 | // SetOrigin sets the origin position of the view's internal buffer,
180 | // so the buffer starts to be printed from this point, which means that
181 | // it is linked with the origin point of view. It can be used to
182 | // implement Horizontal and Vertical scrolling with just incrementing
183 | // or decrementing ox and oy.
184 | func (v *View) SetOrigin(x, y int) error {
185 | if x < 0 || y < 0 {
186 | return errors.New("invalid point")
187 | }
188 | v.ox = x
189 | v.oy = y
190 | return nil
191 | }
192 |
193 | // Origin returns the origin position of the view.
194 | func (v *View) Origin() (x, y int) {
195 | return v.ox, v.oy
196 | }
197 |
198 | // Write appends a byte slice into the view's internal buffer. Because
199 | // View implements the io.Writer interface, it can be passed as parameter
200 | // of functions like fmt.Fprintf, fmt.Fprintln, io.Copy, etc. Clear must
201 | // be called to clear the view's buffer.
202 | func (v *View) Write(p []byte) (n int, err error) {
203 | v.tainted = true
204 |
205 | for _, ch := range bytes.Runes(p) {
206 | switch ch {
207 | case '\n':
208 | v.lines = append(v.lines, nil)
209 | case '\r':
210 | nl := len(v.lines)
211 | if nl > 0 {
212 | v.lines[nl-1] = nil
213 | } else {
214 | v.lines = make([][]cell, 1)
215 | }
216 | default:
217 | cells := v.parseInput(ch)
218 | if cells == nil {
219 | continue
220 | }
221 |
222 | nl := len(v.lines)
223 | if nl > 0 {
224 | v.lines[nl-1] = append(v.lines[nl-1], cells...)
225 | } else {
226 | v.lines = append(v.lines, cells)
227 | }
228 | }
229 | }
230 | return len(p), nil
231 | }
232 |
233 | // parseInput parses char by char the input written to the View. It returns nil
234 | // while processing ESC sequences. Otherwise, it returns a cell slice that
235 | // contains the processed data.
236 | func (v *View) parseInput(ch rune) []cell {
237 | cells := []cell{}
238 |
239 | isEscape, err := v.ei.parseOne(ch)
240 | if err != nil {
241 | for _, r := range v.ei.runes() {
242 | c := cell{
243 | fgColor: v.FgColor,
244 | bgColor: v.BgColor,
245 | chr: r,
246 | }
247 | cells = append(cells, c)
248 | }
249 | v.ei.reset()
250 | } else {
251 | if isEscape {
252 | return nil
253 | }
254 | c := cell{
255 | fgColor: v.ei.curFgColor,
256 | bgColor: v.ei.curBgColor,
257 | chr: ch,
258 | }
259 | cells = append(cells, c)
260 | }
261 |
262 | return cells
263 | }
264 |
265 | // Read reads data into p. It returns the number of bytes read into p.
266 | // At EOF, err will be io.EOF. Calling Read() after Rewind() makes the
267 | // cache to be refreshed with the contents of the view.
268 | func (v *View) Read(p []byte) (n int, err error) {
269 | if v.readOffset == 0 {
270 | v.readCache = v.Buffer()
271 | }
272 | if v.readOffset < len(v.readCache) {
273 | n = copy(p, v.readCache[v.readOffset:])
274 | v.readOffset += n
275 | } else {
276 | err = io.EOF
277 | }
278 | return
279 | }
280 |
281 | // Rewind sets the offset for the next Read to 0, which also refresh the
282 | // read cache.
283 | func (v *View) Rewind() {
284 | v.readOffset = 0
285 | }
286 |
287 | // draw re-draws the view's contents.
288 | func (v *View) draw() error {
289 | maxX, maxY := v.Size()
290 |
291 | if v.Wrap {
292 | if maxX == 0 {
293 | return errors.New("X size of the view cannot be 0")
294 | }
295 | v.ox = 0
296 | }
297 | if v.tainted {
298 | v.viewLines = nil
299 | for i, line := range v.lines {
300 | if v.Wrap {
301 | if len(line) < maxX {
302 | vline := viewLine{linesX: 0, linesY: i, line: line}
303 | v.viewLines = append(v.viewLines, vline)
304 | continue
305 | } else {
306 | for n := 0; n <= len(line); n += maxX {
307 | if len(line[n:]) <= maxX {
308 | vline := viewLine{linesX: n, linesY: i, line: line[n:]}
309 | v.viewLines = append(v.viewLines, vline)
310 | } else {
311 | vline := viewLine{linesX: n, linesY: i, line: line[n : n+maxX]}
312 | v.viewLines = append(v.viewLines, vline)
313 | }
314 | }
315 | }
316 | } else {
317 | vline := viewLine{linesX: 0, linesY: i, line: line}
318 | v.viewLines = append(v.viewLines, vline)
319 | }
320 | }
321 | v.tainted = false
322 | }
323 |
324 | if v.Autoscroll && len(v.viewLines) > maxY {
325 | v.oy = len(v.viewLines) - maxY
326 | }
327 | y := 0
328 | for i, vline := range v.viewLines {
329 | if i < v.oy {
330 | continue
331 | }
332 | if y >= maxY {
333 | break
334 | }
335 | x := 0
336 | for j, c := range vline.line {
337 | if j < v.ox {
338 | continue
339 | }
340 | if x >= maxX {
341 | break
342 | }
343 |
344 | fgColor := c.fgColor
345 | if fgColor == ColorDefault {
346 | fgColor = v.FgColor
347 | }
348 | bgColor := c.bgColor
349 | if bgColor == ColorDefault {
350 | bgColor = v.BgColor
351 | }
352 |
353 | if err := v.setRune(x, y, c.chr, fgColor, bgColor); err != nil {
354 | return err
355 | }
356 | x++
357 | }
358 | y++
359 | }
360 | return nil
361 | }
362 |
363 | // realPosition returns the position in the internal buffer corresponding to the
364 | // point (x, y) of the view.
365 | func (v *View) realPosition(vx, vy int) (x, y int, err error) {
366 | vx = v.ox + vx
367 | vy = v.oy + vy
368 |
369 | if vx < 0 || vy < 0 {
370 | return 0, 0, errors.New("invalid point")
371 | }
372 |
373 | if len(v.viewLines) == 0 {
374 | return vx, vy, nil
375 | }
376 |
377 | if vy < len(v.viewLines) {
378 | vline := v.viewLines[vy]
379 | x = vline.linesX + vx
380 | y = vline.linesY
381 | } else {
382 | vline := v.viewLines[len(v.viewLines)-1]
383 | x = vx
384 | y = vline.linesY + vy - len(v.viewLines) + 1
385 | }
386 |
387 | return x, y, nil
388 | }
389 |
390 | // Clear empties the view's internal buffer.
391 | func (v *View) Clear() {
392 | v.tainted = true
393 |
394 | v.lines = nil
395 | v.viewLines = nil
396 | v.readOffset = 0
397 | v.clearRunes()
398 | }
399 |
400 | // clearRunes erases all the cells in the view.
401 | func (v *View) clearRunes() {
402 | maxX, maxY := v.Size()
403 | for x := 0; x < maxX; x++ {
404 | for y := 0; y < maxY; y++ {
405 | termbox.SetCell(v.x0+x+1, v.y0+y+1, ' ',
406 | termbox.Attribute(v.FgColor), termbox.Attribute(v.BgColor))
407 | }
408 | }
409 | }
410 |
411 | // BufferLines returns the lines in the view's internal
412 | // buffer.
413 | func (v *View) BufferLines() []string {
414 | lines := make([]string, len(v.lines))
415 | for i, l := range v.lines {
416 | str := lineType(l).String()
417 | str = strings.Replace(str, "\x00", " ", -1)
418 | lines[i] = str
419 | }
420 | return lines
421 | }
422 |
423 | // Buffer returns a string with the contents of the view's internal
424 | // buffer.
425 | func (v *View) Buffer() string {
426 | str := ""
427 | for _, l := range v.lines {
428 | str += lineType(l).String() + "\n"
429 | }
430 | return strings.Replace(str, "\x00", " ", -1)
431 | }
432 |
433 | // ViewBufferLines returns the lines in the view's internal
434 | // buffer that is shown to the user.
435 | func (v *View) ViewBufferLines() []string {
436 | lines := make([]string, len(v.viewLines))
437 | for i, l := range v.viewLines {
438 | str := lineType(l.line).String()
439 | str = strings.Replace(str, "\x00", " ", -1)
440 | lines[i] = str
441 | }
442 | return lines
443 | }
444 |
445 | // ViewBuffer returns a string with the contents of the view's buffer that is
446 | // shown to the user.
447 | func (v *View) ViewBuffer() string {
448 | str := ""
449 | for _, l := range v.viewLines {
450 | str += lineType(l.line).String() + "\n"
451 | }
452 | return strings.Replace(str, "\x00", " ", -1)
453 | }
454 |
455 | // Line returns a string with the line of the view's internal buffer
456 | // at the position corresponding to the point (x, y).
457 | func (v *View) Line(y int) (string, error) {
458 | _, y, err := v.realPosition(0, y)
459 | if err != nil {
460 | return "", err
461 | }
462 |
463 | if y < 0 || y >= len(v.lines) {
464 | return "", errors.New("invalid point")
465 | }
466 |
467 | return lineType(v.lines[y]).String(), nil
468 | }
469 |
470 | // Word returns a string with the word of the view's internal buffer
471 | // at the position corresponding to the point (x, y).
472 | func (v *View) Word(x, y int) (string, error) {
473 | x, y, err := v.realPosition(x, y)
474 | if err != nil {
475 | return "", err
476 | }
477 |
478 | if x < 0 || y < 0 || y >= len(v.lines) || x >= len(v.lines[y]) {
479 | return "", errors.New("invalid point")
480 | }
481 |
482 | str := lineType(v.lines[y]).String()
483 |
484 | nl := strings.LastIndexFunc(str[:x], indexFunc)
485 | if nl == -1 {
486 | nl = 0
487 | } else {
488 | nl = nl + 1
489 | }
490 | nr := strings.IndexFunc(str[x:], indexFunc)
491 | if nr == -1 {
492 | nr = len(str)
493 | } else {
494 | nr = nr + x
495 | }
496 | return string(str[nl:nr]), nil
497 | }
498 |
499 | // indexFunc allows to split lines by words taking into account spaces
500 | // and 0.
501 | func indexFunc(r rune) bool {
502 | return r == ' ' || r == 0
503 | }
504 |
--------------------------------------------------------------------------------