func (hds *Heads) ApplyStruts(clients Clients) {
hds.workarea = make(xinerama.Heads, len(hds.geom))
for i, hd := range hds.geom {
hds.workarea[i] = xrect.New(hd.X(), hd.Y(), hd.Width(), hd.Height())
}
rgeom := xwindow.RootGeometry(hds.X)
for i := 0; i < clients.Len(); i++ {
c := clients.Get(i)
strut, _ := ewmh.WmStrutPartialGet(hds.X, c.Id())
if strut == nil {
continue
}
xrect.ApplyStrut(hds.workarea, rgeom.Width(), rgeom.Height(),
strut.Left, strut.Right, strut.Top, strut.Bottom,
strut.LeftStartY, strut.LeftEndY,
strut.RightStartY, strut.RightEndY,
strut.TopStartX, strut.TopEndX,
strut.BottomStartX, strut.BottomEndX)
}
for _, wrk := range hds.workspaces.Wrks {
wrk.Place()
}
}
func main() {
X, _ := xgbutil.NewConn()
heads, err := xinerama.PhysicalHeads(X)
if err != nil {
fmt.Printf("ERROR: %v\n", err)
}
// Test intersection
r1 := xrect.New(0, 0, 100, 100)
r2 := xrect.New(100, 100, 100, 100)
fmt.Println(xrect.IntersectArea(r1, r2))
// Test largest overlap
window := xrect.New(1800, 0, 300, 200)
fmt.Println(xrect.LargestOverlap(window, heads))
// Test ApplyStrut
rgeom, _ := xwindow.RawGeometry(X, xproto.Drawable(X.RootWin()))
fmt.Println("---------------------------")
for i, head := range heads {
fmt.Printf("%d - %v\n", i, head)
}
// Let's actually apply struts to the current environment
clients, _ := ewmh.ClientListGet(X)
for _, client := range clients {
strut, err := ewmh.WmStrutPartialGet(X, client)
if err == nil {
xrect.ApplyStrut(heads, rgeom.Width(), rgeom.Height(),
strut.Left, strut.Right, strut.Top, strut.Bottom,
strut.LeftStartY, strut.LeftEndY,
strut.RightStartY, strut.RightEndY,
strut.TopStartX, strut.TopEndX,
strut.BottomStartX, strut.BottomEndX)
}
}
fmt.Println("---------------------------")
fmt.Println("After applying struts...")
for i, head := range heads {
fmt.Printf("%d - %v\n", i, head)
}
}
func main() {
// Connect to the X server using the DISPLAY environment variable.
X, err := xgbutil.NewConn()
if err != nil {
log.Fatal(err)
}
// Wrap the root window in a nice Window type.
root := xwindow.New(X, X.RootWin())
// Get the geometry of the root window.
rgeom, err := root.Geometry()
if err != nil {
log.Fatal(err)
}
// Get the rectangles for each of the active physical heads.
// These are returned sorted in order from left to right and then top
// to bottom.
// But first check if Xinerama is enabled. If not, use root geometry.
var heads xinerama.Heads
if X.ExtInitialized("XINERAMA") {
heads, err = xinerama.PhysicalHeads(X)
if err != nil {
log.Fatal(err)
}
} else {
heads = xinerama.Heads{rgeom}
}
// Fetch the list of top-level client window ids currently managed
// by the running window manager.
clients, err := ewmh.ClientListGet(X)
if err != nil {
log.Fatal(err)
}
// Output the head geometry before modifying them.
fmt.Println("Workarea for each head:")
for i, head := range heads {
fmt.Printf("\tHead #%d: %s\n", i+1, head)
}
// For each client, check to see if it has struts, and if so, apply
// them to our list of head rectangles.
for _, clientid := range clients {
strut, err := ewmh.WmStrutPartialGet(X, clientid)
if err != nil { // no struts for this client
continue
}
// Apply the struts to our heads.
// This modifies 'heads' in place.
xrect.ApplyStrut(heads, uint(rgeom.Width()), uint(rgeom.Height()),
strut.Left, strut.Right, strut.Top, strut.Bottom,
strut.LeftStartY, strut.LeftEndY,
strut.RightStartY, strut.RightEndY,
strut.TopStartX, strut.TopEndX,
strut.BottomStartX, strut.BottomEndX)
}
// Now output the head geometry again after modification.
fmt.Println("Workarea for each head after applying struts:")
for i, head := range heads {
fmt.Printf("\tHead #%d: %s\n", i+1, head)
}
}