func main() { stdscr, err := gc.Init() if err != nil { log.Fatal(err) } defer gc.End() gc.Echo(false) gc.CBreak(true) gc.Cursor(0) var panels [2]fp.FilePanel rows, cols := stdscr.MaxYX() height, width := rows, cols/2 y, x := 0, 0 activePanel := 0 panels[0] = fp.FilePanel{Height: height, Width: width, Y: y, X: x, Directory: "./", Selected: 0, IsActive: true} panels[1] = fp.FilePanel{Height: height, Width: width, Y: y, X: x + width, Directory: "/home/kuzzmi/", Selected: 2, IsActive: false} panels[0].Draw() panels[1].Draw() gc.UpdatePanels() gc.Update() stdscr.Keypad(true) // stdscr.GetChar() main: for { switch panels[activePanel].Panel.Window().GetChar() { case 'q': break main case gc.KEY_RETURN: panels[activePanel].Execute() case gc.KEY_TAB: panels[0].ToggleActivity() panels[1].ToggleActivity() gc.UpdatePanels() gc.Update() if activePanel == 0 { activePanel = 1 } else { activePanel = 0 } case 'u': panels[activePanel].GoUp() case 'k': panels[activePanel].Select(panels[activePanel].Selected - 1) case 'j': panels[activePanel].Select(panels[activePanel].Selected + 1) case 'i': panels[activePanel].HideHidden() } } stdscr.Delete() }
// contact Menu Window Navigation input handler func contactsWindowNavigation(contactsMenuWin *gc.Window, contactMenu *gc.Menu) int { var c gc.Char var rawInput gc.Key for { gc.Update() rawInput = contactsMenuWin.GetChar() c = gc.Char(rawInput) if rawInput == gc.KEY_TAB || rawInput == gc.KEY_RETURN { return 0 } else if c == gc.Char(27) { return 1 } else if c == gc.Char('j') || rawInput == gc.KEY_DOWN { contactMenu.Driver(gc.REQ_DOWN) changeContact(contactsMenuWin, contactMenu) } else if c == gc.Char('k') || rawInput == gc.KEY_UP { contactMenu.Driver(gc.REQ_UP) changeContact(contactsMenuWin, contactMenu) } else if c == gc.Char('g') { contactMenu.Driver(gc.REQ_FIRST) changeContact(contactsMenuWin, contactMenu) } else if c == gc.Char('G') { contactMenu.Driver(gc.REQ_LAST) changeContact(contactsMenuWin, contactMenu) } else { continue } } }
func (ui *NcurseUi) GetCommand() (output int) { goncurses.Update() goncurses.Echo(false) output = int(ui.contents.GetChar()) goncurses.Echo(true) return }
// Render takes a playfield and reprensents it in a terminal // using ncurses libraires func Render(p blocsBag, fieldWidth int, fieldHeight int) { metrics := calculateMetrics(fieldWidth, fieldHeight) defer createWindow(metrics.height*fieldHeight+2, metrics.width*fieldWidth+2, metrics.offsetHeight+metrics.height-1, metrics.offsetWidth-1, 0, true)() for _, bloc := range p.Blocs() { defer drawBloc(bloc, fieldWidth, fieldHeight)() } gc.Update() }
func (c *Circuit) display() { stdscr, err := gc.Init() if err != nil { log.Println(err) } defer gc.End() rows, cols := stdscr.MaxYX() height, width := len(c.circuit)+1, len(c.circuit[0])+1 y, x := (rows-height)/2, (cols-width)/2 var win *gc.Window win, err = gc.NewWindow(height, width, y, x) if err != nil { log.Println(err) } defer win.Delete() win.Timeout(500) for i := 0; i != height-1; i++ { for j := 0; j != width-1; j++ { if c.circuit[i][j] == "" { continue } char := gc.Char([]rune(c.circuit[i][j])[0]) win.MoveAddChar(i, j, char) } } main: for { for _, com := range c.Components { com.Update() } for _, com := range c.Components { cx, cy, _, _ := com.Space() for coord, out := range com.Visual() { char := gc.Char([]rune(*out)[0]) win.MoveAddChar(cx+coord.X, cy+coord.Y, char) } } win.NoutRefresh() gc.Update() switch win.GetChar() { case 'q': break main } } }
func main() { stdscr, _ := gc.Init() defer gc.End() gc.StartColor() gc.CBreak(true) gc.Echo(true) stdscr.Keypad(true) stdscr.Print("Hit 'tab' to cycle through windows, 'q' to quit") gc.InitPair(1, gc.C_RED, gc.C_BLACK) gc.InitPair(2, gc.C_GREEN, gc.C_BLACK) gc.InitPair(3, gc.C_BLUE, gc.C_BLACK) gc.InitPair(4, gc.C_CYAN, gc.C_BLACK) var panels [3]*gc.Panel y, x := 4, 10 for i := 0; i < 3; i++ { h, w := 10, 40 title := "Window Number %d" window, _ := gc.NewWindow(h, w, y+(i*4), x+(i*10)) window.Box(0, 0) window.MoveAddChar(2, 0, gc.ACS_LTEE) window.HLine(2, 1, gc.ACS_HLINE, w-2) window.MoveAddChar(2, w-1, gc.ACS_RTEE) window.ColorOn(int16(i + 1)) window.MovePrintf(1, (w/2)-(len(title)/2), title, i+1) window.ColorOff(int16(i + 1)) panels[i] = gc.NewPanel(window) } active := 2 for { gc.UpdatePanels() gc.Update() switch stdscr.GetChar() { case 'q': return case gc.KEY_TAB: active += 1 if active > 2 { active = 0 } panels[active].Top() } } }
func main() { stdscr, err := goncurses.Init() if err != nil { log.Fatal("init:", err) } defer goncurses.End() goncurses.Raw(true) goncurses.Echo(false) goncurses.Cursor(0) stdscr.Clear() stdscr.Keypad(true) menu_items := []string{"Choice 1", "Choice 2", "Choice 3", "Choice 4", "Exit"} items := make([]*goncurses.MenuItem, len(menu_items)) for i, val := range menu_items { items[i], _ = goncurses.NewItem(val, "") defer items[i].Free() } menu, err := goncurses.NewMenu(items) if err != nil { stdscr.Print(err) return } defer menu.Free() menu.Post() stdscr.MovePrint(20, 0, "'q' to exit") stdscr.Refresh() for { goncurses.Update() ch := stdscr.GetChar() switch goncurses.KeyString(ch) { case "q": return case "down": menu.Driver(goncurses.REQ_DOWN) case "up": menu.Driver(goncurses.REQ_UP) } } }
func main() { stdscr, _ := gc.Init() defer gc.End() var panels [3]*gc.Panel y, x := 2, 4 for i := 0; i < 3; i++ { window, _ := gc.NewWindow(10, 40, y+i, x+(i*5)) window.Box(0, 0) panels[i] = gc.NewPanel(window) } gc.UpdatePanels() gc.Update() stdscr.GetChar() }
func main() { stdscr, _ := gc.Init() defer gc.End() gc.StartColor() gc.Raw(true) gc.Echo(false) gc.Cursor(0) stdscr.Keypad(true) // build the menu items menu_items := []string{ "Choice 1", "Choice 2", "Choice 3", "Choice 4", "Choice 5", "Choice 6", "Choice 7", "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() menu.Option(gc.O_ONEVALUE, false) y, _ := stdscr.MaxYX() stdscr.MovePrint(y-3, 0, "Use up/down arrows to move, spacebar to "+ "toggle and enter to print. 'q' to exit") stdscr.Refresh() menu.Post() defer menu.UnPost() for { gc.Update() ch := stdscr.GetChar() switch ch { case 'q': return case ' ': menu.Driver(gc.REQ_TOGGLE) case gc.KEY_RETURN, gc.KEY_ENTER: var list string for _, item := range menu.Items() { if item.Value() { list += "\"" + item.Name() + "\" " } } stdscr.Move(20, 0) stdscr.ClearToEOL() stdscr.MovePrint(20, 0, list) stdscr.Refresh() default: menu.Driver(gc.DriverActions[ch]) } } }
func main() { stdscr, err := gc.Init() if err != nil { log.Fatal("init:", err) } defer gc.End() 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_GREEN, gc.C_BLACK) gc.InitPair(3, gc.C_MAGENTA, gc.C_BLACK) // build the menu items menu_items := []string{ "Choice 1", "Choice 2", "Choice 3", "Choice 4", "Choice 5", "Exit"} items := make([]*gc.MenuItem, len(menu_items)) for i, val := range menu_items { items[i], _ = gc.NewItem(val, "") defer items[i].Free() if i == 2 || i == 4 { items[i].Selectable(false) } } // create the menu menu, _ := gc.NewMenu(items) defer menu.Free() y, _ := stdscr.MaxYX() stdscr.MovePrint(y-3, 0, "Use up/down arrows to move; 'q' to exit") stdscr.Refresh() menu.SetForeground(gc.ColorPair(1) | gc.A_REVERSE) menu.SetBackground(gc.ColorPair(2) | gc.A_BOLD) menu.Grey(gc.ColorPair(3) | gc.A_BOLD) menu.Post() defer menu.UnPost() for { gc.Update() ch := stdscr.GetChar() switch ch { case ' ': menu.Driver(gc.REQ_TOGGLE) case 'q': return case gc.KEY_RETURN: stdscr.Move(20, 0) stdscr.ClearToEOL() stdscr.Printf("Item selected is: %s", menu.Current(nil).Name()) menu.PositionCursor() default: menu.Driver(gc.DriverActions[ch]) } } }
func (fp *FilePanel) Redraw() { fp.Draw() gc.Update() }
func windw() { stdscr, err := gc.Init() if err != nil { log.Fatal(err) } defer gc.End() // Turn off character echo, hide the cursor and disable input buffering gc.Echo(false) gc.CBreak(true) gc.Cursor(0) stdscr.Print("Use arrow keys to move the window. Press 'q' to exit") stdscr.NoutRefresh() // Determine the center of the screen and offset those coordinates by // half of the window size we are about to create. These coordinates will // be used to move our window around the screen rows, cols := stdscr.MaxYX() height, width := 20, 40 y, x := (rows-height)/2, (cols-width)/2 // Create a new window centered on the screen and enable the use of the // keypad on it so the arrow keys are available var win *gc.Window win, err = gc.NewWindow(height, width, y, x) if err != nil { log.Fatal(err) } win.Keypad(true) windw: for { // Clear the section of screen where the box is currently located so // that it is blanked by calling Erase on the window and refreshing it // so that the chances are sent to the virtual screen but not actually // output to the terminal win.Erase() win.NoutRefresh() // Move the window to it's new location (if any) and redraw it win.MoveWindow(y, x) win.Box(gc.ACS_VLINE, gc.ACS_HLINE) win.NoutRefresh() // Update will flush only the characters which have changed between the // physical screen and the virtual screen, minimizing the number of // characters which must be sent gc.Update() // In order for the window to display correctly, we must call GetChar() // on it rather than stdscr switch win.GetChar() { case 'q': break windw case 'h': if x > 0 { x-- } case 'l': if x < cols-width { x++ } case 'k': if y > 1 { y-- } case 'j': if y < rows-height { y++ } } } win.Delete() }
func main() { stdscr, _ := gc.Init() defer gc.End() gc.StartColor() gc.Raw(true) gc.Echo(false) gc.Cursor(0) stdscr.Keypad(true) gc.InitPair(1, gc.C_RED, gc.C_BLACK) // build the menu items menu_items := []string{"Choice 1", "Choice 2", "Choice 3", "Choice 4", "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(10, 40, 4, 14) menuwin.Keypad(true) menu.SetWindow(menuwin) dwin := menuwin.Derived(6, 38, 3, 1) menu.SubWindow(dwin) menu.Mark(" * ") // Print centered menu title y, x := menuwin.MaxYX() title := "My Menu" menuwin.Box(0, 0) menuwin.ColorOn(1) menuwin.MovePrint(1, (x/2)-(len(title)/2), title) menuwin.ColorOff(1) menuwin.MoveAddChar(2, 0, gc.ACS_LTEE) menuwin.HLine(2, 1, gc.ACS_HLINE, x-3) menuwin.MoveAddChar(2, x-2, gc.ACS_RTEE) y, x = stdscr.MaxYX() stdscr.MovePrint(y-2, 1, "'q' to exit") stdscr.Refresh() menu.Post() defer menu.UnPost() menuwin.Refresh() for { gc.Update() ch := menuwin.GetChar() switch ch { case 'q': return case gc.KEY_DOWN: menu.Driver(gc.REQ_DOWN) case gc.KEY_UP: menu.Driver(gc.REQ_UP) } } }
func main() { stdscr, _ := gc.Init() defer gc.End() 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{ "Choice 1", "Choice 2", "Choice 3", "Choice 4", "Choice 5", "Choice 6", "Choice 7", "Choice 8", "Choice 9", "Choice 10", "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(HEIGHT, WIDTH, 4, 14) menuwin.Keypad(true) menu.SetWindow(menuwin) dwin := menuwin.Derived(6, 38, 3, 1) menu.SubWindow(dwin) menu.Format(5, 1) menu.Mark(" * ") // Print 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(2, 1, 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() if ch := menuwin.GetChar(); ch == 'q' { return } else { menu.Driver(gc.DriverActions[ch]) } } }
// Returns an articleType that can be downloaded and displayed. func ncurses(articles map[string][]articleType) (article articleType, err error) { // Initialize the standard screen stdscr, err := gc.Init() if err != nil { return } defer gc.End() h, w := stdscr.MaxYX() // Initialize the library gc.Raw(true) gc.Echo(false) gc.Cursor(0) stdscr.Keypad(true) // Build the user menu items userItems := make([]*gc.MenuItem, len(articles)) i := 0 for val := range articles { userItems[i], err = gc.NewItem(val, "") if err != nil { return } defer userItems[i].Free() i++ } // Build the first user's article items articleItems := make([]*gc.MenuItem, len(articles[userItems[0].Name()])) i = 0 for _, val := range articles[userItems[0].Name()] { articleItems[i], err = gc.NewItem(val.title, "") if err != nil { return } defer articleItems[i].Free() i++ } // Create the user menu userMenu, userMenuWin, err := newFeatureMenu(userItems, h, w/2, 0, 0) if err != nil { return } // Post the user menu and refresh the user window userMenu.Post() defer userMenu.UnPost() userMenuWin.Refresh() // Create the article menu articleMenu, articleMenuWin, err := newFeatureMenu(articleItems, h/2, w/2, 0, w/2) if err != nil { return } // Post the article menu and refresh the article window articleMenu.Post() defer articleMenu.UnPost() articleMenuWin.Refresh() // Create the information window used to display article information aInfoWin, err := gc.NewWindow(h/2+1, w/2, h/2, w/2+1) if err != nil { return } displayInfo(aInfoWin, 0, 0, userItems, articles) active := 0 activeA := 0 currentMenuWin := userMenuWin currentMenu := userMenu for { gc.Update() ch := currentMenuWin.GetChar() switch ch { case 'q': return case gc.KEY_UP: if currentMenu == userMenu { if active != 0 { active-- articleItems = make([]*gc.MenuItem, len(articles[userItems[active].Name()])) i = 0 for _, val := range articles[userItems[active].Name()] { articleItems[i], _ = gc.NewItem(val.title, "") defer articleItems[i].Free() i++ } articleMenu.UnPost() articleMenu.SetItems(articleItems) articleMenu.Post() articleMenuWin.Refresh() displayInfo(aInfoWin, active, activeA, userItems, articles) } } else { if activeA != 0 { activeA-- displayInfo(aInfoWin, active, activeA, userItems, articles) } } currentMenu.Driver(gc.DriverActions[ch]) case gc.KEY_DOWN: if currentMenu == userMenu { if active != len(userItems)-1 { active++ articleItems = make([]*gc.MenuItem, len(articles[userItems[active].Name()])) i = 0 for _, val := range articles[userItems[active].Name()] { articleItems[i], _ = gc.NewItem(val.title, "") defer articleItems[i].Free() i++ } articleMenu.UnPost() articleMenu.SetItems(articleItems) articleMenu.Post() articleMenuWin.Refresh() displayInfo(aInfoWin, active, activeA, userItems, articles) } } else { if activeA != len(articleItems)-1 { activeA++ aInfoWin.MovePrint(1, 1, "Auteur : ", userItems[active].Name()) aInfoWin.Refresh() displayInfo(aInfoWin, active, activeA, userItems, articles) } } currentMenu.Driver(gc.DriverActions[ch]) case gc.KEY_LEFT: // If the LEFT key is pressed, then set the active menu and active // menu window to the user ones. Also resets the current article counter if currentMenu == articleMenu { currentMenu = userMenu currentMenuWin = userMenuWin activeA = 0 } case gc.KEY_RIGHT: // If the RIGHT key is pressed, then set the active menu and active // menu window to the article one. if currentMenu == userMenu { currentMenu = articleMenu currentMenuWin = articleMenuWin } case gc.KEY_ENTER, gc.KEY_RETURN, gc.Key('\r'): // If one of the Enter/Return key is pressed, depending on the current // menu, switch to the article menu or start downloading the selected // article. if currentMenu == userMenu { currentMenu = articleMenu currentMenuWin = articleMenuWin activeA = 0 } else { article = articles[userItems[active].Name()][activeA] return } default: currentMenu.Driver(gc.DriverActions[ch]) } } }