func main() {
stdscr, err := goncurses.Init()
if err != nil {
log.Fatal("init", err)
}
defer goncurses.End()
goncurses.Raw(true) // turn on raw "uncooked" input
goncurses.Echo(false) // turn echoing of typed characters off
goncurses.Cursor(0) // hide cursor
stdscr.Keypad(true) // allow keypad input
stdscr.Print("Press a key...")
stdscr.Refresh()
if ch := stdscr.GetChar(); ch == goncurses.KEY_F2 {
stdscr.Print("The F2 key was pressed.")
} else {
stdscr.Print("The key pressed is: ")
stdscr.AttrOn(goncurses.A_BOLD)
stdscr.AddChar(goncurses.Char(ch))
stdscr.AttrOff(goncurses.A_BOLD)
}
stdscr.Refresh()
stdscr.GetChar()
}
func main() {
stdscr, err := gc.Init()
if err != nil {
log.Fatal(err)
}
defer gc.End()
gc.StartColor()
gc.Echo(false)
gc.Raw(true)
var colours = []int16{gc.C_BLACK, gc.C_BLUE, gc.C_CYAN, gc.C_GREEN,
gc.C_MAGENTA, gc.C_RED, gc.C_WHITE, gc.C_YELLOW}
var attributes = []struct {
attr gc.Char
text string
}{
{gc.A_NORMAL, "normal"},
{gc.A_STANDOUT, "standout"},
{gc.A_UNDERLINE | gc.A_BOLD, "underline"},
{gc.A_REVERSE, "reverse"},
{gc.A_BLINK, "blink"},
{gc.A_DIM, "dim"},
{gc.A_BOLD, "bold"},
}
stdscr.MovePrint(0, 0, "Normal terminal colors: ")
for i, c := range colours {
gc.InitPair(int16(i), c, c)
stdscr.ColorOn(int16(i))
stdscr.AddChar(' ')
stdscr.ColorOff(int16(i))
}
stdscr.MovePrint(1, 0, "Bold terminal colors: ")
stdscr.AttrOn(gc.A_BLINK)
for i, _ := range colours {
stdscr.ColorOn(int16(i))
stdscr.AddChar(' ')
stdscr.ColorOff(int16(i))
}
stdscr.AttrOff(gc.A_BLINK)
stdscr.Move(2, 0)
for _, a := range attributes {
stdscr.AttrOn(a.attr)
stdscr.Println(a.text)
stdscr.AttrOff(a.attr)
}
stdscr.GetChar()
}
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()
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() {
var active int
menu := []string{"Choice 1", "Choice 2", "Choice 3", "Choice 4", "Exit"}
stdscr, err := gc.Init()
if err != nil {
log.Fatal("init:", err)
}
defer gc.End()
gc.Raw(true)
gc.Echo(false)
gc.Cursor(0)
stdscr.Keypad(true)
y, x := 5, 2
win, err := gc.NewWindow(HEIGHT, WIDTH, y, x)
if err != nil {
log.Fatal("new_window:", err)
}
stdscr.MovePrint(0, 0, "Use up/down arrow keys, enter to "+
"select or 'q' to quit")
stdscr.MovePrint(1, 0, "You may also left mouse click on an entry to select")
stdscr.Refresh()
printmenu(win, menu, active)
// Check to see if the Mouse is available. This function was not available
// in older versions of ncurses (5.7 and older) and may return false even
// if the mouse is in fact avaiable for use.
if gc.MouseOk() {
stdscr.MovePrint(3, 0, "WARN: Mouse support not detected.")
}
// Adjust the default mouse-click sensitivity to make it more responsive
gc.MouseInterval(50)
// If, for example, you are temporarily disabling the mouse or are
// otherwise altering mouse button detection temporarily, you could
// pass a pointer to a MouseButton object as the 2nd argument to
// record that information. Invocation may look something like:
var prev gc.MouseButton
gc.MouseMask(gc.M_B1_PRESSED, nil) // only detect left mouse clicks
gc.MouseMask(gc.M_ALL, &prev) // temporarily enable all mouse clicks
gc.MouseMask(prev, nil) // change it back
for {
ch := stdscr.GetChar()
switch ch {
case 'q':
return
case gc.KEY_UP:
if active == 0 {
active = len(menu) - 1
} else {
active -= 1
}
case gc.KEY_DOWN:
if active == len(menu)-1 {
active = 0
} else {
active += 1
}
case gc.KEY_MOUSE:
/* pull the mouse event off the queue */
md := gc.GetMouse()
new := getactive(x, y, md.X, md.Y, menu)
if new != -1 {
active = new
}
stdscr.MovePrintf(23, 0, "Choice #%d: %s selected", active+1,
menu[active])
stdscr.ClearToEOL()
stdscr.Refresh()
case gc.KEY_RETURN, gc.KEY_ENTER, gc.Key('\r'):
stdscr.MovePrintf(23, 0, "Choice #%d: %s selected", active+1,
menu[active])
stdscr.ClearToEOL()
stdscr.Refresh()
default:
stdscr.MovePrintf(23, 0, "Character pressed = %3d/%c", ch, ch)
stdscr.ClearToEOL()
stdscr.Refresh()
}
printmenu(win, menu, active)
}
}
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 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])
}
}
}