Merge branch 'dwm-savefloats-20181212-b69c870.diff' into patched
authorDaniel <thefekete@gmail.com>
Sat, 29 Dec 2018 01:02:01 +0000 (02:02 +0100)
committerDaniel <thefekete@gmail.com>
Sat, 29 Dec 2018 01:02:01 +0000 (02:02 +0100)
1  2 
dwm.c

diff --combined dwm.c
--- 1/dwm.c
--- 2/dwm.c
+++ b/dwm.c
  #define TAGMASK                 ((1 << LENGTH(tags)) - 1)
  #define TEXTW(X)                (drw_fontset_getwidth(drw, (X)) + lrpad)
  
 +#define SYSTEM_TRAY_REQUEST_DOCK    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 { SchemeNorm, SchemeSel }; /* color schemes */
  enum { NetSupported, NetWMName, NetWMState, NetWMCheck,
 +       NetSystemTray, NetSystemTrayOP, NetSystemTrayOrientation, NetSystemTrayOrientationHorz,
         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 */
@@@ -106,6 -88,7 +106,7 @@@ struct Client 
        char name[256];
        float mina, maxa;
        int x, y, w, h;
+       int sfx, sfy, sfw, sfh; /* stored float geometry, used on mode revert */
        int oldx, oldy, oldw, oldh;
        int basew, baseh, incw, inch, maxw, maxh, minw, minh;
        int bw, oldbw;
@@@ -159,12 -142,6 +160,12 @@@ typedef struct 
        int monitor;
  } Rule;
  
 +typedef struct Systray   Systray;
 +struct Systray {
 +      Window win;
 +      Client *icons;
 +};
 +
  /* function declarations */
  static void applyrules(Client *c);
  static int applysizehints(Client *c, int *x, int *y, int *w, int *h, int interact);
@@@ -193,10 -170,8 +194,10 @@@ 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 int getrootptr(int *x, int *y);
  static long getstate(Window w);
 +static unsigned int getsystraywidth();
  static int gettextprop(Window w, Atom atom, char *text, unsigned int size);
  static void grabbuttons(Client *c, int focused);
  static void grabkeys(void);
@@@ -214,16 -189,13 +215,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, int 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 int sendevent(Client *c, Atom proto);
 +static int 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);
