add dwm systray
authorBen Doumenc <bdoumenc@gmail.com>
Thu, 17 Oct 2013 15:34:50 +0000 (17:34 +0200)
committerBen Doumenc <bdoumenc@gmail.com>
Thu, 17 Oct 2013 15:34:50 +0000 (17:34 +0200)
suckless/dwm/config.def.h
suckless/dwm/dwm-c794a9f5ae5e-systray.diff [new file with mode: 0644]
suckless/dwm/dwm.c

index 2818bcc..c30c139 100644 (file)
@@ -10,6 +10,8 @@ static const char selbgcolor[]      = "#005577";
 static const char selfgcolor[]      = "#eeeeee";
 static const unsigned int borderpx  = 1;        /* border pixel of windows */
 static const unsigned int snap      = 32;       /* snap pixel */
+static const unsigned int systrayspacing = 2;   /* systray spacing */
+static const Bool showsystray       = True;     /* False means no systray */
 static const Bool showbar           = True;     /* False means no bar */
 static const Bool topbar            = True;     /* False means bottom bar */
 
@@ -51,11 +53,11 @@ static const Layout layouts[] = {
 
 /* commands */
 static const char *dmenucmd[] = { "dmenu_run", "-fn", font, "-nb", normbgcolor, "-nf", normfgcolor, "-sb", selbgcolor, "-sf", selfgcolor, NULL };
-static const char *termcmd[]  = { "gnome-terminal", NULL };
+static const char *termcmd[]  = { "xfce4-terminal", NULL };
 static const char *browsercmd[]  = { "firefox", NULL };
 static const char *projectcmd[]  = { "launchProjectVim.sh", NULL };
 static const char *lockcmd[]  = { "slock", NULL };
-static const char *filecmd[]  = { "nautilus", "--no-desktop", NULL };
+static const char *filecmd[]  = { "pcmanfm", NULL };
 
 static Key keys[] = {
        /* modifier                     key        function        argument */
diff --git a/suckless/dwm/dwm-c794a9f5ae5e-systray.diff b/suckless/dwm/dwm-c794a9f5ae5e-systray.diff
new file mode 100644 (file)
index 0000000..4afe14e
--- /dev/null
@@ -0,0 +1,634 @@
+Author: Jan Christoph Ebersbach <jceb@e-jc.de>, inspired by http://code.google.com/p/dwm-plus
+URL: http://dwm.suckless.org/patches/systray
+Implements a system tray for dwm.
+
+diff -r c794a9f5ae5e config.def.h
+--- a/config.def.h     Sun Jul 08 09:45:53 2012 +0200
++++ b/config.def.h     Sat Aug 18 13:28:31 2012 +0200
+@@ -10,6 +10,8 @@
+ static const char selfgcolor[]      = "#eeeeee";
+ static const unsigned int borderpx  = 1;        /* border pixel of windows */
+ static const unsigned int snap      = 32;       /* snap pixel */
++static const unsigned int systrayspacing = 2;   /* systray spacing */
++static const Bool showsystray       = True;     /* False means no systray */
+ static const Bool showbar           = True;     /* False means no bar */
+ static const Bool topbar            = True;     /* False means bottom bar */
+diff -r c794a9f5ae5e dwm.c
+--- a/dwm.c    Sun Jul 08 09:45:53 2012 +0200
++++ b/dwm.c    Sat Aug 18 13:28:31 2012 +0200
+@@ -56,12 +56,30 @@
+ #define TAGMASK                 ((1 << LENGTH(tags)) - 1)
+ #define TEXTW(X)                (textnw(X, strlen(X)) + dc.font.height)
++#define SYSTEM_TRAY_REQUEST_DOCK    0
++#define _NET_SYSTEM_TRAY_ORIENTATION_HORZ 0
++
++/* XEMBED messages */
++#define XEMBED_EMBEDDED_NOTIFY      0
++#define XEMBED_WINDOW_ACTIVATE      1
++#define XEMBED_FOCUS_IN             4
++#define XEMBED_MODALITY_ON         10
++
++#define XEMBED_MAPPED              (1 << 0)
++#define XEMBED_WINDOW_ACTIVATE      1
++#define XEMBED_WINDOW_DEACTIVATE    2
++
++#define VERSION_MAJOR               0
++#define VERSION_MINOR               0
++#define XEMBED_EMBEDDED_VERSION (VERSION_MAJOR << 16) | VERSION_MINOR
++
+ /* enums */
+ enum { CurNormal, CurResize, CurMove, CurLast };        /* cursor */
+ enum { ColBorder, ColFG, ColBG, ColLast };              /* color */
+-enum { NetSupported, NetWMName, NetWMState,
+-       NetWMFullscreen, NetActiveWindow, NetWMWindowType,
+-       NetWMWindowTypeDialog, NetClientList, NetLast };     /* EWMH atoms */
++enum { NetSupported, NetSystemTray, NetSystemTrayOP, NetSystemTrayOrientation,
++         NetWMName, NetWMState, NetWMFullscreen, NetActiveWindow, NetWMWindowType,
++         NetWMWindowTypeDialog, NetClientList, NetLast }; /* EWMH atoms */
++enum { Manager, Xembed, XembedInfo, XLast }; /* Xembed atoms */
+ enum { WMProtocols, WMDelete, WMState, WMTakeFocus, WMLast }; /* default atoms */
+ enum { ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle,
+        ClkClientWin, ClkRootWin, ClkLast };             /* clicks */
+@@ -155,6 +173,12 @@
+       int monitor;
+ } Rule;
++typedef struct Systray   Systray;
++struct Systray {
++      Window win;
++      Client *icons;
++};
++
+ /* function declarations */
+ static void applyrules(Client *c);
+ static Bool applysizehints(Client *c, int *x, int *y, int *w, int *h, Bool interact);
+@@ -187,9 +211,11 @@
+ static void focusin(XEvent *e);
+ static void focusmon(const Arg *arg);
+ static void focusstack(const Arg *arg);
++static Atom getatomprop(Client *c, Atom prop);
+ static unsigned long getcolor(const char *colstr);
+ static Bool getrootptr(int *x, int *y);
+ static long getstate(Window w);
++static unsigned int getsystraywidth();
+ static Bool gettextprop(Window w, Atom atom, char *text, unsigned int size);
+ static void grabbuttons(Client *c, Bool focused);
+ static void grabkeys(void);
+@@ -208,13 +234,16 @@
+ static void propertynotify(XEvent *e);
+ static void quit(const Arg *arg);
+ static Monitor *recttomon(int x, int y, int w, int h);
++static void removesystrayicon(Client *i);
+ static void resize(Client *c, int x, int y, int w, int h, Bool interact);
++static void resizebarwin(Monitor *m);
+ static void resizeclient(Client *c, int x, int y, int w, int h);
+ static void resizemouse(const Arg *arg);
++static void resizerequest(XEvent *e);
+ static void restack(Monitor *m);
+ static void run(void);
+ static void scan(void);
+-static Bool sendevent(Client *c, Atom proto);
++static Bool sendevent(Window w, Atom proto, int m, long d0, long d1, long d2, long d3, long d4);
+ static void sendmon(Client *c, Monitor *m);
+ static void setclientstate(Client *c, long state);
+ static void setfocus(Client *c);
+@@ -243,18 +272,24 @@
+ static void updatenumlockmask(void);
+ static void updatesizehints(Client *c);
+ static void updatestatus(void);
++static void updatesystray(void);
++static void updatesystrayicongeom(Client *i, int w, int h);
++static void updatesystrayiconstate(Client *i, XPropertyEvent *ev);
+ static void updatewindowtype(Client *c);
+ static void updatetitle(Client *c);
+ static void updatewmhints(Client *c);
+ static void view(const Arg *arg);
+ static Client *wintoclient(Window w);
+ static Monitor *wintomon(Window w);
++static Client *wintosystrayicon(Window w);
+ static int xerror(Display *dpy, XErrorEvent *ee);
+ static int xerrordummy(Display *dpy, XErrorEvent *ee);
+ static int xerrorstart(Display *dpy, XErrorEvent *ee);
+ static void zoom(const Arg *arg);
+ /* variables */
++static Systray *systray = NULL;
++static unsigned long systrayorientation = _NET_SYSTEM_TRAY_ORIENTATION_HORZ;
+ static const char broken[] = "broken";
+ static char stext[256];
+ static int screen;
+@@ -276,9 +311,10 @@
+       [MapRequest] = maprequest,
+       [MotionNotify] = motionnotify,
+       [PropertyNotify] = propertynotify,
++      [ResizeRequest] = resizerequest,
+       [UnmapNotify] = unmapnotify
+ };
+-static Atom wmatom[WMLast], netatom[NetLast];
++static Atom wmatom[WMLast], netatom[NetLast], xatom[XLast];
+ static Bool running = True;
+ static Cursor cursor[CurLast];
+ static Display *dpy;
+@@ -499,6 +535,11 @@
+       XFreeCursor(dpy, cursor[CurMove]);
+       while(mons)
+               cleanupmon(mons);
++      if(showsystray) {
++              XUnmapWindow(dpy, systray->win);
++              XDestroyWindow(dpy, systray->win);
++              free(systray);
++      }
+       XSync(dpy, False);
+       XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime);
+       XDeleteProperty(dpy, root, netatom[NetActiveWindow]);
+@@ -533,9 +575,49 @@
+ void
+ clientmessage(XEvent *e) {
++      XWindowAttributes wa;
++      XSetWindowAttributes swa;
+       XClientMessageEvent *cme = &e->xclient;
+       Client *c = wintoclient(cme->window);
++      if(showsystray && cme->window == systray->win && cme->message_type == netatom[NetSystemTrayOP]) {
++              /* add systray icons */
++              if(cme->data.l[1] == SYSTEM_TRAY_REQUEST_DOCK) {
++                      if(!(c = (Client *)calloc(1, sizeof(Client))))
++                              die("fatal: could not malloc() %u bytes\n", sizeof(Client));
++                      c->win = cme->data.l[2];
++                      c->mon = selmon;
++                      c->next = systray->icons;
++                      systray->icons = c;
++                      XGetWindowAttributes(dpy, c->win, &wa);
++                      c->x = c->oldx = c->y = c->oldy = 0;
++                      c->w = c->oldw = wa.width;
++                      c->h = c->oldh = wa.height;
++                      c->oldbw = wa.border_width;
++                      c->bw = 0;
++                      c->isfloating = True;
++                      /* reuse tags field as mapped status */
++                      c->tags = 1;
++                      updatesizehints(c);
++                      updatesystrayicongeom(c, wa.width, wa.height);
++                      XAddToSaveSet(dpy, c->win);
++                      XSelectInput(dpy, c->win, StructureNotifyMask | PropertyChangeMask | ResizeRedirectMask);
++                      XReparentWindow(dpy, c->win, systray->win, 0, 0);
++                      /* use parents background pixmap */
++                      swa.background_pixmap = ParentRelative;
++                      swa.background_pixel  = dc.norm[ColBG];
++                      XChangeWindowAttributes(dpy, c->win, CWBackPixmap|CWBackPixel, &swa);
++                      sendevent(c->win, netatom[Xembed], StructureNotifyMask, CurrentTime, XEMBED_EMBEDDED_NOTIFY, 0 , systray->win, XEMBED_EMBEDDED_VERSION);
++                      /* FIXME not sure if I have to send these events, too */
++                      sendevent(c->win, netatom[Xembed], StructureNotifyMask, CurrentTime, XEMBED_FOCUS_IN, 0 , systray->win, XEMBED_EMBEDDED_VERSION);
++                      sendevent(c->win, netatom[Xembed], StructureNotifyMask, CurrentTime, XEMBED_WINDOW_ACTIVATE, 0 , systray->win, XEMBED_EMBEDDED_VERSION);
++                      sendevent(c->win, netatom[Xembed], StructureNotifyMask, CurrentTime, XEMBED_MODALITY_ON, 0 , systray->win, XEMBED_EMBEDDED_VERSION);
++                      resizebarwin(selmon);
++                      updatesystray();
++                      setclientstate(c, NormalState);
++              }
++              return;
++      }
+       if(!c)
+               return;
+       if(cme->message_type == netatom[NetWMState]) {
+@@ -587,7 +667,7 @@
+                       dc.drawable = XCreatePixmap(dpy, root, sw, bh, DefaultDepth(dpy, screen));
+                       updatebars();
+                       for(m = mons; m; m = m->next)
+-                              XMoveResizeWindow(dpy, m->barwin, m->wx, m->by, m->ww, bh);
++                              resizebarwin(m);
+                       focus(NULL);
+                       arrange(NULL);
+               }
+@@ -671,6 +751,11 @@
+       if((c = wintoclient(ev->window)))
+               unmanage(c, True);
++      else if((c = wintosystrayicon(ev->window))) {
++              removesystrayicon(c);
++              resizebarwin(selmon);
++              updatesystray();
++      }
+ }
+ void
+@@ -726,6 +811,7 @@
+       unsigned long *col;
+       Client *c;
++      resizebarwin(m);
+       for(c = m->clients; c; c = c->next) {
+               occ |= c->tags;
+               if(c->isurgent)
+@@ -747,6 +833,9 @@
+       if(m == selmon) { /* status is only drawn on selected monitor */
+               dc.w = TEXTW(stext);
+               dc.x = m->ww - dc.w;
++              if(showsystray && m == selmon) {
++                      dc.x -= getsystraywidth();
++              }
+               if(dc.x < x) {
+                       dc.x = x;
+                       dc.w = m->ww - x;
+@@ -775,6 +864,7 @@
+       for(m = mons; m; m = m->next)
+               drawbar(m);
++      updatesystray();
+ }
+ void
+@@ -924,10 +1014,17 @@
+       unsigned long dl;
+       unsigned char *p = NULL;
+       Atom da, atom = None;
++      /* FIXME getatomprop should return the number of items and a pointer to
++       * the stored data instead of this workaround */
++      Atom req = XA_ATOM;
++      if(prop == xatom[XembedInfo])
++              req = xatom[XembedInfo];
+-      if(XGetWindowProperty(dpy, c->win, prop, 0L, sizeof atom, False, XA_ATOM,
++      if(XGetWindowProperty(dpy, c->win, prop, 0L, sizeof atom, False, req,
+                             &da, &di, &dl, &dl, &p) == Success && p) {
+               atom = *(Atom *)p;
++              if(da == xatom[XembedInfo] && dl == 2)
++                      atom = ((Atom *)p)[1];
+               XFree(p);
+       }
+       return atom;
+@@ -969,6 +1066,15 @@
+       return result;
+ }
++unsigned int
++getsystraywidth() {
++      unsigned int w = 0;
++      Client *i;
++      if(showsystray)
++              for(i = systray->icons; i; w += i->w + systrayspacing, i = i->next) ;
++      return w ? w + systrayspacing : 1;
++}
++
+ Bool
+ gettextprop(Window w, Atom atom, char *text, unsigned int size) {
+       char **list = NULL;
+@@ -1103,7 +1209,7 @@
+ killclient(const Arg *arg) {
+       if(!selmon->sel)
+               return;
+-      if(!sendevent(selmon->sel, wmatom[WMDelete])) {
++      if(!sendevent(selmon->sel->win, wmatom[WMDelete], NoEventMask, wmatom[WMDelete], CurrentTime, 0 , 0, 0)) {
+               XGrabServer(dpy);
+               XSetErrorHandler(xerrordummy);
+               XSetCloseDownMode(dpy, DestroyAll);
+@@ -1189,6 +1295,12 @@
+ maprequest(XEvent *e) {
+       static XWindowAttributes wa;
+       XMapRequestEvent *ev = &e->xmaprequest;
++      Client *i;
++      if((i = wintosystrayicon(ev->window))) {
++              sendevent(i->win, netatom[Xembed], StructureNotifyMask, CurrentTime, XEMBED_WINDOW_ACTIVATE, 0, systray->win, XEMBED_EMBEDDED_VERSION);
++              resizebarwin(selmon);
++              updatesystray();
++      }
+       if(!XGetWindowAttributes(dpy, ev->window, &wa))
+               return;
+@@ -1305,6 +1417,16 @@
+       Window trans;
+       XPropertyEvent *ev = &e->xproperty;
++      if((c = wintosystrayicon(ev->window))) {
++              if(ev->atom == XA_WM_NORMAL_HINTS) {
++                      updatesizehints(c);
++                      updatesystrayicongeom(c, c->w, c->h);
++              }
++              else
++                      updatesystrayiconstate(c, ev);
++              resizebarwin(selmon);
++              updatesystray();
++      }
+       if((ev->window == root) && (ev->atom == XA_WM_NAME))
+               updatestatus();
+       else if(ev->state == PropertyDelete)
+@@ -1354,12 +1476,33 @@
+ }
+ void
++removesystrayicon(Client *i) {
++      Client **ii;
++
++      if(!showsystray || !i)
++              return;
++      for(ii = &systray->icons; *ii && *ii != i; ii = &(*ii)->next);
++      if(ii)
++              *ii = i->next;
++      free(i);
++}
++
++
++void
+ resize(Client *c, int x, int y, int w, int h, Bool interact) {
+       if(applysizehints(c, &x, &y, &w, &h, interact))
+               resizeclient(c, x, y, w, h);
+ }
+ void
++resizebarwin(Monitor *m) {
++      unsigned int w = m->ww;
++      if(showsystray && m == selmon)
++              w -= getsystraywidth();
++      XMoveResizeWindow(dpy, m->barwin, m->wx, m->by, w, bh);
++}
++
++void
+ resizeclient(Client *c, int x, int y, int w, int h) {
+       XWindowChanges wc;
+@@ -1426,6 +1569,18 @@
+ }
+ void
++resizerequest(XEvent *e) {
++      XResizeRequestEvent *ev = &e->xresizerequest;
++      Client *i;
++
++      if((i = wintosystrayicon(ev->window))) {
++              updatesystrayicongeom(i, ev->width, ev->height);
++              resizebarwin(selmon);
++              updatesystray();
++      }
++}
++
++void
+ restack(Monitor *m) {
+       Client *c;
+       XEvent ev;
+@@ -1509,25 +1664,35 @@
+ }
+ Bool
+-sendevent(Client *c, Atom proto) {
++sendevent(Window w, Atom proto, int mask, long d0, long d1, long d2, long d3, long d4) {
+       int n;
+-      Atom *protocols;
++      Atom *protocols, mt;
+       Bool exists = False;
+       XEvent ev;
+-      if(XGetWMProtocols(dpy, c->win, &protocols, &n)) {
+-              while(!exists && n--)
+-                      exists = protocols[n] == proto;
+-              XFree(protocols);
++      if(proto == wmatom[WMTakeFocus] || proto == wmatom[WMDelete]) {
++              mt = wmatom[WMProtocols];
++              if(XGetWMProtocols(dpy, w, &protocols, &n)) {
++                      while(!exists && n--)
++                              exists = protocols[n] == proto;
++                      XFree(protocols);
++              }
++      }
++      else {
++              exists = True;
++              mt = proto;
+       }
+       if(exists) {
+               ev.type = ClientMessage;
+-              ev.xclient.window = c->win;
+-              ev.xclient.message_type = wmatom[WMProtocols];
++              ev.xclient.window = w;
++              ev.xclient.message_type = mt;
+               ev.xclient.format = 32;
+-              ev.xclient.data.l[0] = proto;
+-              ev.xclient.data.l[1] = CurrentTime;
+-              XSendEvent(dpy, c->win, False, NoEventMask, &ev);
++              ev.xclient.data.l[0] = d0;
++              ev.xclient.data.l[1] = d1;
++              ev.xclient.data.l[2] = d2;
++              ev.xclient.data.l[3] = d3;
++              ev.xclient.data.l[4] = d4;
++              XSendEvent(dpy, w, False, mask, &ev);
+       }
+       return exists;
+ }
+@@ -1540,7 +1705,7 @@
+                               XA_WINDOW, 32, PropModeReplace,
+                               (unsigned char *) &(c->win), 1);
+       }
+-      sendevent(c, wmatom[WMTakeFocus]);
++      sendevent(c->win, wmatom[WMTakeFocus], NoEventMask, wmatom[WMTakeFocus], CurrentTime, 0, 0, 0);
+ }
+ void
+@@ -1620,12 +1785,18 @@
+       wmatom[WMTakeFocus] = XInternAtom(dpy, "WM_TAKE_FOCUS", False);
+       netatom[NetActiveWindow] = XInternAtom(dpy, "_NET_ACTIVE_WINDOW", False);
+       netatom[NetSupported] = XInternAtom(dpy, "_NET_SUPPORTED", False);
++      netatom[NetSystemTray] = XInternAtom(dpy, "_NET_SYSTEM_TRAY_S0", False);
++      netatom[NetSystemTrayOP] = XInternAtom(dpy, "_NET_SYSTEM_TRAY_OPCODE", False);
++      netatom[NetSystemTrayOrientation] = XInternAtom(dpy, "_NET_SYSTEM_TRAY_ORIENTATION", False);
+       netatom[NetWMName] = XInternAtom(dpy, "_NET_WM_NAME", False);
+       netatom[NetWMState] = XInternAtom(dpy, "_NET_WM_STATE", False);
+       netatom[NetWMFullscreen] = XInternAtom(dpy, "_NET_WM_STATE_FULLSCREEN", False);
+       netatom[NetWMWindowType] = XInternAtom(dpy, "_NET_WM_WINDOW_TYPE", False);
+       netatom[NetWMWindowTypeDialog] = XInternAtom(dpy, "_NET_WM_WINDOW_TYPE_DIALOG", False);
+       netatom[NetClientList] = XInternAtom(dpy, "_NET_CLIENT_LIST", False);
++      xatom[Manager] = XInternAtom(dpy, "MANAGER", False);
++      xatom[Xembed] = XInternAtom(dpy, "_XEMBED", False);
++      xatom[XembedInfo] = XInternAtom(dpy, "_XEMBED_INFO", False);
+       /* init cursors */
+       cursor[CurNormal] = XCreateFontCursor(dpy, XC_left_ptr);
+       cursor[CurResize] = XCreateFontCursor(dpy, XC_sizing);
+@@ -1642,6 +1813,8 @@
+       XSetLineAttributes(dpy, dc.gc, 1, LineSolid, CapButt, JoinMiter);
+       if(!dc.font.set)
+               XSetFont(dpy, dc.gc, dc.font.xfont->fid);
++      /* init system tray */
++      updatesystray();
+       /* init bars */
+       updatebars();
+       updatestatus();
+@@ -1751,7 +1924,18 @@
+ togglebar(const Arg *arg) {
+       selmon->showbar = !selmon->showbar;
+       updatebarpos(selmon);
+-      XMoveResizeWindow(dpy, selmon->barwin, selmon->wx, selmon->by, selmon->ww, bh);
++      resizebarwin(selmon);
++      if(showsystray) {
++              XWindowChanges wc;
++              if(!selmon->showbar)
++                      wc.y = -bh;
++              else if(selmon->showbar) {
++                      wc.y = 0;
++                      if(!selmon->topbar)
++                              wc.y = selmon->mh - bh;
++              }
++              XConfigureWindow(dpy, systray->win, CWY, &wc);
++      }
+       arrange(selmon);
+ }
+@@ -1841,11 +2025,18 @@
+               else
+                       unmanage(c, False);
+       }
++      else if((c = wintosystrayicon(ev->window))) {
++              removesystrayicon(c);
++              resizebarwin(selmon);
++              updatesystray();
++      }
+ }
+ void
+ updatebars(void) {
++      unsigned int w;
+       Monitor *m;
++
+       XSetWindowAttributes wa = {
+               .override_redirect = True,
+               .background_pixmap = ParentRelative,
+@@ -1854,10 +2045,15 @@
+       for(m = mons; m; m = m->next) {
+               if (m->barwin)
+                       continue;
+-              m->barwin = XCreateWindow(dpy, root, m->wx, m->by, m->ww, bh, 0, DefaultDepth(dpy, screen),
++              w = m->ww;
++              if(showsystray && m == selmon)
++                      w -= getsystraywidth();
++              m->barwin = XCreateWindow(dpy, root, m->wx, m->by, w, bh, 0, DefaultDepth(dpy, screen),
+                                         CopyFromParent, DefaultVisual(dpy, screen),
+                                         CWOverrideRedirect|CWBackPixmap|CWEventMask, &wa);
+               XDefineCursor(dpy, m->barwin, cursor[CurNormal]);
++              if(showsystray && m == selmon)
++                      XMapRaised(dpy, systray->win);
+               XMapRaised(dpy, m->barwin);
+       }
+ }
+@@ -2051,6 +2250,107 @@
+ }
+ void
++updatesystrayicongeom(Client *i, int w, int h) {
++      if(i) {
++              i->h = bh;
++              if(w == h)
++                      i->w = bh;
++              else if(h == bh)
++                      i->w = w;
++              else
++                      i->w = (int) ((float)bh * ((float)w / (float)h));
++              applysizehints(i, &(i->x), &(i->y), &(i->w), &(i->h), False);
++              /* force icons into the systray dimenons if they don't want to */
++              if(i->h > bh) {
++                      if(i->w == i->h)
++                              i->w = bh;
++                      else
++                              i->w = (int) ((float)bh * ((float)i->w / (float)i->h));
++                      i->h = bh;
++              }
++      }
++}
++
++void
++updatesystrayiconstate(Client *i, XPropertyEvent *ev) {
++      long flags;
++      int code = 0;
++
++      if(!showsystray || !i || ev->atom != xatom[XembedInfo] ||
++                      !(flags = getatomprop(i, xatom[XembedInfo])))
++              return;
++
++      if(flags & XEMBED_MAPPED && !i->tags) {
++              i->tags = 1;
++              code = XEMBED_WINDOW_ACTIVATE;
++              XMapRaised(dpy, i->win);
++              setclientstate(i, NormalState);
++      }
++      else if(!(flags & XEMBED_MAPPED) && i->tags) {
++              i->tags = 0;
++              code = XEMBED_WINDOW_DEACTIVATE;
++              XUnmapWindow(dpy, i->win);
++              setclientstate(i, WithdrawnState);
++      }
++      else
++              return;
++      sendevent(i->win, xatom[Xembed], StructureNotifyMask, CurrentTime, code, 0,
++                      systray->win, XEMBED_EMBEDDED_VERSION);
++}
++
++void
++updatesystray(void) {
++      XSetWindowAttributes wa;
++      Client *i;
++      unsigned int x = selmon->mx + selmon->mw;
++      unsigned int w = 1;
++
++      if(!showsystray)
++              return;
++      if(!systray) {
++              /* init systray */
++              if(!(systray = (Systray *)calloc(1, sizeof(Systray))))
++                      die("fatal: could not malloc() %u bytes\n", sizeof(Systray));
++              systray->win = XCreateSimpleWindow(dpy, root, x, selmon->by, w, bh, 0, 0, dc.sel[ColBG]);
++              wa.event_mask        = ButtonPressMask | ExposureMask;
++              wa.override_redirect = True;
++              wa.background_pixmap = ParentRelative;
++              wa.background_pixel  = dc.norm[ColBG];
++              XSelectInput(dpy, systray->win, SubstructureNotifyMask);
++              XChangeProperty(dpy, systray->win, netatom[NetSystemTrayOrientation], XA_CARDINAL, 32,
++                              PropModeReplace, (unsigned char *)&systrayorientation, 1);
++              XChangeWindowAttributes(dpy, systray->win, CWEventMask|CWOverrideRedirect|CWBackPixel|CWBackPixmap, &wa);
++              XMapRaised(dpy, systray->win);
++              XSetSelectionOwner(dpy, netatom[NetSystemTray], systray->win, CurrentTime);
++              if(XGetSelectionOwner(dpy, netatom[NetSystemTray]) == systray->win) {
++                      sendevent(root, xatom[Manager], StructureNotifyMask, CurrentTime, netatom[NetSystemTray], systray->win, 0, 0);
++                      XSync(dpy, False);
++              }
++              else {
++                      fprintf(stderr, "dwm: unable to obtain system tray.\n");
++                      free(systray);
++                      systray = NULL;
++                      return;
++              }
++      }
++      for(w = 0, i = systray->icons; i; i = i->next) {
++              XMapRaised(dpy, i->win);
++              w += systrayspacing;
++              XMoveResizeWindow(dpy, i->win, (i->x = w), 0, i->w, i->h);
++              w += i->w;
++              if(i->mon != selmon)
++                      i->mon = selmon;
++      }
++      w = w ? w + systrayspacing : 1;
++      x -= w;
++      XMoveResizeWindow(dpy, systray->win, x, selmon->by, w, bh);
++      /* redraw background */
++      XSetForeground(dpy, dc.gc, dc.norm[ColBG]);
++      XFillRectangle(dpy, systray->win, dc.gc, 0, 0, w, bh);
++      XSync(dpy, False);
++}
++
++void
+ updatewindowtype(Client *c) {
+       Atom state = getatomprop(c, netatom[NetWMState]);
+       Atom wtype = getatomprop(c, netatom[NetWMWindowType]);
+@@ -2119,6 +2413,16 @@
+       return selmon;
+ }
++Client *
++wintosystrayicon(Window w) {
++      Client *i = NULL;
++
++      if(!showsystray || !w)
++              return i;
++      for(i = systray->icons; i && i->win != w; i = i->next) ;
++      return i;
++}
++
+ /* There's no way to check accesses to destroyed windows, thus those cases are
+  * ignored (especially on UnmapNotify's).  Other types of errors call Xlibs
+  * default error handler, which may call exit.  */
index 7941bd1..51d5108 100644 (file)
 #define TAGMASK                 ((1 << LENGTH(tags)) - 1)
 #define TEXTW(X)                (textnw(X, strlen(X)) + dc.font.height)
 
+#define SYSTEM_TRAY_REQUEST_DOCK    0
+#define _NET_SYSTEM_TRAY_ORIENTATION_HORZ 0
+
+/* XEMBED messages */
+#define XEMBED_EMBEDDED_NOTIFY      0
+#define XEMBED_WINDOW_ACTIVATE      1
+#define XEMBED_FOCUS_IN             4
+#define XEMBED_MODALITY_ON         10
+
+#define XEMBED_MAPPED              (1 << 0)
+#define XEMBED_WINDOW_ACTIVATE      1
+#define XEMBED_WINDOW_DEACTIVATE    2
+
+#define VERSION_MAJOR               0
+#define VERSION_MINOR               0
+#define XEMBED_EMBEDDED_VERSION (VERSION_MAJOR << 16) | VERSION_MINOR
+
 /* enums */
 enum { CurNormal, CurResize, CurMove, CurLast };        /* cursor */
 enum { ColBorder, ColFG, ColBG, ColLast };              /* color */
-enum { NetSupported, NetWMName, NetWMState,
-       NetWMFullscreen, NetActiveWindow, NetWMWindowType,
-       NetWMWindowTypeDialog, NetClientList, NetLast };     /* EWMH atoms */
+enum { NetSupported, NetSystemTray, NetSystemTrayOP, NetSystemTrayOrientation,
+          NetWMName, NetWMState, NetWMFullscreen, NetActiveWindow, NetWMWindowType,
+          NetWMWindowTypeDialog, NetClientList, NetLast }; /* EWMH atoms */
+enum { Manager, Xembed, XembedInfo, XLast }; /* Xembed atoms */
 enum { WMProtocols, WMDelete, WMState, WMTakeFocus, WMLast }; /* default atoms */
 enum { ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle,
        ClkClientWin, ClkRootWin, ClkLast };             /* clicks */
@@ -155,6 +173,12 @@ typedef struct {
        int monitor;
 } Rule;
 
+typedef struct Systray   Systray;
+struct Systray {
+       Window win;
+       Client *icons;
+};
+
 /* function declarations */
 static void applyrules(Client *c);
 static Bool applysizehints(Client *c, int *x, int *y, int *w, int *h, Bool interact);
@@ -186,9 +210,11 @@ static void focus(Client *c);
 static void focusin(XEvent *e);
 static void focusmon(const Arg *arg);
 static void focusstack(const Arg *arg);
+static Atom getatomprop(Client *c, Atom prop);
 static unsigned long getcolor(const char *colstr);
 static Bool getrootptr(int *x, int *y);
 static long getstate(Window w);
+static unsigned int getsystraywidth();
 static Bool gettextprop(Window w, Atom atom, char *text, unsigned int size);
 static void grabbuttons(Client *c, Bool focused);
 static void grabkeys(void);
@@ -207,13 +233,16 @@ static void pop(Client *);
 static void propertynotify(XEvent *e);
 static void quit(const Arg *arg);
 static Monitor *recttomon(int x, int y, int w, int h);
+static void removesystrayicon(Client *i);
 static void resize(Client *c, int x, int y, int w, int h, Bool interact);
+static void resizebarwin(Monitor *m);
 static void resizeclient(Client *c, int x, int y, int w, int h);
 static void resizemouse(const Arg *arg);
+static void resizerequest(XEvent *e);
 static void restack(Monitor *m);
 static void run(void);
 static void scan(void);
-static Bool sendevent(Client *c, Atom proto);
+static Bool sendevent(Window w, Atom proto, int m, long d0, long d1, long d2, long d3, long d4);
 static void sendmon(Client *c, Monitor *m);
 static void setclientstate(Client *c, long state);
 static void setfocus(Client *c);
@@ -242,18 +271,24 @@ static void updateclientlist(void);
 static void updatenumlockmask(void);
 static void updatesizehints(Client *c);
 static void updatestatus(void);
+static void updatesystray(void);
+static void updatesystrayicongeom(Client *i, int w, int h);
+static void updatesystrayiconstate(Client *i, XPropertyEvent *ev);
 static void updatewindowtype(Client *c);
 static void updatetitle(Client *c);
 static void updatewmhints(Client *c);
 static void view(const Arg *arg);
 static Client *wintoclient(Window w);
 static Monitor *wintomon(Window w);
+static Client *wintosystrayicon(Window w);
 static int xerror(Display *dpy, XErrorEvent *ee);
 static int xerrordummy(Display *dpy, XErrorEvent *ee);
 static int xerrorstart(Display *dpy, XErrorEvent *ee);
 static void zoom(const Arg *arg);
 
 /* variables */
+static Systray *systray = NULL;
+static unsigned long systrayorientation = _NET_SYSTEM_TRAY_ORIENTATION_HORZ;
 static const char broken[] = "broken";
 static char stext[256];
 static int screen;
@@ -275,9 +310,10 @@ static void (*handler[LASTEvent]) (XEvent *) = {
        [MapRequest] = maprequest,
        [MotionNotify] = motionnotify,
        [PropertyNotify] = propertynotify,
+       [ResizeRequest] = resizerequest,
        [UnmapNotify] = unmapnotify
 };
-static Atom wmatom[WMLast], netatom[NetLast];
+static Atom wmatom[WMLast], netatom[NetLast], xatom[XLast];
 static Bool running = True;
 static Cursor cursor[CurLast];
 static Display *dpy;
@@ -498,6 +534,11 @@ cleanup(void) {
        XFreeCursor(dpy, cursor[CurMove]);
        while(mons)
                cleanupmon(mons);
+       if(showsystray) {
+               XUnmapWindow(dpy, systray->win);
+               XDestroyWindow(dpy, systray->win);
+               free(systray);
+       }
        XSync(dpy, False);
        XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime);
        XDeleteProperty(dpy, root, netatom[NetActiveWindow]);
@@ -532,9 +573,49 @@ clearurgent(Client *c) {
 
 void
 clientmessage(XEvent *e) {
+       XWindowAttributes wa;
+       XSetWindowAttributes swa;
        XClientMessageEvent *cme = &e->xclient;
        Client *c = wintoclient(cme->window);
 
+       if(showsystray && cme->window == systray->win && cme->message_type == netatom[NetSystemTrayOP]) {
+               /* add systray icons */
+               if(cme->data.l[1] == SYSTEM_TRAY_REQUEST_DOCK) {
+                       if(!(c = (Client *)calloc(1, sizeof(Client))))
+                               die("fatal: could not malloc() %u bytes\n", sizeof(Client));
+                       c->win = cme->data.l[2];
+                       c->mon = selmon;
+                       c->next = systray->icons;
+                       systray->icons = c;
+                       XGetWindowAttributes(dpy, c->win, &wa);
+                       c->x = c->oldx = c->y = c->oldy = 0;
+                       c->w = c->oldw = wa.width;
+                       c->h = c->oldh = wa.height;
+                       c->oldbw = wa.border_width;
+                       c->bw = 0;
+                       c->isfloating = True;
+                       /* reuse tags field as mapped status */
+                       c->tags = 1;
+                       updatesizehints(c);
+                       updatesystrayicongeom(c, wa.width, wa.height);
+                       XAddToSaveSet(dpy, c->win);
+                       XSelectInput(dpy, c->win, StructureNotifyMask | PropertyChangeMask | ResizeRedirectMask);
+                       XReparentWindow(dpy, c->win, systray->win, 0, 0);
+                       /* use parents background pixmap */
+                       swa.background_pixmap = ParentRelative;
+                       swa.background_pixel  = dc.norm[ColBG];
+                       XChangeWindowAttributes(dpy, c->win, CWBackPixmap|CWBackPixel, &swa);
+                       sendevent(c->win, netatom[Xembed], StructureNotifyMask, CurrentTime, XEMBED_EMBEDDED_NOTIFY, 0 , systray->win, XEMBED_EMBEDDED_VERSION);
+                       /* FIXME not sure if I have to send these events, too */
+                       sendevent(c->win, netatom[Xembed], StructureNotifyMask, CurrentTime, XEMBED_FOCUS_IN, 0 , systray->win, XEMBED_EMBEDDED_VERSION);
+                       sendevent(c->win, netatom[Xembed], StructureNotifyMask, CurrentTime, XEMBED_WINDOW_ACTIVATE, 0 , systray->win, XEMBED_EMBEDDED_VERSION);
+                       sendevent(c->win, netatom[Xembed], StructureNotifyMask, CurrentTime, XEMBED_MODALITY_ON, 0 , systray->win, XEMBED_EMBEDDED_VERSION);
+                       resizebarwin(selmon);
+                       updatesystray();
+                       setclientstate(c, NormalState);
+               }
+               return;
+       }
        if(!c)
                return;
        if(cme->message_type == netatom[NetWMState]) {
@@ -586,7 +667,7 @@ configurenotify(XEvent *e) {
                        dc.drawable = XCreatePixmap(dpy, root, sw, bh, DefaultDepth(dpy, screen));
                        updatebars();
                        for(m = mons; m; m = m->next)
-                               XMoveResizeWindow(dpy, m->barwin, m->wx, m->by, m->ww, bh);
+                               resizebarwin(m);
                        focus(NULL);
                        arrange(NULL);
                }
@@ -670,6 +751,11 @@ destroynotify(XEvent *e) {
 
        if((c = wintoclient(ev->window)))
                unmanage(c, True);
+       else if((c = wintosystrayicon(ev->window))) {
+               removesystrayicon(c);
+               resizebarwin(selmon);
+               updatesystray();
+       }
 }
 
 void
@@ -715,6 +801,7 @@ drawbar(Monitor *m) {
        unsigned long *col;
        Client *c;
 
+       resizebarwin(m);
        for(c = m->clients; c; c = c->next) {
                occ |= c->tags;
                if(c->isurgent)
@@ -736,6 +823,9 @@ drawbar(Monitor *m) {
        if(m == selmon) { /* status is only drawn on selected monitor */
                dc.w = TEXTW(stext);
                dc.x = m->ww - dc.w;
+               if(showsystray && m == selmon) {
+                       dc.x -= getsystraywidth();
+               }
                if(dc.x < x) {
                        dc.x = x;
                        dc.w = m->ww - x;
@@ -764,6 +854,7 @@ drawbars(void) {
 
        for(m = mons; m; m = m->next)
                drawbar(m);
+       updatesystray();
 }
 
 void
@@ -913,10 +1004,17 @@ getatomprop(Client *c, Atom prop) {
        unsigned long dl;
        unsigned char *p = NULL;
        Atom da, atom = None;
+       /* FIXME getatomprop should return the number of items and a pointer to
+        * the stored data instead of this workaround */
+       Atom req = XA_ATOM;
+       if(prop == xatom[XembedInfo])
+               req = xatom[XembedInfo];
 
-       if(XGetWindowProperty(dpy, c->win, prop, 0L, sizeof atom, False, XA_ATOM,
+       if(XGetWindowProperty(dpy, c->win, prop, 0L, sizeof atom, False, req,
                              &da, &di, &dl, &dl, &p) == Success && p) {
                atom = *(Atom *)p;
+               if(da == xatom[XembedInfo] && dl == 2)
+                       atom = ((Atom *)p)[1];
                XFree(p);
        }
        return atom;
@@ -958,6 +1056,15 @@ getstate(Window w) {
        return result;
 }
 
+unsigned int
+getsystraywidth() {
+       unsigned int w = 0;
+       Client *i;
+       if(showsystray)
+               for(i = systray->icons; i; w += i->w + systrayspacing, i = i->next) ;
+       return w ? w + systrayspacing : 1;
+}
+
 Bool
 gettextprop(Window w, Atom atom, char *text, unsigned int size) {
        char **list = NULL;
@@ -1092,7 +1199,7 @@ void
 killclient(const Arg *arg) {
        if(!selmon->sel)
                return;
-       if(!sendevent(selmon->sel, wmatom[WMDelete])) {
+       if(!sendevent(selmon->sel->win, wmatom[WMDelete], NoEventMask, wmatom[WMDelete], CurrentTime, 0 , 0, 0)) {
                XGrabServer(dpy);
                XSetErrorHandler(xerrordummy);
                XSetCloseDownMode(dpy, DestroyAll);
@@ -1178,6 +1285,12 @@ void
 maprequest(XEvent *e) {
        static XWindowAttributes wa;
        XMapRequestEvent *ev = &e->xmaprequest;
+       Client *i;
+       if((i = wintosystrayicon(ev->window))) {
+               sendevent(i->win, netatom[Xembed], StructureNotifyMask, CurrentTime, XEMBED_WINDOW_ACTIVATE, 0, systray->win, XEMBED_EMBEDDED_VERSION);
+               resizebarwin(selmon);
+               updatesystray();
+       }
 
        if(!XGetWindowAttributes(dpy, ev->window, &wa))
                return;
@@ -1294,6 +1407,16 @@ propertynotify(XEvent *e) {
        Window trans;
        XPropertyEvent *ev = &e->xproperty;
 
+       if((c = wintosystrayicon(ev->window))) {
+               if(ev->atom == XA_WM_NORMAL_HINTS) {
+                       updatesizehints(c);
+                       updatesystrayicongeom(c, c->w, c->h);
+               }
+               else
+                       updatesystrayiconstate(c, ev);
+               resizebarwin(selmon);
+               updatesystray();
+       }
        if((ev->window == root) && (ev->atom == XA_WM_NAME))
                updatestatus();
        else if(ev->state == PropertyDelete)
@@ -1343,12 +1466,33 @@ recttomon(int x, int y, int w, int h) {
 }
 
 void
+removesystrayicon(Client *i) {
+       Client **ii;
+
+       if(!showsystray || !i)
+               return;
+       for(ii = &systray->icons; *ii && *ii != i; ii = &(*ii)->next);
+       if(ii)
+               *ii = i->next;
+       free(i);
+}
+
+
+void
 resize(Client *c, int x, int y, int w, int h, Bool interact) {
        if(applysizehints(c, &x, &y, &w, &h, interact))
                resizeclient(c, x, y, w, h);
 }
 
 void
+resizebarwin(Monitor *m) {
+       unsigned int w = m->ww;
+       if(showsystray && m == selmon)
+               w -= getsystraywidth();
+       XMoveResizeWindow(dpy, m->barwin, m->wx, m->by, w, bh);
+}
+
+void
 resizeclient(Client *c, int x, int y, int w, int h) {
        XWindowChanges wc;
 
@@ -1415,6 +1559,18 @@ resizemouse(const Arg *arg) {
 }
 
 void
+resizerequest(XEvent *e) {
+       XResizeRequestEvent *ev = &e->xresizerequest;
+       Client *i;
+
+       if((i = wintosystrayicon(ev->window))) {
+               updatesystrayicongeom(i, ev->width, ev->height);
+               resizebarwin(selmon);
+               updatesystray();
+       }
+}
+
+void
 restack(Monitor *m) {
        Client *c;
        XEvent ev;
@@ -1498,25 +1654,35 @@ setclientstate(Client *c, long state) {
 }
 
 Bool
-sendevent(Client *c, Atom proto) {
+sendevent(Window w, Atom proto, int mask, long d0, long d1, long d2, long d3, long d4) {
        int n;
-       Atom *protocols;
+       Atom *protocols, mt;
        Bool exists = False;
        XEvent ev;
 
-       if(XGetWMProtocols(dpy, c->win, &protocols, &n)) {
-               while(!exists && n--)
-                       exists = protocols[n] == proto;
-               XFree(protocols);
+       if(proto == wmatom[WMTakeFocus] || proto == wmatom[WMDelete]) {
+               mt = wmatom[WMProtocols];
+               if(XGetWMProtocols(dpy, w, &protocols, &n)) {
+                       while(!exists && n--)
+                               exists = protocols[n] == proto;
+                       XFree(protocols);
+               }
+       }
+       else {
+               exists = True;
+               mt = proto;
        }
        if(exists) {
                ev.type = ClientMessage;
-               ev.xclient.window = c->win;
-               ev.xclient.message_type = wmatom[WMProtocols];
+               ev.xclient.window = w;
+               ev.xclient.message_type = mt;
                ev.xclient.format = 32;
-               ev.xclient.data.l[0] = proto;
-               ev.xclient.data.l[1] = CurrentTime;
-               XSendEvent(dpy, c->win, False, NoEventMask, &ev);
+               ev.xclient.data.l[0] = d0;
+               ev.xclient.data.l[1] = d1;
+               ev.xclient.data.l[2] = d2;
+               ev.xclient.data.l[3] = d3;
+               ev.xclient.data.l[4] = d4;
+               XSendEvent(dpy, w, False, mask, &ev);
        }
        return exists;
 }
@@ -1529,7 +1695,7 @@ setfocus(Client *c) {
                                XA_WINDOW, 32, PropModeReplace,
                                (unsigned char *) &(c->win), 1);
        }
-       sendevent(c, wmatom[WMTakeFocus]);
+       sendevent(c->win, wmatom[WMTakeFocus], NoEventMask, wmatom[WMTakeFocus], CurrentTime, 0, 0, 0);
 }
 
 void
@@ -1609,12 +1775,18 @@ setup(void) {
        wmatom[WMTakeFocus] = XInternAtom(dpy, "WM_TAKE_FOCUS", False);
        netatom[NetActiveWindow] = XInternAtom(dpy, "_NET_ACTIVE_WINDOW", False);
        netatom[NetSupported] = XInternAtom(dpy, "_NET_SUPPORTED", False);
+       netatom[NetSystemTray] = XInternAtom(dpy, "_NET_SYSTEM_TRAY_S0", False);
+       netatom[NetSystemTrayOP] = XInternAtom(dpy, "_NET_SYSTEM_TRAY_OPCODE", False);
+       netatom[NetSystemTrayOrientation] = XInternAtom(dpy, "_NET_SYSTEM_TRAY_ORIENTATION", False);
        netatom[NetWMName] = XInternAtom(dpy, "_NET_WM_NAME", False);
        netatom[NetWMState] = XInternAtom(dpy, "_NET_WM_STATE", False);
        netatom[NetWMFullscreen] = XInternAtom(dpy, "_NET_WM_STATE_FULLSCREEN", False);
        netatom[NetWMWindowType] = XInternAtom(dpy, "_NET_WM_WINDOW_TYPE", False);
        netatom[NetWMWindowTypeDialog] = XInternAtom(dpy, "_NET_WM_WINDOW_TYPE_DIALOG", False);
        netatom[NetClientList] = XInternAtom(dpy, "_NET_CLIENT_LIST", False);
+       xatom[Manager] = XInternAtom(dpy, "MANAGER", False);
+       xatom[Xembed] = XInternAtom(dpy, "_XEMBED", False);
+       xatom[XembedInfo] = XInternAtom(dpy, "_XEMBED_INFO", False);
        /* init cursors */
        cursor[CurNormal] = XCreateFontCursor(dpy, XC_left_ptr);
        cursor[CurResize] = XCreateFontCursor(dpy, XC_sizing);
@@ -1631,6 +1803,8 @@ setup(void) {
        XSetLineAttributes(dpy, dc.gc, 1, LineSolid, CapButt, JoinMiter);
        if(!dc.font.set)
                XSetFont(dpy, dc.gc, dc.font.xfont->fid);
+       /* init system tray */
+       updatesystray();
        /* init bars */
        updatebars();
        updatestatus();
@@ -1740,7 +1914,18 @@ void
 togglebar(const Arg *arg) {
        selmon->showbar = !selmon->showbar;
        updatebarpos(selmon);
-       XMoveResizeWindow(dpy, selmon->barwin, selmon->wx, selmon->by, selmon->ww, bh);
+       resizebarwin(selmon);
+       if(showsystray) {
+               XWindowChanges wc;
+               if(!selmon->showbar)
+                       wc.y = -bh;
+               else if(selmon->showbar) {
+                       wc.y = 0;
+                       if(!selmon->topbar)
+                               wc.y = selmon->mh - bh;
+               }
+               XConfigureWindow(dpy, systray->win, CWY, &wc);
+       }
        arrange(selmon);
 }
 
@@ -1830,11 +2015,18 @@ unmapnotify(XEvent *e) {
                else
                        unmanage(c, False);
        }
+       else if((c = wintosystrayicon(ev->window))) {
+               removesystrayicon(c);
+               resizebarwin(selmon);
+               updatesystray();
+       }
 }
 
 void
 updatebars(void) {
+       unsigned int w;
        Monitor *m;
+
        XSetWindowAttributes wa = {
                .override_redirect = True,
                .background_pixmap = ParentRelative,
@@ -1843,10 +2035,15 @@ updatebars(void) {
        for(m = mons; m; m = m->next) {
                if (m->barwin)
                        continue;
-               m->barwin = XCreateWindow(dpy, root, m->wx, m->by, m->ww, bh, 0, DefaultDepth(dpy, screen),
+               w = m->ww;
+               if(showsystray && m == selmon)
+                       w -= getsystraywidth();
+               m->barwin = XCreateWindow(dpy, root, m->wx, m->by, w, bh, 0, DefaultDepth(dpy, screen),
                                          CopyFromParent, DefaultVisual(dpy, screen),
                                          CWOverrideRedirect|CWBackPixmap|CWEventMask, &wa);
                XDefineCursor(dpy, m->barwin, cursor[CurNormal]);
+               if(showsystray && m == selmon)
+                       XMapRaised(dpy, systray->win);
                XMapRaised(dpy, m->barwin);
        }
 }
@@ -2040,6 +2237,107 @@ updatestatus(void) {
 }
 
 void
+updatesystrayicongeom(Client *i, int w, int h) {
+       if(i) {
+               i->h = bh;
+               if(w == h)
+                       i->w = bh;
+               else if(h == bh)
+                       i->w = w;
+               else
+                       i->w = (int) ((float)bh * ((float)w / (float)h));
+               applysizehints(i, &(i->x), &(i->y), &(i->w), &(i->h), False);
+               /* force icons into the systray dimenons if they don't want to */
+               if(i->h > bh) {
+                       if(i->w == i->h)
+                               i->w = bh;
+                       else
+                               i->w = (int) ((float)bh * ((float)i->w / (float)i->h));
+                       i->h = bh;
+               }
+       }
+}
+
+void
+updatesystrayiconstate(Client *i, XPropertyEvent *ev) {
+       long flags;
+       int code = 0;
+
+       if(!showsystray || !i || ev->atom != xatom[XembedInfo] ||
+                       !(flags = getatomprop(i, xatom[XembedInfo])))
+               return;
+
+       if(flags & XEMBED_MAPPED && !i->tags) {
+               i->tags = 1;
+               code = XEMBED_WINDOW_ACTIVATE;
+               XMapRaised(dpy, i->win);
+               setclientstate(i, NormalState);
+       }
+       else if(!(flags & XEMBED_MAPPED) && i->tags) {
+               i->tags = 0;
+               code = XEMBED_WINDOW_DEACTIVATE;
+               XUnmapWindow(dpy, i->win);
+               setclientstate(i, WithdrawnState);
+       }
+       else
+               return;
+       sendevent(i->win, xatom[Xembed], StructureNotifyMask, CurrentTime, code, 0,
+                       systray->win, XEMBED_EMBEDDED_VERSION);
+}
+
+void
+updatesystray(void) {
+       XSetWindowAttributes wa;
+       Client *i;
+       unsigned int x = selmon->mx + selmon->mw;
+       unsigned int w = 1;
+
+       if(!showsystray)
+               return;
+       if(!systray) {
+               /* init systray */
+               if(!(systray = (Systray *)calloc(1, sizeof(Systray))))
+                       die("fatal: could not malloc() %u bytes\n", sizeof(Systray));
+               systray->win = XCreateSimpleWindow(dpy, root, x, selmon->by, w, bh, 0, 0, dc.sel[ColBG]);
+               wa.event_mask        = ButtonPressMask | ExposureMask;
+               wa.override_redirect = True;
+               wa.background_pixmap = ParentRelative;
+               wa.background_pixel  = dc.norm[ColBG];
+               XSelectInput(dpy, systray->win, SubstructureNotifyMask);
+               XChangeProperty(dpy, systray->win, netatom[NetSystemTrayOrientation], XA_CARDINAL, 32,
+                               PropModeReplace, (unsigned char *)&systrayorientation, 1);
+               XChangeWindowAttributes(dpy, systray->win, CWEventMask|CWOverrideRedirect|CWBackPixel|CWBackPixmap, &wa);
+               XMapRaised(dpy, systray->win);
+               XSetSelectionOwner(dpy, netatom[NetSystemTray], systray->win, CurrentTime);
+               if(XGetSelectionOwner(dpy, netatom[NetSystemTray]) == systray->win) {
+                       sendevent(root, xatom[Manager], StructureNotifyMask, CurrentTime, netatom[NetSystemTray], systray->win, 0, 0);
+                       XSync(dpy, False);
+               }
+               else {
+                       fprintf(stderr, "dwm: unable to obtain system tray.\n");
+                       free(systray);
+                       systray = NULL;
+                       return;
+               }
+       }
+       for(w = 0, i = systray->icons; i; i = i->next) {
+               XMapRaised(dpy, i->win);
+               w += systrayspacing;
+               XMoveResizeWindow(dpy, i->win, (i->x = w), 0, i->w, i->h);
+               w += i->w;
+               if(i->mon != selmon)
+                       i->mon = selmon;
+       }
+       w = w ? w + systrayspacing : 1;
+       x -= w;
+       XMoveResizeWindow(dpy, systray->win, x, selmon->by, w, bh);
+       /* redraw background */
+       XSetForeground(dpy, dc.gc, dc.norm[ColBG]);
+       XFillRectangle(dpy, systray->win, dc.gc, 0, 0, w, bh);
+       XSync(dpy, False);
+}
+
+void
 updatewindowtype(Client *c) {
        Atom state = getatomprop(c, netatom[NetWMState]);
        Atom wtype = getatomprop(c, netatom[NetWMWindowType]);
@@ -2108,6 +2406,16 @@ wintomon(Window w) {
        return selmon;
 }
 
+Client *
+wintosystrayicon(Window w) {
+       Client *i = NULL;
+
+       if(!showsystray || !w)
+               return i;
+       for(i = systray->icons; i && i->win != w; i = i->next) ;
+       return i;
+}
+
 /* There's no way to check accesses to destroyed windows, thus those cases are
  * ignored (especially on UnmapNotify's).  Other types of errors call Xlibs
  * default error handler, which may call exit.  */