// nameSet will set the name of the window and emit a benign message to
// verbose output if it fails.
func (w *window) nameSet(name string) {
// Set _NET_WM_NAME so it looks nice.
err := ewmh.WmNameSet(w.X, w.Id, fmt.Sprintf("imgv :: %s", name))
if err != nil { // not a fatal error
lg("Could not set _NET_WM_NAME: %s", err)
}
}
func (w *Window) SetTitle(title string) {
if w.closed {
return
}
err := ewmh.WmNameSet(w.xu, w.win.Id, title)
if err != nil {
// TODO: log
}
return
}
// This is a slightly modified version of xgraphics.XShowExtra that does
// not set any resize constraints on the window (so that it can go
// fullscreen).
func showImage(im *xgraphics.Image, name string, quit bool) *xwindow.Window {
if len(name) == 0 {
name = "xgbutil Image Window"
}
w, h := im.Rect.Dx(), im.Rect.Dy()
win, err := xwindow.Generate(im.X)
if err != nil {
xgbutil.Logger.Printf("Could not generate new window id: %s", err)
return nil
}
// Create a very simple window with dimensions equal to the image.
win.Create(im.X.RootWin(), 0, 0, w, h, 0)
// Make this window close gracefully.
win.WMGracefulClose(func(w *xwindow.Window) {
xevent.Detach(w.X, w.Id)
keybind.Detach(w.X, w.Id)
mousebind.Detach(w.X, w.Id)
w.Destroy()
if quit {
xevent.Quit(w.X)
}
})
// Set WM_STATE so it is interpreted as a top-level window.
err = icccm.WmStateSet(im.X, win.Id, &icccm.WmState{
State: icccm.StateNormal,
})
if err != nil { // not a fatal error
xgbutil.Logger.Printf("Could not set WM_STATE: %s", err)
}
// Set _NET_WM_NAME so it looks nice.
err = ewmh.WmNameSet(im.X, win.Id, name)
if err != nil { // not a fatal error
xgbutil.Logger.Printf("Could not set _NET_WM_NAME: %s", err)
}
// Paint our image before mapping.
im.XSurfaceSet(win.Id)
im.XDraw()
im.XPaint(win.Id)
// Now we can map, since we've set all our properties.
// (The initial map is when the window manager starts managing.)
win.Map()
return win
}
func setSupported() {
// See COMPLIANCE for what's supported and what isn't (plus rationale).
// ewmhSupported comes from ewmh_supported.go and is automatically
// generated from the COMPLIANCE file.
// Set supported atoms
ewmh.SupportedSet(wm.X, ewmhSupported)
// While we're at it, set the supporting wm hint too.
ewmh.SupportingWmCheckSet(wm.X, wm.X.RootWin(), wm.X.Dummy())
ewmh.SupportingWmCheckSet(wm.X, wm.X.Dummy(), wm.X.Dummy())
ewmh.WmNameSet(wm.X, wm.X.Dummy(), "Wingo")
}
// setName will set the name of the window
func (w *Window) setName(name string) {
err := ewmh.WmNameSet(w.X, w.Id, "vimg :: "+name)
if err != nil { // not a fatal error
lg("Could not set _NET_WM_NAME: %s", err)
}
}
func main() {
X, Xerr = xgbutil.NewConn()
if Xerr != nil {
panic(Xerr)
}
active, _ := ewmh.ActiveWindowGet(X)
parent, _ := xwindow.ParentWindow(X, active)
actOpacity, _ := ewmh.WmWindowOpacityGet(X, parent)
fmt.Printf("Opacity for active window: %f\n", actOpacity)
showDesk, _ := ewmh.ShowingDesktopGet(X)
fmt.Printf("Showing desktop? %v\n", showDesk)
wmName, err := ewmh.GetEwmhWM(X)
if err != nil {
fmt.Printf("No conforming window manager found... :-(\n")
fmt.Println(err)
} else {
fmt.Printf("Window manager: %s\n", wmName)
}
pager := xproto.Window(0x160001e)
middle := xproto.Window(0x3200016)
geom, _ := ewmh.DesktopGeometryGet(X)
desktops, _ := ewmh.DesktopNamesGet(X)
curdesk, _ := ewmh.CurrentDesktopGet(X)
clients, _ := ewmh.ClientListGet(X)
activeName, _ := ewmh.WmNameGet(X, active)
fmt.Printf("Active window: %x\n", active)
fmt.Printf("Current desktop: %d\n", curdesk)
fmt.Printf("Client list: %v\n", clients)
fmt.Printf("Desktop geometry: (width: %d, height: %d)\n",
geom.Width, geom.Height)
fmt.Printf("Active window name: %s\n", activeName)
fmt.Printf("Desktop names: %s\n", desktops)
var desk string
if curdesk < len(desktops) {
desk = desktops[curdesk]
} else {
desk = string(curdesk)
}
fmt.Printf("Current desktop: %s\n", desk)
// fmt.Printf("\nChanging current desktop to 25 from %d\n", curdesk)
ewmh.CurrentDesktopSet(X, curdesk)
// fmt.Printf("Current desktop is now: %d\n", ewmh.CurrentDesktop(X))
fmt.Printf("Setting active win to %x\n", middle)
// ewmh.ActiveWindowReq(X, middle)
rand.Seed(int64(time.Now().Nanosecond()))
randStr := make([]byte, 20)
for i, _ := range randStr {
if rf := rand.Float32(); rf < 0.40 {
randStr[i] = byte('a' + rand.Intn('z'-'a'))
} else if rf < 0.80 {
randStr[i] = byte('A' + rand.Intn('Z'-'A'))
} else {
randStr[i] = ' '
}
}
ewmh.WmNameSet(X, active, string(randStr))
newName, _ := ewmh.WmNameGet(X, active)
fmt.Printf("New name: %s\n", newName)
// deskNames := ewmh.DesktopNamesGet(X)
// fmt.Printf("Desktop names: %s\n", deskNames)
// deskNames[len(deskNames) - 1] = "xgbutil"
// ewmh.DesktopNamesSet(X, deskNames)
// fmt.Printf("Desktop names: %s\n", ewmh.DesktopNamesGet(X))
supported, _ := ewmh.SupportedGet(X)
fmt.Printf("Supported hints: %v\n", supported)
fmt.Printf("Setting supported hints...\n")
ewmh.SupportedSet(X, []string{"_NET_CLIENT_LIST", "_NET_WM_NAME",
"_NET_WM_DESKTOP"})
numDesks, _ := ewmh.NumberOfDesktopsGet(X)
fmt.Printf("Number of desktops: %d\n", numDesks)
// ewmh.NumberOfDesktopsReq(X.EwmhNumberOfDesktops(X) + 1)
// time.Sleep(time.Second)
// fmt.Printf("Number of desktops: %d\n", ewmh.NumberOfDesktops(X))
viewports, _ := ewmh.DesktopViewportGet(X)
fmt.Printf("Viewports (%d): %v\n", len(viewports), viewports)
// viewports[2].X = 50
// viewports[2].Y = 293
// ewmh.DesktopViewportSet(X, viewports)
// time.Sleep(time.Second)
//
// viewports = ewmh.DesktopViewport(X)
// fmt.Printf("Viewports (%d): %v\n", len(viewports), viewports)
// ewmh.CurrentDesktopReq(X, 3)
visDesks, _ := ewmh.VisibleDesktopsGet(X)
workarea, _ := ewmh.WorkareaGet(X)
fmt.Printf("Visible desktops: %v\n", visDesks)
fmt.Printf("Workareas: %v\n", workarea)
// fmt.Printf("Virtual roots: %v\n", ewmh.VirtualRoots(X))
// fmt.Printf("Desktop layout: %v\n", ewmh.DesktopLayout(X))
fmt.Printf("Closing window %x\n", 0x2e004c5)
ewmh.CloseWindow(X, 0x1e00cdf)
fmt.Printf("Moving/resizing window: %x\n", 0x2e004d0)
ewmh.MoveresizeWindow(X, 0x2e004d0, 1920, 30, 500, 500)
// fmt.Printf("Trying to initiate a moveresize...\n")
// ewmh.WmMoveresize(X, 0x2e004db, xgbutil.EwmhMove)
// time.Sleep(5 * time.Second)
// ewmh.WmMoveresize(X, 0x2e004db, xgbutil.EwmhCancel)
// fmt.Printf("Stacking window %x...\n", 0x2e00509)
// ewmh.RestackWindow(X, 0x2e00509)
fmt.Printf("Requesting frame extents for active window...\n")
ewmh.RequestFrameExtents(X, active)
activeDesk, _ := ewmh.WmDesktopGet(X, active)
activeType, _ := ewmh.WmWindowTypeGet(X, active)
fmt.Printf("Active window's desktop: %d\n", activeDesk)
fmt.Printf("Active's types: %v\n", activeType)
// fmt.Printf("Pager's types: %v\n", ewmh.WmWindowType(X, 0x180001e))
// fmt.Printf("Pager's state: %v\n", ewmh.WmState(X, 0x180001e))
// ewmh.WmStateReq(X, active, xgbutil.EwmhStateToggle,
// "_NET_WM_STATE_HIDDEN")
// ewmh.WmStateReqExtra(X, active, xgbutil.EwmhStateToggle,
// "_NET_WM_STATE_MAXIMIZED_VERT",
// "_NET_WM_STATE_MAXIMIZED_HORZ", 2)
activeAllowed, _ := ewmh.WmAllowedActionsGet(X, active)
fmt.Printf("Allowed actions on active: %v\n", activeAllowed)
struts, err := ewmh.WmStrutGet(X, pager)
if err != nil {
fmt.Printf("Pager struts: %v\n", err)
} else {
fmt.Printf("Pager struts: %v\n", struts)
}
pstruts, err := ewmh.WmStrutPartialGet(X, pager)
if err != nil {
fmt.Printf("Pager struts partial: %v - %v\n", pstruts, err)
} else {
fmt.Printf("Pager struts partial: %v\n", pstruts.BottomStartX)
}
// fmt.Printf("Icon geometry for active: %v\n",
// ewmh.WmIconGeometry(X, active))
icons, _ := ewmh.WmIconGet(X, active)
fmt.Printf("Active window's (%x) icon data: (length: %v)\n",
active, len(icons))
for _, icon := range icons {
fmt.Printf("\t(%d, %d)", icon.Width, icon.Height)
fmt.Printf(" :: %d == %d\n", icon.Width*icon.Height, len(icon.Data))
}
// fmt.Printf("Now set them again...\n")
// ewmh.WmIconSet(X, active, icons[:len(icons) - 1])
}
func makeWindow(ximage *xgraphics.Image) (*xwindow.Window, *bool) {
w, h := ximage.Rect.Dx(), ximage.Rect.Dy()
window, err := xwindow.Generate(ximage.X)
if err != nil {
xgbutil.Logger.Printf("Could not generate new window id: %s", err)
return nil, nil
}
window.Create(ximage.X.RootWin(), 0, 0, w, h, xproto.CwBackPixel, 0x00000000)
window.Listen(xproto.EventMaskExposure,
xproto.EventMaskKeyPress,
xproto.EventMaskStructureNotify,
xproto.EventMaskVisibilityChange)
window.WMGracefulClose(func(w *xwindow.Window) {
xevent.Detach(w.X, w.Id)
keybind.Detach(w.X, w.Id)
mousebind.Detach(w.X, w.Id)
w.Destroy()
xevent.Quit(w.X)
})
err = icccm.WmStateSet(ximage.X, window.Id, &icccm.WmState{
State: icccm.StateNormal,
})
if err != nil {
xgbutil.Logger.Printf("Could not set WM_STATE: %s", err)
}
err = ewmh.WmNameSet(ximage.X, window.Id, "Computer System Monitor")
if err != nil {
xgbutil.Logger.Printf("Could not set _NET_WM_NAME: %s", err)
}
err = keybind.KeyPressFun(
func(X *xgbutil.XUtil, ev xevent.KeyPressEvent) {
err := ewmh.WmStateReq(ximage.X, window.Id, ewmh.StateToggle,
"_NET_WM_STATE_FULLSCREEN")
if err != nil {
log.Fatal(err)
}
}).Connect(ximage.X, window.Id, "f", false)
if err != nil {
log.Fatal(err)
}
xevent.ExposeFun(
func(xu *xgbutil.XUtil, event xevent.ExposeEvent) {
ximage.XExpPaint(window.Id, 0, 0)
}).Connect(ximage.X, window.Id)
obscured := false
xevent.VisibilityNotifyFun(
func(xu *xgbutil.XUtil, event xevent.VisibilityNotifyEvent) {
obscured = event.State == xproto.VisibilityFullyObscured
}).Connect(ximage.X, window.Id)
window.Map()
return window, &obscured
}
func (wingo *wingoState) ewmhSupportingWmCheck() {
supportingWin := xwindow.Must(xwindow.Create(X, wingo.root.Id))
ewmh.SupportingWmCheckSet(X, wingo.root.Id, supportingWin.Id)
ewmh.SupportingWmCheckSet(X, supportingWin.Id, supportingWin.Id)
ewmh.WmNameSet(X, supportingWin.Id, "Wingo")
}
// Set the window title.
func (plot *PlotWindow) SetTitle(Title string) {
ewmh.WmNameSet(system.X, plot.window.Id, Title)
}