@@@ -235,7 -207,6 +236,7 @@@ static void seturgent(Client *c, int ur
  static void showhide(Client *c);
  static void sigchld(int unused);
  static void spawn(const Arg *arg);
 +static Monitor *systraytomon(Monitor *m);
  static void tag(const Arg *arg);
  static void tagmon(const Arg *arg);
  static void tile(Monitor *);
@@@ -253,23 -224,18 +254,23 @@@ static int updategeom(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 updatetitle(Client *c);
  static void updatewindowtype(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 const char broken[] = "broken";
  static char stext[256];
  static int screen;
@@@ -292,10 -258,9 +293,10 @@@ static void (*handler[LASTEvent]) (XEve
        [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 int running = 1;
  static Cur *cursor[CurLast];
  static Clr **scheme;
@@@ -518,11 -483,6 +519,11 @@@ cleanup(void
        XUngrabKey(dpy, AnyKey, AnyModifier, root);
        while (mons)
                cleanupmon(mons);
 +      if (showsystray) {
 +              XUnmapWindow(dpy, systray->win);
 +              XDestroyWindow(dpy, systray->win);
 +              free(systray);
 +      }
        for (i = 0; i < CurLast; i++)
                drw_cur_free(drw, cursor[i]);
        for (i = 0; i < LENGTH(colors); i++)
@@@ -553,52 -513,9 +554,52 @@@ cleanupmon(Monitor *mon
  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));
 +                      if (!(c->win = cme->data.l[2])) {
 +                              free(c);
 +                              return;
 +                      }
 +                      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 color */
 +                      swa.background_pixel  = scheme[SchemeNorm][ColBg].pixel;
 +                      XChangeWindowAttributes(dpy, c->win, 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);
 +                      XSync(dpy, False);
 +                      resizebarwin(selmon);
 +                      updatesystray();
 +                      setclientstate(c, NormalState);
 +              }
 +              return;
 +      }
        if (!c)
                return;
        if (cme->message_type == netatom[NetWMState]) {
@@@ -651,7 -568,7 +652,7 @@@ configurenotify(XEvent *e
                                for (c = m->clients; c; c = c->next)
                                        if (c->isfullscreen)
                                                resizeclient(c, m->mx, m->my, m->mw, m->mh);
 -                              XMoveResizeWindow(dpy, m->barwin, m->wx, m->by, m->ww, bh);
 +                              resizebarwin(m);
                        }
                        focus(NULL);
                        arrange(NULL);
@@@ -736,11 -653,6 +737,11 @@@ destroynotify(XEvent *e
  
        if ((c = wintoclient(ev->window)))
                unmanage(c, 1);
 +      else if ((c = wintosystrayicon(ev->window))) {
 +              removesystrayicon(c);
 +              resizebarwin(selmon);
 +              updatesystray();
 +      }
  }
  
  void
@@@ -784,23 -696,19 +785,23 @@@ dirtomon(int dir
  void
  drawbar(Monitor *m)
  {
 -      int x, w, sw = 0;
 +      int x, w, sw = 0, stw = 0;
        int boxs = drw->fonts->h / 9;
        int boxw = drw->fonts->h / 6 + 2;
        unsigned int i, occ = 0, urg = 0;
        Client *c;
  
 +      if(showsystray && m == systraytomon(m))
 +              stw = getsystraywidth();
 +
        /* draw status first so it can be overdrawn by tags later */
        if (m == selmon) { /* status is only drawn on selected monitor */
                drw_setscheme(drw, scheme[SchemeNorm]);
 -              sw = TEXTW(stext) - lrpad + 2; /* 2px right padding */
 -              drw_text(drw, m->ww - sw, 0, sw, bh, 0, stext, 0);
 +              sw = TEXTW(stext) - lrpad / 2 + 2; /* 2px right padding */
 +              drw_text(drw, m->ww - sw - stw, 0, sw, bh, lrpad / 2 - 2, stext, 0);
        }
  
 +      resizebarwin(m);
        for (c = m->clients; c; c = c->next) {
                occ |= c->tags;
                if (c->isurgent)
        drw_setscheme(drw, scheme[SchemeNorm]);
        x = drw_text(drw, x, 0, w, bh, lrpad / 2, m->ltsymbol, 0);
  
 -      if ((w = m->ww - sw - x) > bh) {
 +      if ((w = m->ww - sw - stw - x) > bh) {
                if (m->sel) {
                        drw_setscheme(drw, scheme[m == selmon ? SchemeSel : SchemeNorm]);
                        drw_text(drw, x, 0, w, bh, lrpad / 2, m->sel->name, 0);
                        drw_rect(drw, x, 0, w, bh, 1, 1);
                }
        }
 -      drw_map(drw, m->barwin, 0, 0, m->ww, bh);
 +      drw_map(drw, m->barwin, 0, 0, m->ww - stw, bh);
  }
  
  void
@@@ -869,11 -777,8 +870,11 @@@ expose(XEvent *e
        Monitor *m;
        XExposeEvent *ev = &e->xexpose;
  
 -      if (ev->count == 0 && (m = wintomon(ev->window)))
 +      if (ev->count == 0 && (m = wintomon(ev->window))) {
                drawbar(m);
 +              if (m == selmon)
 +                      updatesystray();
 +      }
  }
  
  void
@@@ -958,17 -863,10 +959,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;
@@@ -1002,16 -900,6 +1003,16 @@@ 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;
 +}
 +
  int
  gettextprop(Window w, Atom atom, char *text, unsigned int size)
  {
@@@ -1116,7 -1004,7 +1117,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);
@@@ -1169,6 -1057,10 +1170,10 @@@ manage(Window w, XWindowAttributes *wa
        updatewindowtype(c);
        updatesizehints(c);
        updatewmhints(c);
+       c->sfx = c->x;
+       c->sfy = c->y;
+       c->sfw = c->w;
+       c->sfh = c->h;
        XSelectInput(dpy, w, EnterWindowMask|FocusChangeMask|PropertyChangeMask|StructureNotifyMask);
        grabbuttons(c, 0);
        if (!c->isfloating)
@@@ -1204,12 -1096,6 +1209,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;
@@@ -1334,16 -1220,6 +1339,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)
@@@ -1394,20 -1270,6 +1399,20 @@@ recttomon(int x, int y, int w, int h
        return r;
  }
  
 +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, int interact)
  {
                resizeclient(c, x, y, w, h);
  }
  
 +void
 +resizebarwin(Monitor *m) {
 +      unsigned int w = m->ww;
 +      if (showsystray && m == systraytomon(m))
 +              w -= getsystraywidth();
 +      XMoveResizeWindow(dpy, m->barwin, m->wx, m->by, w, bh);
 +}
 +
  void
  resizeclient(Client *c, int x, int y, int w, int h)
  {
@@@ -1495,19 -1349,6 +1500,19 @@@ 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)
  {
@@@ -1597,36 -1438,26 +1602,36 @@@ setclientstate(Client *c, long state
  }
  
  int
 -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;
        int exists = 0;
        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;
  }
@@@ -1640,7 -1471,7 +1645,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
@@@ -1729,10 -1560,6 +1734,10 @@@ 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[NetSystemTrayOrientationHorz] = XInternAtom(dpy, "_NET_SYSTEM_TRAY_ORIENTATION_HORZ", False);
        netatom[NetWMName] = XInternAtom(dpy, "_NET_WM_NAME", False);
        netatom[NetWMState] = XInternAtom(dpy, "_NET_WM_STATE", False);
        netatom[NetWMCheck] = XInternAtom(dpy, "_NET_SUPPORTING_WM_CHECK", 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] = drw_cur_create(drw, XC_left_ptr);
        cursor[CurResize] = drw_cur_create(drw, XC_sizing);
        scheme = ecalloc(LENGTH(colors), sizeof(Clr *));
        for (i = 0; i < LENGTH(colors); i++)
                scheme[i] = drw_scm_create(drw, colors[i], 3);
 +      /* init system tray */
 +      updatesystray();
        /* init bars */
        updatebars();
        updatestatus();
@@@ -1884,18 -1706,7 +1889,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);
  }
  
@@@ -1908,8 -1719,16 +1913,16 @@@ togglefloating(const Arg *arg
                return;
        selmon->sel->isfloating = !selmon->sel->isfloating || selmon->sel->isfixed;
        if (selmon->sel->isfloating)
-               resize(selmon->sel, selmon->sel->x, selmon->sel->y,
-                       selmon->sel->w, selmon->sel->h, 0);
+               /* restore last known float dimensions */
+               resize(selmon->sel, selmon->sel->sfx, selmon->sel->sfy,
+                      selmon->sel->sfw, selmon->sel->sfh, False);
+       else {
+               /* save last known float dimensions */
+               selmon->sel->sfx = selmon->sel->x;
+               selmon->sel->sfy = selmon->sel->y;
+               selmon->sel->sfw = selmon->sel->w;
+               selmon->sel->sfh = selmon->sel->h;
+       }
        arrange(selmon);
  }
  
@@@ -1990,18 -1809,11 +2003,18 @@@ unmapnotify(XEvent *e
                else
                        unmanage(c, 0);
        }
 +      else if ((c = wintosystrayicon(ev->window))) {
 +              /* KLUDGE! sometimes icons occasionally unmap their windows, but do
 +               * _not_ destroy them. We map those windows back */
 +              XMapRaised(dpy, c->win);
 +              updatesystray();
 +      }
  }
  
  void
  updatebars(void)
  {
 +      unsigned int w;
        Monitor *m;
        XSetWindowAttributes wa = {
                .override_redirect = True,
        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 == systraytomon(m))
 +                      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]->cursor);
 +              if (showsystray && m == systraytomon(m))
 +                      XMapRaised(dpy, systray->win);
                XMapRaised(dpy, m->barwin);
                XSetClassHint(dpy, m->barwin, &ch);
        }
