// findPresumedWorkspace inspects a client before it is fully managed to // see which workspace it should go to. Basically, if _NET_WM_DESKTOP is // to a valid workspace number, then we grant the request. Otherwise, we use // the current workspace. func (c *Client) findPresumedWorkspace() workspace.Workspacer { d, err := ewmh.WmDesktopGet(wm.X, c.Id()) if err != nil { return wm.Workspace() } if d == 0xFFFFFFFF { return wm.StickyWrk } if d < 0 || d >= uint(len(wm.Heads.Workspaces.Wrks)) { return wm.Workspace() } return wm.Heads.Workspaces.Get(int(d)) }
func (cmd Move) Run() gribble.Value { return syncRun(func() gribble.Value { x, xok := parsePos(wm.Workspace().Geom(), cmd.X, false) y, yok := parsePos(wm.Workspace().Geom(), cmd.Y, true) if !xok || !yok { return nil } withClient(cmd.Client, func(c *xclient.Client) { c.EnsureUnmax() c.LayoutMove(x, y) }) return nil }) }
func (cmd Resize) Run() gribble.Value { return syncRun(func() gribble.Value { w, wok := parseDim(wm.Workspace().Geom(), cmd.Width, false) h, hok := parseDim(wm.Workspace().Geom(), cmd.Height, true) if !wok || !hok { return nil } withClient(cmd.Client, func(c *xclient.Client) { c.EnsureUnmax() c.LayoutResize(w, h) }) return nil }) }
func (c *Client) unstick() { c.sticky = false c.workspace = nil wm.Workspace().Add(c) c.removeState("_NET_WM_STATE_STICKY") }
func (cmd MovePointerRelative) Run() gribble.Value { return syncRun(func() gribble.Value { geom := wm.Workspace().Geom() xproto.WarpPointer(wm.X.Conn(), 0, wm.X.RootWin(), 0, 0, 0, 0, int16(geom.X()+cmd.X), int16(geom.Y()+cmd.Y)) return nil }) }
func (cmd HeadCycle) Run() gribble.Value { return syncRun(func() gribble.Value { cur := wm.Heads.VisibleIndex(wm.Workspace()) next := misc.Mod(cur+1, wm.Heads.NumHeads()) wm.Heads.WithVisibleWorkspace(next, func(wrk *workspace.Workspace) { wm.SetWorkspace(wrk, false) }) wm.FocusFallback() return nil }) }
func (cmd MovePointerRelative) Run() gribble.Value { return syncRun(func() gribble.Value { geom := wm.Workspace().Geom() x, xok := parsePos(geom, cmd.X, false) y, yok := parsePos(geom, cmd.Y, true) if !xok || !yok { return nil } xproto.WarpPointer(wm.X.Conn(), 0, wm.X.RootWin(), 0, 0, 0, 0, int16(geom.X()+x), int16(geom.Y()+y)) return nil }) }
func handleMotionNotify(X *xgbutil.XUtil, ev xevent.MotionNotifyEvent) { qp, err := xproto.QueryPointer(X.Conn(), X.RootWin()).Reply() if err != nil { logger.Warning.Printf("Could not query pointer: %s", err) return } geom := xrect.New(int(qp.RootX), int(qp.RootY), 1, 1) if wrk := wm.Heads.FindMostOverlap(geom); wrk != nil { if wrk != wm.Workspace() { wm.SetWorkspace(wrk, false) wm.FocusFallback() } } }
func (cmd MoveRelative) Run() gribble.Value { return syncRun(func() gribble.Value { geom := wm.Workspace().Geom() x, xok := parsePos(geom, cmd.X, false) y, yok := parsePos(geom, cmd.Y, true) if !xok || !yok { return nil } withClient(cmd.Client, func(c *xclient.Client) { c.EnsureUnmax() c.LayoutMove(geom.X()+x, geom.Y()+y) }) return nil }) }
func (cmd Input) Run() gribble.Value { inputted := make(chan string, 0) response := func(inp *prompt.Input, text string) { inputted <- text inp.Hide() } canceled := func(inp *prompt.Input) { inputted <- "" } geom := wm.Workspace().Geom() if !wm.Prompts.Input.Show(geom, cmd.Label, response, canceled) { return "" } return <-inputted }
func (c *Client) PrepareForFocus() { // There are only two ways a *managed* client is not prepared for focus: // 1) It belongs to any workspace except for the active one. // 2) It is iconified. // It is possible to be both. Check for both and remedy the situation. // We must check for (1) before (2), since a window cannot toggle its // iconification status if its workspace is not the current workspace. if c.workspace != wm.Workspace() { // This isn't applicable if we're sticky. if wrk, ok := c.workspace.(*workspace.Workspace); ok { wm.SetWorkspace(wrk, false) } } if c.iconified { c.IconifyToggle() } }
func (cmd GetWorkspacePrefix) Run() gribble.Value { return syncRun(func() gribble.Value { hasPre := func(wrk *workspace.Workspace, prefix string) bool { return strings.HasPrefix(strings.ToLower(wrk.Name), prefix) } preAndHidden := func(wrk *workspace.Workspace, prefix string) bool { return !wrk.IsVisible() && hasPre(wrk, prefix) } needle := strings.ToLower(cmd.Prefix) cur := wm.Workspace() if hasPre(cur, needle) { past := false for _, wrk := range wm.Heads.Workspaces.Wrks { if past { if preAndHidden(wrk, needle) { return wrk.Name } continue } if wrk == cur { past = true } } // Nothing? Now look for one before 'cur'... for _, wrk := range wm.Heads.Workspaces.Wrks { if wrk == cur { // we've gone too far... return "" } if preAndHidden(wrk, needle) { return wrk.Name } } } else { for _, wrk := range wm.Heads.Workspaces.Wrks { if preAndHidden(wrk, needle) { return wrk.Name } } } return "" }) }
// parsePos takes a string and parses an x or y position from it. // The magic here is that while a string could just be a simple integer, // it could also be a float greater than 0 but <= 1 in terms of the current // head's geometry. func parsePos(gribblePos gribble.Any, y bool) (int, bool) { switch pos := gribblePos.(type) { case int: return pos, true case float64: if pos <= 0 || pos > 1 { logger.Warning.Printf("'%s' not in the valid range (0, 1].", pos) return 0, false } headGeom := wm.Workspace().Geom() if y { return headGeom.Y() + int(float64(headGeom.Height())*pos), true } else { return headGeom.X() + int(float64(headGeom.Width())*pos), true } } panic("unreachable") }
// parseDim takes a string and parses a width or height dimension from it. // The magic here is that while a string could just be a simple integer, // it could also be a float greater than 0 but <= 1 in terms of the current // head's geometry. func parseDim(gribbleDim gribble.Any, height bool) (int, bool) { switch dim := gribbleDim.(type) { case int: return dim, true case float64: if dim <= 0 || dim > 1 { logger.Warning.Printf("'%s' not in the valid range (0, 1].", dim) return 0, false } headGeom := wm.Workspace().Geom() if height { return int(float64(headGeom.Height()) * dim), true } else { return int(float64(headGeom.Width()) * dim), true } } panic("unreachable") }
func (cmd GetHead) Run() gribble.Value { return syncRun(func() gribble.Value { return wm.Heads.VisibleIndex(wm.Workspace()) }) }
func (cmd GetWorkspace) Run() gribble.Value { return syncRun(func() gribble.Value { return wm.Workspace().Name }) }
func main() { if flagWriteConfig { writeConfigFiles() os.Exit(0) } X, err := xgbutil.NewConn() if err != nil { logger.Error.Println(err) logger.Error.Fatalln("Error connecting to X, quitting...") } defer X.Conn().Close() // Do this first! Attempt to retrieve window manager ownership. // This includes waiting for any existing window manager to die. // 'own' also sets up handlers for quitting when a window manager tries // to replace *us*. if err := own(X, flagReplace); err != nil { logger.Error.Fatalf( "Could not establish window manager ownership: %s", err) } if len(flagConfigDir) > 0 { misc.ConfigPaths.Override = flagConfigDir } if len(flagDataDir) > 0 { misc.DataPaths.Override = flagDataDir } misc.ReadData() keybind.Initialize(X) mousebind.Initialize(X) focus.Initialize(X) stack.Initialize(X) cursors.Initialize(X) wm.Initialize(X, commands.Env, newHacks()) hook.Initialize(commands.Env, misc.ConfigFile("hooks.wini")) // Listen to Root. It is all-important. err = xwindow.New(X, X.RootWin()).Listen( xproto.EventMaskPropertyChange | xproto.EventMaskFocusChange | xproto.EventMaskButtonPress | xproto.EventMaskButtonRelease | xproto.EventMaskStructureNotify | xproto.EventMaskSubstructureNotify | xproto.EventMaskSubstructureRedirect) 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) // Tell everyone what we support. setSupported() // Start up the IPC command listener. go ipc() // Just before starting the main event loop, check to see if there are // any clients that already exist that we should manage. manageExistingClients() // Now make sure that clients are in the appropriate visible state. for _, wrk := range wm.Heads.Workspaces.Wrks { if wrk.IsVisible() { wrk.Show() } else { wrk.Hide() } } wm.Heads.ApplyStruts(wm.Clients) wm.FocusFallback() wm.Startup = false pingBefore, pingAfter, pingQuit := xevent.MainPing(X) if len(flagCpuProfile) > 0 { f, err := os.Create(flagCpuProfile) if err != nil { logger.Error.Fatalf("%s\n", err) } pprof.StartCPUProfile(f) defer pprof.StopCPUProfile() } if flagWingoRestarted { hook.Fire(hook.Restarted, hook.Args{}) } else { hook.Fire(hook.Startup, hook.Args{}) } EVENTLOOP: for { select { case <-pingBefore: // Wait for the event to finish processing. <-pingAfter case f := <-commands.SafeExec: commands.SafeReturn <- f() case <-pingQuit: break EVENTLOOP } } if wm.Restart { // We need to tell the next invocation of Wingo that it is being // *restarted*. (So that we don't refire the startup hook.) // Thus, search os.Args for "--wingo-restarted". If it doesn't exist, // add it. found := false for _, arg := range os.Args { if strings.ToLower(strings.TrimSpace(arg)) == "--wingo-restarted" { found = true } } if !found { os.Args = append(os.Args, "--wingo-restarted") } logger.Message.Println("The user has told us to restart...\n\n\n") if err := syscall.Exec(os.Args[0], os.Args, os.Environ()); err != nil { logger.Error.Fatalf("Could not exec '%s': %s", strings.Join(os.Args, " "), err) } } }
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) } }