reverting to plain X11 fonts in order to implement draw.c default

[dwm.git] / dwm.c

diff --git a/dwm.c b/dwm.c
index 84c0ae6..6695ddf 100644 (file)
--- a/dwm.c
+++ b/dwm.c
@@ -36,14 +36,18 @@
 #include <X11/Xlib.h>
 #include <X11/Xproto.h>
 #include <X11/Xutil.h>
 #include <X11/Xlib.h>
 #include <X11/Xproto.h>
 #include <X11/Xutil.h>

+#include <X11/XKBlib.h>

 #ifdef XINERAMA
 #include <X11/extensions/Xinerama.h>
 #endif /* XINERAMA */
 
 #ifdef XINERAMA
 #include <X11/extensions/Xinerama.h>
 #endif /* XINERAMA */
 

+#include "draw.h"
+

 /* macros */
 #define BUTTONMASK              (ButtonPressMask|ButtonReleaseMask)
 /* macros */
 #define BUTTONMASK              (ButtonPressMask|ButtonReleaseMask)

-#define CLEANMASK(mask)         (mask & (ShiftMask|ControlMask|Mod1Mask|Mod2Mask|Mod3Mask|Mod4Mask|Mod5Mask))
-#define INRECT(X,Y,RX,RY,RW,RH) ((X) >= (RX) && (X) < (RX) + (RW) && (Y) >= (RY) && (Y) < (RY) + (RH))
+#define CLEANMASK(mask)         (mask & ~(numlockmask|LockMask) & (ShiftMask|ControlMask|Mod1Mask|Mod2Mask|Mod3Mask|Mod4Mask|Mod5Mask))
+#define INTERSECT(x,y,w,h,m)    (MAX(0, MIN((x)+(w),(m)->wx+(m)->ww) - MAX((x),(m)->wx)) \
+                               * MAX(0, MIN((y)+(h),(m)->wy+(m)->wh) - MAX((y),(m)->wy)))

 #define ISVISIBLE(C)            ((C->tags & C->mon->tagset[C->mon->seltags]))
 #define LENGTH(X)               (sizeof X / sizeof X[0])
 #define MAX(A, B)               ((A) > (B) ? (A) : (B))
 #define ISVISIBLE(C)            ((C->tags & C->mon->tagset[C->mon->seltags]))
 #define LENGTH(X)               (sizeof X / sizeof X[0])
 #define MAX(A, B)               ((A) > (B) ? (A) : (B))


@@ -58,7 +62,8 @@
 enum { CurNormal, CurResize, CurMove, CurLast };        /* cursor */
 enum { ColBorder, ColFG, ColBG, ColLast };              /* color */
 enum { NetSupported, NetWMName, NetWMState,
 enum { CurNormal, CurResize, CurMove, CurLast };        /* cursor */
 enum { ColBorder, ColFG, ColBG, ColLast };              /* color */
 enum { NetSupported, NetWMName, NetWMState,

-       NetWMFullscreen, NetActiveWindow, NetLast };     /* EWMH atoms */
+       NetWMFullscreen, NetActiveWindow, NetWMWindowType,
+       NetWMWindowTypeDialog, NetClientList, NetLast };     /* EWMH atoms */

 enum { WMProtocols, WMDelete, WMState, WMTakeFocus, WMLast }; /* default atoms */
 enum { ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle,
        ClkClientWin, ClkRootWin, ClkLast };             /* clicks */
 enum { WMProtocols, WMDelete, WMState, WMTakeFocus, WMLast }; /* default atoms */
 enum { ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle,
        ClkClientWin, ClkRootWin, ClkLast };             /* clicks */