@@@ -2196,121 -2003,6 +2209,121 @@@ updatestatus(void
        if (!gettextprop(root, XA_WM_NAME, stext, sizeof(stext)))
                strcpy(stext, "dwm-"VERSION);
        drawbar(selmon);
 +      updatesystray();
 +}
 +
 +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;
 +      XWindowChanges wc;
 +      Client *i;
 +      Monitor *m = systraytomon(NULL);
 +      unsigned int x = m->mx + m->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, m->by, w, bh, 0, 0, scheme[SchemeSel][ColBg].pixel);
 +              wa.event_mask        = ButtonPressMask | ExposureMask;
 +              wa.override_redirect = True;
 +              wa.background_pixel  = scheme[SchemeNorm][ColBg].pixel;
 +              XSelectInput(dpy, systray->win, SubstructureNotifyMask);
 +              XChangeProperty(dpy, systray->win, netatom[NetSystemTrayOrientation], XA_CARDINAL, 32,
 +                              PropModeReplace, (unsigned char *)&netatom[NetSystemTrayOrientationHorz], 1);
 +              XChangeWindowAttributes(dpy, systray->win, CWEventMask|CWOverrideRedirect|CWBackPixel, &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) {
 +              /* make sure the background color stays the same */
 +              wa.background_pixel  = scheme[SchemeNorm][ColBg].pixel;
 +              XChangeWindowAttributes(dpy, i->win, CWBackPixel, &wa);
 +              XMapRaised(dpy, i->win);
 +              w += systrayspacing;
 +              i->x = w;
 +              XMoveResizeWindow(dpy, i->win, i->x, 0, i->w, i->h);
 +              w += i->w;
 +              if (i->mon != m)
 +                      i->mon = m;
 +      }
 +      w = w ? w + systrayspacing : 1;
 +      x -= w;
 +      XMoveResizeWindow(dpy, systray->win, x, m->by, w, bh);
 +      wc.x = x; wc.y = m->by; wc.width = w; wc.height = bh;
 +      wc.stack_mode = Above; wc.sibling = m->barwin;
 +      XConfigureWindow(dpy, systray->win, CWX|CWY|CWWidth|CWHeight|CWSibling|CWStackMode, &wc);
 +      XMapWindow(dpy, systray->win);
 +      XMapSubwindows(dpy, systray->win);
 +      /* redraw background */
 +      XSetForeground(dpy, drw->gc, scheme[SchemeNorm][ColBg].pixel);
 +      XFillRectangle(dpy, systray->win, drw->gc, 0, 0, w, bh);
 +      XSync(dpy, False);
  }
  
  void
@@@ -2378,16 -2070,6 +2391,16 @@@ wintoclient(Window w
        return NULL;
  }
  
 +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;
 +}
 +
  Monitor *
  wintomon(Window w)
  {
@@@ -2441,22 -2123,6 +2454,22 @@@ xerrorstart(Display *dpy, XErrorEvent *
        return -1;
  }
  
 +Monitor *
 +systraytomon(Monitor *m) {
 +      Monitor *t;
 +      int i, n;
 +      if(!systraypinning) {
 +              if(!m)
 +                      return selmon;
 +              return m == selmon ? m : NULL;
 +      }
 +      for(n = 1, t = mons; t && t->next; n++, t = t->next) ;
 +      for(i = 1, t = mons; t && t->next && i < systraypinning; i++, t = t->next) ;
 +      if(systraypinningfailfirst && n < systraypinning)
 +              return mons;
 +      return t;
 +}
 +
  void
  zoom(const Arg *arg)
  {