func WorkspaceToHead(headIndex int, wrk *workspace.Workspace) {
if headIndex == Heads.VisibleIndex(wrk) {
return
}
// If headIndex is the currently active head, then just activate 'wrk'
// greedily.
if headIndex == Heads.VisibleIndex(Workspace()) {
SetWorkspace(wrk, true)
return
}
// Now we know that we're setting the workspace of a head that isn't
// active. The last special case to check for is whether the workspace
// we're setting is the currently activate workspace. If it is, then we
// simply activate the workspace at headIndex greedily.
if wrk.IsActive() {
Heads.WithVisibleWorkspace(headIndex, func(w *workspace.Workspace) {
SetWorkspace(w, true)
})
return
}
// Finally, we can just swap workspaces now without worrying about the
// active workspace changing.
Heads.WithVisibleWorkspace(headIndex, func(w *workspace.Workspace) {
Heads.SwitchWorkspaces(wrk, w)
})
ewmhVisibleDesktops()
ewmhCurrentDesktop()
Heads.EwmhWorkarea()
}
func SetWorkspace(wrk *workspace.Workspace, greedy bool) {
old := Workspace()
wrk.Activate(greedy)
if old != Workspace() {
FYI("%s", wrk)
}
ewmhCurrentDesktop()
ewmhVisibleDesktops()
Heads.EwmhWorkarea()
}
func RenameWorkspace(wrk *workspace.Workspace, newName string) error {
if len(newName) == 0 {
return fmt.Errorf("workspaces must have a name of length at least one.")
}
if Heads.Workspaces.Find(newName) != nil {
return fmt.Errorf("a workspace with name '%s' already exists.", newName)
}
wrk.Rename(newName)
ewmhDesktopNames()
return nil
}
func SetWorkspace(wrk *workspace.Workspace, greedy bool) {
mousebind.GrabPointer(X, Root.Id, Root.Id, 0)
old := Workspace()
wrk.Activate(greedy)
if old != Workspace() {
FYI("%s", wrk)
}
ewmhVisibleDesktops()
ewmhCurrentDesktop()
Heads.EwmhWorkarea()
mousebind.UngrabPointer(X)
}
func (c *Client) CheckNewWorkspace() {
var newWrk *workspace.Workspace = nil
curWrk := c.Workspace()
if dragGeom := c.DragGeom(); dragGeom != nil {
newWrk = wm.Heads.FindMostOverlap(dragGeom)
} else {
newWrk = wm.Heads.FindMostOverlap(c.frame.Geom())
}
if newWrk == nil || curWrk == newWrk {
return
}
newWrk.Add(c)
// If this is the active window, switch to this workspace too.
if c.IsActive() {
wm.SetWorkspace(newWrk, false)
}
}
func (hds *Heads) RemoveWorkspace(wk *workspace.Workspace) {
// Don't allow it if this would result in fewer workspaces than there
// are active physical heads.
if len(hds.geom) == len(hds.workspaces.Wrks) {
return
}
// There's a bit of complexity in choosing where to move the clients to.
// Namely, if we're removing a hidden workspace, it's a simple matter of
// moving the clients. However, if we're removing a visible workspace,
// we have to make sure to make another workspace that is hidden take
// its place. (Such a workspace is guaranteed to exist because we have at
// least one more workspace than there are active physical heads.)
if !wk.IsVisible() {
moveClientsTo := hds.workspaces.Wrks[len(hds.workspaces.Wrks)-1]
if moveClientsTo == wk {
moveClientsTo = hds.workspaces.Wrks[len(hds.workspaces.Wrks)-2]
}
wk.RemoveAllAndAdd(moveClientsTo)
} else {
// Find the last-most hidden workspace that is not itself.
for i := len(hds.workspaces.Wrks) - 1; i >= 0; i-- {
work := hds.workspaces.Wrks[i]
if work != wk && !work.IsVisible() {
hds.SwitchWorkspaces(wk, work)
wk.RemoveAllAndAdd(work)
break
}
}
}
hds.workspaces.Remove(wk)
}
func (hds *Heads) RemoveWorkspace(wk *workspace.Workspace) {
// Don't allow it if this would result in fewer workspaces than there
// are active physical heads.
if len(hds.geom) == len(hds.Workspaces.Wrks) {
panic("Cannot have fewer workspaces than active monitors.")
}
// A non-empty workspace cannot be removed.
if len(wk.Clients) > 0 {
panic(fmt.Sprintf("Non-empty workspace '%s' cannot be removed.", wk))
}
if wk.IsVisible() {
// Find the last-most hidden workspace that is not itself and switch.
for i := len(hds.Workspaces.Wrks) - 1; i >= 0; i-- {
work := hds.Workspaces.Wrks[i]
if work != wk && !work.IsVisible() {
hds.SwitchWorkspaces(wk, work)
break
}
}
}
hds.Workspaces.Remove(wk)
}
func (hds *Heads) SwitchWorkspaces(wk1, wk2 *workspace.Workspace) {
v1, v2 := hds.visibleIndex(wk1), hds.visibleIndex(wk2)
switch {
case v1 > -1 && v2 > -1:
hds.visibles[v1], hds.visibles[v2] = hds.visibles[v2], hds.visibles[v1]
wk1.Place()
wk2.Place()
case v1 > -1 && v2 == -1:
hds.visibles[v1] = wk2
wk1.Hide()
wk2.Show()
case v1 == -1 && v2 > -1:
hds.visibles[v2] = wk1
wk2.Hide()
wk1.Show()
case v1 == -1 && v2 == -1:
// Meaningless
default:
panic("unreachable")
}
}