@@ -125,6 +130,7 @@ typedef struct {
 struct Monitor {
        char ltsymbol[16];
        float mfact;
 struct Monitor {
        char ltsymbol[16];
        float mfact;

+       int nmaster;

        int num;
        int by;               /* bar geometry */
        int mx, my, mw, mh;   /* screen size */
        int num;
        int by;               /* bar geometry */
        int mx, my, mw, mh;   /* screen size */


@@ -189,6 +195,7 @@ static long getstate(Window w);
 static Bool gettextprop(Window w, Atom atom, char *text, unsigned int size);
 static void grabbuttons(Client *c, Bool focused);
 static void grabkeys(void);
 static Bool gettextprop(Window w, Atom atom, char *text, unsigned int size);
 static void grabbuttons(Client *c, Bool focused);
 static void grabkeys(void);

+static void incnmaster(const Arg *arg);

 static void initfont(const char *fontstr);
 static void keypress(XEvent *e);
 static void killclient(const Arg *arg);
 static void initfont(const char *fontstr);
 static void keypress(XEvent *e);
 static void killclient(const Arg *arg);


@@ -196,12 +203,13 @@ static void manage(Window w, XWindowAttributes *wa);
 static void mappingnotify(XEvent *e);
 static void maprequest(XEvent *e);
 static void monocle(Monitor *m);
 static void mappingnotify(XEvent *e);
 static void maprequest(XEvent *e);
 static void monocle(Monitor *m);

+static void motionnotify(XEvent *e);

 static void movemouse(const Arg *arg);
 static Client *nexttiled(Client *c);
 static void pop(Client *);
 static void propertynotify(XEvent *e);
 static void movemouse(const Arg *arg);
 static Client *nexttiled(Client *c);
 static void pop(Client *);
 static void propertynotify(XEvent *e);

-static Monitor *ptrtomon(int x, int y);

 static void quit(const Arg *arg);
 static void quit(const Arg *arg);

+static Monitor *recttomon(int x, int y, int w, int h);

 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 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);


@@ -212,6 +220,7 @@ static Bool sendevent(Client *c, Atom proto);
 static void sendmon(Client *c, Monitor *m);
 static void setclientstate(Client *c, long state);
 static void setfocus(Client *c);
 static void sendmon(Client *c, Monitor *m);
 static void setclientstate(Client *c, long state);
 static void setfocus(Client *c);

+static void setfullscreen(Client *c, Bool fullscreen);

 static void setlayout(const Arg *arg);
 static void setmfact(const Arg *arg);
 static void setup(void);
 static void setlayout(const Arg *arg);
 static void setmfact(const Arg *arg);
 static void setup(void);


@@ -232,9 +241,11 @@ static void unmapnotify(XEvent *e);
 static Bool updategeom(void);
 static void updatebarpos(Monitor *m);
 static void updatebars(void);
 static Bool updategeom(void);
 static void updatebarpos(Monitor *m);
 static void updatebars(void);

+static void updateclientlist(void);

 static void updatenumlockmask(void);
 static void updatesizehints(Client *c);
 static void updatestatus(void);
 static void updatenumlockmask(void);
 static void updatesizehints(Client *c);
 static void updatestatus(void);

+static void updatewindowtype(Client *c);

 static void updatetitle(Client *c);
 static void updatewmhints(Client *c);
 static void view(const Arg *arg);
 static void updatetitle(Client *c);
 static void updatewmhints(Client *c);
 static void view(const Arg *arg);


@@ -265,11 +276,12 @@ static void (*handler[LASTEvent]) (XEvent *) = {
        [KeyPress] = keypress,
        [MappingNotify] = mappingnotify,
        [MapRequest] = maprequest,
        [KeyPress] = keypress,
        [MappingNotify] = mappingnotify,
        [MapRequest] = maprequest,

+       [MotionNotify] = motionnotify,

        [PropertyNotify] = propertynotify,
        [UnmapNotify] = unmapnotify
 };
 static Atom wmatom[WMLast], netatom[NetLast];
        [PropertyNotify] = propertynotify,
        [UnmapNotify] = unmapnotify
 };
 static Atom wmatom[WMLast], netatom[NetLast];

-static Bool running = True;
+static Bool running = True, usexkb;

 static Cursor cursor[CurLast];
 static Display *dpy;
 static DC dc;
 static Cursor cursor[CurLast];
 static Display *dpy;
 static DC dc;


@@ -289,31 +301,31 @@ applyrules(Client *c) {
        unsigned int i;
        const Rule *r;
        Monitor *m;
        unsigned int i;
        const Rule *r;
        Monitor *m;

-       XClassHint ch = { 0 };
+       XClassHint ch = { NULL, NULL };

 
        /* rule matching */
        c->isfloating = c->tags = 0;
 
        /* rule matching */
        c->isfloating = c->tags = 0;

-       if(XGetClassHint(dpy, c->win, &ch)) {
-               class = ch.res_class ? ch.res_class : broken;
-               instance = ch.res_name ? ch.res_name : broken;
-               for(i = 0; i < LENGTH(rules); i++) {
-                       r = &rules[i];
-                       if((!r->title || strstr(c->name, r->title))
-                       && (!r->class || strstr(class, r->class))
-                       && (!r->instance || strstr(instance, r->instance)))
-                       {
-                               c->isfloating = r->isfloating;
-                               c->tags |= r->tags;
-                               for(m = mons; m && m->num != r->monitor; m = m->next);
-                               if(m)
-                                       c->mon = m;
-                       }
+       XGetClassHint(dpy, c->win, &ch);
+       class    = ch.res_class ? ch.res_class : broken;
+       instance = ch.res_name  ? ch.res_name  : broken;
+
+       for(i = 0; i < LENGTH(rules); i++) {
+               r = &rules[i];
+               if((!r->title || strstr(c->name, r->title))
+               && (!r->class || strstr(class, r->class))
+               && (!r->instance || strstr(instance, r->instance)))
+               {
+                       c->isfloating = r->isfloating;
+                       c->tags |= r->tags;
+                       for(m = mons; m && m->num != r->monitor; m = m->next);
+                       if(m)
+                               c->mon = m;

                }
                }

-               if(ch.res_class)
-                       XFree(ch.res_class);
-               if(ch.res_name)
-                       XFree(ch.res_name);

        }
        }

+       if(ch.res_class)
+               XFree(ch.res_class);
+       if(ch.res_name)
+               XFree(ch.res_name);

        c->tags = c->tags & TAGMASK ? c->tags & TAGMASK : c->mon->tagset[c->mon->seltags];
 }
 
        c->tags = c->tags & TAGMASK ? c->tags & TAGMASK : c->mon->tagset[c->mon->seltags];
 }
 


@@ -336,20 +348,20 @@ applysizehints(Client *c, int *x, int *y, int *w, int *h, Bool interact) {
                        *y = 0;
        }
        else {
                        *y = 0;
        }
        else {

-               if(*x > m->mx + m->mw)
-                       *x = m->mx + m->mw - WIDTH(c);
-               if(*y > m->my + m->mh)
-                       *y = m->my + m->mh - HEIGHT(c);
-               if(*x + *w + 2 * c->bw < m->mx)
-                       *x = m->mx;
-               if(*y + *h + 2 * c->bw < m->my)
-                       *y = m->my;
+               if(*x >= m->wx + m->ww)
+                       *x = m->wx + m->ww - WIDTH(c);
+               if(*y >= m->wy + m->wh)
+                       *y = m->wy + m->wh - HEIGHT(c);
+               if(*x + *w + 2 * c->bw <= m->wx)
+                       *x = m->wx;
+               if(*y + *h + 2 * c->bw <= m->wy)
+                       *y = m->wy;

        }
        if(*h < bh)
                *h = bh;
        if(*w < bh)
                *w = bh;
        }
        if(*h < bh)
                *h = bh;
        if(*w < bh)
                *w = bh;

