func draw() bool { termbox.Clear(termbox.ColorDefault, termbox.ColorDefault) dots := NewCellsBox([]termbox.Cell{dot, dot, dot, dot, dot, dot, dot, dot, dot, dot, dot, dot, dot, dot, dot, dot, dot, dot, dot, dot, }, 5) greenPlus := NewCellsBox([]termbox.Cell{greenPlus, greenPlus, greenPlus, greenPlus}, 2) if err := greenPlus.DrawInto(dots, 1, 2); err != nil { termbox.Close() fmt.Fprintf(os.Stderr, "%v1\r\n", err) return false } if err := dots.DrawInto(&TermBox{}, 0, 0); err != nil { termbox.Close() fmt.Fprintf(os.Stderr, "%v2\r\n", err) return false } termbox.SetCell(0, 0, '+', termbox.ColorRed, termbox.ColorDefault) termbox.SetCell(1, 0, '+', termbox.ColorRed, termbox.ColorDefault) termbox.SetCell(7, 0, '+', termbox.ColorRed, termbox.ColorDefault) termbox.Flush() return true }
func (b *board) highlightPos(x, y int) { if !b.in(x, y) { return } b.curPosVert = !b.curPosVert fg := fgcolor | termbox.AttrBold bg := bgcolor | termbox.AttrBold defch := '·' var xch, ych rune if b.curPosVert { xch = defch ych = '⇣' } else { xch = '⇢' ych = defch } // draw position indicators for i := b.x; i < x; i += 2 { termbox.SetCell(i, y, xch, fg, bg) } for i := b.y; i <= y; i++ { if (x-b.x)%2 == 1 { termbox.SetCell(x-1, i, ych, fg, bg) } else { termbox.SetCell(x, i, ych, fg, bg) } } termbox.Flush() }
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 drawSections() { if term.dm.Curr == nil || len(term.dm.Curr.Sections) == 0 { return } st := term.ofs.trk en := st + len(term.dm.Curr.Sections) + 3 drawBottomCorners(en) drawHLines(en) drawVLines(vLine{0, st, en}, vLine{79, st, en}, vLine{28, st, en}) // pattern tempo if term.mode == tempoMode { msg := fmt.Sprintf("tracks, bpm = %v", term.input.String()) tbPrintDef(2, st, msg) tbPrint(16+len(msg), st, tb.ColorBlack, tb.ColorYellow, " ") } else { msg := fmt.Sprintf("tracks, bpm = %v", term.dm.Curr.Tempo) tbPrintDef(2, st, msg) } // beat numbers for i := 0; i < 16; i++ { if term.beat == i { tbPrintf(i*3+30, st, tb.ColorBlue, tb.ColorBlack, "%2d", i+1) } else { tbPrintf(i*3+30, st, tb.ColorWhite, tb.ColorBlack, "%2d", i+1) } } // sequence sections for i, sec := range term.dm.Curr.Sections { tbPrintf(2, st+2+i, tb.ColorWhite, tb.ColorBlack, "%4d", sec.ID) if sec.Enabled { tbPrintf(8, st+2+i, tb.ColorGreen, tb.ColorBlack, "%18s", sec.Name) } else { tbPrintf(8, st+2+i, tb.ColorWhite, tb.ColorBlack, "%18s", sec.Name) } if term.cur.sec == 1 && term.cur.row == i { tbPrint(27, st+2+i, tb.ColorWhite, tb.ColorBlack, "*") } for j, beat := range sec.Beats { conb := term.cur.sec == 1 && term.cur.row == i && term.cur.col == j if beat && conb { tb.SetCell(j*3+31, st+2+i, 'x', tb.ColorMagenta, tb.ColorYellow) } else if beat && j == term.beat { tb.SetCell(j*3+31, st+2+i, 'x', tb.ColorBlue, tb.ColorBlack) } else if beat { setCellDefaultColor(j*3+31, st+2+i, 'x') } else if conb { tb.SetCell(j*3+31, st+2+i, ' ', tb.ColorDefault, tb.ColorGreen) } } } }
func draw() bool { termbox.Clear(termbox.ColorDefault, termbox.ColorDefault) termbox.SetCell(0, 0, 'H', 0, 0) termbox.SetCell(1, 0, 'e', 0, 0) termbox.SetCell(2, 0, 'y', 0, 0) textField.DrawInto(&box.TermBox{}, 4, 0) termbox.Flush() return true }
// Draws borders _outside_ the func DrawBorder(p BorderedPanel) { r := p.Bounds() b := p.Border() var border []rune switch b.Ch { case 's', 'S': border = singleBorder case 'd', 'D': border = doubleBorder default: border = []rune{b.Ch, b.Ch, b.Ch, b.Ch, b.Ch, b.Ch} } termbox.SetCell(r.Min.X-1, r.Min.Y-1, borderClash(r.Min.X-1, r.Min.Y-1, border[4], 3), b.Fg, b.Bg) termbox.SetCell(r.Max.X, r.Min.Y-1, borderClash(r.Max.X, r.Min.Y-1, border[5], 6), b.Fg, b.Bg) termbox.SetCell(r.Min.X-1, r.Max.Y, borderClash(r.Min.X-1, r.Max.Y, border[3], 9), b.Fg, b.Bg) termbox.SetCell(r.Max.X, r.Max.Y, borderClash(r.Max.X, r.Max.Y, border[2], 12), b.Fg, b.Bg) for x := r.Min.X; x < r.Min.X+r.Dx(); x++ { termbox.SetCell(x, r.Min.Y-1, borderClash(x, r.Min.Y-1, border[0], 2), b.Fg, b.Bg) termbox.SetCell(x, r.Min.Y+r.Dy(), borderClash(x, r.Min.Y+r.Dy(), border[0], 8), b.Fg, b.Bg) } for y := r.Min.Y; y < r.Min.Y+r.Dy(); y++ { termbox.SetCell(r.Min.X-1, y, borderClash(r.Min.X-1, y, border[1], 1), b.Fg, b.Bg) termbox.SetCell(r.Min.X+r.Dx(), y, borderClash(r.Min.X+r.Dx(), y, border[1], 4), b.Fg, b.Bg) } }
func (m *Mainboard) Init(xStart int, yStart int, width int, height int) { m.xStart = xStart m.yStart = yStart m.width = width m.height = height var x int = xStart + 1 var y int = yStart + 1 // Draw Top tm.SetCell(xStart, yStart, '+', tm.ColorDefault, tm.ColorDefault) for x < xStart+width { tm.SetCell(x, yStart, '-', tm.ColorDefault, tm.ColorDefault) x++ } tm.SetCell(x, yStart, '+', tm.ColorDefault, tm.ColorDefault) // Draw Sides for y < yStart+height { tm.SetCell(xStart, y, '|', tm.ColorDefault, tm.ColorDefault) tm.SetCell(xStart+width, y, '|', tm.ColorDefault, tm.ColorDefault) y++ } // Draw Bottom x = xStart + 1 tm.SetCell(xStart, y, '+', tm.ColorDefault, tm.ColorDefault) for x < xStart+width { tm.SetCell(x, y, '-', tm.ColorDefault, tm.ColorDefault) x++ } tm.SetCell(x, y, '+', tm.ColorDefault, tm.ColorDefault) }
// drawRectWithAttr draws a rectangle with unicode borders at position (x,y) with area of // w*h with the given foreground and background attributes. Attributes can be // colors and/or styling. func drawRectWithAttr(x, y, w, h int, fgattr, bgattr termbox.Attribute) { // top border termbox.SetCell(x-1, y-1, '┌', fgattr, bgattr) fill(x, y-1, w, 1, '─') termbox.SetCell(x+w, y-1, '┐', fgattr, bgattr) // body border fill(x-1, y, 1, h, '│') fill(x+w, y, 1, h, '│') // bottom border termbox.SetCell(x-1, y+h, '└', fgcolor, bgcolor) fill(x, y+h, w, 1, '─') termbox.SetCell(x+w, y+h, '┘', fgcolor, bgcolor) }
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 }
func print_tb(x, y int, fg, bg tb.Attribute, msg string) { for _, c := range msg { tb.SetCell(x, y, c, fg, bg) x++ } tb.Flush() }
func (a *area) Clear() { for i := 0; i < a.w; i++ { for j := 0; j < a.h; j++ { termbox.SetCell(a.x+i, a.y+j, ' ', a.fgColor, a.bgColor) } } }
func fillInBox(xStart, xMax, yStart, yMax int, fg, bg tb.Attribute) { for i := xStart; i <= xMax; i++ { for j := yStart; j <= yMax; j++ { tb.SetCell(i, j, ' ', fg, bg) } } }
func main() { err := tb.Init() if err != nil { panic(err) } defer tb.Close() tb.SetInputMode(tb.InputEsc) tb.Clear(tb.ColorCyan, tb.ColorBlue) tb.Flush() loop: for i := 0; ; i++ { ev := tb.PollEvent() switch ev.Type { case tb.EventKey: if ev.Key == tb.KeyCtrlC { break loop } tb.SetCell(i, i, ev.Ch, tb.ColorGreen, tb.ColorBlack) tb.Flush() case tb.EventError: panic(ev.Err) } } }
// fill draws a rectangle at position (x,y) with area of w*h and fills the // inside with r. func fill(x, y, w, h int, r rune) { for ly := 0; ly < h; ly++ { for lx := 0; lx < w; lx++ { termbox.SetCell(x+lx, y+ly, r, fgcolor, bgcolor) } } }
func tbprint(origin coord, msg string, fg, bg termbox.Attribute) coord { for _, r := range msg { termbox.SetCell(origin.x, origin.y, r, fg, bg) origin = origin.right(1) } return origin }
func buildInnerField(f field, origin coord) { var symbol rune fg := termbox.ColorWhite bg := termbox.ColorBlack for y := 0; y < f.dimensions.y; y++ { for x := 0; x < f.dimensions.x; x++ { theoretical := coord{x, y} statusHere := f.statusAt(theoretical) switch statusHere { case unknown: symbol = ' ' case empty: symbol = '~' fg = termbox.ColorCyan case miss: symbol = '~' fg = termbox.ColorGreen case hit: symbol = '▓' fg = termbox.ColorRed case occupied: symbol = '█' } actual := theoretical.viewPos(origin) termbox.SetCell(actual.x, actual.y, symbol, fg, bg) } } }
func clearArea(r image.Rectangle, bg Attribute) { for i := r.Min.X; i < r.Max.X; i++ { for j := r.Min.Y; j < r.Max.Y; j++ { tm.SetCell(i, j, ' ', tm.ColorDefault, toTmAttr(bg)) } } }
func print_tb(x, y int, msg string, fg, bg termbox.Attribute) { for _, c := range []rune(msg) { termbox.SetCell(x, y, c, fg, bg) x += runewidth.RuneWidth(c) } termbox.Flush() }
func termboxLogPrint(msg string) { x := 0 y := 20 for _, c := range msg { termbox.SetCell(x, y, c, termbox.ColorWhite, termbox.ColorBlack) x++ } }
func Draw(s Surface, xorigin, yorigin int) { w, h := s.Size() for y := 0; y < h; y++ { for x := 0; x < w; x++ { termbox.SetCell(xorigin+x, yorigin+y, s.Rune(x, y), 0, 0) } } }
// PutChar sets value for the Canvas cell: rune and its colors. Returns result of // operation: e.g, if the symbol position is outside Canvas the operation fails // and the function returns false func PutChar(x, y int, r rune) bool { if InClipRect(x, y) { term.SetCell(x, y, r, canvas.textColor, canvas.backColor) return true } return false }
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 debug_tb(x, y int, fg, bg tb.Attribute, msg string) { for _, c := range msg { tb.SetCell(x, y, c, fg, bg) x++ } tb.Flush() _ = tb.PollEvent().Ch }
func drawRectangle(x, y, w, h int) { for i := x; i < w+x; i++ { for j := y; j < h+y; j++ { tb.SetCell(i, j, ' ', tb.ColorBlack, tb.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 (m *ModeSearch) HandleKey(s *Session, ev termbox.Event) (Mode, error) { if m.s == nil { m.s = s m.b = util.NewBuffer([]byte{}) m.view = &view.Wrap{} m.view.SetBuf(m.b) m.view.SetSize(s.W-1, 1) m.view.SetTabwidth(1) } var err error if ev.Ch != 0 { m.b.Insert(m.pos, ev.Ch) m.pos++ } switch ev.Key { case termbox.KeyEnter: s.Search, err = regexp.Compile(string(m.b.Bytes())) if err != nil { msg := err.Error() for i, ch := range msg { termbox.SetCell(i, s.H, ch, 0, 0) } return &ModeEdit{}, nil } s.UpdSearch() s.NextMatch() return &ModeEdit{}, nil case termbox.KeySpace: m.b.Insert(m.pos, ' ') m.pos++ case termbox.KeyBackspace, termbox.KeyBackspace2: m.b.Delete(m.pos, -1) m.pos-- case termbox.KeyEsc: return &ModeEdit{}, nil } surf := m.view.Render() termbox.SetCell(0, s.H, '/', 0, 0) view.Draw(surf, 1, s.H) return m, nil }
// Render renders all Bufferer in the given order from left to right, // right could overlap on left ones. func Render(rs ...Bufferer) { tm.Clear(tm.ColorDefault, toTmAttr(theme.BodyBg)) for _, r := range rs { buf := r.Buffer() for _, v := range buf { tm.SetCell(v.X, v.Y, v.Ch, toTmAttr(v.Fg), toTmAttr(v.Bg)) } } tm.Flush() }
func buildLabels(f field, origin coord) { var labelOrigin coord // column headers labelOrigin.x = origin.x labelOrigin.y = origin.y - 1 for i, symbol := range f.cols() { theoretical := coord{i, 0} actual := theoretical.viewPos(labelOrigin) termbox.SetCell(actual.x, actual.y, symbol, termbox.ColorMagenta, termbox.ColorBlack) } // row headers labelOrigin.x = origin.x - 2 labelOrigin.y = origin.y for i, symbol := range f.rows() { theoretical := coord{0, i} actual := theoretical.viewPos(labelOrigin) termbox.SetCell(actual.x, actual.y, symbol, termbox.ColorMagenta, termbox.ColorBlack) } }
func printBoard(board TheirBoard, xStart, yStart int) { print_tb(xStart-1, 9, "/ - - - - - - - - - -\\", termbox.ColorBlack, termbox.ColorWhite) // X then Y // y := yStart for y := 0; y < 10; y++ { for x := 0; x < 10; x++ { termbox.SetCell(xStart-1, yStart+y, '|', termbox.ColorBlack, termbox.ColorWhite) switch board[x][y] { case 1: termbox.SetCell(xStart+(x*2), yStart+y, 'X', termbox.ColorRed, termbox.ColorBlack) case 2: termbox.SetCell(xStart+(x*2), yStart+y, ' ', 8, termbox.ColorBlack) default: termbox.SetCell(xStart+(x*2), yStart+y, '~', termbox.ColorGreen, termbox.ColorCyan) termbox.SetCell(xStart+(x*2)-1, yStart+y, ' ', termbox.ColorGreen, termbox.ColorCyan) } } termbox.SetCell(xStart+(10*2), yStart+y, '|', termbox.ColorBlack, termbox.ColorWhite) } termbox.Flush() print_tb(xStart-1, yStart+10, "\\ - - - - - - - - - -/", termbox.ColorBlack, termbox.ColorWhite) }
func draw(img image.Image) { w, h := termbox.Size() iw, ih := img.Bounds().Max.X, img.Bounds().Max.Y sw, sh := fit(w, h, iw*2, ih) termbox.Clear(termbox.ColorDefault, termbox.ColorDefault) for y := 0; y < h; y++ { for x := 0; x < w; x++ { if x >= sw || y >= sh { termbox.SetCell(x, y, ' ', termbox.ColorDefault, termbox.ColorDefault) continue } xi := x * img.Bounds().Max.X / sw yi := y * img.Bounds().Max.Y / sh a := palette.Convert(img.At(xi, yi)) if at, ok := a.(attrColor); ok { termbox.SetCell(x, y, ' ', termbox.ColorDefault, termbox.Attribute(at)) } } } termbox.Flush() }