func New(ctl *ui.Controller, state ui.State) *TermView {
// initialize terminal display
termbox.Init()
// make sure ngrok doesn't quit until we've cleaned up
ctl.Wait.Add(1)
w, _ := termbox.Size()
v := &TermView{
ctl: ctl,
updates: ctl.Updates.Reg(),
flush: make(chan int),
subviews: make([]ui.View, 0),
state: state,
Logger: log.NewPrefixLogger(),
area: NewArea(0, 0, w, 10),
}
v.Logger.AddLogPrefix("view")
v.Logger.AddLogPrefix("term")
switch p := state.GetProtocol().(type) {
case *proto.Http:
v.subviews = append(v.subviews, NewHttp(p, v.flush, ctl.Shutdown, 0, 10))
default:
}
v.Render()
go v.run()
go v.input()
return v
}
// Returns buffered struct of the main screen.
// NOTE: Resize creates new buffer?
func MainScreen() *Buffered {
width, height := termbox.Size()
return &Buffered{
Unbuffered: Unbuffered{r: image.Rect(0, 0, width, height)},
buffer: termbox.CellBuffer(),
}
}
func (s *Session) Run() error {
s.mode = &ModeEdit{}
data, err := ioutil.ReadFile(s.File)
if err != nil {
return err
}
s.Buf = util.NewBuffer(data)
s.W, s.H = termbox.Size()
s.H--
s.View.SetBuf(s.Buf)
s.View.SetSize(s.W, s.H)
s.View.SetTabwidth(s.Tabwidth)
for {
s.Draw()
termbox.Flush()
termbox.Clear(0, 0)
ev := termbox.PollEvent()
switch ev.Type {
case termbox.EventKey:
s.mode, err = s.mode.HandleKey(s, ev)
if err != nil {
return err
}
case termbox.EventResize:
s.W, s.H = ev.Width, ev.Height-1
s.View.SetSize(s.W, s.H)
case termbox.EventMouse:
case termbox.EventError:
return ev.Err
}
}
}
func (c *Composer) moveTopWindow(ev Event) bool {
if len(c.windows) > 0 {
view := c.topWindow()
if view != nil {
x, y := view.Pos()
w, h := view.Size()
x1, y1 := x, y
cx, cy := term.Size()
if ev.Key == term.KeyArrowUp && y > 0 {
y--
} else if ev.Key == term.KeyArrowDown && y+h < cy {
y++
} else if ev.Key == term.KeyArrowLeft && x > 0 {
x--
} else if ev.Key == term.KeyArrowRight && x+w < cx {
x++
}
if x1 != x || y1 != y {
view.SetPos(x, y)
event := Event{Type: EventMove, X: x, Y: y}
c.sendEventToActiveWindow(event)
RefreshScreen()
}
}
return true
}
return false
}
func (w *Window) Repaint() error {
w.Lock()
err := termbox.Clear(w.Fg, w.Bg)
width, height := termbox.Size()
if err != nil {
return err
}
for _, row := range w.Widgets[w.scrollPos:] {
j := 0
for _, c := range row.Text {
termbox.SetCell(w.x, w.y, rune(c), row.Fg[j], row.Bg[j])
j++
if w.x += 1; w.x > width {
break
}
}
w.x = 0
if w.y += 1; w.y > height {
break
}
}
w.y = 0
w.x = 0
w.Unlock()
return nil
}
/* A multiplayer rogue-like in the spirit of TOAG, but implemented in termbox-go */
func main() {
//flag.Parse()
/* start network handling and channels */
max_dimensions := 80 * 24
screen := make([]nr.Sprite, max_dimensions)
world := loadWorld()
/* initialize termbox interface */
err := tb.Init()
check(err)
tb.SetInputMode(tb.InputAlt)
w, h := tb.Size()
tb.Clear(tb.ColorBlack, tb.ColorBlack)
tb.Flush()
go draw(w, h)
for run := true; run == true; {
switch ev := tb.PollEvent(); ev.Type {
case tb.EventKey:
//key := ev.Ch
if ev.Key == tb.KeyCtrlQ {
tb.Flush()
run = false
}
default:
}
}
}
func (panel *Unbuffered) At(x, y int) termbox.Cell {
if !panel.contains(x, y) {
return termbox.Cell{}
}
width, _ := termbox.Size()
return termbox.CellBuffer()[(panel.r.Min.Y+y)*width+(panel.r.Min.X+x)]
}
func NewPrinter(lineWidth int) *Printer {
ret := &Printer{
lineWidth: lineWidth,
}
ret.w, ret.h = box.Size()
return ret
}
func draw_piece(well *Well, operation string, this_piece *Tetronimo) {
well_depth := len(well.debris_map)
term_col, term_row := tb.Size()
vert_headroom := int((term_row-well_depth)/2) - 1
well_bottom := len(well.debris_map) + vert_headroom
well_left := ((term_col / 2) - len(well.debris_map[0]))
for t_vert := range this_piece.shape {
for t_horz := range this_piece.shape[t_vert] {
if this_piece.shape[t_vert][t_horz] > 0 {
color := tb.ColorDefault
if operation == "draw" {
color = set_color(this_piece.shape[t_vert][t_horz])
}
height := (well_bottom - this_piece.height + t_vert)
longitude := (well_left + (this_piece.longitude * 2) + (t_horz * 2))
tb.SetCell(longitude, height, 0, 0, color)
tb.SetCell(longitude+1, height, 0, 0, color)
}
}
}
}
func (t *TermBox) Fill(cell *termbox.Cell) {
w, h := termbox.Size()
for y := 0; y < h; y++ {
for x := 0; x < w; x++ {
termbox.SetCell(x, y, cell.Ch, cell.Fg, cell.Bg)
}
}
}
func (w *Window) ScrollUp() {
if _, height := termbox.Size(); len(w.Widgets) <= height {
return
}
if w.scrollPos > 0 {
w.scrollPos -= 1
}
}
func (t *TermBox) GetCell(x, y int) *termbox.Cell {
w, h := termbox.Size()
idx := y*w + x
if idx > w*h {
return nil
}
return &termbox.CellBuffer()[idx]
}
// Reset reinitializes canvas: set clipping rectangle to the whole
// terminal window, clears clip and color saved data, sets colors
// to default ones
func Reset() {
canvas.width, canvas.height = term.Size()
canvas.clipX, canvas.clipY = 0, 0
canvas.clipW, canvas.clipH = canvas.width, canvas.height
canvas.textColor = ColorWhite
canvas.backColor = ColorBlack
canvas.attrStack = make([]attr, 0)
canvas.clipStack = make([]rect, 0)
}
func (w *Window) ScrollDown() {
_, height := termbox.Size()
if len(w.Widgets) <= height {
return
}
rowLength := len(w.Widgets)
if w.scrollPos < (rowLength - height) {
w.scrollPos += 1
}
}
func main() {
fname := os.Args[1]
f, err := os.Open(fname)
if err != nil {
log.Fatal(err)
}
defer f.Close()
img, _, err := image.Decode(f)
if err != nil {
log.Fatal(err)
}
err = termbox.Init()
if err != nil {
panic(err)
}
defer termbox.Close()
if termbox.SetOutputMode(termbox.Output256) == termbox.Output256 {
palette = upgrade(palette)
}
lw, lh := termbox.Size()
draw(img)
loop:
for {
ev := termbox.PollEvent()
switch ev.Type {
case termbox.EventKey:
if ev.Key == termbox.KeyEsc {
break loop
}
case termbox.EventResize:
termbox.Flush()
if w, h := termbox.Size(); lw != w || lh != h {
lw, lh = w, h
draw(img)
}
}
}
}
func (tb termbox) Read(x, y int) (ch rune, fg, bg Color) {
cells := T.CellBuffer()
w, h := T.Size()
index := x + (y * w)
if index < 0 || index >= w*h {
return ' ', ColorBlack, ColorBlack
}
cell := cells[index]
return cell.Ch, termbox_to_color(cell.Fg), termbox_to_color(cell.Bg)
}
// Init initializes termui library. This function should be called before any others.
// After initialization, the library must be finalized by 'Close' function.
func Init() error {
Body = NewGrid()
Body.X = 0
Body.Y = 0
Body.BgColor = theme.BodyBg
defer (func() {
w, _ := tm.Size()
Body.Width = w
})()
return tm.Init()
}
// TODO make new widget traffic light
// Waiting for canvas from termui
func initWidgets() (*ui.List, *ui.Par, *ui.Par, *ui.Par, *ui.Par) {
ui.UseTheme("Jenkins Term UI")
title := "q to quit - " + *jenkinsUrl
if *filter != "" {
title += " filter on " + *filter
}
p := ui.NewPar(title)
_, h := tm.Size()
p.Height = 3
p.TextFgColor = ui.ColorWhite
p.Border.Label = "Go Jenkins Dashboard"
p.Border.FgColor = ui.ColorCyan
info := ui.NewPar("")
info.Height = 3
info.Y = h - 3
info.TextFgColor = ui.ColorWhite
info.Border.FgColor = ui.ColorWhite
ls := ui.NewList()
ls.ItemFgColor = ui.ColorYellow
ls.Border.Label = "Jobs"
ls.Y = 3
ls.Height = h - 6
width, height := 4, 5
redbox, yellowbox, greenbox := ui.NewPar(""), ui.NewPar(""), ui.NewPar("")
redbox.HasBorder, yellowbox.HasBorder, greenbox.HasBorder = false, false, false
redbox.Height, yellowbox.Height, greenbox.Height = height, height, height
redbox.Width, yellowbox.Width, greenbox.Width = width, width, width
redbox.BgColor = ui.ColorRed
yellowbox.BgColor = ui.ColorYellow
greenbox.BgColor = ui.ColorGreen
ui.Body.AddRows(
ui.NewRow(
ui.NewCol(12, 0, p),
),
ui.NewRow(
ui.NewCol(10, 0, ls),
ui.NewCol(2, 0, redbox, yellowbox, greenbox),
),
ui.NewRow(
ui.NewCol(12, 0, info),
),
)
ui.Body.Align()
ui.Render(ui.Body)
return ls, info, redbox, yellowbox, greenbox
}
func (scr *Screen) Blit(x, y int) {
termWidth, _ := tb.Size()
startOffset := (y * termWidth) + x
cells := tb.CellBuffer()
for i := 0; i < scr.height; i++ {
tbRangeStart := startOffset + (i * termWidth)
tbRangeEnd := tbRangeStart + scr.width
scrRangeStart := i * scr.width
scrRangeEnd := scrRangeStart + scr.width
copy(cells[tbRangeStart:tbRangeEnd], scr.buffer[scrRangeStart:scrRangeEnd])
}
}
func printStatus(status string) {
termw, termh := term.Size()
statusLine := termh - 1
// clear
for i := 0; i < termw; i++ {
SetCell(statusLine, i, ' ', term.ColorBlack, term.ColorWhite)
}
// draw
o := 0
for _, r := range status {
SetCell(statusLine, o, r, term.ColorBlack, term.ColorWhite)
o += runewidth.RuneWidth(r)
}
}
func printErrorStatus(err string) {
termw, termh := term.Size()
statusLine := termh - 1
// clear
for i := 0; i < termw; i++ {
SetCell(statusLine, i, ' ', term.ColorBlack, term.ColorRed)
}
// draw
o := 0
for _, r := range err {
SetCell(statusLine, o, r, term.ColorBlack, term.ColorRed)
o += runewidth.RuneWidth(r)
}
}
func calibratePoint(et gaze.EyeTracker, x, y float64) {
termbox.Clear(0, 0)
sizeX, sizeY := termbox.Size()
dx, dy := int(float64(sizeX)*x), int(float64(sizeY)*y)
termbox.CellBuffer()[sizeX*dy+dx] = termbox.Cell{'#', marker, termbox.ColorDefault}
termbox.Flush()
//log.Printf("Termbox Size: (%d, %d)", sizeX, sizeY)
log.Printf("Calibrating (%.3f, %.3f)", x, y)
done := make(chan struct{})
time.Sleep(1 * time.Second) //Minimum time. Gives user time to react.
et.AddPointToCalibration(gaze.NewPoint2D(x, y), func(err error) {
close(done) //Synchronizing async call.
})
<-done
}
// selects the next row
func (w *Window) NextRow() {
_, maxy := termbox.Size()
if w.scrollable == true {
if w.selected+w.scrollPos == len(w.Rows)-1 {
return // bottom of the visible output
} else if w.selected == maxy-1 {
w.ScrollDown()
} else {
w.selected += 1
}
} else {
w.selected += 1
}
}
func drawMessage(s string) {
ns := addNewlines(s, 80)
w, h := tb.Size()
wc := w / 2
hc := h / 2
rectW := 82
rectH := strings.Count(ns, "\n") + 3
rectX := wc - rectW/2
rectY := hc - rectH/2
drawRectangle(rectX, rectY, rectW, rectH)
drawString(rectX+2, rectY+1, ns)
}
func main() {
if err := tb.Init(); err != nil {
panic(err)
} else {
defer tb.Close()
tb.HideCursor()
}
x, y := tb.Size()
drawBoundingBox(0, x-1, 0, y-1)
drawTypedBoundingBox(tb.ColorBlack, tb.ColorWhite)(x/3, 2*x/3, y/3, 2*y/3)
fillInBox(x/3+1, 2*x/3-1, y/3+1, 2*y/3-1, tb.ColorBlack, tb.ColorWhite)
tb.Flush()
time.Sleep(3 * time.Second)
}
func drawPoint(point gaze.Point2D, attributes termbox.Attribute) {
sizeX, sizeY := termbox.Size()
x, y := int(float64(sizeX)*point.X()), int(float64(sizeY)*point.Y())
switch {
case x < 0:
x = 0
case x >= sizeX:
x = sizeX - 1
}
switch {
case y < 0:
y = 0
case y >= sizeY:
y = sizeY - 1
}
termbox.CellBuffer()[sizeX*y+x] = termbox.Cell{'O', attributes, termbox.ColorWhite}
}
func draw_debris(well *Well) {
term_col, term_row := tb.Size()
well_depth := len(well.debris_map)
vert_headroom := int((term_row-well_depth)/2) - 1
for row := range well.debris_map {
for col := range well.debris_map[row] {
row_loc := vert_headroom + len(well.debris_map) - row
col_loc := ((term_col / 2) - len(well.debris_map[0])) + (col * 2)
color := set_color(well.debris_map[row][col])
tb.SetCell(col_loc, row_loc, 0, 0, color)
tb.SetCell(col_loc+1, row_loc, 0, 0, color)
}
}
}
func render(s state) {
tb.Clear(tb.ColorDefault, tb.ColorDefault)
w, h := tb.Size()
drawString(1, 1, fmt.Sprint("dust: ", s.dust))
if s.howManyBuilt(searcher.name) > 0 {
drawString(1, 2, fmt.Sprint("data disks: ", s.disks))
}
if s.highestDust >= collector.baseCost {
drawString(1, 3,
fmt.Sprint(
"[c]ollectors(", collector.currentCost(s), "): ",
s.howManyBuilt(collector.name)))
}
if s.highestDust >= searcher.baseCost {
drawString(1, 4, fmt.Sprint(
"[s]earcher(", searcher.currentCost(s), "): ",
s.howManyBuilt(searcher.name)))
}
helpMessage := "hit [space] to take a turn, [h] for help, [q] or [Esc] to quit"
nextTurnMessage := fmt.Sprint(
"next turn:", getDescription(s.nextTurnEvent))
drawString((w/2)-(len(helpMessage)/2), h-1, helpMessage)
drawString((w/2)-(len(nextTurnMessage)/2), h-2, nextTurnMessage)
if len(s.message) > 0 {
drawMessage(s.message)
}
err := tb.Flush()
if err != nil {
panic(err)
}
}
func NewTermView(ctl mvc.Controller) *TermView {
// initialize terminal display
termbox.Init()
w, _ := termbox.Size()
v := &TermView{
ctl: ctl,
updates: ctl.Updates().Reg(),
redraw: util.NewBroadcast(),
flush: make(chan int),
shutdown: make(chan int),
Logger: log.NewPrefixLogger("view", "term"),
area: NewArea(0, 0, w, 10),
}
ctl.Go(v.run)
ctl.Go(v.input)
return v
}
func (g *game) draw() {
// update board and racks
g.board.qb = g.pos().Board()
g.rack1.player = g.playerById(0)
g.rack2.player = g.playerById(1)
g.w, g.h = termbox.Size()
termbox.Clear(fgcolor, bgcolor)
defer termbox.Flush()
// board
g.board.x = (g.w - g.board.w*2 + 2 + 1) / 2
g.board.y = (g.h - g.board.h - g.rack1.h - g.editbox.h - 2) / 2
g.board.draw()
// racks
g.rack1.x = g.board.x
g.rack1.y = g.board.y + g.board.h + 2
g.rack1.draw()
g.rack2.x = g.board.x + g.rack1.w + 2
g.rack2.y = g.board.y + g.board.h + 2
g.rack2.draw()
if g.player().Id() == 0 {
g.rack1.setActive()
} else {
g.rack2.setActive()
}
// editbox
g.editbox.x = g.board.x + g.editbox.w/2 + 1
g.editbox.y = g.rack1.y - g.rack1.h + 4
g.editbox.draw()
// legend
if g.showLegend {
g.legend.x = g.board.x + g.board.w*2 - 8
g.legend.y = g.board.y + g.board.h
g.legend.draw()
}
}