// keyResponse translates key board input into two different actions: canceling
// the current prompt and making a choice in the cycle prompt.
// Canceling a prompt corresponds to the "CycleConfig.CancelKey" being pressed.
// Making a choice in the cycle prompt corresponds to releasing all of the
// modifiers used to initiate showing the prompt (when "CycleConfig.AutoChoose"
// is true).
// If CancelKey is empty, then no cancel key functionality is provided.
// If AutoChoose is false, then releasing the modifiers will have no effect.
//
// For thos interested in the X details:
// The prompt cycle dialog needs to choose the selection when the
// modifiers (i.e., "alt" in "alt-tab") are released.
// The only way to do this (generally) is to check the raw KeyRelease event.
// Namely, if the keycode *released* is a modifier, we have to and-out
// that modifier from the key release event data. If the modifiers
// remaining aren't up to snuff with the original grabbed modifiers,
// then we can finally "choose" the selection.
// TL;DR - This is how we "exit" the prompt cycle dialog.
func (cycle *Cycle) keyResponse() xevent.KeyReleaseFun {
f := func(X *xgbutil.XUtil, ev xevent.KeyReleaseEvent) {
if !cycle.showing {
return
}
mods, kc := keybind.DeduceKeyInfo(ev.State, ev.Detail)
// If the key release is the cancel key, quit the prompt and
// don't do anything.
if keybind.KeyMatch(X, cycle.config.CancelKey, mods, kc) {
cycle.Hide()
return
}
mods &= ^keybind.ModGet(X, ev.Detail)
if cycle.grabMods > 0 {
if mods&cycle.grabMods == 0 {
cycle.Choose()
}
} else {
if keybind.KeyMatch(X, cycle.config.ConfirmKey, mods, kc) {
cycle.Choose()
}
}
}
return xevent.KeyReleaseFun(f)
}
func (ct *CommandTray) keyPress() xevent.KeyPressFun {
f := func(X *xgbutil.XUtil, ev xevent.KeyPressEvent) {
// print("Cake:\n")
if !ct.is_focused {
// print("Boom\n")
return
}
mods, kc := keybind.DeduceKeyInfo(ev.State, ev.Detail)
// print("Key Press:", mods, kc, "\n")
switch {
case keybind.KeyMatch(X, "Escape", mods, kc):
ct.Blur()
case keybind.KeyMatch(X, "Return", mods, kc):
ct.activate()
case keybind.KeyMatch(X, "Up", mods, kc):
ct.selected -= 1
if ct.selected < 0 {
ct.selected = len(ct.cmds)
}
ct.Draw()
case keybind.KeyMatch(X, "Down", mods, kc):
if len(ct.cmds) > 0 {
ct.selected += 1
ct.selected %= len(ct.cmds)
ct.Draw()
}
case keybind.KeyMatch(X, "BackSpace", mods, kc):
if len(ct.input) > 0 {
ct.input = ct.input[:len(ct.input)-1]
ct.getCommands()
ct.Draw()
}
default:
s := keybind.LookupString(X, mods, kc)
if len(s) == 1 {
ct.input = append(ct.input, rune(strings.ToLower(s)[0]))
ct.selected = 0
ct.getCommands()
ct.Draw()
}
}
}
return xevent.KeyPressFun(f)
}
func (slct *Select) keyResponse() xevent.KeyPressFun {
f := func(X *xgbutil.XUtil, ev xevent.KeyPressEvent) {
if !slct.showing {
return
}
beforeLen := len(slct.input.Text)
mods, kc := keybind.DeduceKeyInfo(ev.State, ev.Detail)
slct.input.Add(mods, kc)
switch {
case keybind.KeyMatch(X, slct.config.BackspaceKey, mods, kc):
slct.input.Remove()
case keybind.KeyMatch(X, slct.config.CancelKey, mods, kc):
slct.Hide()
return
case keybind.KeyMatch(X, slct.config.ConfirmKey, mods, kc):
if slct.selected >= 0 && slct.selected < len(slct.items) {
slct.items[slct.selected].choose()
slct.Hide()
} else if len(slct.items) == 1 {
slct.items[0].choose()
slct.Hide()
}
return
case keybind.KeyMatch(X, "Tab", mods, kc) ||
keybind.KeyMatch(X, "ISO_Left_Tab", mods, kc):
if len(slct.items) == 0 {
break
}
if mods&xproto.ModMaskShift > 0 {
if slct.selected == -1 {
slct.selected++
}
slct.selected = misc.Mod(slct.selected-1, len(slct.items))
} else {
slct.selected = misc.Mod(slct.selected+1, len(slct.items))
}
slct.highlight()
}
// If the length of the input changed, then re-evaluate completion
if beforeLen != len(slct.input.Text) {
slct.FilterItems(string(slct.input.Text))
slct.selected = -1
slct.highlight()
}
}
return xevent.KeyPressFun(f)
}
func (msg *Message) keyResponse() xevent.KeyPressFun {
f := func(X *xgbutil.XUtil, ev xevent.KeyPressEvent) {
if !msg.showing {
return
}
mods, kc := keybind.DeduceKeyInfo(ev.State, ev.Detail)
switch {
case keybind.KeyMatch(X, msg.config.ConfirmKey, mods, kc):
fallthrough
case keybind.KeyMatch(X, msg.config.CancelKey, mods, kc):
msg.Hide()
}
}
return xevent.KeyPressFun(f)
}
func (inp *Input) keyResponse() xevent.KeyPressFun {
f := func(X *xgbutil.XUtil, ev xevent.KeyPressEvent) {
if !inp.showing {
return
}
mods, kc := keybind.DeduceKeyInfo(ev.State, ev.Detail)
switch {
case keybind.KeyMatch(X, "Up", mods, kc):
if inp.historyIndex > 0 {
inp.historyIndex--
inp.input.SetString(inp.history[inp.historyIndex])
}
case keybind.KeyMatch(X, "Down", mods, kc):
if inp.historyIndex < len(inp.history) {
inp.historyIndex++
if inp.historyIndex < len(inp.history) {
inp.input.SetString(inp.history[inp.historyIndex])
} else {
inp.input.Reset()
}
}
case keybind.KeyMatch(X, inp.config.BackspaceKey, mods, kc):
inp.input.Remove()
case keybind.KeyMatch(X, inp.config.ConfirmKey, mods, kc):
if inp.do != nil {
s := string(inp.input.Text)
histLen := len(inp.history)
// Don't added repeated entries.
if histLen == 0 || s != inp.history[histLen-1] {
inp.history = append(inp.history, s)
}
inp.do(inp, s)
}
case keybind.KeyMatch(X, inp.config.CancelKey, mods, kc):
if inp.canceled != nil {
inp.canceled(inp)
}
inp.Hide()
default:
inp.input.Add(mods, kc)
}
}
return xevent.KeyPressFun(f)
}
func main() {
X, err := xgbutil.NewConn()
if err != nil {
log.Println(err)
return
}
//Initialize the keybind package
keybind.Initialize(X)
//Create a window
win, err := xwindow.Generate(X)
if err != nil {
log.Fatalf("Could not generate a new window X id: %s", err)
}
win.Create(X.RootWin(), 0, 0, 1024, 768, xproto.CwBackPixel, 0x606060ff)
// Listen for Key{Press,Release} events.
win.Listen(xproto.EventMaskKeyPress, xproto.EventMaskKeyRelease)
// Map the window. This is what makes it on the screen
win.Map()
//Make a ...callback... for the events and connect
xevent.KeyPressFun(
func(X *xgbutil.XUtil, e xevent.KeyPressEvent) {
modStr := keybind.ModifierString(e.State)
keyStr := keybind.LookupString(X, e.State, e.Detail)
if len(modStr) > 0 {
log.Printf("Key: %s-%s\n", modStr, keyStr)
} else {
log.Println("Key:", keyStr)
}
if keybind.KeyMatch(X, "Escape", e.State, e.Detail) {
if e.State&xproto.ModMaskControl > 0 {
log.Println("Control-Escape detected. Quitting...")
xevent.Quit(X)
}
}
}).Connect(X, win.Id)
//So here i'm going to try to make a image..'
img := xgraphics.New(X, image.Rect(0, 0, 1024, 768))
err = img.XSurfaceSet(win.Id)
if err != nil {
log.Printf("Error while setting window surface to image %d: %s\n",
win, err)
} else {
log.Printf("Window %d surface set to image OK\n", win)
}
// I /think/ XDraw actually sends data to server?
img.XDraw()
// I /think/ XPaint tells the server to paint image to window
img.XPaint(win.Id)
//Start the routine that updates the window
go updater(img, win)
//This seems to start a main loop for listening to xevents
xevent.Main(X)
}
func main() {
X, err := xgbutil.NewConn()
fatal(err)
// Remember to always initialize the keybind package before usage.
keybind.Initialize(X)
// We create a benign parent window. Its only value in this example is
// instructional. In particular, it shows how to have a sub-window get
// focus using the ICCCM WM_TAKE_FOCUS protocol. (Since by default,
// the window manager will assign focus to your top-level window.)
// The real magic happens below with the WMTakeFocus method call.
parentWin, err := xwindow.Create(X, X.RootWin())
fatal(err)
// NewInput creates a new input window and handles all of the text drawing
// for you. It can be any width, but the height will be automatically
// determined by the height extents of the font size chosen.
input := text.NewInput(X, parentWin.Id, width, padding, font, fontSize,
fontColor, bgColor)
parentWin.Resize(input.Geom.Width(), input.Geom.Height())
// Make sure X reports KeyPress events when this window is focused.
input.Listen(xproto.EventMaskKeyPress)
// Listen to KeyPress events. If it's a BackSpace, remove the last
// character in the input box. If it's "Return" quit. If it's "Escape",
// clear the input box.
// Otherwise, try to add the key pressed to the input box.
// (Not all key presses correspond to a single character that is added.)
xevent.KeyPressFun(
func(X *xgbutil.XUtil, ev xevent.KeyPressEvent) {
mods, kc := ev.State, ev.Detail
switch {
case keybind.KeyMatch(X, "BackSpace", mods, kc):
input.Remove()
case keybind.KeyMatch(X, "Return", mods, kc):
log.Println("Return has been pressed.")
log.Printf("The current text is: %s", string(input.Text))
log.Println("Quitting...")
xevent.Quit(X)
case keybind.KeyMatch(X, "Escape", mods, kc):
input.Reset()
default:
input.Add(mods, kc)
}
}).Connect(X, input.Id)
// Implement the WM_DELETE_WINDOW protocol.
parentWin.WMGracefulClose(func(w *xwindow.Window) {
xevent.Quit(X)
})
// Implement the WM_TAKE_FOCUS protocol. The callback function provided
// is executed when a valid WM_TAKE_FOCUS ClientMessage event has been
// received from the window manager.
// According to ICCCM Section 4.2.7, this is one of the three valid ways
// of setting input focus to a sub-window. (It's also easiest since it
// doesn't require us to monitor FocusChange events. EW.)
// If you have multiple sub-windows that can be focused, this callback
// function is where the logic would go to pick which sub-window should
// be focused upon receipt of a WM_TAKE_FOCUS message.
parentWin.WMTakeFocus(func(w *xwindow.Window, tstamp xproto.Timestamp) {
input.FocusParent(tstamp)
})
// Map the window and start the main X event loop.
input.Map()
parentWin.Map()
xevent.Main(X)
}
func main() {
// Connect to the X server using the DISPLAY environment variable.
X, err := xgbutil.NewConn()
if err != nil {
log.Fatal(err)
}
// Anytime the keybind (mousebind) package is used, keybind.Initialize
// *should* be called once. It isn't strictly necessary, but allows your
// keybindings to persist even if the keyboard mapping is changed during
// run-time. (Assuming you're using the xevent package's event loop.)
// It also handles the case when your modifier map is changed.
keybind.Initialize(X)
// Create a new window. We will listen for key presses and translate them
// only when this window is in focus. (Similar to how `xev` works.)
win, err := xwindow.Generate(X)
if err != nil {
log.Fatalf("Could not generate a new window X id: %s", err)
}
win.Create(X.RootWin(), 0, 0, 500, 500, xproto.CwBackPixel, 0xffffffff)
// Listen for Key{Press,Release} events.
win.Listen(xproto.EventMaskKeyPress, xproto.EventMaskKeyRelease)
// Map the window.
win.Map()
// Notice that we use xevent.KeyPressFun instead of keybind.KeyPressFun,
// because we aren't trying to make a grab *and* because we want to listen
// to *all* key press events, rather than just a particular key sequence
// that has been pressed.
wid := win.Id
if flagRoot {
wid = X.RootWin()
}
xevent.KeyPressFun(
func(X *xgbutil.XUtil, e xevent.KeyPressEvent) {
// keybind.LookupString does the magic of implementing parts of
// the X Keyboard Encoding to determine an english representation
// of the modifiers/keycode tuple.
// N.B. It's working for me, but probably isn't 100% correct in
// all environments yet.
modStr := keybind.ModifierString(e.State)
keyStr := keybind.LookupString(X, e.State, e.Detail)
if len(modStr) > 0 {
log.Printf("Key: %s-%s\n", modStr, keyStr)
} else {
log.Println("Key:", keyStr)
}
if keybind.KeyMatch(X, "Escape", e.State, e.Detail) {
if e.State&xproto.ModMaskControl > 0 {
log.Println("Control-Escape detected. Quitting...")
xevent.Quit(X)
}
}
}).Connect(X, wid)
// If we want root, then we take over the entire keyboard.
if flagRoot {
if err := keybind.GrabKeyboard(X, X.RootWin()); err != nil {
log.Fatalf("Could not grab keyboard: %s", err)
}
log.Println("WARNING: We are taking *complete* control of the root " +
"window. The only way out is to press 'Control + Escape' or to " +
"close the window with the mouse.")
}
// Finally, start the main event loop. This will route any appropriate
// KeyPressEvents to your callback function.
log.Println("Program initialized. Start pressing keys!")
xevent.Main(X)
}