Пример #1
0
func main() {
	opts := options.Client{}
	opts.Parse()

	if opts.ServerIP == "" {
		zc := zeroconf.NewClient("_goptyscreen._tcp.")
		zc.Dial()
		opts.ServerIP = zc.Host
		opts.Port = zc.Port
	}

	defer goncurses.End()
	_, err := goncurses.Init()
	if err != nil {
		panic(err)
	}

	goncurses.Cursor(0) // no cursor please
	goncurses.StartColor()

	list := pty_client.NewList(opts.ServerIP, opts.Port)
	list.Fetch()
	key_port, screen_port := list.GetSelection()
	goncurses.End()

	pty_client.Connect(opts.ServerIP, key_port, screen_port)
}
func initializeNcurses() (stdscr *gc.Window, colors *colorsDefined, resetScreen resetScreenFn) {

	stdscr, err := gc.Init()
	if err != nil {
		log.Fatal(err)
	}
	defer gc.End()
	resetScreen = func() {
		gc.End()
	}

	// Turn off character echo, hide the cursor and disable input buffering
	gc.Echo(false)
	gc.CBreak(true)
	gc.StartColor()

	// initialize colors
	whiteOnBlack := int16(1)
	gc.InitPair(whiteOnBlack, gc.C_WHITE, gc.C_BLACK)
	greenOnBlack := int16(2)
	gc.InitPair(greenOnBlack, gc.C_GREEN, gc.C_BLACK)
	redOnBlack := int16(3)
	gc.InitPair(redOnBlack, gc.C_RED, gc.C_BLACK)

	// Set the cursor visibility.
	// Options are: 0 (invisible/hidden), 1 (normal) and 2 (extra-visible)
	gc.Cursor(0)

	colors = &colorsDefined{whiteOnBlack, greenOnBlack, redOnBlack}

	return
}
Пример #3
0
func (view *View) RunForever() string {
	window, err := goncurses.Init()
	view.Window = window
	if err != nil {
		panic(err)
	}
	defer goncurses.End()

	goncurses.CBreak(true)
	goncurses.Echo(false)
	window.Clear()
	var ch goncurses.Key

	view.InitPaint()

	for {
		ch = window.GetChar()
		if ch == 'q' {
			break
		}

		if handler, ok := HandlerMap[ch]; ok {
			handler(view.World)
		}
		view.World.RunMonsterActions()
		if view.World.Player.Hitpoints <= 0 {
			return "You have been slain!"
		}
		if len(view.World.AliveMonsters()) == 0 {
			return "You have vanquished all the monsters!"
		}
		view.Paint()
	}
	return ""
}
func main() {
	s, err := gc.Init()
	if err != nil {
		log.Fatal("init:", err)
	}
	defer gc.End()
	gc.Cursor(0)
	s.Move(20, 0)
	s.Print("Key check in ")
	for i := 3; i >= 1; i-- {
		s.MovePrint(20, 13, i)
		s.Refresh()
		time.Sleep(500 * time.Millisecond)
	}
	s.Println()
	gc.Echo(false)

	// task requirement next two lines
	s.Timeout(0)
	k := s.GetChar()

	if k == 0 {
		s.Println("No key pressed")
	} else {
		s.Println("You pressed", gc.KeyString(k))
	}
	s.Refresh()
	s.Timeout(-1)
	gc.FlushInput()
	gc.Cursor(1)
	s.GetChar()
}
func main() {
	s, err := goncurses.Init()
	if err != nil {
		log.Fatal("init:", err)
	}
	defer goncurses.End()
	height, width := s.MaxYX()
	fmt.Println(height, width)
}
func main() {
	s, err := gc.Init()
	if err != nil {
		log.Fatal("init:", err)
	}
	defer gc.End()
	s.Move(5, 2)
	s.Println("Hello")
	s.GetChar()
}
func main() {
	s, err := gc.Init()
	if err != nil {
		log.Fatal("init:", err)
	}
	defer gc.End()
	gc.Cursor(0)
	time.Sleep(3 * time.Second)
	gc.Cursor(1)
	s.GetChar()
}
Пример #8
0
func (cw *chatWin) dialog(messages chan message) {
	stdscr, err := goncurses.Init()
	if err != nil {
		log.Fatal("init:", err)
	}
	defer goncurses.End()

	goncurses.Raw(false)
	stdscr.ScrollOk(true)

	rows, cols := stdscr.MaxYX()
	chats, err := goncurses.NewWindow(rows-MESSAGE_WIN_SIZE, cols, 0, 0)
	if err != nil {
		log.Fatal("Error setting up chat window")
	}

	chats.ScrollOk(true)
	chats.Box(goncurses.ACS_VLINE, goncurses.ACS_HLINE)
	chats.Refresh()

	messageWin, err := goncurses.NewWindow(MESSAGE_WIN_SIZE, cols, rows-MESSAGE_WIN_SIZE, 0)
	if err != nil {
		log.Fatal("Error setting up chat window")
	}
	cw.msgRows, cw.msgCols = messageWin.MaxYX()
	// allow special characters to come through (e.g. arrow keys)
	messageWin.Keypad(true)
	// sets terminal to non-blocking
	// this also seems to print characters as they're typed, which causes some weird workarounds
	goncurses.HalfDelay(1)

	messageWin.Print(PROMPT)
	for {
		select {
		case msg := <-messages:
			y, _ := chats.CursorYX()
			chats.MovePrint(y+1, 1, fmt.Sprintf("%s: %s", msg.From, msg.Message))
			chats.Refresh()
			messageWin.Refresh()
		default:
			line := cw.handleInput(messageWin)
			if line != "" {
				log.Println("Entered message:", line)
				msg := message{From: cw.username, Message: line}
				// TODO: uncomment once turnpike is fixed to not send events to the sender
				// y, _ := chats.CursorYX()
				// chats.MovePrint(y+1, 1, fmt.Sprintf("%s: %s", msg.From, msg.Message))
				// chats.Refresh()
				cw.msgs <- msg
			}
		}
	}
}
Пример #9
0
func ExampleInit() {
	// You should always test to make sure ncurses has initialized properly.
	// In order for your error messages to be visible on the terminal you will
	// need to either log error messages or output them to to stderr.
	stdscr, err := goncurses.Init()
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	defer goncurses.End()
	stdscr.Print("Press enter to continue...")
	stdscr.Refresh()
}
func main() {
	s, err := goncurses.Init()
	if err != nil {
		log.Fatal("goncurses:", err)
	}
	defer goncurses.End()
	s.Println("Clearing screen...")
	s.Refresh()
	time.Sleep(1 * time.Second)

	s.Clear() // clear screen

	// Goncurses saves the screen on Init and restores it on End.  This
	// GetChar() allows you to see the effect of the program before it exits.
	s.GetChar() // press any key to continue
}
Пример #11
0
func NewSupervisor() (supervisor *Supervisor) {
	supervisor = new(Supervisor)

	defer goncurses.End()
	_, err := goncurses.Init()
	if err != nil {
		panic(err)
	}

	goncurses.Cursor(2) // high visibilty cursor
	goncurses.StartColor()

	supervisor.list_window = supervisor_views.NewList()
	supervisor.command_window = supervisor_views.NewCommand()

	supervisor.list_window.Refresh()
	supervisor.command_window.Refresh()

	return
}
func main() {
	s, err := gc.Init()
	if err != nil {
		log.Fatal("init:", err)
	}
	defer gc.End()
	// determine color support
	if !gc.HasColors() {
		log.Fatal("no color support")
	}
	// set background color
	gc.StartColor()
	gc.InitPair(1, gc.C_WHITE, gc.C_BLUE)
	s.ColorOn(1)
	s.SetBackground(gc.Char(' ') | gc.ColorPair(1))
	// blinking, different background color
	s.AttrOn(gc.A_BLINK)
	gc.InitPair(2, gc.C_WHITE, gc.C_RED)
	s.ColorOn(2)
	s.Print("   Blinking Red   ")
	s.GetChar()
}
func main() {
	s, err := gc.Init()
	if err != nil {
		log.Fatal("init:", err)
	}
	defer gc.End()
	gc.StartColor()
	const (
		red   = 1
		green = 2
		blue  = 3
	)
	gc.InitPair(red, gc.C_RED, gc.C_BLACK)
	gc.InitPair(green, gc.C_GREEN, gc.C_BLACK)
	gc.InitPair(blue, gc.C_BLUE, gc.C_BLACK)
	s.ColorOn(red)
	s.Println("Red")
	s.ColorOn(green)
	s.Println("Green")
	s.ColorOn(blue)
	s.Println("Blue")
	s.GetChar()
}
Пример #14
0
func main() {
	scr, _ := gc.Init()
	defer gc.End()

	rows, cols := scr.Maxyx()

	gc.InitPair(ChatAreaColor, gc.C_WHITE, gc.C_BLACK)
	gc.InitPair(InputAreaColor, gc.C_BLACK, gc.C_WHITE)

	chatArea := scr.Derived(rows-1, cols, 0, 0)
	chatArea.SetBackground(gc.Character(' ' | gc.ColorPair(ChatAreaColor)))

	inputArea := scr.Derived(1, cols, rows-1, 0)
	chatArea.SetBackground(gc.Character(' ' | gc.ColorPair(InputAreaColor)))

	chat := make(chan string)
	go func() {
		for msg := range chat {
			msg = fmt.Sprintf("%v| %v", time.Now().Format("15:04:05"), msg)
			chatArea.Scroll(1)
			chatArea.MovePrint(rows-2, 0, msg)
			chatArea.Refresh()
		}
	}()
	defer close(chat)

	userInputChan := make(chan string)
	go func() {
		for msg := range userInputChan {
			if len(msg) > 0 && msg[0] == '/' {
				chat <- fmt.Sprintf("Command: %s", msg[1:])
			} else {
				chat <- msg
			}
		}
	}()
	defer close(userInputChan)

	gc.Echo(false)
	gc.CBreak(true)
	gc.Raw(true)
	chatArea.ScrollOk(true)
	scr.Keypad(true)

	chat <- "Welcome to snails shitty chat thing."
	chat <- "Press esc to quit, it may or may not break stuff. "
	chat <- "If it does, do a 'reset' to fix it."
	buffer := ""
	for {
		chatArea.Refresh()
		key := inputArea.GetChar()
		switch key {
		case gc.Key(27):
			return
		case gc.KEY_RETURN:
			userInputChan <- buffer
			buffer = ""
			chatArea.Refresh()
		case gc.Key(127): //backspace
			l := len(buffer)
			if l > 0 {
				buffer = buffer[:l-1]
			}
		default:
			buffer = fmt.Sprintf("%s%c", buffer, key)
		}
		inputArea.Clear()
		inputArea.MovePrint(0, 0, buffer)
	}

}
// Why realMain? See https://groups.google.com/forum/#!topic/golang-nuts/_Twwb5ULStM
// So that defer will run propoerly
func realMain() (exitStatus int) {

	// initialize ncurses
	stdscr, colors, resetScreen := initializeNcurses()

	// clean up the screen before we die
	defer func() {
		if err := recover(); err != nil {
			resetScreen()
			fmt.Fprintf(os.Stderr, "exiting from error: %s \n", err)
			ERROR.Println("exiting from error: ", err)
			exitStatus = 1
			os.Exit(1)
		}
	}()

	// draw the stuff on the screen
	msgWin, workerCountWin, durWin, reqSecWin, barsWin, scaleWin, maxWin := drawDisplay(stdscr)

	// create our various channels
	infoMsgsCh := make(chan ncursesMsg)
	exitCh := make(chan int)
	changeNumRequestersCh := make(chan interface{})
	changeNumRequestersListenerCh := make(chan interface{})
	reqMadeOnSecCh := make(chan interface{})
	reqMadeOnSecListenerCh := make(chan interface{})
	reqMadeOnSecSlaveListenerCh := make(chan interface{})
	failsOnSecCh := make(chan int)
	durationCh := make(chan int64)
	durationDisplayCh := make(chan string)
	reqSecDisplayCh := make(chan string)
	bytesPerSecCh := make(chan bytesPerSecMsg)
	bytesPerSecDisplayCh := make(chan string)
	barsToDrawCh := make(chan currentBars)

	// start all the worker goroutines
	go windowRunloop(infoMsgsCh, exitCh, changeNumRequestersCh, msgWin)
	go barsController(reqMadeOnSecListenerCh, failsOnSecCh, barsToDrawCh, reqSecDisplayCh)
	go requesterController(infoMsgsCh, changeNumRequestersListenerCh, reqMadeOnSecCh, failsOnSecCh, durationCh, bytesPerSecCh, *testUrl, *introduceRandomFails)
	go durationWinController(durationCh, durationDisplayCh)
	go bytesPerSecController(bytesPerSecCh, bytesPerSecDisplayCh)

	numRequestersBcaster := bcast.MakeNew(changeNumRequestersCh, INFO)
	numRequestersBcaster.Join(changeNumRequestersListenerCh)

	reqMadeOnSecBcaster := bcast.MakeNew(reqMadeOnSecCh, INFO)
	reqMadeOnSecBcaster.Join(reqMadeOnSecListenerCh)

	if *listen > 0 {
		port := *listen
		// we don't want to join until we start the listener
		joinUp := func() {
			reqMadeOnSecBcaster.Join(reqMadeOnSecSlaveListenerCh)
		}
		go slave.ListenForMaster(port, changeNumRequestersCh, reqMadeOnSecSlaveListenerCh, joinUp, INFO)
	} else if len(slaveList) > 0 {
		connectToSlaves(slaveList, numRequestersBcaster, reqMadeOnSecCh)
	}

	currentScale := int64(1)

	// This is the main loop controlling the ncurses display. Since ncurses
	// wasn't designed with concurrency in mind, only one goroutine should
	// write to a window, so I'm putting all the window writing in here.
main:
	for {
		select {
		case msg := <-infoMsgsCh:
			updateMsgWin(msg, msgWin, workerCountWin)
		case msg := <-durationDisplayCh:
			// that %7s should really be determined from durWidth
			durWin.MovePrint(1, 1, fmt.Sprintf("%11s", msg))
			durWin.NoutRefresh()
		case msg := <-reqSecDisplayCh:
			reqSecWin.MovePrint(1, 1, fmt.Sprintf("%14s", msg))
			reqSecWin.NoutRefresh()
		case msg := <-barsToDrawCh:
			currentScale = calculateScale(msg.max)
			// 25 is the number of rows in the window, s/b dynamic or defined elsewhere
			maxWin.MovePrint(1, 1, fmt.Sprintf("%5d", msg.max))
			maxWin.NoutRefresh()
			scaleWin.MovePrint(1, 1, fmt.Sprintf("%5d", currentScale))
			scaleWin.NoutRefresh()
			updateBarsWin(msg, barsWin, *colors, currentScale)
		case msg := <-bytesPerSecDisplayCh:
			//msgAsFloat64, err := strconv.ParseFloat(msg, 64)
			//if err != nil {
			//    panic(fmt.Sprintf("converting %s failed: %v", msg, err))
			//}
			//if msgAsFloat64 > 0 {
			if msg != "      0.00" {
				INFO.Println("bytes/sec for each second: ", msg)
			}
		case exitStatus = <-exitCh:
			break main
		}

		gc.Update()
	}

	msgWin.Delete()
	gc.End()
	INFO.Println("exiting with status ", exitStatus)
	return exitStatus
}
Пример #16
0
func main() {
	stdscr, _ := gc.Init()
	defer gc.End()

	yMAX, xMAX := stdscr.MaxYX()
	yMAX = yMAX - 5
	xMAX = xMAX - 5

	gc.StartColor()
	gc.Raw(true)
	gc.Echo(false)
	gc.Cursor(0)
	stdscr.Keypad(true)
	//gc.InitPair(1, gc.C_RED, gc.C_BLACK)
	//gc.InitPair(2, gc.C_CYAN, gc.C_BLACK)

	// build the menu items
	menu_items := []string{
		" P  - 152.111.192.51",
		" W  - 152.111.192.52",
		" E  - 152.111.192.53",
		" R  - 152.111.192.54",
		" T  - 152.111.192.55",
		"Exit"}
	items := make([]*gc.MenuItem, len(menu_items))
	for i, val := range menu_items {
		items[i], _ = gc.NewItem(val, "")
		defer items[i].Free()
	}

	// create the menu
	menu, _ := gc.NewMenu(items)
	defer menu.Free()

	menuwin, _ := gc.NewWindow(yMAX, xMAX, 1, 1)
	menuwin.Keypad(true)

	menu.SetWindow(menuwin)
	//dwin := menuwin.Derived(6, 38, 3, 1)

	//menu.SubWindow(dwin)
	menu.Option(gc.O_SHOWDESC, true)
	menu.Format(5, 2)
	menu.Mark("*")

	// MovePrint centered menu title
	title := "My Menu"
	menuwin.Box(0, 0)
	menuwin.ColorOn(1)
	menuwin.MovePrint(1, (WIDTH/2)-(len(title)/2), title)
	menuwin.ColorOff(1)
	menuwin.MoveAddChar(2, 0, gc.ACS_LTEE)

	//menuwin.HLine(4, 1, gc.ACS_HLINE, WIDTH-2)
	//  menuwin.HLine(12, 10, gc.ACS_HLINE, WIDTH-2)

	//menuwin.MoveAddChar(2, WIDTH-1, gc.ACS_RTEE)

	y, _ := stdscr.MaxYX()
	stdscr.ColorOn(2)
	stdscr.MovePrint(y-3, 1,
		"Use up/down arrows or page up/down to navigate. 'q' to exit")
	stdscr.ColorOff(2)
	stdscr.Refresh()

	menu.Post()
	defer menu.UnPost()
	menuwin.Refresh()

	for {
		gc.Update()

		ch := menuwin.GetChar()

		if ch == 'p' {

			cmd2 := exec.Command("clear")
			cmd2.Stdout = os.Stdout
			cmd2.Stdin = os.Stdin
			//cmd2.Stderr = os.Stderr
			cmd2.Run()

			cmd := exec.Command("ssh", "[email protected]")
			cmd.Stdout = os.Stdout
			cmd.Stdin = os.Stdin
			cmd.Stderr = os.Stderr

			cmd.Run()
			return

		} else if ch == 'q' {
			return
		} else if ch == 27 {
			return
		} else {
			menu.Driver(gc.DriverActions[ch])
		}
	}
}
Пример #17
0
func cli() {
	var e error
	scr, e = goncurses.Init()

	if e != nil {
		log.Fatal(e)
	}

	defer goncurses.End()

	exit := false

	pageNum := 0

	p := NewPageCache()

	for !exit {
		scr.Refresh()
		h, _ := scr.MaxYX()

		scr.Clear()

		height := h - BOTTOM_MARGIN

		start := height * pageNum
		end := start + height

		for end > len(p.Articles) {
			p.GetNext()
		}

		for i, ar := range p.Articles[start:end] {
			scr.Printf("%d. (%d): %s\n", start+i+1, ar.Karma, ar.Title)
		}

		scr.Print("\n(n: next, p: previous, <num>c: view comments, <num>o: open in browser, q: quit)  ")
		scr.Refresh()

		doneWithInput := false
		input := ""
		for !doneWithInput {
			c := scr.GetChar()

			if c == 127 {
				c = goncurses.Key(goncurses.KEY_BACKSPACE)
			}

			ch := goncurses.KeyString(c)
			switch ch {
			case "c":
				if num, err := strconv.Atoi(input); err == nil {
					if num < 1 {
						doneWithInput = true
						break
					}

					for num-1 > len(p.Articles) {
						p.GetNext()
					}

					text := p.Articles[num-1].PrintComments()
					line := 0

					cont := true
					for cont {
						scr.Clear()
						scr.Print(pagify(text, line))
						scr.Print("\n\n(d/u scroll 30 lines; j/k: scroll 1 line; n/p scroll 1 page; q: quit)")
						scr.Refresh()

						a := scr.GetChar()

						switch goncurses.KeyString(a) {
						case "d":
							line += 30
							break
						case "u":
							line -= 30
							break
						case "j":
							line += 1
							break
						case "k":
							line -= 1
							break
						case "n":
							line += h
							break
						case "p":
							line -= h
							break
						case "q":
							cont = false
							break
						default:
							scr.DelChar()
							scr.DelChar()
							break
						}

						// Verify lines are not negative. Bad mojo
						if line < 0 {
							line = 0
						}
					}

					doneWithInput = true
				} else {
					scr.Clear()
					scr.Print("\n\nPlease enter a number to select a comment\n\n")
					scr.Refresh()
					scr.GetChar()
					doneWithInput = true
				}
			case "o":
				if num, err := strconv.Atoi(input); err == nil {
					for num-1 > len(p.Articles) {
						p.GetNext()
					}

					viewInBrowser := exec.Command("xdg-open", p.Articles[num-1].Url)
					viewInBrowser.Start()
					doneWithInput = true
				} else {
					scr.Clear()
					scr.Print("\n\nPlease enter a number to view an article\n\n")
					scr.Refresh()
					doneWithInput = true
				}
			case "q":
				doneWithInput = true
				exit = true
			case "n":
				pageNum += 1
				doneWithInput = true
			case "p":
				if pageNum > 0 {
					pageNum -= 1
				}
				doneWithInput = true
			case "enter":
				continue
			case "backspace":
				//Not the prettiest but whatever
				cy, cx := scr.CursorYX()
				if len(input) > 0 {
					input = input[:len(input)-1]
					scr.MoveDelChar(cy, cx-3)
					scr.DelChar()
					scr.DelChar()
				} else {
					scr.MoveDelChar(cy, cx-2)
					scr.DelChar()
					scr.DelChar()
				}
			default:
				input += ch
				break
			}
		}
	}
}
Пример #18
0
//Get a new page by passing a url
func NewPage(url string) *Page {
	p := Page{
		Url:      url,
		Articles: make([]*Article, 0),
	}

	url = YC_ROOT + url

	head, _ := http.NewRequest("HEAD", url, nil)

	if resp, err := client.Do(head); err == nil {
		c := resp.Cookies()
		cfduid = c[0].Raw
	} else {
		goncurses.End()
		log.Println(resp)
		log.Println(err)
	}

	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		log.Fatal(err)
	}

	doc := doReq(req)

	//Get all the trs with subtext for children then go back one (for the first row)
	rows := doc.Find(".subtext").ParentsFilteredUntil("tr", "tbody").Prev()

	var a bool

	p.NextUrl, a = doc.Find("td.title").Last().Find("a").Attr("href")

	if !a {
		goncurses.End()
		log.Println("Could not retreive next hackernews page. Time to go outside?")
	}

	for len(p.NextUrl) > 0 && p.NextUrl[0] == '/' {
		p.NextUrl = p.NextUrl[1:]
	}

	rows.Each(func(i int, row *goquery.Selection) {
		ar := Article{
			Rank: len(p.Articles) + i,
		}

		title := row.Find(".title").Eq(1)
		link := title.Find("a").First()

		ar.Title = link.Text()

		if url, exists := link.Attr("href"); exists {
			ar.Url = url
		}

		row = row.Next()

		row.Find("span").Each(func(i int, s *goquery.Selection) {
			if karma, err := strconv.Atoi(strings.Split(s.Text(), " ")[0]); err == nil {
				ar.Karma = karma
			} else {
				log.Println(err)
			}

			if idSt, exists := s.Attr("id"); exists {
				if id, err := strconv.Atoi(strings.Split(idSt, "_")[1]); err == nil {
					ar.Id = id
				} else {
					log.Println(err)
				}
			}
		})

		sub := row.Find("td.subtext")
		t := sub.Text()

		ar.Created = parseCreated(t)

		ar.User = sub.Find("a").First().Text()

		comStr := strings.Split(sub.Find("a").Last().Text(), " ")[0]

		if comNum, err := strconv.Atoi(comStr); err == nil {
			ar.NumComments = comNum
		}

		p.Articles = append(p.Articles, &ar)

	})

	return &p
}