//GetClients get windows list
func GetClients() []Client {
clients := []Client{}
var err error
X, err = xgbutil.NewConn()
if err != nil {
log.Fatal(err)
}
wids, err := ewmh.ClientListGet(X)
if err != nil {
log.Fatal(err)
}
a, _ := ewmh.ActiveWindowGet(X)
for _, wid := range wids {
name, err := ewmh.WmNameGet(X, wid)
if name == "Shadow" {
SHADOW = wid
continue
}
if err != nil { // not a fatal error
log.Println(err)
name = ""
}
desk, _ := ewmh.WmDesktopGet(X, wid)
class, _ := icccm.WmClassGet(X, wid)
clients = append(clients, Client{
wid, name, desk, wid == a, class.Class,
})
}
return clients
}
// 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 (rs RunningSource) GetMatches(inp string, ct *CommandTray) []Command {
cmds := make([]Command, 0)
if ct.X == nil {
return []Command{}
}
clis, err := ewmh.ClientListGet(ct.X)
if err != nil {
return cmds
}
for _, xwin := range clis {
dt, err := ewmh.CurrentDesktopGet(ct.X)
if err != nil {
dt = 0xFFFFFFFF
}
wdt, err := ewmh.WmDesktopGet(ct.X, xwin)
if err != nil {
wdt = dt
}
if dt != wdt {
continue
}
name, err := xprop.PropValStr(xprop.GetProperty(ct.X, xwin, "_NET_WM_NAME"))
if err != nil {
//print("Err1: ", err.Error(), "\n")
name, err = xprop.PropValStr(xprop.GetProperty(ct.X, xwin, "WM_NAME"))
if err != nil {
//print("Err2: ", err.Error(), "\n")
name = "Unnamed Window"
}
}
if strings.Contains(strings.ToLower(name), inp) {
cmds = append(cmds, RunningCommand{X: ct.X, win: xwin, name: name})
}
}
return cmds
}
func (self *SessionModule) GetWindow(window_id string) (SessionWindow, error) {
window := SessionWindow{}
if id, err := self.toX11WindowId(window_id); err == nil {
xgbWindow := xwindow.New(self.X, id)
geom, _ := xgbWindow.DecorGeometry()
process := SessionProcess{}
window.ID = uint32(id)
window.Title, _ = ewmh.WmNameGet(self.X, id)
//window.IconUri = r.Path() + "/" + id
windowWorkspace, _ := ewmh.WmDesktopGet(self.X, id)
activeWinId, _ := ewmh.ActiveWindowGet(self.X)
if windowWorkspace == 0xFFFFFFFF {
window.AllWorkspaces = true
} else {
window.Workspace = windowWorkspace
}
if id == activeWinId {
window.Active = true
}
// calculate window dimensions from desktop and window frame boundaries
window.Dimensions.Width = uint(geom.Width())
window.Dimensions.Height = uint(geom.Height())
window.Dimensions.X = geom.X()
window.Dimensions.Y = geom.Y()
// fill in process details
process.PID, _ = ewmh.WmPidGet(self.X, id)
window.Process = process
// get window state flags
window.Flags = make(map[string]bool)
// minimized
if self.x11HasWmState(id, `_NET_WM_STATE_HIDDEN`) {
window.Flags["minimized"] = true
}
// shaded
if self.x11HasWmState(id, `_NET_WM_STATE_SHADED`) {
window.Flags[`shaded`] = true
}
// maximized
if self.x11HasWmState(id, `_NET_WM_STATE_MAXIMIZED_VERT`) && self.x11HasWmState(id, `_NET_WM_STATE_MAXIMIZED_HORZ`) {
window.Flags[`maximized`] = true
}
// above
if self.x11HasWmState(id, `_NET_WM_STATE_ABOVE`) {
window.Flags[`above`] = true
}
// below
if self.x11HasWmState(id, `_NET_WM_STATE_BELOW`) {
window.Flags[`below`] = true
}
// urgent
if self.x11HasWmState(id, `_NET_WM_STATE_DEMANDS_ATTENTION`) {
window.Flags[`urgent`] = true
}
// skip_taskbar
if self.x11HasWmState(id, `_NET_WM_STATE_SKIP_TASKBAR`) {
window.Flags[`skip_taskbar`] = true
}
// skip_pager
if self.x11HasWmState(id, `_NET_WM_STATE_SKIP_PAGER`) {
window.Flags[`skip_pager`] = true
}
// sticky
if self.x11HasWmState(id, `_NET_WM_STATE_STICKY`) {
window.Flags[`sticky`] = true
}
// fullscreen
if self.x11HasWmState(id, `_NET_WM_STATE_FULLSCREEN`) {
window.Flags[`fullscreen`] = true
}
// modal
if self.x11HasWmState(id, `_NET_WM_STATE_MODAL`) {
window.Flags[`modal`] = true
}
// ICCCM WM_CLASS instance
if wmClass, err := icccm.WmClassGet(self.X, id); err == nil {
window.ClassInstance = wmClass.Instance
window.ClassName = wmClass.Class
if entry, ok := self.Applications.Entries[window.ClassInstance]; ok {
window.EntryName = entry.Key
}
}
return window, nil
} else {
return window, 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])
}