// works for new deepin wm.
func checkCurrentDesktop(xid xproto.Window) (bool, error) {
num, err := xprop.PropValNum(xprop.GetProperty(XU, xid, "_NET_WM_DESKTOP"))
if err != nil {
return false, err
}
currentDesktop, err := xprop.PropValNum(xprop.GetProperty(XU, XU.RootWin(), "_NET_CURRENT_DESKTOP"))
if err != nil {
return false, err
}
return num == currentDesktop, nil
}
// WM_HINTS get
func WmHintsGet(xu *xgbutil.XUtil,
win xproto.Window) (hints *Hints, err error) {
lenExpect := 9
raw, err := xprop.PropValNums(xprop.GetProperty(xu, win, "WM_HINTS"))
if err != nil {
return nil, err
}
if len(raw) != lenExpect {
return nil,
fmt.Errorf("WmHints: There are %d fields in "+
"WM_HINTS, but xgbutil expects %d.", len(raw), lenExpect)
}
hints = &Hints{}
hints.Flags = raw[0]
hints.Input = raw[1]
hints.InitialState = raw[2]
hints.IconPixmap = xproto.Pixmap(raw[3])
hints.IconWindow = xproto.Window(raw[4])
hints.IconX = raw[5]
hints.IconY = raw[6]
hints.IconMask = xproto.Pixmap(raw[7])
hints.WindowGroup = xproto.Window(raw[8])
return hints, nil
}
func isNormalWindow(xid xproto.Window) bool {
winProps, err := xproto.GetWindowAttributes(XU.Conn(), xid).Reply()
if err != nil {
logger.Debug("faild Get WindowAttributes:", xid, err)
return false
}
if winProps.MapState != xproto.MapStateViewable {
return false
}
// logger.Debug("enter isNormalWindow:", xid)
if wmClass, err := icccm.WmClassGet(XU, xid); err == nil {
if wmClass.Instance == "explorer.exe" && wmClass.Class == "Wine" {
return false
} else if wmClass.Class == "DDELauncher" {
// FIXME:
// start_monitor_launcher_window like before?
return false
} else if wmClass.Class == "Desktop" {
// FIXME:
// get_desktop_pid like before?
return false
} else if wmClass.Class == "Dlock" {
return false
}
}
if isSkipTaskbar(xid) {
return false
}
types, err := ewmh.WmWindowTypeGet(XU, xid)
if err != nil {
logger.Debug("Get Window Type failed:", err)
if _, err := xprop.GetProperty(XU, xid, "_XEMBED_INFO"); err != nil {
logger.Debug("has _XEMBED_INFO")
return true
} else {
logger.Debug("Get _XEMBED_INFO failed:", err)
return false
}
}
mayBeDocked := false
cannotBeDoced := false
for _, wmType := range types {
if wmType == "_NET_WM_WINDOW_TYPE_NORMAL" {
mayBeDocked = true
} else if wmType == "_NET_WM_WINDOW_TYPE_DIALOG" {
if !canBeMinimized(xid) {
mayBeDocked = false
break
} else {
mayBeDocked = true
}
} else if contains(cannotBeDockedType, wmType) {
cannotBeDoced = true
}
}
isNormal := mayBeDocked && !cannotBeDoced
return isNormal
}
func changeWorkspaceIfNeeded(xid xproto.Window) error {
desktopNum, err := xprop.PropValNum(xprop.GetProperty(XU, xid, "_NET_WM_DESKTOP"))
if err != nil {
return fmt.Errorf("Get _NET_WM_DESKTOP failed: %s", err)
}
currentDesktop, err := ewmh.CurrentDesktopGet(XU)
if err != nil {
return fmt.Errorf("Get _NET_CURRENT_DESKTOP failed: %v", err)
}
if currentDesktop == desktopNum {
return fmt.Errorf("No need to change workspace, the current desktop is already %v", currentDesktop)
}
timeStamp, err := ewmh.WmUserTimeGet(XU, xid)
if err != nil {
logger.Warningf("Get timestamp of 0x%x failed: %v", uint32(xid), err)
}
err = ewmh.ClientEvent(XU, XU.RootWin(), "_NET_CURRENT_DESKTOP", int(desktopNum), int(timeStamp))
if err != nil {
return fmt.Errorf("Send ClientMessage Failed: %v", err)
}
return nil
}
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 updateCurrentViewport() {
currentViewport, _ = xprop.PropValNums(
xprop.GetProperty(
XU,
XU.RootWin(),
"DEEPIN_SCREEN_VIEWPORT",
))
}
// _NET_DESKTOP_GEOMETRY get
func DesktopGeometryGet(xu *xgbutil.XUtil) (*DesktopGeometry, error) {
geom, err := xprop.PropValNums(xprop.GetProperty(xu, xu.RootWin(),
"_NET_DESKTOP_GEOMETRY"))
if err != nil {
return nil, err
}
return &DesktopGeometry{Width: int(geom[0]), Height: int(geom[1])}, nil
}
// _NET_WM_WINDOW_OPACITY get
// This isn't part of the EWMH spec, but is widely used by drop in
// compositing managers (i.e., xcompmgr, cairo-compmgr, etc.).
// This property is typically set not on a client window, but the *parent*
// of a client window in reparenting window managers.
// The float returned will be in the range [0.0, 1.0] where 0.0 is completely
// transparent and 1.0 is completely opaque.
func WmWindowOpacityGet(xu *xgbutil.XUtil, win xproto.Window) (float64, error) {
intOpacity, err := xprop.PropValNum(
xprop.GetProperty(xu, win, "_NET_WM_WINDOW_OPACITY"))
if err != nil {
return 0, err
}
return float64(uint(intOpacity)) / float64(0xffffffff), nil
}
// Refreshes the internal cache of properties.
//
// NOTE: you do not have to call this, unless you want a more up-to-date value
// set than when you first created it with New -- or the last Refresh call.
func (xs *XSettings) Refresh() error {
xs.props = make(map[string]*XSetting)
gso := xproto.GetSelectionOwner(xs.X.Conn(), atomXSettings)
reply, err := gso.Reply()
if err != nil {
return err
}
prop, err := xprop.GetProperty(xs.X, reply.Owner, "_XSETTINGS_SETTINGS")
if err != nil {
return err
}
data := bytes.NewReader(prop.Value)
var endian binary.ByteOrder
var tmp byte
if tmp, err = data.ReadByte(); err != nil {
return err
}
if tmp == 0 {
endian = binary.LittleEndian
} else {
endian = binary.BigEndian
}
buff := make([]byte, 3, 3)
if n, err := data.Read(buff); n != 3 || err != nil {
return err
}
if err = binary.Read(data, endian, &xs.Serial); err != nil {
return err
}
var num uint32
if err = binary.Read(data, endian, &num); err != nil {
return err
}
for i := uint32(0); i < num; i++ {
setting, name, err := xs.readSetting(data, endian)
if err != nil {
return err
}
xs.props[name] = setting
}
return nil
}
func (app *RuntimeApp) updateWmName(xid xproto.Window) {
if name, err := ewmh.WmNameGet(XU, xid); err == nil && name != "" {
app.xids[xid].Title = name
return
}
if name, err := xprop.PropValStr(xprop.GetProperty(XU, xid,
"WM_NAME")); err == nil {
app.xids[xid].Title = name
}
}
// _NET_WM_HANDLED_ICONS get
func WmHandledIconsGet(xu *xgbutil.XUtil, win xproto.Window) (bool, error) {
reply, err := xprop.GetProperty(xu, win, "_NET_WM_HANDLED_ICONS")
if err != nil {
return false, err
}
val, err := xprop.PropValNum(reply, nil)
if err != nil {
return false, err
}
return val == 1, nil
}
// _NET_SHOWING_DESKTOP get
func ShowingDesktopGet(xu *xgbutil.XUtil) (bool, error) {
reply, err := xprop.GetProperty(xu, xu.RootWin(), "_NET_SHOWING_DESKTOP")
if err != nil {
return false, err
}
val, err := xprop.PropValNum(reply, nil)
if err != nil {
return false, err
}
return val == 1, nil
}
// _NET_WM_STRUT get
func WmStrutGet(xu *xgbutil.XUtil, win xproto.Window) (*WmStrut, error) {
struts, err := xprop.PropValNums(xprop.GetProperty(xu, win,
"_NET_WM_STRUT"))
if err != nil {
return nil, err
}
return &WmStrut{
Left: struts[0],
Right: struts[1],
Top: struts[2],
Bottom: struts[3],
}, nil
}
func (ams *AppMenuSource) Open(ct *CommandTray) bool {
ams.app = nil
ams.menu = nil
active, err := ewmh.ActiveWindowGet(ct.X)
if err != nil {
return false
}
uniqName, err := xprop.PropValStr(xprop.GetProperty(ct.X, active, "_GTK_UNIQUE_BUS_NAME"))
if err != nil {
return false
}
pathMenu, err := xprop.PropValStr(xprop.GetProperty(ct.X, active, "_GTK_APP_MENU_OBJECT_PATH"))
if err != nil {
return false
}
pathApp, err := xprop.PropValStr(xprop.GetProperty(ct.X, active, "_GTK_APPLICATION_OBJECT_PATH"))
if err != nil {
return false
}
// Done parsing props! Yay!
ams.app = &utils.GtkActions{
ams.Conn.Object(uniqName, dbus.ObjectPath(pathApp)),
}
ams.menu = &utils.GtkMenu{
ams.Conn.Object(uniqName, dbus.ObjectPath(pathMenu)),
}
return true
}
// _NET_FRAME_EXTENTS get
func FrameExtentsGet(xu *xgbutil.XUtil,
win xproto.Window) (*FrameExtents, error) {
raw, err := xprop.PropValNums(xprop.GetProperty(xu, win,
"_NET_FRAME_EXTENTS"))
if err != nil {
return nil, err
}
return &FrameExtents{
Left: int(raw[0]),
Right: int(raw[1]),
Top: int(raw[2]),
Bottom: int(raw[3]),
}, nil
}
// WM_CLASS get
func WmClassGet(xu *xgbutil.XUtil, win xproto.Window) (*WmClass, error) {
raw, err := xprop.PropValStrs(xprop.GetProperty(xu, win, "WM_CLASS"))
if err != nil {
return nil, err
}
if len(raw) != 2 {
return nil,
fmt.Errorf("WmClass: Two string make up WM_CLASS, but "+
"xgbutil found %d in '%v'.", len(raw), raw)
}
return &WmClass{
Instance: raw[0],
Class: raw[1],
}, nil
}
// WM_STATE get
func WmStateGet(xu *xgbutil.XUtil, win xproto.Window) (*WmState, error) {
raw, err := xprop.PropValNums(xprop.GetProperty(xu, win, "WM_STATE"))
if err != nil {
return nil, err
}
if len(raw) != 2 {
return nil,
fmt.Errorf("WmState: Expected two integers in WM_STATE property "+
"but xgbutil found %d in '%v'.", len(raw), raw)
}
return &WmState{
State: raw[0],
Icon: xproto.Window(raw[1]),
}, nil
}
// _NET_WM_ICON_GEOMETRY get
func WmIconGeometryGet(xu *xgbutil.XUtil,
win xproto.Window) (*WmIconGeometry, error) {
geom, err := xprop.PropValNums(xprop.GetProperty(xu, win,
"_NET_WM_ICON_GEOMETRY"))
if err != nil {
return nil, err
}
return &WmIconGeometry{
X: int(geom[0]),
Y: int(geom[1]),
Width: geom[2],
Height: geom[3],
}, nil
}
// _NET_WM_FULLSCREEN_MONITORS get
func WmFullscreenMonitorsGet(xu *xgbutil.XUtil,
win xproto.Window) (*WmFullscreenMonitors, error) {
raw, err := xprop.PropValNums(
xprop.GetProperty(xu, win, "_NET_WM_FULLSCREEN_MONITORS"))
if err != nil {
return nil, err
}
return &WmFullscreenMonitors{
Top: raw[0],
Bottom: raw[1],
Left: raw[2],
Right: raw[3],
}, nil
}
func (icon *Icon) Class() string {
if icon.classCache != "" {
return icon.classCache
}
val, err := xprop.PropValStr(xprop.GetProperty(icon.Socket.X, icon.Socket.Id, "WM_CLASS"))
if err != nil {
println("Error getting property:", err)
return ""
}
icon.classCache = val
return val
}
// _NET_DESKTOP_VIEWPORT get
func DesktopViewportGet(xu *xgbutil.XUtil) ([]DesktopViewport, error) {
coords, err := xprop.PropValNums(xprop.GetProperty(xu, xu.RootWin(),
"_NET_DESKTOP_VIEWPORT"))
if err != nil {
return nil, err
}
viewports := make([]DesktopViewport, len(coords)/2)
for i, _ := range viewports {
viewports[i] = DesktopViewport{
X: int(coords[i*2]),
Y: int(coords[i*2+1]),
}
}
return viewports, nil
}
// _NET_WM_STRUT_PARTIAL get
func WmStrutPartialGet(xu *xgbutil.XUtil,
win xproto.Window) (*WmStrutPartial, error) {
struts, err := xprop.PropValNums(xprop.GetProperty(xu, win,
"_NET_WM_STRUT_PARTIAL"))
if err != nil {
return nil, err
}
return &WmStrutPartial{
Left: struts[0], Right: struts[1], Top: struts[2], Bottom: struts[3],
LeftStartY: struts[4], LeftEndY: struts[5],
RightStartY: struts[6], RightEndY: struts[7],
TopStartX: struts[8], TopEndX: struts[9],
BottomStartX: struts[10], BottomEndX: struts[11],
}, nil
}
// WM_ICON_SIZE get
func WmIconSizeGet(xu *xgbutil.XUtil, win xproto.Window) (*IconSize, error) {
raw, err := xprop.PropValNums(xprop.GetProperty(xu, win, "WM_ICON_SIZE"))
if err != nil {
return nil, err
}
if len(raw) != 6 {
return nil,
fmt.Errorf("WmIconSize: Expected six integers in WM_ICON_SIZE "+
"property, but xgbutil found "+"%d in '%v'.", len(raw), raw)
}
return &IconSize{
MinWidth: raw[0], MinHeight: raw[1],
MaxWidth: raw[2], MaxHeight: raw[3],
WidthInc: raw[4], HeightInc: raw[5],
}, nil
}
// _NET_WORKAREA get
func WorkareaGet(xu *xgbutil.XUtil) ([]Workarea, error) {
rects, err := xprop.PropValNums(xprop.GetProperty(xu, xu.RootWin(),
"_NET_WORKAREA"))
if err != nil {
return nil, err
}
workareas := make([]Workarea, len(rects)/4)
for i, _ := range workareas {
workareas[i] = Workarea{
X: int(rects[i*4]),
Y: int(rects[i*4+1]),
Width: rects[i*4+2],
Height: rects[i*4+3],
}
}
return workareas, nil
}
func (cmd TagGet) Run() gribble.Value {
if !validTagName.MatchString(cmd.Name) {
return cmdError("Tag names must match %s.", validTagName.String())
}
tval := ""
withClient(cmd.Client, func(c *xclient.Client) {
var err error
tagName := fmt.Sprintf("_WINGO_TAG_%s", cmd.Name)
tval, err = xprop.PropValStr(xprop.GetProperty(wm.X, c.Id(), tagName))
if err != nil {
// Log the error, but give the caller an empty string.
logger.Warning.Println(err)
}
})
return tval
}
func (sock *XEmbedSocket) load() error {
vals, err := xprop.PropValNums(xprop.GetProperty(sock.X, sock.id, "_XEMBED_INFO"))
if err != nil {
sock.Version = 0
sock.Flags = SocketFlags(0)
return nil // F*****g Qt.
}
if len(vals) < 2 {
return fmt.Errorf("Expected 2 nums in property -- got %d", len(vals))
}
sock.Version = uint32(vals[0])
sock.Flags = SocketFlags(vals[1])
return nil
}
func (wa *fullScreenWorkaround) detectTarget(w xproto.Window) {
pid, _ := xprop.PropValNum(xprop.GetProperty(wa.xu, w, "_NET_WM_PID"))
contents, err := ioutil.ReadFile(fmt.Sprintf("/proc/%d/cmdline", pid))
if err != nil {
return
}
if wa.isFullScreen(w) {
for _, target := range wa.targets {
if strings.Contains(string(contents), target) {
wa.inhibit(target, string(contents))
return
}
}
}
wa.isHintingTarget = false
}
// works for old deepin wm.
func checkDeepinWindowViewports(xid xproto.Window) (bool, error) {
viewports, err := xprop.PropValNums(xprop.GetProperty(XU, xid,
"DEEPIN_WINDOW_VIEWPORTS"))
if err != nil {
return false, err
}
workspaces := make([][]uint, 0)
for i := uint(0); i < viewports[0]; i++ {
viewport := make([]uint, 2)
viewport[0] = viewports[i*2+1]
viewport[1] = viewports[i*2+2]
workspaces = append(workspaces, viewport)
}
if currentViewport == nil {
updateCurrentViewport()
}
return isCoverWorkspace(workspaces, currentViewport), nil
}
// _NET_DESKTOP_LAYOUT get
func DesktopLayoutGet(xu *xgbutil.XUtil) (dl *DesktopLayout, err error) {
dlraw, err := xprop.PropValNums(xprop.GetProperty(xu, xu.RootWin(),
"_NET_DESKTOP_LAYOUT"))
if err != nil {
return nil, err
}
dl = &DesktopLayout{}
dl.Orientation = int(dlraw[0])
dl.Columns = int(dlraw[1])
dl.Rows = int(dlraw[2])
if len(dlraw) > 3 {
dl.StartingCorner = int(dlraw[3])
} else {
dl.StartingCorner = TopLeft
}
return dl, nil
}
// _NET_WM_OPAQUE_REGION get
func WmOpaqueRegionGet(xu *xgbutil.XUtil,
win xproto.Window) ([]WmOpaqueRegion, error) {
raw, err := xprop.PropValNums(xprop.GetProperty(xu, win,
"_NET_WM_OPAQUE_REGION"))
if err != nil {
return nil, err
}
regions := make([]WmOpaqueRegion, len(raw)/4)
for i, _ := range regions {
regions[i] = WmOpaqueRegion{
X: int(raw[i*4+0]),
Y: int(raw[i*4+1]),
Width: raw[i*4+2],
Height: raw[i*4+3],
}
}
return regions, nil
}