Xinqi Bao's Git

projects / dwm.git / blobdiff
summary | log | commit | diff | tree
raw | inline | side by side
applied Hiltjo Posthuma's line saver patch
[dwm.git] / dwm.c
diff --git a/dwm.c b/dwm.c
index 2b4d6b0..4b43a18 100644 (file)
--- a/dwm.c
+++ b/dwm.c
@@ -57,7 +57,8 @@
 /* enums */
 enum { CurNormal, CurResize, CurMove, CurLast };        /* cursor */
 enum { ColBorder, ColFG, ColBG, ColLast };              /* color */
 /* enums */
 enum { CurNormal, CurResize, CurMove, CurLast };        /* cursor */
 enum { ColBorder, ColFG, ColBG, ColLast };              /* color */
-enum { NetSupported, NetWMName, NetLast };              /* EWMH atoms */
+enum { NetSupported, NetWMName, NetWMState,
+       NetWMFullscreen, NetLast };                      /* EWMH atoms */
 enum { WMProtocols, WMDelete, WMState, WMLast };        /* default atoms */
 enum { ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle,
        ClkClientWin, ClkRootWin, ClkLast };             /* clicks */
 enum { WMProtocols, WMDelete, WMState, WMLast };        /* default atoms */
 enum { ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle,
        ClkClientWin, ClkRootWin, ClkLast };             /* clicks */