-       if(resizehints || c->isfloating) {
+       if(resizehints || c->isfloating || !c->mon->lt[c->mon->sellt]->arrange) {

                /* see last two sentences in ICCCM 4.1.2.3 */
                baseismin = c->basew == c->minw && c->baseh == c->minh;
                if(!baseismin) { /* temporarily remove base dimensions */
                /* see last two sentences in ICCCM 4.1.2.3 */
                baseismin = c->basew == c->minw && c->baseh == c->minh;
                if(!baseismin) { /* temporarily remove base dimensions */


@@ -389,10 +401,10 @@ arrange(Monitor *m) {
                showhide(m->stack);
        else for(m = mons; m; m = m->next)
                showhide(m->stack);
                showhide(m->stack);
        else for(m = mons; m; m = m->next)
                showhide(m->stack);

-       focus(NULL);
-       if(m)
+       if(m) {

                arrangemon(m);
                arrangemon(m);

-       else for(m = mons; m; m = m->next)
+               restack(m);
+       } else for(m = mons; m; m = m->next)

                arrangemon(m);
 }
 
                arrangemon(m);
 }
 


@@ -401,7 +413,6 @@ 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);
        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


@@ -433,16 +444,16 @@ buttonpress(XEvent *e) {
        }
        if(ev->window == selmon->barwin) {
                i = x = 0;
        }
        if(ev->window == selmon->barwin) {
                i = x = 0;

-               do {
+               do

                        x += TEXTW(tags[i]);
                        x += TEXTW(tags[i]);

-               } while(ev->x >= x && ++i < LENGTH(tags));
+               while(ev->x >= x && ++i < LENGTH(tags));

                if(i < LENGTH(tags)) {
                        click = ClkTagBar;
                        arg.ui = 1 << i;
                }
                else if(ev->x < x + blw)
                        click = ClkLtSymbol;
                if(i < LENGTH(tags)) {
                        click = ClkTagBar;
                        arg.ui = 1 << i;
                }
                else if(ev->x < x + blw)
                        click = ClkLtSymbol;

-               else if(ev->x > selmon->wx + selmon->ww - TEXTW(stext))
+               else if(ev->x > selmon->ww - TEXTW(stext))

                        click = ClkStatusText;
                else
                        click = ClkWinTitle;
                        click = ClkStatusText;
                else
                        click = ClkWinTitle;


@@ -492,6 +503,7 @@ cleanup(void) {
                cleanupmon(mons);
        XSync(dpy, False);
        XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime);
                cleanupmon(mons);
        XSync(dpy, False);
        XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime);

+       XDeleteProperty(dpy, root, netatom[NetActiveWindow]);

 }
 
 void
 }
 
 void


