func (c *Client) Close() {
if strIndex("WM_DELETE_WINDOW", c.protocols) > -1 {
wm_protocols, err := xprop.Atm(wm.X, "WM_PROTOCOLS")
if err != nil {
logger.Warning.Println(err)
return
}
wm_del_win, err := xprop.Atm(wm.X, "WM_DELETE_WINDOW")
if err != nil {
logger.Warning.Println(err)
return
}
cm, err := xevent.NewClientMessage(32, c.Id(), wm_protocols,
int(wm_del_win))
if err != nil {
logger.Warning.Println(err)
return
}
err = xproto.SendEventChecked(wm.X.Conn(), false, c.Id(), 0,
string(cm.Bytes())).Check()
if err != nil {
logger.Message.Printf("Could not send WM_DELETE_WINDOW "+
"ClientMessage because: %s", err)
}
} else {
c.win.Kill() // HULK SMASH!
}
}
func Focus(c Client) {
Remove(c)
if c.CanFocus() || c.SendFocusNotify() {
Clients = append(Clients, c)
c.PrepareForFocus()
c.Focused()
}
if c.CanFocus() {
c.Win().Focus()
}
if c.SendFocusNotify() {
protsAtm, err := xprop.Atm(X, "WM_PROTOCOLS")
if err != nil {
logger.Warning.Println(err)
return
}
takeFocusAtm, err := xprop.Atm(X, "WM_TAKE_FOCUS")
if err != nil {
logger.Warning.Println(err)
return
}
cm, err := xevent.NewClientMessage(32, c.Id(), protsAtm,
int(takeFocusAtm), int(X.TimeGet()))
if err != nil {
logger.Warning.Println(err)
return
}
xproto.SendEvent(X.Conn(), false, c.Id(), 0, string(cm.Bytes()))
}
}
func (m *TrayManager) RequireManageTrayIcons() {
mstype, err := xprop.Atm(TrayXU, "MANAGER")
if err != nil {
logger.Warning("Get MANAGER Failed")
return
}
timeStamp, _ := ewmh.WmUserTimeGet(TrayXU, m.owner)
cm, err := xevent.NewClientMessage(
32,
TrayXU.RootWin(),
mstype,
int(timeStamp),
int(_NET_SYSTEM_TRAY_S0),
int(m.owner),
)
if err != nil {
logger.Warning("Send MANAGER Request failed:", err)
return
}
// !!! ewmh.ClientEvent not use EventMaskStructureNotify.
xevent.SendRootEvent(TrayXU, cm,
uint32(xproto.EventMaskStructureNotify))
}
// announce sends a ClientMessage event to the root window to let everyone
// know that Wingo is the boss. (As per ICCCM 2.8.)
func announce(X *xgbutil.XUtil) {
typAtom, err := xprop.Atm(X, "MANAGER")
if err != nil {
logger.Warning.Println(err)
return
}
manSelAtom, err := managerAtom(X)
if err != nil {
logger.Warning.Println(err)
return
}
cm, err := xevent.NewClientMessage(32, X.RootWin(), typAtom,
int(X.TimeGet()), int(manSelAtom), int(X.Dummy()))
xproto.SendEvent(X.Conn(), false, X.RootWin(),
xproto.EventMaskStructureNotify, string(cm.Bytes()))
}
// ClientEvent is a convenience function that sends ClientMessage events
// to the root window as specified by the EWMH spec.
func ClientEvent(xu *xgbutil.XUtil, window xproto.Window, messageType string,
data ...interface{}) error {
mstype, err := xprop.Atm(xu, messageType)
if err != nil {
return err
}
evMask := (xproto.EventMaskSubstructureNotify |
xproto.EventMaskSubstructureRedirect)
cm, err := xevent.NewClientMessage(32, window, mstype, data...)
if err != nil {
return err
}
return xevent.SendRootEvent(xu, cm, uint32(evMask))
}
func (sock *XEmbedSocket) sendMessage(msg XEmbedMessage, detail, data1, data2 int) (err error) {
if xembedAtom == 0 {
xembedAtom, err = xprop.Atom(sock.X, "_XEMBED", false)
if err != nil {
return
}
}
clientMsg, err := xevent.NewClientMessage(32, sock.id, xembedAtom, detail, data1, data2)
if err == nil {
xproto.SendEvent(sock.X.Conn(), false, sock.id, xproto.EventMaskNoEvent, string(clientMsg.Bytes()))
}
return
}
func New(X *xgbutil.XUtil) (*SystemTray, error) {
tray := &SystemTray{
X: X,
}
var err error
if sysTrayAtom == 0 {
sysTrayAtom, err = xprop.Atom(X, "_NET_SYSTEM_TRAY_S0", false)
if err != nil {
return nil, err
}
}
if sysTrayMsgAtom == 0 {
sysTrayMsgAtom, err = xprop.Atom(X, "_NET_SYSTEM_TRAY_OPCODE", false)
if err != nil {
return nil, err
}
}
if managerEventAtom == 0 {
managerEventAtom, err = xprop.Atom(X, "MANAGER", false)
if err != nil {
return nil, err
}
}
tray.wid, err = xwindow.Create(X, X.RootWin())
if err != nil {
return nil, err
}
ts, err := currentTime(X)
if err != nil {
return nil, err
}
X.TimeSet(ts)
// tray.wid.Listen(xproto.EventMaskNoEvent | xproto.EventMaskPropertyChange)
err = xproto.SetSelectionOwnerChecked(tray.X.Conn(), tray.wid.Id, sysTrayAtom, tray.X.TimeGet()).Check()
if err != nil {
return nil, err
}
reply, err := xproto.GetSelectionOwner(X.Conn(), sysTrayAtom).Reply()
if err != nil {
return nil, err
}
if reply.Owner != tray.wid.Id {
return nil, fmt.Errorf("Could not get ownership of the thingy-thing.")
}
evt, err := xevent.NewClientMessage(32, X.RootWin(), managerEventAtom,
int(X.TimeGet()), int(sysTrayAtom), int(tray.wid.Id))
if err != nil {
return nil, err
}
if err = xevent.SendRootEvent(X, evt, xproto.EventMaskStructureNotify); err != nil {
return nil, err
}
xevent.ClientMessageFun(func(_ *xgbutil.XUtil, ev xevent.ClientMessageEvent) {
tray.event(ev)
}).Connect(tray.X, tray.wid.Id)
return tray, nil
}