func main() {
X, err := xgbutil.NewConn()
if err != nil {
log.Fatal(err)
}
// Create window for receiving compressed MotionNotify events.
cwin := newWindow(X, 0x00ff00)
// Attach event handler for MotionNotify that compresses events.
xevent.MotionNotifyFun(
func(X *xgbutil.XUtil, ev xevent.MotionNotifyEvent) {
ev = compressMotionNotify(X, ev)
fmt.Printf("COMPRESSED: (EventX %d, EventY %d)\n",
ev.EventX, ev.EventY)
time.Sleep(workTime)
}).Connect(X, cwin.Id)
// Create window for receiving uncompressed MotionNotify events.
uwin := newWindow(X, 0xff0000)
// Attach event handler for MotionNotify that does not compress events.
xevent.MotionNotifyFun(
func(X *xgbutil.XUtil, ev xevent.MotionNotifyEvent) {
fmt.Printf("UNCOMPRESSED: (EventX %d, EventY %d)\n",
ev.EventX, ev.EventY)
time.Sleep(workTime)
}).Connect(X, uwin.Id)
xevent.Main(X)
}
// Drag is the public interface that will make the appropriate connections
// to register a drag event for three functions: the begin function, the
// step function and the end function.
// The 'grabwin' is the window that the grab is placed on (and therefore the
// window where all button events are redirected to after the drag has started),
// and the 'win' is the window that the initial 'begin' callback is set on.
// In typical use cases, these windows should be the same.
// If 'grab' is false, then no pointer grab is issued.
func Drag(xu *xgbutil.XUtil, grabwin xproto.Window, win xproto.Window,
buttonStr string, grab bool,
begin xgbutil.MouseDragBeginFun, step xgbutil.MouseDragFun,
end xgbutil.MouseDragFun) {
ButtonPressFun(
func(xu *xgbutil.XUtil, ev xevent.ButtonPressEvent) {
DragBegin(xu, ev, grabwin, win, begin, step, end)
}).Connect(xu, win, buttonStr, false, grab)
// If the grab win isn't the dummy, then setup event handlers for the
// grab window.
if grabwin != xu.Dummy() {
xevent.MotionNotifyFun(dragStep).Connect(xu, grabwin)
xevent.ButtonReleaseFun(DragEnd).Connect(xu, grabwin)
}
}
func rootInit(X *xgbutil.XUtil) {
var err error
// Listen to Root. It is all-important.
evMasks := xproto.EventMaskPropertyChange |
xproto.EventMaskFocusChange |
xproto.EventMaskButtonPress |
xproto.EventMaskButtonRelease |
xproto.EventMaskStructureNotify |
xproto.EventMaskSubstructureNotify |
xproto.EventMaskSubstructureRedirect
if wm.Config.FfmHead {
evMasks |= xproto.EventMaskPointerMotion
}
err = xwindow.New(X, X.RootWin()).Listen(evMasks)
if err != nil {
logger.Error.Fatalf("Could not listen to Root window events: %s", err)
}
// Update state when the root window changes size
wm.RootGeomChangeFun().Connect(X, wm.Root.Id)
// Oblige map request events
xevent.MapRequestFun(
func(X *xgbutil.XUtil, ev xevent.MapRequestEvent) {
xclient.New(ev.Window)
}).Connect(X, wm.Root.Id)
// Oblige configure requests from windows we don't manage.
xevent.ConfigureRequestFun(
func(X *xgbutil.XUtil, ev xevent.ConfigureRequestEvent) {
// Make sure we aren't managing this client.
if wm.FindManagedClient(ev.Window) != nil {
return
}
xwindow.New(X, ev.Window).Configure(int(ev.ValueMask),
int(ev.X), int(ev.Y), int(ev.Width), int(ev.Height),
ev.Sibling, ev.StackMode)
}).Connect(X, wm.Root.Id)
xevent.FocusInFun(
func(X *xgbutil.XUtil, ev xevent.FocusInEvent) {
if ignoreRootFocus(ev.Mode, ev.Detail) {
return
}
if len(wm.Workspace().Clients) == 0 {
return
}
wm.FocusFallback()
}).Connect(X, wm.Root.Id)
// Listen to Root client message events. This is how we handle all
// of the EWMH bullshit.
xevent.ClientMessageFun(handleClientMessages).Connect(X, wm.Root.Id)
// Check where the pointer is on motion events. If it's crossed a monitor
// boundary, switch the focus of the head.
if wm.Config.FfmHead {
xevent.MotionNotifyFun(handleMotionNotify).Connect(X, wm.Root.Id)
}
}
// Initialize attaches the appropriate callbacks to make mouse bindings easier.
// i.e., prep the dummy window to handle mouse dragging events
func Initialize(xu *xgbutil.XUtil) {
xevent.MotionNotifyFun(dragStep).Connect(xu, xu.Dummy())
xevent.ButtonReleaseFun(DragEnd).Connect(xu, xu.Dummy())
}