@@ -528,31 +540,10 @@ clientmessage(XEvent *e) {
 
        if(!c)
                return;
 
        if(!c)
                return;

-       if(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->isfullscreen = True;
-                       c->oldstate = c->isfloating;
-                       c->oldbw = c->bw;
-                       c->bw = 0;
-                       c->isfloating = True;
-                       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->isfullscreen = False;
-                       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);
-               }
+       if(cme->message_type == netatom[NetWMState]) {
+               if(cme->data.l[1] == netatom[NetWMFullscreen] || cme->data.l[2] == netatom[NetWMFullscreen])
+                       setfullscreen(c, (cme->data.l[0] == 1 /* _NET_WM_STATE_ADD    */
+                                     || (cme->data.l[0] == 2 /* _NET_WM_STATE_TOGGLE */ && !c->isfullscreen)));

        }
        else if(cme->message_type == netatom[NetActiveWindow]) {
                if(!ISVISIBLE(c)) {
        }
        else if(cme->message_type == netatom[NetActiveWindow]) {
                if(!ISVISIBLE(c)) {


@@ -587,8 +578,9 @@ configurenotify(XEvent *e) {
        XConfigureEvent *ev = &e->xconfigure;
        Bool dirty;
 
        XConfigureEvent *ev = &e->xconfigure;
        Bool dirty;
 

+       // TODO: updategeom handling sucks, needs to be simplified

        if(ev->window == root) {
        if(ev->window == root) {

-               dirty = (sw != ev->width);
+               dirty = (sw != ev->width || sh != ev->height);

                sw = ev->width;
                sh = ev->height;
                if(updategeom() || dirty) {
                sw = ev->width;
                sh = ev->height;
                if(updategeom() || dirty) {


@@ -598,6 +590,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);

+                       focus(NULL);

                        arrange(NULL);
                }
        }
                        arrange(NULL);
                }
        }


@@ -615,18 +608,26 @@ configurerequest(XEvent *e) {
                        c->bw = ev->border_width;
                else if(c->isfloating || !selmon->lt[selmon->sellt]->arrange) {
                        m = c->mon;
                        c->bw = ev->border_width;
                else if(c->isfloating || !selmon->lt[selmon->sellt]->arrange) {
                        m = c->mon;

-                       if(ev->value_mask & CWX)
+                       if(ev->value_mask & CWX) {
+                               c->oldx = c->x;

                                c->x = m->mx + ev->x;
                                c->x = m->mx + ev->x;

-                       if(ev->value_mask & CWY)
+                       }
+                       if(ev->value_mask & CWY) {
+                               c->oldy = c->y;

                                c->y = m->my + ev->y;
                                c->y = m->my + ev->y;

-                       if(ev->value_mask & CWWidth)
+                       }
+                       if(ev->value_mask & CWWidth) {
+                               c->oldw = c->w;

                                c->w = ev->width;
                                c->w = ev->width;

-                       if(ev->value_mask & CWHeight)
+                       }
+                       if(ev->value_mask & CWHeight) {
+                               c->oldh = c->h;

                                c->h = ev->height;
                                c->h = ev->height;

+                       }

                        if((c->x + c->w) > m->mx + m->mw && c->isfloating)
                        if((c->x + c->w) > m->mx + m->mw && c->isfloating)

-                               c->x = m->mx + (m->mw / 2 - c->w / 2); /* center in x direction */
+                               c->x = m->mx + (m->mw / 2 - WIDTH(c) / 2); /* center in x direction */

                        if((c->y + c->h) > m->my + m->mh && c->isfloating)
                        if((c->y + c->h) > m->my + m->mh && c->isfloating)

-                               c->y = m->my + (m->mh / 2 - c->h / 2); /* center in y direction */
+                               c->y = m->my + (m->mh / 2 - HEIGHT(c) / 2); /* center in y direction */

                        if((ev->value_mask & (CWX|CWY)) && !(ev->value_mask & (CWWidth|CWHeight)))
                                configure(c);
                        if(ISVISIBLE(c))
                        if((ev->value_mask & (CWX|CWY)) && !(ev->value_mask & (CWWidth|CWHeight)))
                                configure(c);
                        if(ISVISIBLE(c))


@@ -656,6 +657,7 @@ createmon(void) {
                die("fatal: could not malloc() %u bytes\n", sizeof(Monitor));
        m->tagset[0] = m->tagset[1] = 1;
        m->mfact = mfact;
                die("fatal: could not malloc() %u bytes\n", sizeof(Monitor));
        m->tagset[0] = m->tagset[1] = 1;
        m->mfact = mfact;

+       m->nmaster = nmaster;

        m->showbar = showbar;
        m->topbar = topbar;
        m->lt[0] = &layouts[0];
        m->showbar = showbar;
        m->topbar = topbar;
        m->lt[0] = &layouts[0];


@@ -712,12 +714,10 @@ dirtomon(int dir) {
                if(!(m = selmon->next))
                        m = mons;
        }
                if(!(m = selmon->next))
                        m = mons;
        }

-       else {
-               if(selmon == mons)
-                       for(m = mons; m->next; m = m->next);
-               else
-                       for(m = mons; m->next != selmon; m = m->next);
-       }
+       else if(selmon == mons)
+               for(m = mons; m->next; m = m->next);
+       else
+               for(m = mons; m->next != selmon; m = m->next);

        return m;
 }
 
        return m;
 }
 


@@ -820,16 +820,21 @@ 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;
        Monitor *m;
        XCrossingEvent *ev = &e->xcrossing;
 
        if((ev->mode != NotifyNormal || ev->detail == NotifyInferior) && ev->window != root)
                return;

-       if((m = wintomon(ev->window)) && m != selmon) {
+       c = wintoclient(ev->window);
+       m = c ? c->mon : wintomon(ev->window);
+       if(m != selmon) {

                unfocus(selmon->sel, True);
                selmon = m;
        }
                unfocus(selmon->sel, True);
                selmon = m;
        }

-       focus((wintoclient(ev->window)));
+       else if(!c || c == selmon->sel)
+               return;
+       focus(c);

 }
 
 void
 }
 
 void


@@ -859,8 +864,10 @@ focus(Client *c) {
                XSetWindowBorder(dpy, c->win, dc.sel[ColBorder]);
                setfocus(c);
        }
                XSetWindowBorder(dpy, c->win, dc.sel[ColBorder]);
                setfocus(c);
        }

-       else
+       else {

                XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime);
                XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime);

+               XDeleteProperty(dpy, root, netatom[NetActiveWindow]);
+       }

        selmon->sel = c;
        drawbars();
 }
        selmon->sel = c;
        drawbars();
 }


@@ -881,7 +888,8 @@ focusmon(const Arg *arg) {
                return;
        if((m = dirtomon(arg->i)) == selmon)
                return;
                return;
        if((m = dirtomon(arg->i)) == selmon)
                return;

-       unfocus(selmon->sel, True);
+       unfocus(selmon->sel, False); /* s/True/False/ fixes input focus issues
+                                       in gedit and anjuta */

        selmon = m;
        focus(NULL);
 }
        selmon = m;
        focus(NULL);
 }


@@ -912,6 +920,21 @@ focusstack(const Arg *arg) {
        }
 }
 
        }
 }
 

+Atom
+getatomprop(Client *c, Atom prop) {
+       int di;
+       unsigned long dl;
+       unsigned char *p = NULL;
+       Atom da, atom = None;
+
+       if(XGetWindowProperty(dpy, c->win, prop, 0L, sizeof atom, False, XA_ATOM,
+                             &da, &di, &dl, &dl, &p) == Success && p) {
+               atom = *(Atom *)p;
+               XFree(p);
+       }
+       return atom;
+}
+

 unsigned long
 getcolor(const char *colstr) {
        Colormap cmap = DefaultColormap(dpy, screen);
 unsigned long
 getcolor(const char *colstr) {
        Colormap cmap = DefaultColormap(dpy, screen);


@@ -1004,21 +1027,25 @@ grabkeys(void) {
                KeyCode code;
 
                XUngrabKey(dpy, AnyKey, AnyModifier, root);
                KeyCode code;
 
                XUngrabKey(dpy, AnyKey, AnyModifier, root);

-               for(i = 0; i < LENGTH(keys); i++) {
+               for(i = 0; i < LENGTH(keys); i++)

                        if((code = XKeysymToKeycode(dpy, keys[i].keysym)))
                                for(j = 0; j < LENGTH(modifiers); j++)
                                        XGrabKey(dpy, code, keys[i].mod | modifiers[j], root,
                                                 True, GrabModeAsync, GrabModeAsync);
                        if((code = XKeysymToKeycode(dpy, keys[i].keysym)))
                                for(j = 0; j < LENGTH(modifiers); j++)
                                        XGrabKey(dpy, code, keys[i].mod | modifiers[j], root,
                                                 True, GrabModeAsync, GrabModeAsync);

-               }

        }
 }
 
        }
 }
 

