// initialize initializes the application. It will normally attempt to
// allocate a default screen if one is not already established.
func (app *Application) initialize() error {
if app.screen == nil {
if app.screen, app.err = tcell.NewScreen(); app.err != nil {
return app.err
}
app.screen.SetStyle(app.style)
}
return nil
}
func main() {
tcell.SetEncodingFallback(tcell.EncodingFallbackASCII)
s, e := tcell.NewScreen()
if e != nil {
fmt.Fprintf(os.Stderr, "%v\n", e)
os.Exit(1)
}
if e = s.Init(); e != nil {
fmt.Fprintf(os.Stderr, "%v\n", e)
os.Exit(1)
}
s.SetStyle(tcell.StyleDefault.
Foreground(tcell.ColorBlack).
Background(tcell.ColorWhite))
s.Clear()
quit := make(chan struct{})
go func() {
for {
ev := s.PollEvent()
switch ev := ev.(type) {
case *tcell.EventKey:
switch ev.Key() {
case tcell.KeyEscape, tcell.KeyEnter:
close(quit)
return
case tcell.KeyCtrlL:
s.Sync()
}
case *tcell.EventResize:
s.Sync()
}
}
}()
cnt := 0
dur := time.Duration(0)
loop:
for {
select {
case <-quit:
break loop
case <-time.After(time.Millisecond * 50):
}
start := time.Now()
makebox(s)
cnt++
dur += time.Now().Sub(start)
}
s.Fini()
fmt.Printf("Finished %d boxes in %s\n", cnt, dur)
fmt.Printf("Average is %0.3f ms / box\n", (float64(dur)/float64(cnt))/1000000.0)
}
// Init initializes the screen for use.
func Init() error {
outMode = OutputNormal
if s, e := tcell.NewScreen(); e != nil {
return e
} else if e = s.Init(); e != nil {
return e
} else {
screen = s
return nil
}
}
// InitScreen creates and initializes the tcell screen
func InitScreen() {
// Should we enable true color?
truecolor := os.Getenv("MICRO_TRUECOLOR") == "1"
// In order to enable true color, we have to set the TERM to `xterm-truecolor` when
// initializing tcell, but after that, we can set the TERM back to whatever it was
oldTerm := os.Getenv("TERM")
if truecolor {
os.Setenv("TERM", "xterm-truecolor")
}
// Initilize tcell
var err error
screen, err = tcell.NewScreen()
if err != nil {
fmt.Println(err)
os.Exit(1)
}
if err = screen.Init(); err != nil {
fmt.Println(err)
os.Exit(1)
}
// Now we can put the TERM back to what it was before
if truecolor {
os.Setenv("TERM", oldTerm)
}
// Default style
defStyle = tcell.StyleDefault.
Foreground(tcell.ColorDefault).
Background(tcell.ColorDefault)
// There may be another default style defined in the colorscheme
if style, ok := colorscheme["default"]; ok {
defStyle = style
}
screen.SetStyle(defStyle)
screen.EnableMouse()
}
func (g *Game) Init() error {
g.lives = 5
if screen, err := tcell.NewScreen(); err != nil {
return err
} else if err = screen.Init(); err != nil {
return err
} else {
screen.SetStyle(tcell.StyleDefault.
Background(tcell.ColorBlack).
Foreground(tcell.ColorWhite))
g.screen = screen
}
// XXX: Add a main screen
g.screen.EnableMouse()
g.level = GetLevel("level1")
if g.level == nil {
g.screen.Fini()
return errors.New("Cannot find data (did you run rebuild.sh?)")
}
g.lview = views.NewViewPort(g.screen, 0, 1, -1, -1)
g.level.SetView(g.lview)
g.level.SetGame(g)
g.sview = views.NewViewPort(g.screen, 0, 0, -1, 1)
g.sbar = views.NewTextBar()
g.sbar.SetView(g.sview)
g.quitq = make(chan struct{})
g.eventq = make(chan tcell.Event)
g.level.Reset()
g.level.ShowPress()
RegisterFallbacks(g.screen)
return nil
}
func main() {
s, e := tcell.NewScreen()
if e != nil {
fmt.Fprintf(os.Stderr, "%v\n", e)
os.Exit(1)
}
encoding.Register()
if e = s.Init(); e != nil {
fmt.Fprintf(os.Stderr, "%v\n", e)
os.Exit(1)
}
plain := tcell.StyleDefault
bold := style.Bold(true)
s.SetStyle(tcell.StyleDefault.
Foreground(tcell.ColorBlack).
Background(tcell.ColorWhite))
s.Clear()
quit := make(chan struct{})
style = bold
putln(s, "Press ESC to Exit")
putln(s, "Character set: "+s.CharacterSet())
style = plain
putln(s, "English: October")
putln(s, "Icelandic: október")
putln(s, "Arabic: أكتوبر")
putln(s, "Russian: октября")
putln(s, "Greek: Οκτωβρίου")
putln(s, "Chinese: 十月 (note, two double wide characters)")
putln(s, "Combining: A\u030a (should look like Angstrom)")
putln(s, "Emoticon: \U0001f618 (blowing a kiss)")
putln(s, "Airplane: \u2708 (fly away)")
putln(s, "Command: \u2318 (mac clover key)")
putln(s, "Enclose: !\u20e3 (should be enclosed exclamation)")
putln(s, "")
putln(s, "Box:")
putln(s, string([]rune{
tcell.RuneULCorner,
tcell.RuneHLine,
tcell.RuneTTee,
tcell.RuneHLine,
tcell.RuneURCorner,
}))
putln(s, string([]rune{
tcell.RuneVLine,
tcell.RuneBullet,
tcell.RuneVLine,
tcell.RuneLantern,
tcell.RuneVLine,
})+" (bullet, lantern/section)")
putln(s, string([]rune{
tcell.RuneLTee,
tcell.RuneHLine,
tcell.RunePlus,
tcell.RuneHLine,
tcell.RuneRTee,
}))
putln(s, string([]rune{
tcell.RuneVLine,
tcell.RuneDiamond,
tcell.RuneVLine,
tcell.RuneUArrow,
tcell.RuneVLine,
})+" (diamond, up arrow)")
putln(s, string([]rune{
tcell.RuneLLCorner,
tcell.RuneHLine,
tcell.RuneBTee,
tcell.RuneHLine,
tcell.RuneLRCorner,
}))
s.Show()
go func() {
for {
ev := s.PollEvent()
switch ev := ev.(type) {
case *tcell.EventKey:
switch ev.Key() {
case tcell.KeyEscape, tcell.KeyEnter:
close(quit)
return
case tcell.KeyCtrlL:
s.Sync()
}
case *tcell.EventResize:
s.Sync()
}
}
}()
<-quit
s.Fini()
}
func main() {
// parse flags
args, err := flags.Parse(&opts)
if err != nil {
flagError := err.(*flags.Error)
if flagError.Type == flags.ErrHelp {
return
}
if flagError.Type == flags.ErrUnknownFlag {
fmt.Println("Use --help to view all available options.")
return
}
fmt.Printf("Error parsing flags: %s\n", err)
return
}
if len(args) > 0 {
// we don't accept too much arguments..
fmt.Printf("Unknown argument '%s'.\n", args[0])
return
}
if opts.FPS < 1 || opts.FPS > 60 {
fmt.Println("Error: option --fps not within range 1-60")
os.Exit(1)
}
// Start profiling (if required)
if len(opts.Profile) > 0 {
f, err := os.Create(opts.Profile)
if err != nil {
fmt.Printf("Error opening profiling file: %s\n", err)
os.Exit(1)
}
pprof.StartCPUProfile(f)
}
// Juse a println for fun..
fmt.Println("Opening connection to The Matrix.. Please stand by..")
// setup logging with logfile /dev/null or ~/.gomatrix-log
filename := os.DevNull
if opts.Logging {
filename = os.Getenv("HOME") + "/.gomatrix-log"
}
logfile, err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
fmt.Printf("Could not open logfile. %s\n", err)
os.Exit(1)
}
defer logfile.Close()
log.SetOutput(logfile)
log.Println("-------------")
log.Println("Starting gomatrix. This logfile is for development/debug purposes.")
characters = halfWidthKana
if opts.Ascii {
characters = alphaNumerics
}
// seed the rand package with time
rand.Seed(time.Now().UnixNano())
// initialize tcell
if screen, err = tcell.NewScreen(); err != nil {
fmt.Println("Could not start tcell for gomatrix. View ~/.gomatrix-log for error messages.")
log.Printf("Cannot alloc screen, tcell.NewScreen() gave an error:\n%s", err)
os.Exit(1)
}
err = screen.Init()
if err != nil {
fmt.Println("Could not start tcell for gomatrix. View ~/.gomatrix-log for error messages.")
log.Printf("Cannot start gomatrix, screen.Init() gave an error:\n%s", err)
os.Exit(1)
}
screen.HideCursor()
screen.SetStyle(tcell.StyleDefault.
Background(tcell.ColorBlack).
Foreground(tcell.ColorBlack))
screen.Clear()
// StreamDisplay manager
go func() {
var lastWidth int
for newSizes := range sizesUpdateCh {
log.Printf("New width: %d\n", newSizes.width)
diffWidth := newSizes.width - lastWidth
if diffWidth == 0 {
// same column size, wait for new information
log.Println("Got resize over channel, but diffWidth = 0")
continue
}
if diffWidth > 0 {
log.Printf("Starting %d new SD's\n", diffWidth)
for newColumn := lastWidth; newColumn < newSizes.width; newColumn++ {
// create stream display
sd := &StreamDisplay{
column: newColumn,
stopCh: make(chan bool, 1),
streams: make(map[*Stream]bool),
newStream: make(chan bool, 1), // will only be filled at start and when a spawning stream has it's tail released
}
streamDisplaysByColumn[newColumn] = sd
// start StreamDisplay in goroutine
go sd.run()
// create first new stream
sd.newStream <- true
}
lastWidth = newSizes.width
}
if diffWidth < 0 {
log.Printf("Closing %d SD's\n", diffWidth)
for closeColumn := lastWidth - 1; closeColumn > newSizes.width; closeColumn-- {
// get sd
sd := streamDisplaysByColumn[closeColumn]
// delete from map
delete(streamDisplaysByColumn, closeColumn)
// inform sd that it's being closed
sd.stopCh <- true
}
lastWidth = newSizes.width
}
}
}()
// set initial sizes
setSizes(screen.Size())
// flusher flushes the tcell every x miliseconds
fpsSleepTime := time.Duration(1000000/opts.FPS) * time.Microsecond
go func() {
for {
// <-time.After(40 * time.Millisecond) //++ TODO: find out wether .After() or .Sleep() is better performance-wise
time.Sleep(fpsSleepTime)
screen.Show()
}
}()
// make chan for tembox events and run poller to send events on chan
eventChan := make(chan tcell.Event)
go func() {
for {
event := screen.PollEvent()
eventChan <- event
}
}()
// register signals to channel
sigChan := make(chan os.Signal)
signal.Notify(sigChan, os.Interrupt)
signal.Notify(sigChan, os.Kill)
// handle tcell events and unix signals
done := false
for !done {
// select for either event or signal
select {
case event := <-eventChan:
log.Printf("Have event: \n%s", spew.Sdump(event))
// switch on event type
switch ev := event.(type) {
case *tcell.EventKey:
switch ev.Key() {
case tcell.KeyCtrlZ, tcell.KeyCtrlC:
done = true
continue
//++ TODO: add more fun keys (slowmo? freeze? rampage?)
case tcell.KeyCtrlL:
screen.Sync()
case tcell.KeyRune:
switch ev.Rune() {
case 'q':
done = true
continue
case 'c':
screen.Clear()
case 'a':
characters = alphaNumerics
case 'k':
characters = halfWidthKana
}
}
case *tcell.EventResize: // set sizes
w, h := ev.Size()
setSizes(w, h)
case *tcell.EventError: // quit
log.Fatalf("Quitting because of tcell error: %v", ev.Error())
done = true
continue
}
case signal := <-sigChan:
log.Printf("Have signal: \n%s", spew.Sdump(signal))
done = true
continue
}
}
// close down
screen.Fini()
log.Println("stopping gomatrix")
fmt.Println("Thank you for connecting with Morpheus' Matrix API v4.2. Have a nice day!")
// stop profiling (if required)
if len(opts.Profile) > 0 {
pprof.StopCPUProfile()
}
}
// This program just shows simple mouse and keyboard events. Press ESC twice to
// exit.
func main() {
encoding.Register()
s, e := tcell.NewScreen()
if e != nil {
fmt.Fprintf(os.Stderr, "%v\n", e)
os.Exit(1)
}
if e := s.Init(); e != nil {
fmt.Fprintf(os.Stderr, "%v\n", e)
os.Exit(1)
}
defStyle = tcell.StyleDefault.
Background(tcell.ColorBlack).
Foreground(tcell.ColorWhite)
s.SetStyle(defStyle)
s.EnableMouse()
s.Clear()
posfmt := "Mouse: %d, %d "
btnfmt := "Buttons: %s"
keyfmt := "Keys: %s"
white := tcell.StyleDefault.
Foreground(tcell.ColorBrightWhite).Background(tcell.ColorRed)
mx, my := -1, -1
ox, oy := -1, -1
bx, by := -1, -1
w, h := s.Size()
lchar := '*'
bstr := ""
lks := ""
ecnt := 0
for {
drawBox(s, 1, 1, 42, 6, white, ' ')
emitStr(s, 2, 2, white, "Press ESC twice to exit, C to clear.")
emitStr(s, 2, 3, white, fmt.Sprintf(posfmt, mx, my))
emitStr(s, 2, 4, white, fmt.Sprintf(btnfmt, bstr))
emitStr(s, 2, 5, white, fmt.Sprintf(keyfmt, lks))
s.Show()
bstr = ""
ev := s.PollEvent()
st := tcell.StyleDefault.Background(tcell.ColorBrightRed)
up := tcell.StyleDefault.
Background(tcell.ColorBrightBlue).
Foreground(tcell.ColorBrightGreen)
w, h = s.Size()
// always clear any old selection box
if ox >= 0 && oy >= 0 && bx >= 0 {
drawSelect(s, ox, oy, bx, by, false)
}
switch ev := ev.(type) {
case *tcell.EventResize:
s.Sync()
s.SetCell(w-1, h-1, st, 'R')
case *tcell.EventKey:
s.SetCell(w-2, h-2, st, ev.Rune())
s.SetCell(w-1, h-1, st, 'K')
if ev.Key() == tcell.KeyEscape {
ecnt++
if ecnt > 1 {
s.Fini()
os.Exit(0)
}
} else {
ecnt = 0
if ev.Rune() == 'C' || ev.Rune() == 'c' {
s.Clear()
}
}
lks = ev.Name()
case *tcell.EventMouse:
x, y := ev.Position()
button := ev.Buttons()
for i := uint(0); i < 8; i++ {
if int(button)&(1<<i) != 0 {
bstr += fmt.Sprintf(" Button%d", i+1)
}
}
if button&tcell.WheelUp != 0 {
bstr += " WheelUp"
}
if button&tcell.WheelDown != 0 {
bstr += " WheelDown"
}
if button&tcell.WheelLeft != 0 {
bstr += " WheelLeft"
}
if button&tcell.WheelRight != 0 {
bstr += " WheelRight"
}
// Only buttons, not wheel events
button &= tcell.ButtonMask(0xff)
ch := '*'
if button != tcell.ButtonNone && ox < 0 {
ox, oy = x, y
}
switch ev.Buttons() {
case tcell.ButtonNone:
if ox >= 0 {
bg := tcell.Color((lchar-'0')*2 + 1)
drawBox(s, ox, oy, x, y,
up.Background(bg),
lchar)
ox, oy = -1, -1
bx, by = -1, -1
}
case tcell.Button1:
ch = '1'
case tcell.Button2:
ch = '2'
case tcell.Button3:
ch = '3'
case tcell.Button4:
ch = '4'
case tcell.Button5:
ch = '5'
case tcell.Button6:
ch = '6'
case tcell.Button7:
ch = '7'
case tcell.Button8:
ch = '8'
default:
ch = '*'
}
if button != tcell.ButtonNone {
bx, by = x, y
}
lchar = ch
s.SetCell(w-1, h-1, st, 'M')
mx, my = x, y
default:
s.SetCell(w-1, h-1, st, 'X')
}
if ox >= 0 && bx >= 0 {
drawSelect(s, ox, oy, bx, by, true)
}
}
}