func main() {
X, err := xgbutil.NewConn()
if err != nil {
log.Fatal(err)
}
// Anytime the mousebind (keybind) package is used, mousebind.Initialize
// *should* be called once. In the case of the mousebind package, this
// isn't strictly necessary (currently!), but the 'Drag' features of
// the mousebind package won't work without it.
mousebind.Initialize(X)
// Create two windows to prove we can close one while keeping the
// other alive.
newWindow(X)
newWindow(X)
xevent.Main(X)
}
func main() {
X, err := xgbutil.NewConn()
fatal(err)
// Whenever the mousebind package is used, you must call Initialize.
// Similarly for the keybind package.
keybind.Initialize(X)
mousebind.Initialize(X)
// Easter egg! Use a right click to draw a gopher.
gopherPng, _, err := image.Decode(bytes.NewBuffer(gopher.GopherPng()))
fatal(err)
// Now scale it to a reasonable size.
gopher := xgraphics.Scale(gopherPng, gopherWidth, gopherHeight)
// Create a new xgraphics.Image. It automatically creates an X pixmap for
// you, and handles drawing to windows in the XDraw, XPaint and
// XSurfaceSet functions.
// N.B. An error is possible since X pixmap allocation can fail.
canvas := xgraphics.New(X, image.Rect(0, 0, width, height))
// Color in the background color.
canvas.For(func(x, y int) xgraphics.BGRA {
return bg
})
// Use the convenience function XShowExtra to create and map the
// canvas window.
// XShowExtra will also set the surface window of canvas for us.
// We also use XShowExtra to set the name of the window and to quit the
// main event loop when the window is closed.
win := canvas.XShowExtra("Pointer painting", true)
// Listen for pointer motion events and key press events.
win.Listen(xproto.EventMaskButtonPress | xproto.EventMaskButtonRelease |
xproto.EventMaskKeyPress)
// The mousebind drag function runs three callbacks: one when the drag is
// first started, another at each "step" in the drag, and a final one when
// the drag is done.
// The button sequence (in this case '1') is pressed, the first callback
// is executed. If the first return value is true, the drag continues
// and a pointer grab is initiated with the cursor id specified in the
// second return value (use 0 to keep the cursor unchanged).
// If it's false, the drag stops.
// Note that Drag will automatically compress MotionNotify events.
mousebind.Drag(X, win.Id, win.Id, "1", false,
func(X *xgbutil.XUtil, rx, ry, ex, ey int) (bool, xproto.Cursor) {
drawPencil(canvas, win, ex, ey)
return true, 0
},
func(X *xgbutil.XUtil, rx, ry, ex, ey int) {
drawPencil(canvas, win, ex, ey)
},
func(X *xgbutil.XUtil, rx, ry, ex, ey int) {})
mousebind.Drag(X, win.Id, win.Id, "3", false,
func(X *xgbutil.XUtil, rx, ry, ex, ey int) (bool, xproto.Cursor) {
drawGopher(canvas, gopher, win, ex, ey)
return true, 0
},
func(X *xgbutil.XUtil, rx, ry, ex, ey int) {
drawGopher(canvas, gopher, win, ex, ey)
},
func(X *xgbutil.XUtil, rx, ry, ex, ey int) {})
// Bind to the clear key specified, and just redraw the bg color.
keybind.KeyPressFun(
func(X *xgbutil.XUtil, ev xevent.KeyPressEvent) {
clearCanvas(canvas, win)
}).Connect(X, win.Id, clearKey, false)
// Bind a callback to each key specified in the 'pencils' color map.
// The response is to simply switch the pencil color.
for key, clr := range pencils {
c := clr
keybind.KeyPressFun(
func(X *xgbutil.XUtil, ev xevent.KeyPressEvent) {
log.Printf("Changing pencil color to: %#v", c)
pencil = c
}).Connect(X, win.Id, key, false)
}
// Output some basic directions.
fmt.Println("Use the left or right buttons on your mouse to paint " +
"squares and gophers.")
fmt.Println("Pressing numbers 1, 2, 3, 4, 5 or 6 will switch your pencil " +
"color.")
fmt.Println("Pressing 'c' will clear the canvas.")
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 mousebind (keybind) package is used, mousebind.Initialize
// *should* be called once. In the case of the mousebind package, this
// isn't strictly necessary, but the 'Drag' features of the mousebind
// package won't work without it.
mousebind.Initialize(X)
// Before attaching callbacks, wrap them in a callback function type.
// The mouse package exposes two such callback types:
// mousebind.ButtonPressFun and mousebind.ButtonReleaseFun.
cb1 := mousebind.ButtonPressFun(
func(X *xgbutil.XUtil, e xevent.ButtonPressEvent) {
log.Println("Button press!")
})
// We can now attach the callback to a particular window and button
// combination. This particular example grabs a button on the root window,
// which makes it a global mouse binding.
// Also, "Mod4-1" typically corresponds to pressing down the "Super" or
// "Windows" key on your keyboard, and then pressing the left mouse button.
// The last two parameters are whether to make a synchronous grab and
// whether to actually issue a grab, respectively.
// (The parameters used here are the common case.)
// See the documentation for the Connect method for more details.
err = cb1.Connect(X, X.RootWin(), "Mod4-1", false, true)
// A mouse binding can fail if the mouse string could not be parsed, or if
// you're trying to bind a button that has already been grabbed by another
// client.
if err != nil {
log.Fatal(err)
}
// We can even attach multiple callbacks to the same button.
err = mousebind.ButtonPressFun(
func(X *xgbutil.XUtil, e xevent.ButtonPressEvent) {
log.Println("A second handler always happens after the first.")
}).Connect(X, X.RootWin(), "Mod4-1", false, true)
if err != nil {
log.Fatal(err)
}
// Finally, if we want this client to stop responding to mouse events, we
// can attach another handler that, when run, detaches all previous
// handlers.
// This time, we'll show an example of a ButtonRelease binding.
err = mousebind.ButtonReleaseFun(
func(X *xgbutil.XUtil, e xevent.ButtonReleaseEvent) {
// Use mousebind.Detach to detach the root window
// from all ButtonPress *and* ButtonRelease handlers.
mousebind.Detach(X, X.RootWin())
mousebind.Detach(X, X.RootWin())
log.Printf("Detached all Button{Press,Release}Events from the "+
"root window (%d).", X.RootWin())
}).Connect(X, X.RootWin(), "Mod4-Shift-1", false, true)
if err != nil {
log.Fatal(err)
}
// Finally, start the main event loop. This will route any appropriate
// ButtonPressEvents to your callback function.
log.Println("Program initialized. Start pressing mouse buttons!")
xevent.Main(X)
}