+void
+incnmaster(const Arg *arg) {
+       selmon->nmaster = MAX(selmon->nmaster + arg->i, 0);
+       arrange(selmon);
+}
+

 void
 initfont(const char *fontstr) {
        char *def, **missing;
        int n;
 
 void
 initfont(const char *fontstr) {
        char *def, **missing;
        int n;
 

-       missing = NULL;

        dc.font.set = XCreateFontSet(dpy, fontstr, &missing, &n, &def);
        if(missing) {
                while(n--)
        dc.font.set = XCreateFontSet(dpy, fontstr, &missing, &n, &def);
        if(missing) {
                while(n--)


@@ -1066,7 +1093,10 @@ keypress(XEvent *e) {
        XKeyEvent *ev;
 
        ev = &e->xkey;
        XKeyEvent *ev;
 
        ev = &e->xkey;

-       keysym = XKeycodeToKeysym(dpy, (KeyCode)ev->keycode, 0);
+       if(usexkb)
+               keysym = XkbKeycodeToKeysym(dpy, (KeyCode)ev->keycode, 0, 0);
+       else
+               keysym = XKeycodeToKeysym(dpy, (KeyCode)ev->keycode, 0);

        for(i = 0; i < LENGTH(keys); i++)
                if(keysym == keys[i].keysym
                && CLEANMASK(keys[i].mod) == CLEANMASK(ev->state)
        for(i = 0; i < LENGTH(keys); i++)
                if(keysym == keys[i].keysym
                && CLEANMASK(keys[i].mod) == CLEANMASK(ev->state)


@@ -1108,32 +1138,27 @@ manage(Window w, XWindowAttributes *wa) {
                applyrules(c);
        }
        /* geometry */
                applyrules(c);
        }
        /* geometry */

-       c->x = c->oldx = wa->x + c->mon->wx;
-       c->y = c->oldy = wa->y + c->mon->wy;
+       c->x = c->oldx = wa->x;
+       c->y = c->oldy = wa->y;

        c->w = c->oldw = wa->width;
        c->h = c->oldh = wa->height;
        c->oldbw = wa->border_width;
        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->isfloating = True;
-               c->x = c->mon->mx;
-               c->y = c->mon->my;
-               c->bw = 0;
-       }
-       else {
-               if(c->x + WIDTH(c) > c->mon->mx + c->mon->mw)
-                       c->x = c->mon->mx + c->mon->mw - WIDTH(c);
-               if(c->y + HEIGHT(c) > c->mon->my + c->mon->mh)
-                       c->y = c->mon->my + c->mon->mh - HEIGHT(c);
-               c->x = MAX(c->x, c->mon->mx);
-               /* only fix client y-offset, if the client center might cover the bar */
-               c->y = MAX(c->y, ((c->mon->by == 0) && (c->x + (c->w / 2) >= c->mon->wx)
-                          && (c->x + (c->w / 2) < c->mon->wx + c->mon->ww)) ? bh : c->mon->my);
-               c->bw = borderpx;
-       }
+
+       if(c->x + WIDTH(c) > c->mon->mx + c->mon->mw)
+               c->x = c->mon->mx + c->mon->mw - WIDTH(c);
+       if(c->y + HEIGHT(c) > c->mon->my + c->mon->mh)
+               c->y = c->mon->my + c->mon->mh - HEIGHT(c);
+       c->x = MAX(c->x, c->mon->mx);
+       /* only fix client y-offset, if the client center might cover the bar */
+       c->y = MAX(c->y, ((c->mon->by == c->mon->my) && (c->x + (c->w / 2) >= c->mon->wx)
+                  && (c->x + (c->w / 2) < c->mon->wx + c->mon->ww)) ? bh : c->mon->my);
+       c->bw = borderpx;
+

        wc.border_width = c->bw;
        XConfigureWindow(dpy, w, CWBorderWidth, &wc);
        XSetWindowBorder(dpy, w, dc.norm[ColBorder]);
        configure(c); /* propagates border_width, if size doesn't change */
        wc.border_width = c->bw;
        XConfigureWindow(dpy, w, CWBorderWidth, &wc);
        XSetWindowBorder(dpy, w, dc.norm[ColBorder]);
        configure(c); /* propagates border_width, if size doesn't change */

+       updatewindowtype(c);

        updatesizehints(c);
        updatewmhints(c);
        XSelectInput(dpy, w, EnterWindowMask|FocusChangeMask|PropertyChangeMask|StructureNotifyMask);
        updatesizehints(c);
        updatewmhints(c);
        XSelectInput(dpy, w, EnterWindowMask|FocusChangeMask|PropertyChangeMask|StructureNotifyMask);


@@ -1144,10 +1169,16 @@ manage(Window w, XWindowAttributes *wa) {
                XRaiseWindow(dpy, c->win);
        attach(c);
        attachstack(c);
                XRaiseWindow(dpy, c->win);
        attach(c);
        attachstack(c);

+       XChangeProperty(dpy, root, netatom[NetClientList], XA_WINDOW, 32, PropModeAppend,
+                       (unsigned char *) &(c->win), 1);

        XMoveResizeWindow(dpy, c->win, c->x + 2 * sw, c->y, c->w, c->h); /* some windows require this */
        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);
        setclientstate(c, NormalState);

+       if (c->mon == selmon)
+               unfocus(selmon->sel, False);
+       c->mon->sel = c;

        arrange(c->mon);
        arrange(c->mon);

+       XMapWindow(dpy, c->win);
+       focus(NULL);

 }
 
 void
 }
 
 void


@@ -1186,6 +1217,22 @@ monocle(Monitor *m) {
                resize(c, m->wx, m->wy, m->ww - 2 * c->bw, m->wh - 2 * c->bw, False);
 }
 
                resize(c, m->wx, m->wy, m->ww - 2 * c->bw, m->wh - 2 * c->bw, False);
 }
 

+void
+motionnotify(XEvent *e) {
+       static Monitor *mon = NULL;
+       Monitor *m;
+       XMotionEvent *ev = &e->xmotion;
+
+       if(ev->window != root)
+               return;
+       if((m = recttomon(ev->x_root, ev->y_root, 1, 1)) != mon && mon) {
+               unfocus(selmon->sel, True);
+               selmon = m;
+               focus(NULL);
+       }
+       mon = m;
+}
+

 void
 movemouse(const Arg *arg) {
        int x, y, ocx, ocy, nx, ny;
 void
 movemouse(const Arg *arg) {
        int x, y, ocx, ocy, nx, ny;


@@ -1195,6 +1242,8 @@ movemouse(const Arg *arg) {
 
        if(!(c = selmon->sel))
                return;
 
        if(!(c = selmon->sel))
                return;

+       if(c->isfullscreen) /* no support moving fullscreen windows by mouse */
+               return;

        restack(selmon);
        ocx = c->x;
        ocy = c->y;
        restack(selmon);
        ocx = c->x;
        ocy = c->y;


@@ -1234,7 +1283,7 @@ movemouse(const Arg *arg) {
                }
        } while(ev.type != ButtonRelease);
        XUngrabPointer(dpy, CurrentTime);
                }
        } while(ev.type != ButtonRelease);
        XUngrabPointer(dpy, CurrentTime);

-       if((m = ptrtomon(c->x + c->w / 2, c->y + c->h / 2)) != selmon) {
+       if((m = recttomon(c->x, c->y, c->w, c->h)) != selmon) {

                sendmon(c, m);
                selmon = m;
                focus(NULL);
                sendmon(c, m);
                selmon = m;
                focus(NULL);


@@ -1286,23 +1335,29 @@ propertynotify(XEvent *e) {
                        if(c == c->mon->sel)
                                drawbar(c->mon);
                }
                        if(c == c->mon->sel)
                                drawbar(c->mon);
                }

+               if(ev->atom == netatom[NetWMWindowType])
+                       updatewindowtype(c);

        }
 }
 
        }
 }
 