@@ -83,10 +84,11 @@ struct Client {
        char name[256];
        float mina, maxa;
        int x, y, w, h;
        char name[256];
        float mina, maxa;
        int x, y, w, h;
+       int oldx, oldy, oldw, oldh;
        int basew, baseh, incw, inch, maxw, maxh, minw, minh;
        int bw, oldbw;
        unsigned int tags;
        int basew, baseh, incw, inch, maxw, maxh, minw, minh;
        int bw, oldbw;
        unsigned int tags;
-       Bool isfixed, isfloating, isurgent;
+       Bool isfixed, isfloating, isurgent, oldstate;
        Client *next;
        Client *snext;
        Monitor *mon;
        Client *next;
        Client *snext;
        Monitor *mon;
@@ -121,7 +123,7 @@ typedef struct {
 } Layout;
 
 struct Monitor {
 } Layout;
 
 struct Monitor {
-       const char *ltsymbol;
+       char ltsymbol[16];
        float mfact;
        int num;
        int by;               /* bar geometry */
        float mfact;
        int num;
        int by;               /* bar geometry */
@@ -152,17 +154,20 @@ typedef struct {
 /* function declarations */
 static void applyrules(Client *c);
 static Bool applysizehints(Client *c, int *x, int *y, int *w, int *h, Bool interact);
 /* function declarations */
 static void applyrules(Client *c);
 static Bool applysizehints(Client *c, int *x, int *y, int *w, int *h, Bool interact);
-static void arrange(void);
+static void arrange(Monitor *m);
+static void arrangemon(Monitor *m);
 static void attach(Client *c);
 static void attachstack(Client *c);
 static void buttonpress(XEvent *e);
 static void checkotherwm(void);
 static void cleanup(void);
 static void attach(Client *c);
 static void attachstack(Client *c);
 static void buttonpress(XEvent *e);
 static void checkotherwm(void);
 static void cleanup(void);
-static void cleanupmons(void);
+static void cleanupmon(Monitor *mon);
 static void clearurgent(Client *c);
 static void clearurgent(Client *c);
+static void clientmessage(XEvent *e);
 static void configure(Client *c);
 static void configurenotify(XEvent *e);
 static void configurerequest(XEvent *e);
 static void configure(Client *c);
 static void configurenotify(XEvent *e);
 static void configurerequest(XEvent *e);
+static Monitor *createmon(void);
 static void destroynotify(XEvent *e);
 static void detach(Client *c);
 static void detachstack(Client *c);
 static void destroynotify(XEvent *e);
 static void detach(Client *c);
 static void detachstack(Client *c);
@@ -198,6 +203,7 @@ static Monitor *ptrtomon(int x, int y);
 static void propertynotify(XEvent *e);
 static void quit(const Arg *arg);
 static void resize(Client *c, int x, int y, int w, int h, Bool interact);
 static void propertynotify(XEvent *e);
 static void quit(const Arg *arg);
 static void resize(Client *c, int x, int y, int w, int h, Bool interact);
+static void resizeclient(Client *c, int x, int y, int w, int h);
 static void resizemouse(const Arg *arg);
 static void restack(Monitor *m);
 static void run(void);
 static void resizemouse(const Arg *arg);
 static void restack(Monitor *m);
 static void run(void);
@@ -218,7 +224,7 @@ static void togglebar(const Arg *arg);
 static void togglefloating(const Arg *arg);
 static void toggletag(const Arg *arg);
 static void toggleview(const Arg *arg);
 static void togglefloating(const Arg *arg);
 static void toggletag(const Arg *arg);
 static void toggleview(const Arg *arg);
-static void unfocus(Client *c);
+static void unfocus(Client *c, Bool setfocus);
 static void unmanage(Client *c, Bool destroyed);
 static void unmapnotify(XEvent *e);
 static Bool updategeom(void);
 static void unmanage(Client *c, Bool destroyed);
 static void unmapnotify(XEvent *e);
 static Bool updategeom(void);
@@ -247,6 +253,7 @@ static int (*xerrorxlib)(Display *, XErrorEvent *);
 static unsigned int numlockmask = 0;
 static void (*handler[LASTEvent]) (XEvent *) = {
        [ButtonPress] = buttonpress,
 static unsigned int numlockmask = 0;
 static void (*handler[LASTEvent]) (XEvent *) = {
        [ButtonPress] = buttonpress,
+       [ClientMessage] = clientmessage,
        [ConfigureRequest] = configurerequest,
        [ConfigureNotify] = configurenotify,
        [DestroyNotify] = destroynotify,
        [ConfigureRequest] = configurerequest,
        [ConfigureNotify] = configurenotify,
        [DestroyNotify] = destroynotify,
@@ -378,18 +385,24 @@ applysizehints(Client *c, int *x, int *y, int *w, int *h, Bool interact) {
 }
 
 void
 }
 
 void
-arrange(void) {
-       Monitor *m;
-
-       for(m = mons; m; m = m->next)
+arrange(Monitor *m) {
+       if(m)
+               showhide(m->stack);
+       else for(m = mons; m; m = m->next)
                showhide(m->stack);
        focus(NULL);
                showhide(m->stack);
        focus(NULL);
-       for(m = mons; m; m = m->next) {
-               m->ltsymbol = m->lt[m->sellt]->symbol;
-               if(m->lt[m->sellt]->arrange)
-                       m->lt[m->sellt]->arrange(m);
-               restack(m);
-       }
+       if(m)
+               arrangemon(m);
+       else for(m = mons; m; m = m->next)
+               arrangemon(m);
+}
+
+void
+arrangemon(Monitor *m) {
+       strncpy(m->ltsymbol, m->lt[m->sellt]->symbol, sizeof m->ltsymbol);
+       if(m->lt[m->sellt]->arrange)
+               m->lt[m->sellt]->arrange(m);
+       restack(m);
 }
 
 void
 }
 
 void
@@ -415,7 +428,7 @@ buttonpress(XEvent *e) {
        click = ClkRootWin;
        /* focus monitor if necessary */
        if((m = wintomon(ev->window)) && m != selmon) {
        click = ClkRootWin;
        /* focus monitor if necessary */
        if((m = wintomon(ev->window)) && m != selmon) {
-               unfocus(selmon->sel);
+               unfocus(selmon->sel, True);
                selmon = m;
                focus(NULL);
        }
                selmon = m;
                focus(NULL);
        }
@@ -479,22 +492,25 @@ cleanup(void) {
        XFreeCursor(dpy, cursor[CurNormal]);
        XFreeCursor(dpy, cursor[CurResize]);
        XFreeCursor(dpy, cursor[CurMove]);
        XFreeCursor(dpy, cursor[CurNormal]);
        XFreeCursor(dpy, cursor[CurResize]);
        XFreeCursor(dpy, cursor[CurMove]);
-       cleanupmons();
+       while(mons)
+               cleanupmon(mons);
        XSync(dpy, False);
        XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime);
 }
 
 void
        XSync(dpy, False);
        XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime);
 }
 
 void
-cleanupmons(void) {
+cleanupmon(Monitor *mon) {
        Monitor *m;
 
        Monitor *m;
 
-       while(mons) {
-               m = mons->next;
-               XUnmapWindow(dpy, mons->barwin);
-               XDestroyWindow(dpy, mons->barwin);
-               free(mons);
-               mons = m;
+       if(mon == mons)
+               mons = mons->next;
+       else {
+               for(m = mons; m && m->next != mon; m = m->next);
+               m->next = mon->next;
        }
        }
+       XUnmapWindow(dpy, mon->barwin);
+       XDestroyWindow(dpy, mon->barwin);
+       free(mon);
 }
 
 void
 }
 
 void
@@ -542,7 +558,7 @@ configurenotify(XEvent *e) {
                        updatebars();
                        for(m = mons; m; m = m->next)
                                XMoveResizeWindow(dpy, m->barwin, m->wx, m->by, m->ww, bh);
                        updatebars();
                        for(m = mons; m; m = m->next)
                                XMoveResizeWindow(dpy, m->barwin, m->wx, m->by, m->ww, bh);
-                       arrange();
+                       arrange(NULL);
                }
        }
 }
                }
        }
 }
