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 (f *Form) Run() error { draw := func() bool { termbox.Clear(termbox.ColorDefault, termbox.ColorDefault) f.DrawInto(&box.TermBox{}, 0, 0) termbox.Flush() return true } err := termbox.Init() defer termbox.Close() if err != nil { return err } if draw() { f.running = true for f.running { ev := termbox.PollEvent() if !f.HandleEvent(&ev) { f.running = false } draw() } } else { return errors.New("fail sadness") } return nil }
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) } } }
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 (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 } } }
/* 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 draw() bool { termbox.Clear(termbox.ColorDefault, termbox.ColorDefault) labelField.DrawInto(&box.TermBox{}, 0, 0) termbox.Flush() return true }
func clear(fg, bg termbox.Attribute) error { mutex.Lock() err := termbox.Clear(fg, bg) mutex.Unlock() updateRootBuffer() return err }
// Repaints everything on the screen func RefreshScreen() { term.Clear(ColorWhite, ColorBlack) for _, wnd := range comp.windows { wnd.Draw() } term.Flush() }
// 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 drawDrumMachine() { tb.Clear(tb.ColorDefault, tb.ColorDefault) term.ofs.seq = drawHeader() if term.mode == newModePickSample || term.mode == newModeEnterName { term.ofs.trk = drawSamples() } else { term.ofs.trk = drawSequences() drawSections() } tb.Flush() }
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 }
func (tb termboxImpl) WaitEvent() bool { switch ev := tb.proxy(); ev.Type { // PollEvent will be blocked case termbox.EventKey: if ev.Key == termbox.KeyEsc { return true } case termbox.EventResize: termbox.Clear(termbox.ColorDefault, termbox.ColorDefault) case termbox.EventError: panic(ev.Err) } return false }
func main() { termbox.Init() defer termbox.Close() et, err := gaze.AnyEyeTracker() if err != nil { log.Println(err) return } et.Connect() defer et.Close() termbox.Clear(0, termbox.ColorWhite) //Set bg to white. et.StartTracking(func(data *gaze.GazeData) { ts := data.TrackingStatus() if ts >= gaze.BothEyesTracked && ts != gaze.OneEyeTrackedUnknownWhich { termbox.Clear(0, termbox.ColorWhite) drawPoint(*data.Left().GazePointOnDisplay(), leftMarker) drawPoint(*data.Right().GazePointOnDisplay(), rightMarker) termbox.Flush() } }) done := make(chan struct{}) go func() { for { event := termbox.PollEvent() if event.Type == termbox.EventKey && event.Key == termbox.KeyEsc { close(done) } } }() <-done }
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 }
// Display the baord // b1 our board = b2 their board func Display(b1, b2 TheirBoard, writer io.Writer) { fmt.Println("Display") // Clear the terminal termbox.Clear(termbox.ColorWhite, termbox.ColorBlack) xStart := 10 yStart := 10 print_tb(5, 5, "Battle Ships", termbox.ColorMagenta, termbox.ColorWhite) printBoard(b1, xStart, yStart) printBoard(b2, xStart+30, yStart) }
func (this *Game) Draw() { tb.Clear(tb.ColorDefault, tb.ColorDefault) this.ForEachActivePanel(func(p *Panel) { p.Clear() p.DrawBorder() }) x, y := this.Player.Position() this.ViewPanel.Screen.SetCell(x, y, '@', tb.ColorWhite, tb.ColorBlack) this.ForEachActivePanel(func(p *Panel) { p.Blit() }) tb.Flush() }
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 main() { rand.Seed(time.Now().UnixNano()) dim := dimensions{10, 10} ships := canonicalBattleship() attackField := makeScatteredField(dim, ships, adversary) attackOrigin := coord{0, 0} defendField := makeScatteredField(dim, ships, human) defendOrigin := coord{30, 0} printOrigin := coord{0, 30} termbox.Init() defer termbox.Close() termbox.HideCursor() termbox.Clear(termbox.ColorBlack, termbox.ColorBlack) buildLabels(attackField, attackOrigin) buildLabels(defendField, defendOrigin) // game loop var msg_us, msg_them string for attackField.shipsLeft() && defendField.shipsLeft() { buildInnerField(attackField, attackOrigin) buildInnerField(defendField, defendOrigin) termbox.Flush() msg_us = move(&attackField) termbox.Flush() msg_them = counterMove(&defendField) tbprint(printOrigin, msg_us, termbox.ColorWhite, termbox.ColorBlack) tbprint(printOrigin.down(1), msg_them, termbox.ColorWhite, termbox.ColorBlack) termbox.Flush() } if defendField.shipsLeft() { fmt.Println("You've won! Congratulations.") } else if attackField.shipsLeft() { fmt.Println("You've lost!") } }
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() } }
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() }
func (w *Window) Redraw() error { w.Lock() err := termbox.Clear(w.Fg, w.Bg) maxx, maxy := termbox.Size() if err != nil { return err } for i, row := range w.Rows[w.scrollPos:] { for _, c := range row.Text { if i == w.selected { termbox.SetCell(w.xpos, w.ypos, rune(c), row.Fg, row.Bg) } else { termbox.SetCell(w.xpos, w.ypos, rune(c), w.Fg, w.Bg) } if w.xpos += 1; w.xpos > maxx { break } } w.xpos = 0 if w.ypos += 1; w.ypos > maxy { break } } w.ypos = 0 w.xpos = 0 // redundant but lets avoid problems later w.Unlock() return nil }
func main() { // log stack defer func() { if r := recover(); r != nil { buf := make([]byte, 1024*1024*8) n := runtime.Stack(buf, true) errFile, err := os.Create("err.local") if err != nil { return } errFile.WriteString(fmt.Sprintf("error: %v\n\n", r)) errFile.Write(buf[:n]) errFile.Close() } }() // termbox err := box.Init() if err != nil { log.Fatal(err) } defer box.Close() go func() { for { ev := box.PollEvent() if ev.Type == box.EventKey { if ev.Key == box.KeyEsc { os.Exit(0) } } } }() // socks5 server socksServer, err := socks.New(globalConfig["local"]) if err != nil { log.Fatal(err) } clientReader := cr.New() defer clientReader.Close() // connect to remote server addr, err := net.ResolveTCPAddr("tcp", globalConfig["remote"]) if err != nil { log.Fatal("cannot resolve remote addr ", err) } commId := rand.Int63() cipherKey := []byte(globalConfig["key"]) getServerConn := func() *net.TCPConn { serverConn, err := net.DialTCP("tcp", nil, addr) if err != nil { log.Fatal("cannot connect to remote server ", err) } // auth origin := genRandBytes(64) encrypted, err := encrypt(cipherKey, origin) if err != nil { log.Fatal(err) } serverConn.Write(origin) serverConn.Write(encrypted) var response byte err = binary.Read(serverConn, binary.LittleEndian, &response) if err != nil || response != byte(1) { log.Fatal("auth fail ", err) } // sent comm id binary.Write(serverConn, binary.LittleEndian, commId) return serverConn } comm := session.NewComm(getServerConn(), cipherKey) // keepalive keepaliveSession := comm.NewSession(-1, []byte(keepaliveSessionMagic), nil) keepaliveTicker := time.NewTicker(PING_INTERVAL) // heartbeat heartbeat := time.NewTicker(time.Second * 1) t1 := time.Now() delta := func() string { return fmt.Sprintf("%-.0fs", time.Now().Sub(t1).Seconds()) } var memStats runtime.MemStats printer := NewPrinter(40) reconnectTimes := 0 loop: for { select { // ping case <-keepaliveTicker.C: keepaliveSession.Signal(sigPing) // heartbeat case <-heartbeat.C: if time.Now().Sub(comm.LastReadTime) > BAD_CONN_THRESHOLD { comm.UseConn(getServerConn()) reconnectTimes += 1 } box.Clear(box.ColorDefault, box.ColorDefault) printer.Reset() printer.Print("conf %s", CONFIG_FILEPATH) printer.Print("listening %v", globalConfig["local"]) printer.Print("connected %v", addr) printer.Print("reconnected %d times", reconnectTimes) printer.Print("%s %s >-< %s", delta(), formatFlow(comm.BytesSent), formatFlow(comm.BytesReceived)) runtime.ReadMemStats(&memStats) printer.Print("%s memory in use", formatFlow(memStats.Alloc)) printer.Print("--- %d connections %d sessions ---", clientReader.Count, len(comm.Sessions)) for _, sessionId := range ByValue(comm.Sessions, func(a, b reflect.Value) bool { return a.Interface().(*session.Session).StartTime.After(b.Interface().(*session.Session).StartTime) }).Interface().([]int64) { session := comm.Sessions[sessionId] serv, ok := session.Obj.(*Serv) if !ok { continue } if serv.localClosed { printer.Print("Lx %s", serv.hostPort) } else if serv.remoteClosed { printer.Print("Rx %s", serv.hostPort) } else { printer.Print(serv.hostPort) } } box.Flush() // new socks client case socksClient := <-socksServer.Clients: serv := &Serv{ clientConn: socksClient.Conn, hostPort: socksClient.HostPort, } serv.session = comm.NewSession(-1, []byte(socksClient.HostPort), serv) clientReader.Add(socksClient.Conn, serv) // client events case ev := <-clientReader.Events: serv := ev.Obj.(*Serv) switch ev.Type { case cr.DATA: // client data serv.session.Send(ev.Data) case cr.EOF, cr.ERROR: // client close if serv.session == nil { // serv already closed continue loop } serv.session.Signal(sigClose) serv.localClosed = true if serv.remoteClosed { serv.Close() } else { time.AfterFunc(time.Minute*3, func() { serv.Close() }) } } // server events case ev := <-comm.Events: switch ev.Type { case session.SESSION: log.Fatal("local should not have received this type of event") case session.DATA: serv := ev.Session.Obj.(*Serv) serv.clientConn.Write(ev.Data) case session.SIGNAL: sig := ev.Data[0] if sig == sigClose { serv := ev.Session.Obj.(*Serv) time.AfterFunc(time.Second*3, func() { serv.clientConn.Close() }) serv.remoteClosed = true if serv.localClosed { serv.Close() } else { time.AfterFunc(time.Minute*3, func() { serv.Close() }) } } else if sig == sigPing { } case session.ERROR: log.Fatal("error when communicating with server ", string(ev.Data)) } } } }
func run(projection bool) { var t []Point3D var p *Point3D tg.Clear(tg.ColorRed|tg.AttrBold, tg.ColorBlack|tg.AttrBold) angleX, angleY, angleZ := 0.0, 0.0, 0.0 c := NewCanvas() for { //for rounds := 0; rounds < 1000; rounds++ { // Will hold transformed vertices. t = []Point3D{} for _, v := range vertices { // Rotate the point around X axis, then around Y axis, and finally around Z axis. p = &v p = p.RotateX(angleX) p = p.RotateY(angleY) p = p.RotateZ(angleZ) if projection { // Transform the point from 3D to 2D p = p.Project(50, 50, 50, 50) } // Put the point in the list of transformed vertices t = append(t, *p) } for _, f := range faces { c.DrawLine(t[f[0]].x, t[f[0]].y, t[f[1]].x, t[f[1]].y) c.DrawLine(t[f[1]].x, t[f[1]].y, t[f[2]].x, t[f[2]].y) c.DrawLine(t[f[2]].x, t[f[2]].y, t[f[3]].x, t[f[3]].y) c.DrawLine(t[f[3]].x, t[f[3]].y, t[f[0]].x, t[f[0]].y) } f := c.Frame(-40, -40, 80, 80) //stdscr.AddStr(0, 0, '{0}\n'.format(f)) xoffset := 2 for y, line := range strings.Split(f, "\n") { pos := 0 for _, r := range line { // iterates over runes, not positions tg.SetCell(xoffset+pos, y, r, tg.ColorRed|tg.AttrBold, tg.ColorBlack|tg.AttrBold) pos++ } } //stdscr.Refresh() tg.Flush() angleX += 2.0 angleY += 3.0 angleZ += 5.0 time.Sleep(50 * time.Millisecond) c.Clear() //tg.Clear(tg.ColorRed|tg.AttrBold, tg.ColorBlack|tg.AttrBold) // TODO: Fork termbox and implement PeekEvent //e := PeekEvent() //switch e.Type { //case EventKey: // switch e.Key { // case KeyEsc, KeyEnter, KeySpace: // return // } //} } }
func termboxExample() { err := termbox.Init() if err != nil { panic(err) } defer termbox.Close() termbox.SetInputMode(termbox.InputEsc | termbox.InputMouse) termbox.Clear(termbox.ColorDefault, termbox.ColorDefault) termbox.Flush() inputmode := 0 ctrlxpressed := false loop: for { switch ev := termbox.PollEvent(); ev.Type { case termbox.EventKey: // コンソールが消えるっぽい if ev.Key == termbox.KeyCtrlS && ctrlxpressed { termbox.Sync() break } // Ctrl+Xモード時のCtrl+Qでループを抜ける if ev.Key == termbox.KeyCtrlQ && ctrlxpressed { break loop } if ev.Key == termbox.KeyCtrlC && ctrlxpressed { chmap := []termbox.InputMode{ termbox.InputEsc | termbox.InputMouse, termbox.InputAlt | termbox.InputMouse, termbox.InputEsc, termbox.InputAlt, } inputmode++ if inputmode >= len(chmap) { inputmode = 0 } termbox.SetInputMode(chmap[inputmode]) } // Ctrl+X 入モード切り替え if ev.Key == termbox.KeyCtrlX { ctrlxpressed = true } else { ctrlxpressed = false } termbox.Clear(termbox.ColorDefault, termbox.ColorDefault) dispatch_press(&ev) pretty_print_press(&ev) termbox.Flush() case termbox.EventResize: // ターミナルのサイズ変更で呼ばれる termbox.Clear(termbox.ColorDefault, termbox.ColorDefault) pretty_print_resize(&ev) termbox.Flush() case termbox.EventMouse: // ターミナルにタッチすると呼ばれる termbox.Clear(termbox.ColorDefault, termbox.ColorDefault) pretty_print_mouse(&ev) termbox.Flush() case termbox.EventError: panic(ev.Err) } } }
func main() { tm.Init() tm.Clear(tm.ColorDefault, tm.ColorDefault) gameOver := false playerWon := false emitter := emission.NewEmitter() emitter.On(event.EVENT_KEY_CTRL_C, func() { gameOver = true }) emitter.On(event.EVENT_PLAYER_WINS, func() { playerWon = true gameOver = true }) emitter.On(event.EVENT_PLAYER_LOSES, func() { gameOver = true }) keyboard := new(keyboard.Keyboard) keyboard.Init(emitter) mainboard := new(gameboard.Mainboard) mainboard.Init(1, 1, 50, 20) player := new(player.Player) player.Init(emitter, 1, 50, 20) alienManager := new(alien.AlienManager) alienManager.Init(emitter, 1, 1, 50, 20) var currentTime syscall.Timeval eventQueue := make(chan tm.Event) go func() { for { eventQueue <- tm.PollEvent() } }() timer := time.NewTimer(time.Duration(time.Millisecond * 60)) for gameOver == false { select { case ev := <-eventQueue: if ev.Type == tm.EventKey { keyboard.HandleEvent(ev.Key) } case <-timer.C: syscall.Gettimeofday(¤tTime) emitter.Emit(event.EVENT_HEARTBEAT, (int64(currentTime.Sec)*1e3 + int64(currentTime.Usec)/1e3)) timer.Reset(time.Duration(time.Millisecond * 60)) } tm.Flush() } tm.Close() if playerWon == true { fmt.Println("You win!") } else { fmt.Println("You lose :(") } }
func Clear() { tm.Clear(tm.ColorDefault, toTmAttr(ThemeAttr("bg"))) }
func main() { var newFlag bool flag.BoolVar(&newFlag, "new", false, "let tor to edit a new file.") flag.Parse() args := flag.Args() if len(args) == 0 { fmt.Println("please, set text file") os.Exit(1) } farg := args[len(args)-1] f, initL, initO, err := parseFileArg(farg) if err != nil { fmt.Println("file arg is invalid: ", err) os.Exit(1) } exist := true if _, err := os.Stat(f); os.IsNotExist(err) { exist = false } if !exist && !newFlag { fmt.Println("file not exist. please retry with -new flag.") os.Exit(1) } else if exist && newFlag { fmt.Println("file already exist.") os.Exit(1) } var text *Text if exist { text, err = open(f) if err != nil { fmt.Println(err) os.Exit(1) } } else { lines := make([]Line, 0) lines = append(lines, Line{""}) text = &Text{lines: lines, tabToSpace: false, tabWidth: 4, edited: false} } err = term.Init() if err != nil { panic(err) } defer term.Close() term.SetInputMode(term.InputAlt) // term.SetOutputMode(term.Output256) term.Clear(term.ColorDefault, term.ColorDefault) term.Flush() termw, termh := term.Size() mainarea := NewArea(Point{0, 0}, Point{termh - 1, termw}) win := NewWindow(mainarea.Size()) cursor := &Cursor{} selection := &Selection{} history := newHistory() mode := &ModeSelector{} mode.normal = &NormalMode{ text: text, cursor: cursor, selection: selection, history: history, f: f, mode: mode, copied: loadConfig("copy"), } mode.find = &FindMode{ mode: mode, str: loadConfig("find"), } mode.replace = &ReplaceMode{ mode: mode, str: loadConfig("replace"), } mode.gotoline = &GotoLineMode{ cursor: cursor, mode: mode, } mode.exit = &ExitMode{ f: f, cursor: cursor, mode: mode, } mode.current = mode.normal // will start tor as normal mode. selection.m = mode.normal // Set cursor. cursor.m = mode.normal if initL != -1 { l := initL // to internal line number if l != 0 { l-- } cursor.GotoLine(l) if initO != -1 { cursor.SetO(initO) } } else { l, b := loadLastPosition(f) cursor.GotoLine(l) cursor.SetCloseToB(b) } events := make(chan term.Event, 20) go func() { for { events <- term.PollEvent() } }() for { win.Follow(cursor, 3) clearScreen(mainarea) drawScreen(mainarea, win, mode.normal.text, selection, cursor) if mode.current.Error() != "" { printErrorStatus(mode.current.Error()) } else { printStatus(mode.current.Status()) } if mode.current == mode.normal { winP := cursor.Position().Sub(win.min) term.SetCursor(mainarea.min.o+winP.o, mainarea.min.l+winP.l) } else { term.SetCursor(vlen(mode.current.Status(), mode.normal.text.tabWidth), termh) } term.Flush() // wait for keyboard input select { case ev := <-events: switch ev.Type { case term.EventKey: mode.current.Handle(ev) case term.EventResize: term.Clear(term.ColorDefault, term.ColorDefault) termw, termh = term.Size() resizeScreen(mainarea, win, termw, termh) } } } }
func (tb termbox) Clear() { T.Clear(T.ColorWhite, T.ColorBlack) }
func (tb termboxImpl) Clear() { termbox.Clear(termbox.ColorDefault, termbox.ColorDefault) }