-Monitor *
-ptrtomon(int x, int y) {
-       Monitor *m;
-
-       for(m = mons; m; m = m->next)
-               if(INRECT(x, y, m->wx, m->wy, m->ww, m->wh))
-                       return m;
-       return selmon;
-}

 void
 quit(const Arg *arg) {
        running = False;
 }
 
 void
 quit(const Arg *arg) {
        running = False;
 }
 

+Monitor *
+recttomon(int x, int y, int w, int h) {
+       Monitor *m, *r = selmon;
+       int a, area = 0;
+
+       for(m = mons; m; m = m->next)
+               if((a = INTERSECT(x, y, w, h, m)) > area) {
+                       area = a;
+                       r = m;
+               }
+       return r;
+}
+

 void
 resize(Client *c, int x, int y, int w, int h, Bool interact) {
        if(applysizehints(c, &x, &y, &w, &h, interact))
 void
 resize(Client *c, int x, int y, int w, int h, Bool interact) {
        if(applysizehints(c, &x, &y, &w, &h, interact))


@@ -1333,6 +1388,8 @@ resizemouse(const Arg *arg) {
 
        if(!(c = selmon->sel))
                return;
 
        if(!(c = selmon->sel))
                return;

+       if(c->isfullscreen) /* no support resizing fullscreen windows by mouse */
+               return;

        restack(selmon);
        ocx = c->x;
        ocy = c->y;
        restack(selmon);
        ocx = c->x;
        ocy = c->y;


@@ -1366,7 +1423,7 @@ resizemouse(const Arg *arg) {
        XWarpPointer(dpy, None, c->win, 0, 0, 0, 0, c->w + c->bw - 1, c->h + c->bw - 1);
        XUngrabPointer(dpy, CurrentTime);
        while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
        XWarpPointer(dpy, None, c->win, 0, 0, 0, 0, c->w + c->bw - 1, c->h + c->bw - 1);
        XUngrabPointer(dpy, CurrentTime);
        while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));

-       if((m = ptrtomon(c->x + c->w / 2, c->y + c->h / 2)) != selmon) {
+       if((m = recttomon(c->x, c->y, c->w, c->h)) != selmon) {

                sendmon(c, m);
                selmon = m;
                focus(NULL);
                sendmon(c, m);
                selmon = m;
                focus(NULL);


@@ -1402,10 +1459,9 @@ run(void) {
        XEvent ev;
        /* main event loop */
        XSync(dpy, False);
        XEvent ev;
        /* 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


@@ -1483,11 +1539,43 @@ sendevent(Client *c, Atom proto) {
 
 void
 setfocus(Client *c) {
 
 void
 setfocus(Client *c) {

-       if(!c->neverfocus)
+       if(!c->neverfocus) {

                XSetInputFocus(dpy, c->win, RevertToPointerRoot, CurrentTime);
                XSetInputFocus(dpy, c->win, RevertToPointerRoot, CurrentTime);

+               XChangeProperty(dpy, root, netatom[NetActiveWindow],
+                               XA_WINDOW, 32, PropModeReplace,
+                               (unsigned char *) &(c->win), 1);
+       }

        sendevent(c, wmatom[WMTakeFocus]);
 }
 
        sendevent(c, wmatom[WMTakeFocus]);
 }
 

+void
+setfullscreen(Client *c, Bool fullscreen) {
+       if(fullscreen) {
+               XChangeProperty(dpy, c->win, netatom[NetWMState], XA_ATOM, 32,
+                               PropModeReplace, (unsigned char*)&netatom[NetWMFullscreen], 1);
+               c->isfullscreen = True;
+               c->oldstate = c->isfloating;
+               c->oldbw = c->bw;
+               c->bw = 0;
+               c->isfloating = True;
+               resizeclient(c, c->mon->mx, c->mon->my, c->mon->mw, c->mon->mh);
+               XRaiseWindow(dpy, c->win);
+       }
+       else {
+               XChangeProperty(dpy, c->win, netatom[NetWMState], XA_ATOM, 32,
+                               PropModeReplace, (unsigned char*)0, 0);
+               c->isfullscreen = False;
+               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
 setlayout(const Arg *arg) {
        if(!arg || !arg->v || arg->v != selmon->lt[selmon->sellt])
 void
 setlayout(const Arg *arg) {
        if(!arg || !arg->v || arg->v != selmon->lt[selmon->sellt])


@@ -1518,6 +1606,7 @@ setmfact(const Arg *arg) {
 void
 setup(void) {
        XSetWindowAttributes wa;
 void
 setup(void) {
        XSetWindowAttributes wa;

+       int dummy = 0, xkbmajor = XkbMajorVersion, xkbminor = XkbMinorVersion;

 
        /* clean up any zombies immediately */
        sigchld(0);
 
        /* clean up any zombies immediately */
        sigchld(0);


@@ -1540,6 +1629,9 @@ setup(void) {
        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[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);

        /* 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);


@@ -1562,13 +1654,15 @@ setup(void) {
        /* EWMH support per view */
        XChangeProperty(dpy, root, netatom[NetSupported], XA_ATOM, 32,
                        PropModeReplace, (unsigned char *) netatom, NetLast);
        /* EWMH support per view */
        XChangeProperty(dpy, root, netatom[NetSupported], XA_ATOM, 32,
                        PropModeReplace, (unsigned char *) netatom, NetLast);

+       XDeleteProperty(dpy, root, netatom[NetClientList]);

        /* select for events */
        wa.cursor = cursor[CurNormal];
        /* select for events */
        wa.cursor = cursor[CurNormal];

-       wa.event_mask = SubstructureRedirectMask|SubstructureNotifyMask|ButtonPressMask
-                       |EnterWindowMask|LeaveWindowMask|StructureNotifyMask
-                       |PropertyChangeMask;
+       wa.event_mask = SubstructureRedirectMask|SubstructureNotifyMask|ButtonPressMask|PointerMotionMask
+                       |EnterWindowMask|LeaveWindowMask|StructureNotifyMask|PropertyChangeMask;

        XChangeWindowAttributes(dpy, root, CWEventMask|CWCursor, &wa);
        XSelectInput(dpy, root, wa.event_mask);
        XChangeWindowAttributes(dpy, root, CWEventMask|CWCursor, &wa);
        XSelectInput(dpy, root, wa.event_mask);

+       /* init xkb */
+       usexkb = XkbQueryExtension(dpy, &dummy, &dummy, &dummy, &xkbmajor, &xkbminor);

        grabkeys();
 }
 
        grabkeys();
 }
 


@@ -1584,7 +1678,7 @@ showhide(Client *c) {
        }
        else { /* hide clients bottom up */
                showhide(c->snext);
        }
        else { /* hide clients bottom up */
                showhide(c->snext);

-               XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);
+               XMoveWindow(dpy, c->win, WIDTH(c) * -2, c->y);

        }
 }
 
        }
 }
 