@@ -592,6 +608,22 @@ configurerequest(XEvent *e) {
        XSync(dpy, False);
 }
 
        XSync(dpy, False);
 }
 
+Monitor *
+createmon(void) {
+       Monitor *m;
+
+       if(!(m = (Monitor *)calloc(1, sizeof(Monitor))))
+               die("fatal: could not malloc() %u bytes\n", sizeof(Monitor));
+       m->tagset[0] = m->tagset[1] = 1;
+       m->mfact = mfact;
+       m->showbar = showbar;
+       m->topbar = topbar;
+       m->lt[0] = &layouts[0];
+       m->lt[1] = &layouts[1 % LENGTH(layouts)];
+       strncpy(m->ltsymbol, layouts[0].symbol, sizeof m->ltsymbol);
+       return m;
+}
+
 void
 destroynotify(XEvent *e) {
        Client *c;
 void
 destroynotify(XEvent *e) {
        Client *c;
@@ -758,20 +790,16 @@ drawtext(const char *text, unsigned long col[ColLast], Bool invert) {
 
 void
 enternotify(XEvent *e) {
 
 void
 enternotify(XEvent *e) {
-       Client *c;
        Monitor *m;
        XCrossingEvent *ev = &e->xcrossing;
 
        if((ev->mode != NotifyNormal || ev->detail == NotifyInferior) && ev->window != root)
                return;
        if((m = wintomon(ev->window)) && m != selmon) {
        Monitor *m;
        XCrossingEvent *ev = &e->xcrossing;
 
        if((ev->mode != NotifyNormal || ev->detail == NotifyInferior) && ev->window != root)
                return;
        if((m = wintomon(ev->window)) && m != selmon) {
-               unfocus(selmon->sel);
+               unfocus(selmon->sel, True);
                selmon = m;
        }
                selmon = m;
        }
-       if((c = wintoclient(ev->window)))
-               focus(c);
-       else
-               focus(NULL);
+       focus(wintoclient(ev->window));
 }
 
 void
 }
 
 void
@@ -787,8 +815,9 @@ void
 focus(Client *c) {
        if(!c || !ISVISIBLE(c))
                for(c = selmon->stack; c && !ISVISIBLE(c); c = c->snext);
 focus(Client *c) {
        if(!c || !ISVISIBLE(c))
                for(c = selmon->stack; c && !ISVISIBLE(c); c = c->snext);
-       if(selmon->sel)
-               unfocus(selmon->sel);
+       /* was if(selmon->sel) */
+       if(selmon->sel && selmon->sel != c)
+               unfocus(selmon->sel, False);
        if(c) {
                if(c->mon != selmon)
                        selmon = c->mon;
        if(c) {
                if(c->mon != selmon)
                        selmon = c->mon;
@@ -820,8 +849,9 @@ focusmon(const Arg *arg) {
 
        if(!mons->next)
                return;
 
        if(!mons->next)
                return;
-       m = dirtomon(arg->i);
-       unfocus(selmon->sel);
+       if((m = dirtomon(arg->i)) == selmon)
+               return;
+       unfocus(selmon->sel, True);
        selmon = m;
        focus(NULL);
 }
        selmon = m;
        focus(NULL);
 }
@@ -873,15 +903,14 @@ getrootptr(int *x, int *y) {
 
 long
 getstate(Window w) {
 
 long
 getstate(Window w) {
-       int format, status;
+       int format;
        long result = -1;
        unsigned char *p = NULL;
        unsigned long n, extra;
        Atom real;
 
        long result = -1;
        unsigned char *p = NULL;
        unsigned long n, extra;
        Atom real;
 
-       status = XGetWindowProperty(dpy, w, wmatom[WMState], 0L, 2L, False, wmatom[WMState],
-                                   &real, &format, &n, &extra, (unsigned char **)&p);
-       if(status != Success)
+       if(XGetWindowProperty(dpy, w, wmatom[WMState], 0L, 2L, False, wmatom[WMState],
+                             &real, &format, &n, &extra, (unsigned char **)&p) != Success)
                return -1;
        if(n != 0)
                result = *p;
                return -1;
        if(n != 0)
                result = *p;
@@ -1005,6 +1034,19 @@ isprotodel(Client *c) {
        return ret;
 }
 
        return ret;
 }
 
+#ifdef XINERAMA
+static Bool
+isuniquegeom(XineramaScreenInfo *unique, size_t len, XineramaScreenInfo *info) {
+       unsigned int i;
+
+       for(i = 0; i < len; i++)
+               if(unique[i].x_org == info->x_org && unique[i].y_org == info->y_org
+               && unique[i].width == info->width && unique[i].height == info->height)
+                       return False;
+       return True;
+}
+#endif /* XINERAMA */
+
 void
 keypress(XEvent *e) {
        unsigned int i;
 void
 keypress(XEvent *e) {
        unsigned int i;
@@ -1069,12 +1111,13 @@ manage(Window w, XWindowAttributes *wa) {
                applyrules(c);
        }
        /* geometry */
                applyrules(c);
        }
        /* geometry */
-       c->x = wa->x + c->mon->wx;
-       c->y = wa->y + c->mon->wy;
-       c->w = wa->width;
-       c->h = wa->height;
+       c->x = c->oldx = wa->x + c->mon->wx;
+       c->y = c->oldy = wa->y + c->mon->wy;
+       c->w = c->oldw = wa->width;
+       c->h = c->oldh = wa->height;
        c->oldbw = wa->border_width;
        if(c->w == c->mon->mw && c->h == c->mon->mh) {
        c->oldbw = wa->border_width;
        if(c->w == c->mon->mw && c->h == c->mon->mh) {
+               c->isfloating = 1;
                c->x = c->mon->mx;
                c->y = c->mon->my;
                c->bw = 0;
                c->x = c->mon->mx;
                c->y = c->mon->my;
                c->bw = 0;
@@ -1098,7 +1141,7 @@ manage(Window w, XWindowAttributes *wa) {
        XSelectInput(dpy, w, EnterWindowMask|FocusChangeMask|PropertyChangeMask|StructureNotifyMask);
        grabbuttons(c, False);
        if(!c->isfloating)
        XSelectInput(dpy, w, EnterWindowMask|FocusChangeMask|PropertyChangeMask|StructureNotifyMask);
        grabbuttons(c, False);
        if(!c->isfloating)
-               c->isfloating = trans != None || c->isfixed;
+               c->isfloating = c->oldstate = trans != None || c->isfixed;
        if(c->isfloating)
                XRaiseWindow(dpy, c->win);
        attach(c);
        if(c->isfloating)
                XRaiseWindow(dpy, c->win);
        attach(c);
@@ -1106,7 +1149,7 @@ manage(Window w, XWindowAttributes *wa) {
        XMoveResizeWindow(dpy, c->win, c->x + 2 * sw, c->y, c->w, c->h); /* some windows require this */
        XMapWindow(dpy, c->win);
        setclientstate(c, NormalState);
        XMoveResizeWindow(dpy, c->win, c->x + 2 * sw, c->y, c->w, c->h); /* some windows require this */
        XMapWindow(dpy, c->win);
        setclientstate(c, NormalState);
-       arrange();
+       arrange(c->mon);
 }
 
 void
 }
 
 void
@@ -1133,17 +1176,14 @@ maprequest(XEvent *e) {
 
 void
 monocle(Monitor *m) {
 
 void
 monocle(Monitor *m) {
-       static char ntext[8];
        unsigned int n = 0;
        Client *c;
 
        for(c = m->clients; c; c = c->next)
                if(ISVISIBLE(c))
                        n++;
        unsigned int n = 0;
        Client *c;
 
        for(c = m->clients; c; c = c->next)
                if(ISVISIBLE(c))
                        n++;
-       if(n > 0) { /* override layout symbol */
-               snprintf(ntext, sizeof ntext, "[%d]", n);
-               m->ltsymbol = ntext;
-       }
+       if(n > 0) /* override layout symbol */
+               snprintf(m->ltsymbol, sizeof m->ltsymbol, "[%d]", n);
        for(c = nexttiled(m->clients); c; c = nexttiled(c->next))
                resize(c, m->wx, m->wy, m->ww - 2 * c->bw, m->wh - 2 * c->bw, False);
 }
        for(c = nexttiled(m->clients); c; c = nexttiled(c->next))
                resize(c, m->wx, m->wy, m->ww - 2 * c->bw, m->wh - 2 * c->bw, False);
 }
@@ -1235,7 +1275,7 @@ propertynotify(XEvent *e) {
                case XA_WM_TRANSIENT_FOR:
                        XGetTransientForHint(dpy, c->win, &trans);
                        if(!c->isfloating && (c->isfloating = (wintoclient(trans) != NULL)))
                case XA_WM_TRANSIENT_FOR:
                        XGetTransientForHint(dpy, c->win, &trans);
                        if(!c->isfloating && (c->isfloating = (wintoclient(trans) != NULL)))
-                               arrange();
+                               arrange(c->mon);
                        break;
                case XA_WM_NORMAL_HINTS:
                        updatesizehints(c);
                        break;
                case XA_WM_NORMAL_HINTS:
                        updatesizehints(c);
@@ -1253,6 +1293,39 @@ propertynotify(XEvent *e) {
        }
 }
 
        }
 }
 
+void
+clientmessage(XEvent *e) {
+       XClientMessageEvent *cme = &e->xclient;
+       Client *c;
+
+       if((c = wintoclient(cme->window))
+       && (cme->message_type == netatom[NetWMState] && cme->data.l[1] == netatom[NetWMFullscreen]))
+       {
+               if(cme->data.l[0]) {
+                       XChangeProperty(dpy, cme->window, netatom[NetWMState], XA_ATOM, 32,
+                                       PropModeReplace, (unsigned char*)&netatom[NetWMFullscreen], 1);
+                       c->oldstate = c->isfloating;
+                       c->oldbw = c->bw;
+                       c->bw = 0;
+                       c->isfloating = 1;
+                       resizeclient(c, c->mon->mx, c->mon->my, c->mon->mw, c->mon->mh);
+                       XRaiseWindow(dpy, c->win);
+               }
+               else {
+                       XChangeProperty(dpy, cme->window, netatom[NetWMState], XA_ATOM, 32,
+                                       PropModeReplace, (unsigned char*)0, 0);
+                       c->isfloating = c->oldstate;
+                       c->bw = c->oldbw;
+                       c->x = c->oldx;
+                       c->y = c->oldy;
+                       c->w = c->oldw;
+                       c->h = c->oldh;
+                       resizeclient(c, c->x, c->y, c->w, c->h);
+                       arrange(c->mon);
+               }
+       }
+}
+
 void
 quit(const Arg *arg) {
        running = False;
 void
 quit(const Arg *arg) {
        running = False;
@@ -1260,18 +1333,22 @@ quit(const Arg *arg) {
 
 void
 resize(Client *c, int x, int y, int w, int h, Bool interact) {
 
 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
+resizeclient(Client *c, int x, int y, int w, int h) {
        XWindowChanges wc;
 
        XWindowChanges wc;
 
-       if(applysizehints(c, &x, &y, &w, &h, interact)) {
-               c->x = wc.x = x;
-               c->y = wc.y = y;
-               c->w = wc.width = w;
-               c->h = wc.height = h;
-               wc.border_width = c->bw;
-               XConfigureWindow(dpy, c->win, CWX|CWY|CWWidth|CWHeight|CWBorderWidth, &wc);
-               configure(c);
-               XSync(dpy, False);
-       }
+       c->oldx = c->x; c->x = wc.x = x;
+       c->oldy = c->y; c->y = wc.y = y;
+       c->oldw = c->w; c->w = wc.width = w;
+       c->oldh = c->h; c->h = wc.height = h;
+       wc.border_width = c->bw;
+       XConfigureWindow(dpy, c->win, CWX|CWY|CWWidth|CWHeight|CWBorderWidth, &wc);
+       configure(c);
+       XSync(dpy, False);
 }
 
 void
 }
 
 void
@@ -1330,7 +1407,7 @@ restack(Monitor *m) {
        XEvent ev;
        XWindowChanges wc;
 
        XEvent ev;
        XWindowChanges wc;
 
-       drawbars();
+       drawbar(m);
        if(!m->sel)
                return;
        if(m->sel->isfloating || !m->lt[m->sellt]->arrange)
        if(!m->sel)
                return;
        if(m->sel->isfloating || !m->lt[m->sellt]->arrange)
@@ -1351,12 +1428,12 @@ restack(Monitor *m) {
 void
 run(void) {
        XEvent ev;
 void
 run(void) {
        XEvent ev;
-
        /* main event loop */
        XSync(dpy, False);
        /* main event loop */
        XSync(dpy, False);
-       while(running && !XNextEvent(dpy, &ev))
+       while(running && !XNextEvent(dpy, &ev)) {
                if(handler[ev.type])
                        handler[ev.type](&ev); /* call handler */
                if(handler[ev.type])
                        handler[ev.type](&ev); /* call handler */
+       }
 }
 
 void
 }
 
 void
@@ -1389,7 +1466,7 @@ void
 sendmon(Client *c, Monitor *m) {
        if(c->mon == m)
                return;
 sendmon(Client *c, Monitor *m) {
        if(c->mon == m)
                return;
-       unfocus(c);
+       unfocus(c, True);
        detach(c);
        detachstack(c);
        c->mon = m;
        detach(c);
        detachstack(c);
        c->mon = m;
@@ -1397,7 +1474,7 @@ sendmon(Client *c, Monitor *m) {
        attach(c);
        attachstack(c);
        focus(NULL);
        attach(c);
        attachstack(c);
        focus(NULL);
-       arrange();
+       arrange(NULL);
 }
 
 void
 }
 
 void
@@ -1414,10 +1491,11 @@ setlayout(const Arg *arg) {
                selmon->sellt ^= 1;
        if(arg && arg->v)
                selmon->lt[selmon->sellt] = (Layout *)arg->v;
                selmon->sellt ^= 1;
        if(arg && arg->v)
                selmon->lt[selmon->sellt] = (Layout *)arg->v;
+       strncpy(selmon->ltsymbol, selmon->lt[selmon->sellt]->symbol, sizeof selmon->ltsymbol);
        if(selmon->sel)
        if(selmon->sel)
-               arrange();
+               arrange(selmon);
        else
        else
-               drawbars();
+               drawbar(selmon);
 }
 
 /* arg > 1.0 will set mfact absolutly */
 }
 
 /* arg > 1.0 will set mfact absolutly */
@@ -1431,7 +1509,7 @@ setmfact(const Arg *arg) {
        if(f < 0.1 || f > 0.9)
                return;
        selmon->mfact = f;
        if(f < 0.1 || f > 0.9)
                return;
        selmon->mfact = f;
-       arrange();
+       arrange(selmon);
 }
 
 void
 }
 
 void
@@ -1455,6 +1533,8 @@ setup(void) {
        wmatom[WMState] = XInternAtom(dpy, "WM_STATE", False);
        netatom[NetSupported] = XInternAtom(dpy, "_NET_SUPPORTED", False);
        netatom[NetWMName] = XInternAtom(dpy, "_NET_WM_NAME", False);
        wmatom[WMState] = XInternAtom(dpy, "WM_STATE", False);
        netatom[NetSupported] = XInternAtom(dpy, "_NET_SUPPORTED", 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);
        /* init cursors */
        cursor[CurNormal] = XCreateFontCursor(dpy, XC_left_ptr);
        cursor[CurResize] = XCreateFontCursor(dpy, XC_sizing);
        /* init cursors */
        cursor[CurNormal] = XCreateFontCursor(dpy, XC_left_ptr);
        cursor[CurResize] = XCreateFontCursor(dpy, XC_sizing);
@@ -1528,7 +1608,7 @@ void
 tag(const Arg *arg) {
        if(selmon->sel && arg->ui & TAGMASK) {
                selmon->sel->tags = arg->ui & TAGMASK;
 tag(const Arg *arg) {
        if(selmon->sel && arg->ui & TAGMASK) {
                selmon->sel->tags = arg->ui & TAGMASK;
-               arrange();
+               arrange(selmon);
        }
 }
 
        }
 }
 
@@ -1585,7 +1665,7 @@ togglebar(const Arg *arg) {
        selmon->showbar = !selmon->showbar;
        updatebarpos(selmon);
        XMoveResizeWindow(dpy, selmon->barwin, selmon->wx, selmon->by, selmon->ww, bh);
        selmon->showbar = !selmon->showbar;
        updatebarpos(selmon);
        XMoveResizeWindow(dpy, selmon->barwin, selmon->wx, selmon->by, selmon->ww, bh);
-       arrange();
+       arrange(selmon);
 }
 
 void
 }
 
 void
@@ -1596,7 +1676,7 @@ togglefloating(const Arg *arg) {
        if(selmon->sel->isfloating)
                resize(selmon->sel, selmon->sel->x, selmon->sel->y,
                       selmon->sel->w, selmon->sel->h, False);
        if(selmon->sel->isfloating)
                resize(selmon->sel, selmon->sel->x, selmon->sel->y,
                       selmon->sel->w, selmon->sel->h, False);
-       arrange();
+       arrange(selmon);
 }
 
 void
 }
 
 void
@@ -1608,7 +1688,7 @@ toggletag(const Arg *arg) {
        newtags = selmon->sel->tags ^ (arg->ui & TAGMASK);
        if(newtags) {
                selmon->sel->tags = newtags;
        newtags = selmon->sel->tags ^ (arg->ui & TAGMASK);
        if(newtags) {
                selmon->sel->tags = newtags;
-               arrange();
+               arrange(selmon);
        }
 }
 
        }
 }
 
@@ -1618,21 +1698,23 @@ toggleview(const Arg *arg) {
 
        if(newtagset) {
                selmon->tagset[selmon->seltags] = newtagset;
 
        if(newtagset) {
                selmon->tagset[selmon->seltags] = newtagset;
-               arrange();
+               arrange(selmon);
        }
 }
 
 void
        }
 }
 
 void
-unfocus(Client *c) {
+unfocus(Client *c, Bool setfocus) {
        if(!c)
                return;
        grabbuttons(c, False);
        XSetWindowBorder(dpy, c->win, dc.norm[ColBorder]);
        if(!c)
                return;
        grabbuttons(c, False);
        XSetWindowBorder(dpy, c->win, dc.norm[ColBorder]);
-       XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime);
+       if(setfocus)
+               XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime);
 }
 
 void
 unmanage(Client *c, Bool destroyed) {
 }
 
 void
 unmanage(Client *c, Bool destroyed) {
+       Monitor *m = c->mon;
        XWindowChanges wc;
 
        /* The server grab construct avoids race conditions. */
        XWindowChanges wc;
 
        /* The server grab construct avoids race conditions. */
@@ -1651,7 +1733,7 @@ unmanage(Client *c, Bool destroyed) {
        }
        free(c);
        focus(NULL);
        }
        free(c);
        focus(NULL);
-       arrange();
+       arrange(m);
 }
 
 void
 }
 
 void
@@ -1695,131 +1777,84 @@ updatebarpos(Monitor *m) {
 
 Bool
 updategeom(void) {
 
 Bool
 updategeom(void) {
-       int i, j, nn = 1, n = 1;
-       Client *c;
-       Monitor *newmons = NULL, *m = NULL, *tm;
+       Bool dirty = False;
 
 #ifdef XINERAMA
 
 #ifdef XINERAMA
-       XineramaScreenInfo *info = NULL;
-       Bool *flags = NULL;
-
-       if(XineramaIsActive(dpy))
-               info = XineramaQueryScreens(dpy, &n);
-       flags = (Bool *)malloc(sizeof(Bool) * n);
-       for(i = 0; i < n; i++)
-               flags[i] = False;
-       /* next double-loop seeks any combination of retrieved Xinerama info
-        * with existing monitors, this is used to avoid unnecessary
-        * re-allocations of monitor structs */
-       for(i = 0, nn = n; i < n; i++)
-               for(j = 0, m = mons; m; m = m->next, j++)
-                       if(!flags[j]) {
-                               if((flags[j] = (
-                                       info[i].x_org == m->mx
-                                       && info[i].y_org == m->my
-                                       && info[i].width == m->mw
-                                       && info[i].height == m->mh)
-                               ))
-                                       --nn;
-                       }
-       if(nn == 0) { /* no need to re-allocate monitors */
-               j = 0;
-               for(i = 0, m = mons; m; m = m->next, i++) {
-                       m->num = info[i].screen_number;
-                       if(info[i].x_org != m->mx
-                       || info[i].y_org != m->my
-                       || info[i].width != m->mw
-                       || info[i].height != m->mh)
-                       {
-                               m->mx = m->wx = info[i].x_org;
-                               m->my = m->wy = info[i].y_org;
-                               m->mw = m->ww = info[i].width;
-                               m->mh = m->wh = info[i].height;
-                               updatebarpos(m);
-                               j++;
-                       }
-               }
+       if(XineramaIsActive(dpy)) {
+               int i, j, n, nn;
+               Client *c;
+               Monitor *m;
+               XineramaScreenInfo *info = XineramaQueryScreens(dpy, &nn);
+               XineramaScreenInfo *unique = NULL;
+
+               for(n = 0, m = mons; m; m = m->next, n++);
+               /* only consider unique geometries as separate screens */
+               if(!(unique = (XineramaScreenInfo *)malloc(sizeof(XineramaScreenInfo) * nn)))
+                       die("fatal: could not malloc() %u bytes\n", sizeof(XineramaScreenInfo) * nn);
+               for(i = 0, j = 0; i < nn; i++)
+                       if(isuniquegeom(unique, j, &info[i]))
+                               memcpy(&unique[j++], &info[i], sizeof(XineramaScreenInfo));
                XFree(info);
                XFree(info);
-               free(flags);
-               return j > 0;
-       }
-       /* next algorithm only considers unique geometries as separate screens */
-       for(i = 0; i < n; i++)
-               flags[i] = False; /* used for ignoring certain monitors */
-       for(i = 0, nn = n; i < n; i++)
-               for(j = 0; j < n; j++)
-                       if(i != j && !flags[i]) {
-                               if((flags[i] = (
-                                       info[i].x_org == info[j].x_org
-                                       && info[i].y_org == info[j].y_org
-                                       && info[i].width == info[j].width
-                                       && info[i].height == info[j].height)
-                               ))
-                                       --nn;
+               nn = j;
+               if(n <= nn) {
+                       for(i = 0; i < (nn - n); i++) { /* new monitors available */
+                               for(m = mons; m && m->next; m = m->next);
+                               if(m)
+                                       m->next = createmon();
+                               else
+                                       mons = createmon();
                        }
                        }
-#endif /* XINERAMA */
-       /* allocate monitor(s) for the new geometry setup */
-       for(i = 0; i < nn; i++) {
-               if(!(m = (Monitor *)malloc(sizeof(Monitor))))
-                       die("fatal: could not malloc() %u bytes\n", sizeof(Monitor));
-               m->next = newmons;
-               newmons = m;
-       }
-       /* initialise monitor(s) */
-#ifdef XINERAMA
-       if(XineramaIsActive(dpy)) {
-               for(i = 0, m = newmons; m && i < n; i++) {
-                       if(!flags[i]) { /* only use screens that aren't dublettes */
-                               m->num = info[i].screen_number;
-                               m->mx = m->wx = info[i].x_org;
-                               m->my = m->wy = info[i].y_org;
-                               m->mw = m->ww = info[i].width;
-                               m->mh = m->wh = info[i].height;
-                               m = m->next;
+                       for(i = 0, m = mons; i < nn && m; m = m->next, i++)
+                               if(i >= n
+                               || (unique[i].x_org != m->mx || unique[i].y_org != m->my
+                                   || unique[i].width != m->mw || unique[i].height != m->mh))
+                               {
+                                       dirty = True;
+                                       m->num = i;
+                                       m->mx = m->wx = unique[i].x_org;
+                                       m->my = m->wy = unique[i].y_org;
+                                       m->mw = m->ww = unique[i].width;
+                                       m->mh = m->wh = unique[i].height;
+                                       updatebarpos(m);
+                               }
+               }
+               else { /* less monitors available nn < n */
+                       for(i = nn; i < n; i++) {
+                               for(m = mons; m && m->next; m = m->next);
+                               while(m->clients) {
+                                       dirty = True;
+                                       c = m->clients;
+                                       m->clients = c->next;
+                                       detachstack(c);
+                                       c->mon = mons;
+                                       attach(c);
+                                       attachstack(c);
+                               }
+                               if(m == selmon)
+                                       selmon = mons;
+                               cleanupmon(m);
                        }
                }
                        }
                }
-               XFree(info);
-               free(flags);
+               free(unique);
        }
        else
 #endif /* XINERAMA */
        /* default monitor setup */
        {
        }
        else
 #endif /* XINERAMA */
        /* default monitor setup */
        {
-               m->num = 0;
-               m->mx = m->wx = 0;
-               m->my = m->wy = 0;
-               m->mw = m->ww = sw;
-               m->mh = m->wh = sh;
-       }
-       /* bar geometry setup */
-       for(m = newmons; m; m = m->next) {
-               m->sel = m->stack = m->clients = NULL;
-               m->seltags = 0;
-               m->sellt = 0;
-               m->tagset[0] = m->tagset[1] = 1;
-               m->mfact = mfact;
-               m->showbar = showbar;
-               m->topbar = topbar;
-               m->lt[0] = &layouts[0];
-               m->lt[1] = &layouts[1 % LENGTH(layouts)];
-               m->ltsymbol = layouts[0].symbol;
-               updatebarpos(m);
-       }
-       /* reassign left over clients of disappeared monitors */
-       for(tm = mons; tm; tm = tm->next)
-               while(tm->clients) {
-                       c = tm->clients;
-                       tm->clients = c->next;
-                       detachstack(c);
-                       c->mon = newmons;
-                       attach(c);
-                       attachstack(c);
+               if(!mons)
+                       mons = createmon();
+               if(mons->mw != sw || mons->mh != sh) {
+                       dirty = True;
+                       mons->mw = mons->ww = sw;
+                       mons->mh = mons->wh = sh;
+                       updatebarpos(mons);
                }
                }
-       /* select focused monitor */
-       cleanupmons();
-       selmon = mons = newmons;
-       selmon = wintomon(root);
-       return True;
+       }
+       if(dirty) {
+               selmon = mons;
+               selmon = wintomon(root);
+       }
+       return dirty;
 }
 
 void
 }
 
 void
@@ -1924,7 +1959,7 @@ view(const Arg *arg) {
        selmon->seltags ^= 1; /* toggle sel tagset */
        if(arg->ui & TAGMASK)
                selmon->tagset[selmon->seltags] = arg->ui & TAGMASK;
        selmon->seltags ^= 1; /* toggle sel tagset */
        if(arg->ui & TAGMASK)
                selmon->tagset[selmon->seltags] = arg->ui & TAGMASK;
-       arrange();
+       arrange(selmon);
 }
 
 Client *
 }
 
 Client *
@@ -2002,13 +2037,13 @@ zoom(const Arg *arg) {
        detach(c);
        attach(c);
        focus(c);
        detach(c);
        attach(c);
        focus(c);
-       arrange();
+       arrange(c->mon);
 }
 
 int
 main(int argc, char *argv[]) {
        if(argc == 2 && !strcmp("-v", argv[1]))
 }
 
 int
 main(int argc, char *argv[]) {
        if(argc == 2 && !strcmp("-v", argv[1]))
-               die("dwm-"VERSION", © 2006-2009 dwm engineers, see LICENSE for details\n");
+               die("dwm-"VERSION", © 2006-2010 dwm engineers, see LICENSE for details\n");
        else if(argc != 1)
                die("usage: dwm [-v]\n");
        if(!setlocale(LC_CTYPE, "") || !XSupportsLocale())
        else if(argc != 1)
                die("usage: dwm [-v]\n");
        if(!setlocale(LC_CTYPE, "") || !XSupportsLocale())