@@ -1612,6 +1706,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;

+               focus(NULL);

                arrange(selmon);
        }
 }
                arrange(selmon);
        }
 }


@@ -1636,32 +1731,28 @@ textnw(const char *text, unsigned int len) {
 
 void
 tile(Monitor *m) {
 
 void
 tile(Monitor *m) {

-       int x, y, h, w, mw;
-       unsigned int i, n;
+       unsigned int i, n, h, mw, my, ty;

        Client *c;
 
        for(n = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), n++);
        if(n == 0)
                return;
        Client *c;
 
        for(n = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), n++);
        if(n == 0)
                return;

-       /* master */
-       c = nexttiled(m->clients);
-       mw = m->mfact * m->ww;
-       resize(c, m->wx, m->wy, (n == 1 ? m->ww : mw) - 2 * c->bw, m->wh - 2 * c->bw, False);
-       if(--n == 0)
-               return;
-       /* tile stack */
-       x = (m->wx + mw > c->x + c->w) ? c->x + c->w + 2 * c->bw : m->wx + mw;
-       y = m->wy;
-       w = (m->wx + mw > c->x + c->w) ? m->wx + m->ww - x : m->ww - mw;
-       h = m->wh / n;
-       if(h < bh)
-               h = m->wh;
-       for(i = 0, c = nexttiled(c->next); c; c = nexttiled(c->next), i++) {
-               resize(c, x, y, w - 2 * c->bw, /* remainder */ ((i + 1 == n)
-                      ? m->wy + m->wh - y - 2 * c->bw : h - 2 * c->bw), False);
-               if(h != m->wh)
-                       y = c->y + HEIGHT(c);
-       }
+
+       if(n > m->nmaster)
+               mw = m->nmaster ? m->ww * m->mfact : 0;
+       else
+               mw = m->ww;
+       for(i = my = ty = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), i++)
+               if(i < m->nmaster) {
+                       h = (m->wh - my) / (MIN(n, m->nmaster) - i);
+                       resize(c, m->wx, m->wy + my, mw - (2*c->bw), h - (2*c->bw), False);
+                       my += HEIGHT(c);
+               }
+               else {
+                       h = (m->wh - ty) / (n - i);
+                       resize(c, m->wx + mw, m->wy + ty, m->ww - mw - (2*c->bw), h - (2*c->bw), False);
+                       ty += HEIGHT(c);
+               }

 }
 
 void
 }
 
 void


@@ -1676,6 +1767,8 @@ void
 togglefloating(const Arg *arg) {
        if(!selmon->sel)
                return;
 togglefloating(const Arg *arg) {
        if(!selmon->sel)
                return;

+       if(selmon->sel->isfullscreen) /* no support for fullscreen windows */
+               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->isfloating = !selmon->sel->isfloating || selmon->sel->isfixed;
        if(selmon->sel->isfloating)
                resize(selmon->sel, selmon->sel->x, selmon->sel->y,


@@ -1692,6 +1785,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;

+               focus(NULL);

                arrange(selmon);
        }
 }
                arrange(selmon);
        }
 }


@@ -1702,6 +1796,7 @@ toggleview(const Arg *arg) {
 
        if(newtagset) {
                selmon->tagset[selmon->seltags] = newtagset;
 
        if(newtagset) {
                selmon->tagset[selmon->seltags] = newtagset;

+               focus(NULL);

                arrange(selmon);
        }
 }
                arrange(selmon);
        }
 }


@@ -1712,8 +1807,10 @@ unfocus(Client *c, Bool setfocus) {
                return;
        grabbuttons(c, False);
        XSetWindowBorder(dpy, c->win, dc.norm[ColBorder]);
                return;
        grabbuttons(c, False);
        XSetWindowBorder(dpy, c->win, dc.norm[ColBorder]);

-       if(setfocus)
+       if(setfocus) {

                XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime);
                XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime);

+               XDeleteProperty(dpy, root, netatom[NetActiveWindow]);
+       }

 }
 
 void
 }
 
 void


@@ -1737,6 +1834,7 @@ unmanage(Client *c, Bool destroyed) {
        }
        free(c);
        focus(NULL);
        }
        free(c);
        focus(NULL);

+       updateclientlist();

        arrange(m);
 }
 
        arrange(m);
 }
 


@@ -1745,8 +1843,12 @@ unmapnotify(XEvent *e) {
        Client *c;
        XUnmapEvent *ev = &e->xunmap;
 
        Client *c;
        XUnmapEvent *ev = &e->xunmap;
 

-       if((c = wintoclient(ev->window)))
-               unmanage(c, False);
+       if((c = wintoclient(ev->window))) {
+               if(ev->send_event)
+                       setclientstate(c, WithdrawnState);
+               else
+                       unmanage(c, False);
+       }

 }
 
 void
 }
 
 void


@@ -1758,6 +1860,8 @@ updatebars(void) {
                .event_mask = ButtonPressMask|ExposureMask
        };
        for(m = mons; m; m = m->next) {
                .event_mask = ButtonPressMask|ExposureMask
        };
        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),
                                          CopyFromParent, DefaultVisual(dpy, screen),
                                          CWOverrideRedirect|CWBackPixmap|CWEventMask, &wa);
                m->barwin = XCreateWindow(dpy, root, m->wx, m->by, m->ww, bh, 0, DefaultDepth(dpy, screen),
                                          CopyFromParent, DefaultVisual(dpy, screen),
                                          CWOverrideRedirect|CWBackPixmap|CWEventMask, &wa);


@@ -1779,6 +1883,19 @@ updatebarpos(Monitor *m) {
                m->by = -bh;
 }
 
                m->by = -bh;
 }
 

+void
+updateclientlist() {
+       Client *c;
+       Monitor *m;
+
+       XDeleteProperty(dpy, root, netatom[NetClientList]);
+       for(m = mons; m; m = m->next)
+               for(c = m->clients; c; c = c->next)
+                       XChangeProperty(dpy, root, netatom[NetClientList],
+                                       XA_WINDOW, 32, PropModeAppend,
+                                       (unsigned char *) &(c->win), 1);
+}
+

 Bool
 updategeom(void) {
        Bool dirty = False;
 Bool
 updategeom(void) {
        Bool dirty = False;


@@ -1941,6 +2058,17 @@ updatestatus(void) {
        drawbar(selmon);
 }
 
        drawbar(selmon);
 }
 

+void
+updatewindowtype(Client *c) {
+       Atom state = getatomprop(c, netatom[NetWMState]);
+       Atom wtype = getatomprop(c, netatom[NetWMWindowType]);
+
+       if(state == netatom[NetWMFullscreen])
+               setfullscreen(c, True);
+       if(wtype == netatom[NetWMWindowTypeDialog])
+               c->isfloating = True;
+}
+

 void
 updatewmhints(Client *c) {
        XWMHints *wmh;
 void
 updatewmhints(Client *c) {
        XWMHints *wmh;


@@ -1967,6 +2095,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;

+       focus(NULL);

        arrange(selmon);
 }
 
        arrange(selmon);
 }
 


@@ -1989,7 +2118,7 @@ wintomon(Window w) {
        Monitor *m;
 
        if(w == root && getrootptr(&x, &y))
        Monitor *m;
 
        if(w == root && getrootptr(&x, &y))

-               return ptrtomon(x, y);
+               return recttomon(x, y, 1, 1);

        for(m = mons; m; m = m->next)
                if(w == m->barwin)
                        return m;
        for(m = mons; m; m = m->next)
                if(w == m->barwin)
                        return m;


@@ -2047,7 +2176,7 @@ zoom(const Arg *arg) {
 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-2011 dwm engineers, see LICENSE for details\n");
+               die("dwm-"VERSION", © 2006-2012 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())