Add patches from suckless.org

3 files changed, 1070 insertions, 0 deletions

diff --git a/patches/dwm-6.1-pertag-tab-v2b.diff b/patches/dwm-6.1-pertag-tab-v2b.diff
new file mode 100644
index 0000000..f289bde
--- /dev/null
+++ b/patches/dwm-6.1-pertag-tab-v2b.diff
@@ -0,0 +1,841 @@
+diff --git a/config.def.h b/config.def.h
+index 7054c06..f0b33c5 100644
+--- a/config.def.h
++++ b/config.def.h
+@@ -15,10 +15,21 @@ static const unsigned int borderpx  = 1;        /* border pixel of windows */
+ static const unsigned int snap      = 32;       /* snap pixel */
+ static const int showbar            = 1;        /* 0 means no bar */
+ static const int topbar             = 1;        /* 0 means bottom bar */
++/*   Display modes of the tab bar: never shown, always shown, shown only in */
++/*   monocle mode in presence of several windows.                           */
++/*   Modes after showtab_nmodes are disabled                                */
++enum showtab_modes { showtab_never, showtab_auto, showtab_nmodes, showtab_always};
++static const int showtab            = showtab_auto; /* Default tab bar show mode */
++static const Bool toptab            = False;    /* False means bottom tab bar */
+ 
+ /* tagging */
+ static const char *tags[] = { "1", "2", "3", "4", "5", "6", "7", "8", "9" };
+ 
++/* default layout per tags */
++/* The first element is for all-tag view, following i-th element corresponds to */
++/* tags[i]. Layout is referred using the layouts array index.*/
++static int def_layouts[1 + LENGTH(tags)]  = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
++
+ static const Rule rules[] = {
+ 	/* xprop(1):
+ 	 *	WM_CLASS(STRING) = instance, class
+@@ -62,6 +73,7 @@ static Key keys[] = {
+ 	{ MODKEY,                       XK_p,      spawn,          {.v = dmenucmd } },
+ 	{ MODKEY|ShiftMask,             XK_Return, spawn,          {.v = termcmd } },
+ 	{ MODKEY,                       XK_b,      togglebar,      {0} },
++	{ MODKEY,                       XK_w,      tabmode,        {-1} },
+ 	{ MODKEY,                       XK_j,      focusstack,     {.i = +1 } },
+ 	{ MODKEY,                       XK_k,      focusstack,     {.i = -1 } },
+ 	{ MODKEY,                       XK_i,      incnmaster,     {.i = +1 } },
+@@ -109,5 +121,6 @@ static Button buttons[] = {
+ 	{ ClkTagBar,            0,              Button3,        toggleview,     {0} },
+ 	{ ClkTagBar,            MODKEY,         Button1,        tag,            {0} },
+ 	{ ClkTagBar,            MODKEY,         Button3,        toggletag,      {0} },
++	{ ClkTabBar,            0,              Button1,        focuswin,       {0} },
+ };
+ 
+diff --git a/dwm.1 b/dwm.1
+index 6687011..077d92b 100644
+--- a/dwm.1
++++ b/dwm.1
+@@ -19,14 +19,22 @@ layout applied.
+ Windows are grouped by tags. Each window can be tagged with one or multiple
+ tags. Selecting certain tags displays all windows with these tags.
+ .P
+-Each screen contains a small status bar which displays all available tags, the
+-layout, the title of the focused window, and the text read from the root window
+-name property, if the screen is focused. A floating window is indicated with an
+-empty square and a maximised floating window is indicated with a filled square
+-before the windows title.  The selected tags are indicated with a different
+-color. The tags of the focused window are indicated with a filled square in the
+-top left corner.  The tags which are applied to one or more windows are
+-indicated with an empty square in the top left corner.
++Each screen contains two small status bars.
++.P
++One bar displays all available tags, the layout, the title of the focused
++window, and the text read from the root window name property, if the screen is
++focused. A floating window is indicated with an empty square and a maximised
++floating window is indicated with a filled square before the windows title.  The
++selected tags are indicated with a different color. The tags of the focused
++window are indicated with a filled square in the top left corner.  The tags
++which are applied to one or more windows are indicated with an empty square in
++the top left corner.
++.P
++Another bar contains a tab for each window of the current view and allows
++navigation between windows, especially in the monocle mode. The different
++display modes of this bar are described under the Mod1\-w Keybord command
++section.  When a single tag is selected, that tag is indicated in the left corner
++of the tab bar.
+ .P
+ dwm draws a small border around windows to indicate the focus state.
+ .SH OPTIONS
+@@ -43,7 +51,8 @@ command.
+ .TP
+ .B Button1
+ click on a tag label to display all windows with that tag, click on the layout
+-label toggles between tiled and floating layout.
++label toggles between tiled and floating layout, click on a window name in the
++tab bar brings focus to that window.
+ .TP
+ .B Button3
+ click on a tag label adds/removes all windows with that tag to/from the view.
+@@ -104,6 +113,12 @@ Increase master area size.
+ .B Mod1\-h
+ Decrease master area size.
+ .TP
++.B Mod1\-w
++Cycle over the tab bar display modes: never displayed, always displayed,
++displayed only in monocle mode when the view contains than one window (auto
++mode). Some display modes can be disabled in the configuration, config.h. In
++the default configuration only "never" and "auto" display modes are enabled.
++.TP
+ .B Mod1\-Return
+ Zooms/cycles focused window to/from master area (tiled layouts only).
+ .TP
+diff --git a/dwm.c b/dwm.c
+index 0362114..887a839 100644
+--- a/dwm.c
++++ b/dwm.c
+@@ -64,7 +64,7 @@ enum { NetSupported, NetWMName, NetWMState,
+        NetWMFullscreen, NetActiveWindow, NetWMWindowType,
+        NetWMWindowTypeDialog, NetClientList, NetLast }; /* EWMH atoms */
+ enum { WMProtocols, WMDelete, WMState, WMTakeFocus, WMLast }; /* default atoms */
+-enum { ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle,
++enum { ClkTagBar, ClkTabBar, ClkLtSymbol, ClkStatusText, ClkWinTitle,
+        ClkClientWin, ClkRootWin, ClkLast }; /* clicks */
+ 
+ typedef union {
+@@ -111,25 +111,35 @@ typedef struct {
+ 	void (*arrange)(Monitor *);
+ } Layout;
+ 
++#define MAXTABS 50
++
++typedef struct Pertag Pertag;
+ struct Monitor {
+ 	char ltsymbol[16];
+ 	float mfact;
+ 	int nmaster;
+ 	int num;
+ 	int by;               /* bar geometry */
++	int ty;               /* tab bar geometry */
+ 	int mx, my, mw, mh;   /* screen size */
+ 	int wx, wy, ww, wh;   /* window area  */
+ 	unsigned int seltags;
+ 	unsigned int sellt;
+ 	unsigned int tagset[2];
+ 	int showbar;
++	int showtab;
+ 	int topbar;
++	int toptab;
+ 	Client *clients;
+ 	Client *sel;
+ 	Client *stack;
+ 	Monitor *next;
+ 	Window barwin;
++	Window tabwin;
++	int ntabs;
++	int tab_widths[MAXTABS];
+ 	const Layout *lt[2];
++	Pertag *pertag;
+ };
+ 
+ typedef struct {
+@@ -164,12 +174,15 @@ static void detachstack(Client *c);
+ static Monitor *dirtomon(int dir);
+ static void drawbar(Monitor *m);
+ static void drawbars(void);
++static void drawtab(Monitor *m);
++static void drawtabs(void);
+ static void enternotify(XEvent *e);
+ static void expose(XEvent *e);
+ static void focus(Client *c);
+ static void focusin(XEvent *e);
+ static void focusmon(const Arg *arg);
+ static void focusstack(const Arg *arg);
++static void focuswin(const Arg* arg);
+ static int getrootptr(int *x, int *y);
+ static long getstate(Window w);
+ static int gettextprop(Window w, Atom atom, char *text, unsigned int size);
+@@ -206,6 +219,7 @@ static void setup(void);
+ static void showhide(Client *c);
+ static void sigchld(int unused);
+ static void spawn(const Arg *arg);
++static void tabmode(const Arg *arg);
+ static void tag(const Arg *arg);
+ static void tagmon(const Arg *arg);
+ static void tile(Monitor *);
+@@ -240,6 +254,7 @@ static char stext[256];
+ static int screen;
+ static int sw, sh;           /* X display screen geometry width, height */
+ static int bh, blw = 0;      /* bar geometry */
++static int th = 0;           /* tab bar geometry */
+ static int (*xerrorxlib)(Display *, XErrorEvent *);
+ static unsigned int numlockmask = 0;
+ static void (*handler[LASTEvent]) (XEvent *) = {
+@@ -270,6 +285,16 @@ static Window root;
+ /* configuration, allows nested code to access above variables */
+ #include "config.h"
+ 
++struct Pertag {
++	unsigned int curtag, prevtag; /* current and previous tag */
++	int nmasters[LENGTH(tags) + 1]; /* number of windows in master area */
++	float mfacts[LENGTH(tags) + 1]; /* mfacts per tag */
++	unsigned int sellts[LENGTH(tags) + 1]; /* selected layouts */
++	const Layout *ltidxs[LENGTH(tags) + 1][2]; /* matrix of tags and layouts indexes  */
++	Bool showbars[LENGTH(tags) + 1]; /* display bar for the current tag */
++	Client *prevzooms[LENGTH(tags) + 1]; /* store zoom information */
++};
++
+ /* compile-time check if all tags fit into an unsigned int bit array. */
+ struct NumTags { char limitexceeded[LENGTH(tags) > 31 ? -1 : 1]; };
+ 
+@@ -393,6 +418,8 @@ arrange(Monitor *m)
+ void
+ arrangemon(Monitor *m)
+ {
++	updatebarpos(m);
++	XMoveResizeWindow(dpy, m->tabwin, m->wx, m->ty, m->ww, th);
+ 	strncpy(m->ltsymbol, m->lt[m->sellt]->symbol, sizeof m->ltsymbol);
+ 	if (m->lt[m->sellt]->arrange)
+ 		m->lt[m->sellt]->arrange(m);
+@@ -442,14 +469,33 @@ buttonpress(XEvent *e)
+ 			click = ClkStatusText;
+ 		else
+ 			click = ClkWinTitle;
+-	} else if ((c = wintoclient(ev->window))) {
++	}
++	if(ev->window == selmon->tabwin) {
++		i = 0; x = 0;
++		for(c = selmon->clients; c; c = c->next){
++		  if(!ISVISIBLE(c)) continue;
++		  x += selmon->tab_widths[i];
++		  if (ev->x > x)
++		    ++i;
++		  else
++		    break;
++		  if(i >= m->ntabs) break;
++		}
++		if(c) {
++		  click = ClkTabBar;
++		  arg.ui = i;
++		}
++	}
++	else if((c = wintoclient(ev->window))) {
+ 		focus(c);
+ 		click = ClkClientWin;
+ 	}
+-	for (i = 0; i < LENGTH(buttons); i++)
+-		if (click == buttons[i].click && buttons[i].func && buttons[i].button == ev->button
+-		&& CLEANMASK(buttons[i].mask) == CLEANMASK(ev->state))
+-			buttons[i].func(click == ClkTagBar && buttons[i].arg.i == 0 ? &arg : &buttons[i].arg);
++	for(i = 0; i < LENGTH(buttons); i++)
++		if(click == buttons[i].click && buttons[i].func && buttons[i].button == ev->button
++		   && CLEANMASK(buttons[i].mask) == CLEANMASK(ev->state)){
++		  buttons[i].func(((click == ClkTagBar || click == ClkTabBar)
++				   && buttons[i].arg.i == 0) ? &arg : &buttons[i].arg);
++		}
+ }
+ 
+ void
+@@ -469,23 +515,24 @@ cleanup(void)
+ 	Arg a = {.ui = ~0};
+ 	Layout foo = { "", NULL };
+ 	Monitor *m;
+-	size_t i;
+ 
+ 	view(&a);
+ 	selmon->lt[selmon->sellt] = &foo;
+ 	for (m = mons; m; m = m->next)
+-		while (m->stack)
+-			unmanage(m->stack, 0);
++		while(m->stack)
++			unmanage(m->stack, False);
+ 	XUngrabKey(dpy, AnyKey, AnyModifier, root);
+ 	while (mons)
+ 		cleanupmon(mons);
+-	for (i = 0; i < CurLast; i++)
+-		drw_cur_free(drw, cursor[i]);
+-	for (i = 0; i < SchemeLast; i++) {
+-		drw_clr_free(scheme[i].border);
+-		drw_clr_free(scheme[i].bg);
+-		drw_clr_free(scheme[i].fg);
+-	}
++	drw_cur_free(drw, cursor[CurNormal]);
++	drw_cur_free(drw, cursor[CurResize]);
++	drw_cur_free(drw, cursor[CurMove]);
++	drw_clr_free(scheme[SchemeNorm].border);
++	drw_clr_free(scheme[SchemeNorm].bg);
++	drw_clr_free(scheme[SchemeNorm].fg);
++	drw_clr_free(scheme[SchemeSel].border);
++	drw_clr_free(scheme[SchemeSel].bg);
++	drw_clr_free(scheme[SchemeSel].fg);
+ 	drw_free(drw);
+ 	XSync(dpy, False);
+ 	XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime);
+@@ -505,6 +552,8 @@ cleanupmon(Monitor *mon)
+ 	}
+ 	XUnmapWindow(dpy, mon->barwin);
+ 	XDestroyWindow(dpy, mon->barwin);
++	XUnmapWindow(dpy, mon->tabwin);
++	XDestroyWindow(dpy, mon->tabwin);
+ 	free(mon);
+ }
+ 
+@@ -526,6 +575,7 @@ clientmessage(XEvent *e)
+ {
+ 	XClientMessageEvent *cme = &e->xclient;
+ 	Client *c = wintoclient(cme->window);
++	int i;
+ 
+ 	if (!c)
+ 		return;
+@@ -537,6 +587,8 @@ clientmessage(XEvent *e)
+ 		if (!ISVISIBLE(c)) {
+ 			c->mon->seltags ^= 1;
+ 			c->mon->tagset[c->mon->seltags] = c->tags;
++			for(i=0; !(c->tags & 1 << i); i++);
++			view(&(Arg){.ui = 1 << i});
+ 		}
+ 		pop(c);
+ 	}
+@@ -565,6 +617,7 @@ void
+ configurenotify(XEvent *e)
+ {
+ 	Monitor *m;
++	Client *c;
+ 	XConfigureEvent *ev = &e->xconfigure;
+ 	int dirty;
+ 
+@@ -576,8 +629,14 @@ configurenotify(XEvent *e)
+ 		if (updategeom() || dirty) {
+ 			drw_resize(drw, sw, bh);
+ 			updatebars();
+-			for (m = mons; m; m = m->next)
++			//refreshing display of status bar. The tab bar is handled by the arrange()
++			//method, which is called below
++			for(m = mons; m; m = m->next){
++				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);
++			}
+ 			focus(NULL);
+ 			arrange(NULL);
+ 		}
+@@ -640,16 +699,41 @@ Monitor *
+ createmon(void)
+ {
+ 	Monitor *m;
++	int i;
+ 
+ 	m = ecalloc(1, sizeof(Monitor));
+ 	m->tagset[0] = m->tagset[1] = 1;
+ 	m->mfact = mfact;
+ 	m->nmaster = nmaster;
+ 	m->showbar = showbar;
++	m->showtab = showtab;
+ 	m->topbar = topbar;
+-	m->lt[0] = &layouts[0];
++	m->toptab = toptab;
++	m->ntabs = 0;
++	m->lt[0] = &layouts[def_layouts[1] % LENGTH(layouts)];
+ 	m->lt[1] = &layouts[1 % LENGTH(layouts)];
+ 	strncpy(m->ltsymbol, layouts[0].symbol, sizeof m->ltsymbol);
++	if(!(m->pertag = (Pertag *)calloc(1, sizeof(Pertag))))
++		die("fatal: could not malloc() %u bytes\n", sizeof(Pertag));
++	m->pertag->curtag = m->pertag->prevtag = 1;
++	for(i=0; i <= LENGTH(tags); i++) {
++		/* init nmaster */
++		m->pertag->nmasters[i] = m->nmaster;
++
++		/* init mfacts */
++		m->pertag->mfacts[i] = m->mfact;
++
++		/* init layouts */
++		m->pertag->ltidxs[i][0] = &layouts[def_layouts[i % LENGTH(def_layouts)] % LENGTH(layouts)];
++		m->pertag->ltidxs[i][1] = m->lt[1];
++		m->pertag->sellts[i] = m->sellt;
++
++		/* init showbar */
++		m->pertag->showbars[i] = m->showbar;
++
++		/* swap focus and zoomswap*/
++		m->pertag->prevzooms[i] = NULL;
++	}
+ 	return m;
+ }
+ 
+@@ -763,6 +847,104 @@ drawbars(void)
+ }
+ 
+ void
++drawtabs(void) {
++	Monitor *m;
++
++	for(m = mons; m; m = m->next)
++		drawtab(m);
++}
++
++static int
++cmpint(const void *p1, const void *p2) {
++  /* The actual arguments to this function are "pointers to
++     pointers to char", but strcmp(3) arguments are "pointers
++     to char", hence the following cast plus dereference */
++  return *((int*) p1) > * (int*) p2;
++}
++
++
++void
++drawtab(Monitor *m) {
++	Client *c;
++	int i;
++	int itag = -1;
++	char view_info[50];
++	int view_info_w = 0;
++	int sorted_label_widths[MAXTABS];
++	int tot_width;
++	int maxsize = bh;
++	int x = 0;
++	int w = 0;
++
++	//view_info: indicate the tag which is displayed in the view
++	for(i = 0; i < LENGTH(tags); ++i){
++	  if((selmon->tagset[selmon->seltags] >> i) & 1) {
++	    if(itag >=0){ //more than one tag selected
++	      itag = -1;
++	      break;
++	    }
++	    itag = i;
++	  }
++	}
++	if(0 <= itag  && itag < LENGTH(tags)){
++	  snprintf(view_info, sizeof view_info, "[%s]", tags[itag]);
++	} else {
++	  strncpy(view_info, "[...]", sizeof view_info);
++	}
++	view_info[sizeof(view_info) - 1 ] = 0;
++	view_info_w = TEXTW(view_info);
++	tot_width = view_info_w;
++
++	/* Calculates number of labels and their width */
++	m->ntabs = 0;
++	for(c = m->clients; c; c = c->next){
++	  if(!ISVISIBLE(c)) continue;
++	  m->tab_widths[m->ntabs] = TEXTW(c->name);
++	  tot_width += m->tab_widths[m->ntabs];
++	  ++m->ntabs;
++	  if(m->ntabs >= MAXTABS) break;
++	}
++
++	if(tot_width > m->ww){ //not enough space to display the labels, they need to be truncated
++	  memcpy(sorted_label_widths, m->tab_widths, sizeof(int) * m->ntabs);
++	  qsort(sorted_label_widths, m->ntabs, sizeof(int), cmpint);
++	  tot_width = view_info_w;
++	  for(i = 0; i < m->ntabs; ++i){
++	    if(tot_width + (m->ntabs - i) * sorted_label_widths[i] > m->ww)
++	      break;
++	    tot_width += sorted_label_widths[i];
++	  }
++	  maxsize = (m->ww - tot_width) / (m->ntabs - i);
++	} else{
++	  maxsize = m->ww;
++	}
++	i = 0;
++	for(c = m->clients; c; c = c->next){
++	  if(!ISVISIBLE(c)) continue;
++	  if(i >= m->ntabs) break;
++	  if(m->tab_widths[i] >  maxsize) m->tab_widths[i] = maxsize;
++	  w = m->tab_widths[i];
++	  drw_setscheme(drw, (c == m->sel) ? &scheme[SchemeSel] : &scheme[SchemeNorm]);
++	  drw_text(drw, x, 0, w, th, c->name, 0);
++	  x += w;
++	  ++i;
++	}
++
++	drw_setscheme(drw, &scheme[SchemeNorm]);
++
++	/* cleans interspace between window names and current viewed tag label */
++	w = m->ww - view_info_w - x;
++	drw_text(drw, x, 0, w, th, "", 0);
++
++	/* view info */
++	x += w;
++	w = view_info_w;
++	drw_text(drw, x, 0, w, th, view_info, 0);
++
++	drw_map(drw, m->tabwin, 0, 0, m->ww, th);
++}
++
++void
+ enternotify(XEvent *e)
+ {
+ 	Client *c;
+@@ -787,8 +969,10 @@ 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);
++		drawtab(m);
++	}
+ }
+ 
+ void
+@@ -806,7 +990,7 @@ focus(Client *c)
+ 			clearurgent(c);
+ 		detachstack(c);
+ 		attachstack(c);
+-		grabbuttons(c, 1);
++		grabbuttons(c, True);
+ 		XSetWindowBorder(dpy, c->win, scheme[SchemeSel].border->pix);
+ 		setfocus(c);
+ 	} else {
+@@ -815,6 +999,7 @@ focus(Client *c)
+ 	}
+ 	selmon->sel = c;
+ 	drawbars();
++	drawtabs();
+ }
+ 
+ /* there are some broken focus acquiring clients */
+@@ -868,6 +1053,19 @@ focusstack(const Arg *arg)
+ 	}
+ }
+ 
++void
++focuswin(const Arg* arg){
++  int iwin = arg->i;
++  Client* c = NULL;
++  for(c = selmon->clients; c && (iwin || !ISVISIBLE(c)) ; c = c->next){
++    if(ISVISIBLE(c)) --iwin;
++  };
++  if(c) {
++    focus(c);
++    restack(selmon);
++  }
++}
++
+ Atom
+ getatomprop(Client *c, Atom prop)
+ {
+@@ -981,7 +1179,7 @@ grabkeys(void)
+ void
+ incnmaster(const Arg *arg)
+ {
+-	selmon->nmaster = MAX(selmon->nmaster + arg->i, 0);
++	selmon->nmaster = selmon->pertag->nmasters[selmon->pertag->curtag] = MAX(selmon->nmaster + arg->i, 0);
+ 	arrange(selmon);
+ }
+ 
+@@ -1139,7 +1337,7 @@ motionnotify(XEvent *e)
+ 	if (ev->window != root)
+ 		return;
+ 	if ((m = recttomon(ev->x_root, ev->y_root, 1, 1)) != mon && mon) {
+-		unfocus(selmon->sel, 1);
++		unfocus(selmon->sel, True);
+ 		selmon = m;
+ 		focus(NULL);
+ 	}
+@@ -1159,11 +1357,13 @@ movemouse(const Arg *arg)
+ 		return;
+ 	if (c->isfullscreen) /* no support moving fullscreen windows by mouse */
+ 		return;
++	if(c->isfullscreen) /* no support moving fullscreen windows by mouse */
++		return;
+ 	restack(selmon);
+ 	ocx = c->x;
+ 	ocy = c->y;
+ 	if (XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
+-	None, cursor[CurMove]->cursor, CurrentTime) != GrabSuccess)
++			 None, cursor[CurMove]->cursor, CurrentTime) != GrabSuccess)
+ 		return;
+ 	if (!getrootptr(&x, &y))
+ 		return;
+@@ -1250,12 +1450,14 @@ propertynotify(XEvent *e)
+ 		case XA_WM_HINTS:
+ 			updatewmhints(c);
+ 			drawbars();
++			drawtabs();
+ 			break;
+ 		}
+ 		if (ev->atom == XA_WM_NAME || ev->atom == netatom[NetWMName]) {
+ 			updatetitle(c);
+ 			if (c == c->mon->sel)
+ 				drawbar(c->mon);
++			drawtab(c->mon);
+ 		}
+ 		if (ev->atom == netatom[NetWMWindowType])
+ 			updatewindowtype(c);
+@@ -1317,11 +1519,13 @@ resizemouse(const Arg *arg)
+ 		return;
+ 	if (c->isfullscreen) /* no support resizing fullscreen windows by mouse */
+ 		return;
++	if(c->isfullscreen) /* no support resizing fullscreen windows by mouse */
++		return;
+ 	restack(selmon);
+ 	ocx = c->x;
+ 	ocy = c->y;
+ 	if (XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
+-	                None, cursor[CurResize]->cursor, CurrentTime) != GrabSuccess)
++			 None, cursor[CurResize]->cursor, CurrentTime) != GrabSuccess)
+ 		return;
+ 	XWarpPointer(dpy, None, c->win, 0, 0, 0, 0, c->w + c->bw - 1, c->h + c->bw - 1);
+ 	do {
+@@ -1369,6 +1573,7 @@ restack(Monitor *m)
+ 	XWindowChanges wc;
+ 
+ 	drawbar(m);
++	drawtab(m);
+ 	if (!m->sel)
+ 		return;
+ 	if (m->sel->isfloating || !m->lt[m->sellt]->arrange)
+@@ -1477,11 +1682,11 @@ sendevent(Client *c, Atom proto)
+ void
+ setfocus(Client *c)
+ {
+-	if (!c->neverfocus) {
++	if(!c->neverfocus) {
+ 		XSetInputFocus(dpy, c->win, RevertToPointerRoot, CurrentTime);
+ 		XChangeProperty(dpy, root, netatom[NetActiveWindow],
+-		                XA_WINDOW, 32, PropModeReplace,
+-		                (unsigned char *) &(c->win), 1);
++ 		                XA_WINDOW, 32, PropModeReplace,
++ 		                (unsigned char *) &(c->win), 1);
+ 	}
+ 	sendevent(c, wmatom[WMTakeFocus]);
+ }
+@@ -1517,10 +1722,13 @@ setfullscreen(Client *c, int fullscreen)
+ void
+ setlayout(const Arg *arg)
+ {
+-	if (!arg || !arg->v || arg->v != selmon->lt[selmon->sellt])
+-		selmon->sellt ^= 1;
+-	if (arg && arg->v)
+-		selmon->lt[selmon->sellt] = (Layout *)arg->v;
++	if(!arg || !arg->v || arg->v != selmon->lt[selmon->sellt]) {
++		selmon->pertag->sellts[selmon->pertag->curtag] ^= 1;
++		selmon->sellt = selmon->pertag->sellts[selmon->pertag->curtag];
++	}
++	if(arg && arg->v)
++		selmon->pertag->ltidxs[selmon->pertag->curtag][selmon->sellt] = (Layout *)arg->v;
++	selmon->lt[selmon->sellt] = selmon->pertag->ltidxs[selmon->pertag->curtag][selmon->sellt];
+ 	strncpy(selmon->ltsymbol, selmon->lt[selmon->sellt]->symbol, sizeof selmon->ltsymbol);
+ 	if (selmon->sel)
+ 		arrange(selmon);
+@@ -1539,7 +1747,7 @@ setmfact(const Arg *arg)
+ 	f = arg->f < 1.0 ? arg->f + selmon->mfact : arg->f - 1.0;
+ 	if (f < 0.1 || f > 0.9)
+ 		return;
+-	selmon->mfact = f;
++	selmon->mfact = selmon->pertag->mfacts[selmon->pertag->curtag] = f;
+ 	arrange(selmon);
+ }
+ 
+@@ -1559,8 +1767,9 @@ setup(void)
+ 	drw = drw_create(dpy, screen, root, sw, sh);
+ 	drw_load_fonts(drw, fonts, LENGTH(fonts));
+ 	if (!drw->fontcount)
+-		die("no fonts could be loaded.\n");
++		die("No fonts could be loaded.\n");
+ 	bh = drw->fonts[0]->h + 2;
++	th = bh;
+ 	updategeom();
+ 	/* init atoms */
+ 	wmatom[WMProtocols] = XInternAtom(dpy, "WM_PROTOCOLS", False);
+@@ -1632,10 +1841,10 @@ sigchld(int unused)
+ void
+ spawn(const Arg *arg)
+ {
+-	if (arg->v == dmenucmd)
++	if(arg->v == dmenucmd)
+ 		dmenumon[0] = '0' + selmon->num;
+-	if (fork() == 0) {
+-		if (dpy)
++	if(fork() == 0) {
++		if(dpy)
+ 			close(ConnectionNumber(dpy));
+ 		setsid();
+ 		execvp(((char **)arg->v)[0], (char **)arg->v);
+@@ -1692,18 +1901,29 @@ tile(Monitor *m)
+ void
+ togglebar(const Arg *arg)
+ {
+-	selmon->showbar = !selmon->showbar;
++	selmon->showbar = selmon->pertag->showbars[selmon->pertag->curtag] = !selmon->showbar;
+ 	updatebarpos(selmon);
+ 	XMoveResizeWindow(dpy, selmon->barwin, selmon->wx, selmon->by, selmon->ww, bh);
+ 	arrange(selmon);
+ }
+ 
+ void
++tabmode(const Arg *arg)
++{
++	if(arg && arg->i >= 0)
++		selmon->showtab = arg->ui % showtab_nmodes;
++	else
++		selmon->showtab = (selmon->showtab + 1 ) % showtab_nmodes;
++	arrange(selmon);
++}
++
++
++void
+ togglefloating(const Arg *arg)
+ {
+-	if (!selmon->sel)
++	if(!selmon->sel)
+ 		return;
+-	if (selmon->sel->isfullscreen) /* no support for fullscreen windows */
++	if(selmon->sel->isfullscreen) /* no support for fullscreen windows */
+ 		return;
+ 	selmon->sel->isfloating = !selmon->sel->isfloating || selmon->sel->isfixed;
+ 	if (selmon->sel->isfloating)
+@@ -1731,9 +1951,29 @@ void
+ toggleview(const Arg *arg)
+ {
+ 	unsigned int newtagset = selmon->tagset[selmon->seltags] ^ (arg->ui & TAGMASK);
++	int i;
+ 
+ 	if (newtagset) {
++		if(newtagset == ~0) {
++			selmon->pertag->prevtag = selmon->pertag->curtag;
++			selmon->pertag->curtag = 0;
++		}
++		/* test if the user did not select the same tag */
++		if(!(newtagset & 1 << (selmon->pertag->curtag - 1))) {
++			selmon->pertag->prevtag = selmon->pertag->curtag;
++			for (i=0; !(newtagset & 1 << i); i++) ;
++			selmon->pertag->curtag = i + 1;
++		}
+ 		selmon->tagset[selmon->seltags] = newtagset;
++
++		/* apply settings for this view */
++		selmon->nmaster = selmon->pertag->nmasters[selmon->pertag->curtag];
++		selmon->mfact = selmon->pertag->mfacts[selmon->pertag->curtag];
++		selmon->sellt = selmon->pertag->sellts[selmon->pertag->curtag];
++		selmon->lt[selmon->sellt] = selmon->pertag->ltidxs[selmon->pertag->curtag][selmon->sellt];
++		selmon->lt[selmon->sellt^1] = selmon->pertag->ltidxs[selmon->pertag->curtag][selmon->sellt^1];
++		if (selmon->showbar != selmon->pertag->showbars[selmon->pertag->curtag])
++			togglebar(NULL);
+ 		focus(NULL);
+ 		arrange(selmon);
+ 	}
+@@ -1744,7 +1984,7 @@ unfocus(Client *c, int setfocus)
+ {
+ 	if (!c)
+ 		return;
+-	grabbuttons(c, 0);
++	grabbuttons(c, False);
+ 	XSetWindowBorder(dpy, c->win, scheme[SchemeNorm].border->pix);
+ 	if (setfocus) {
+ 		XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime);
+@@ -1809,20 +2049,44 @@ updatebars(void)
+ 		                          CWOverrideRedirect|CWBackPixmap|CWEventMask, &wa);
+ 		XDefineCursor(dpy, m->barwin, cursor[CurNormal]->cursor);
+ 		XMapRaised(dpy, m->barwin);
++		m->tabwin = XCreateWindow(dpy, root, m->wx, m->ty, m->ww, th, 0, DefaultDepth(dpy, screen),
++					  CopyFromParent, DefaultVisual(dpy, screen),
++					  CWOverrideRedirect|CWBackPixmap|CWEventMask, &wa);
++		XDefineCursor(dpy, m->tabwin, cursor[CurNormal]->cursor);
++		XMapRaised(dpy, m->tabwin);
+ 	}
+ }
+ 
+ void
+ updatebarpos(Monitor *m)
+ {
++	Client *c;
++	int nvis = 0;
++	
+ 	m->wy = m->my;
+ 	m->wh = m->mh;
+ 	if (m->showbar) {
+ 		m->wh -= bh;
+ 		m->by = m->topbar ? m->wy : m->wy + m->wh;
+-		m->wy = m->topbar ? m->wy + bh : m->wy;
+-	} else
++		if ( m->topbar )
++			m->wy += bh;
++	} else {
+ 		m->by = -bh;
++	}
++
++	for(c = m->clients; c; c = c->next){
++	  if(ISVISIBLE(c)) ++nvis;
++	}
++
++	if(m->showtab == showtab_always
++	   || ((m->showtab == showtab_auto) && (nvis > 1) && (m->lt[m->sellt]->arrange == monocle))){
++		m->wh -= th;
++		m->ty = m->toptab ? m->wy : m->wy + m->wh;
++		if ( m->toptab )
++			m->wy += th;
++	} else {
++		m->ty = -th;
++	}
+ }
+ 
+ void
+@@ -2004,9 +2268,9 @@ updatewindowtype(Client *c)
+ 	Atom wtype = getatomprop(c, netatom[NetWMWindowType]);
+ 
+ 	if (state == netatom[NetWMFullscreen])
+-		setfullscreen(c, 1);
++		setfullscreen(c, True);
+ 	if (wtype == netatom[NetWMWindowTypeDialog])
+-		c->isfloating = 1;
++		c->isfloating = True;
+ }
+ 
+ void
+@@ -2031,11 +2295,33 @@ updatewmhints(Client *c)
+ void
+ view(const Arg *arg)
+ {
+-	if ((arg->ui & TAGMASK) == selmon->tagset[selmon->seltags])
++	int i;
++	unsigned int tmptag;
++
++	if((arg->ui & TAGMASK) == selmon->tagset[selmon->seltags])
+ 		return;
+ 	selmon->seltags ^= 1; /* toggle sel tagset */
+-	if (arg->ui & TAGMASK)
++	if(arg->ui & TAGMASK) {
++		selmon->pertag->prevtag = selmon->pertag->curtag;
+ 		selmon->tagset[selmon->seltags] = arg->ui & TAGMASK;
++		if(arg->ui == ~0)
++			selmon->pertag->curtag = 0;
++		else {
++			for (i=0; !(arg->ui & 1 << i); i++) ;
++			selmon->pertag->curtag = i + 1;
++		}
++	} else {
++		tmptag = selmon->pertag->prevtag;
++		selmon->pertag->prevtag = selmon->pertag->curtag;
++		selmon->pertag->curtag = tmptag;
++	}
++	selmon->nmaster = selmon->pertag->nmasters[selmon->pertag->curtag];
++	selmon->mfact = selmon->pertag->mfacts[selmon->pertag->curtag];
++	selmon->sellt = selmon->pertag->sellts[selmon->pertag->curtag];
++	selmon->lt[selmon->sellt] = selmon->pertag->ltidxs[selmon->pertag->curtag][selmon->sellt];
++	selmon->lt[selmon->sellt^1] = selmon->pertag->ltidxs[selmon->pertag->curtag][selmon->sellt^1];
++	if (selmon->showbar != selmon->pertag->showbars[selmon->pertag->curtag])
++		togglebar(NULL);
+ 	focus(NULL);
+ 	arrange(selmon);
+ }
+@@ -2063,7 +2349,7 @@ wintomon(Window w)
+ 	if (w == root && getrootptr(&x, &y))
+ 		return recttomon(x, y, 1, 1);
+ 	for (m = mons; m; m = m->next)
+-		if (w == m->barwin)
++		if(w == m->barwin || w == m->tabwin)
+ 			return m;
+ 	if ((c = wintoclient(w)))
+ 		return c->mon;
diff --git a/patches/dwm-autoresize-6.1.diff b/patches/dwm-autoresize-6.1.diff
new file mode 100644
index 0000000..76530b9
--- /dev/null
+++ b/patches/dwm-autoresize-6.1.diff
@@ -0,0 +1,35 @@
+diff --git a/dwm.c b/dwm.c
+index 0362114..e4e8514 100644
+--- a/dwm.c
++++ b/dwm.c
+@@ -92,7 +92,7 @@ struct Client {
+ 	int basew, baseh, incw, inch, maxw, maxh, minw, minh;
+ 	int bw, oldbw;
+ 	unsigned int tags;
+-	int isfixed, isfloating, isurgent, neverfocus, oldstate, isfullscreen;
++	int isfixed, isfloating, isurgent, neverfocus, oldstate, isfullscreen, needresize;
+ 	Client *next;
+ 	Client *snext;
+ 	Monitor *mon;
+@@ -621,6 +621,8 @@ configurerequest(XEvent *e)
+ 				configure(c);
+ 			if (ISVISIBLE(c))
+ 				XMoveResizeWindow(dpy, c->win, c->x, c->y, c->w, c->h);
++			else
++				c->needresize = 1;
+ 		} else
+ 			configure(c);
+ 	} else {
+@@ -1611,6 +1613,12 @@ showhide(Client *c)
+ 	if (ISVISIBLE(c)) {
+ 		/* show clients top down */
+ 		XMoveWindow(dpy, c->win, c->x, c->y);
++		if (c->needresize) {
++			c->needresize = 0;
++			XMoveResizeWindow(dpy, c->win, c->x, c->y, c->w, c->h);
++		} else {
++			XMoveWindow(dpy, c->win, c->x, c->y);
++		}
+ 		if ((!c->mon->lt[c->mon->sellt]->arrange || c->isfloating) && !c->isfullscreen)
+ 			resize(c, c->x, c->y, c->w, c->h, 0);
+ 		showhide(c->snext);
diff --git a/patches/dwm-statuscolors-6.1.diff b/patches/dwm-statuscolors-6.1.diff
new file mode 100644
index 0000000..3aead49
--- /dev/null
+++ b/patches/dwm-statuscolors-6.1.diff
@@ -0,0 +1,194 @@
+diff -up dwm/drw.c dwm-statuscolors/drw.c
+--- dwm/drw.c	2015-11-08 15:39:37.000000000 -0700
++++ dwm-statuscolors/drw.c	2015-11-28 15:42:28.534399525 -0700
+@@ -206,6 +206,68 @@ drw_setscheme(Drw *drw, ClrScheme *schem
+ 	drw->scheme = scheme;
+ }
+ 
++int
++drw_get_width(Drw *drw, int numcolors, const char *text)
++{
++	int i;
++	Fnt *curfont = drw->fonts[0];
++	int w = drw_text(drw, 0, 0, 0, 0, text, 0) + curfont->h;
++
++	for (i = 0; i < strlen(text); i++) {
++		if (text[i] > 0 && text[i] <= numcolors) {
++			/* we found a color code
++			 * drw_text counted it as a normal character and added one character's width
++			 * we aren't going to render this character, so we remove one character's width */
++			w -= curfont->xfont->max_advance_width;
++
++			if (i == 0 || i + 1 == strlen(text)) {
++				/* we're on the first or the last character of the string
++				 * drw_text already added one character's height (divided by 2) as padding to the beginning and end
++				 * we don't want to double this padding, so we skip this character */
++				continue;
++			}
++
++			if (text[i - 1] > 0 && text[i - 1] <= numcolors) {
++				/* the previous character was also a color code
++				 * we already added padding in the previous iteration
++				 * we don't want to double this padding, so we skip this character */
++				continue;
++			}
++
++			/* we are somewhere in the middle of the string and the color has changed
++			 * we want to add one character's height (divided by 2) as padding to the end of the previous colored text
++			 * and to the beginning of the new colored text */
++			w += curfont->h;
++		}
++	}
++
++  return w;
++}
++
++void
++drw_colored_text(Drw *drw, ClrScheme *scheme, int numcolors, int x, int y, unsigned int w, unsigned int h, char *text)
++{
++	if (!drw || !drw->fontcount || !drw->scheme)
++		return;
++
++	char *buf = text, *ptr = buf, c = 1;
++	int i;
++
++	while (*ptr) {
++		for (i = 0; *ptr < 0 || *ptr > numcolors; i++, ptr++);
++		if (!*ptr)
++			break;
++		c = *ptr;
++		*ptr = 0;
++		if (i)
++			x = drw_text(drw, x, y, w, h, buf, 0) + drw->fonts[0]->h;
++		*ptr = c;
++		drw_setscheme(drw, &scheme[c-1]);
++		buf = ++ptr;
++	}
++	drw_text(drw, x, y, w, h, buf, 0);
++}
++
+ void
+ drw_rect(Drw *drw, int x, int y, unsigned int w, unsigned int h, int filled, int empty, int invert)
+ {
+diff -up dwm/drw.h dwm-statuscolors/drw.h
+--- dwm/drw.h	2015-11-08 15:39:37.000000000 -0700
++++ dwm-statuscolors/drw.h	2015-11-28 15:39:44.427726312 -0700
+@@ -67,6 +67,8 @@ void drw_setfont(Drw *, Fnt *);
+ void drw_setscheme(Drw *, ClrScheme *);
+ 
+ /* Drawing functions */
++int drw_get_width(Drw *, int, const char *);
++void drw_colored_text(Drw *, ClrScheme *, int, int, int, unsigned int, unsigned int, char *);
+ void drw_rect(Drw *, int, int, unsigned int, unsigned int, int, int, int);
+ int drw_text(Drw *, int, int, unsigned int, unsigned int, const char *, int);
+ 
+diff -up dwm/dwm.c dwm-statuscolors/dwm.c
+--- dwm/dwm.c	2015-11-08 15:39:37.000000000 -0700
++++ dwm-statuscolors/dwm.c	2015-11-28 15:45:32.134406853 -0700
+@@ -51,6 +51,7 @@
+                                * 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 MAXCOLORS               9
+ #define MOUSEMASK               (BUTTONMASK|PointerMotionMask)
+ #define WIDTH(X)                ((X)->w + 2 * (X)->bw)
+ #define HEIGHT(X)               ((X)->h + 2 * (X)->bw)
+@@ -261,7 +262,7 @@ static void (*handler[LASTEvent]) (XEven
+ static Atom wmatom[WMLast], netatom[NetLast];
+ static int running = 1;
+ static Cur *cursor[CurLast];
+-static ClrScheme scheme[SchemeLast];
++static ClrScheme scheme[MAXCOLORS];
+ static Display *dpy;
+ static Drw *drw;
+ static Monitor *mons, *selmon;
+@@ -718,35 +719,35 @@ drawbar(Monitor *m)
+ 	x = 0;
+ 	for (i = 0; i < LENGTH(tags); i++) {
+ 		w = TEXTW(tags[i]);
+-		drw_setscheme(drw, m->tagset[m->seltags] & 1 << i ? &scheme[SchemeSel] : &scheme[SchemeNorm]);
+-		drw_text(drw, x, 0, w, bh, tags[i], urg & 1 << i);
++		drw_setscheme(drw, &scheme[(m->tagset[m->seltags] & 1 << i) ? 1 : (urg & 1 << i ? 2 : 0)]);
++		drw_text(drw, x, 0, w, bh, tags[i], 0);
+ 		drw_rect(drw, x + 1, 1, dx, dx, m == selmon && selmon->sel && selmon->sel->tags & 1 << i,
+-		           occ & 1 << i, urg & 1 << i);
++		         occ & 1 << i, 0);
+ 		x += w;
+ 	}
+ 	w = blw = TEXTW(m->ltsymbol);
+-	drw_setscheme(drw, &scheme[SchemeNorm]);
++	drw_setscheme(drw, &scheme[0]);
+ 	drw_text(drw, x, 0, w, bh, m->ltsymbol, 0);
+ 	x += w;
+ 	xx = x;
+ 	if (m == selmon) { /* status is only drawn on selected monitor */
+-		w = TEXTW(stext);
++		w = drw_get_width(drw, NUMCOLORS, stext);
+ 		x = m->ww - w;
+ 		if (x < xx) {
+ 			x = xx;
+ 			w = m->ww - xx;
+ 		}
+-		drw_text(drw, x, 0, w, bh, stext, 0);
++		drw_colored_text(drw, scheme, NUMCOLORS, x, 0, w, bh, stext);
+ 	} else
+ 		x = m->ww;
+ 	if ((w = x - xx) > bh) {
+ 		x = xx;
+ 		if (m->sel) {
+-			drw_setscheme(drw, m == selmon ? &scheme[SchemeSel] : &scheme[SchemeNorm]);
++			drw_setscheme(drw, &scheme[m == selmon ? 1 : 0]);
+ 			drw_text(drw, x, 0, w, bh, m->sel->name, 0);
+ 			drw_rect(drw, x + 1, 1, dx, dx, m->sel->isfixed, m->sel->isfloating, 0);
+ 		} else {
+-			drw_setscheme(drw, &scheme[SchemeNorm]);
++			drw_setscheme(drw, &scheme[0]);
+ 			drw_rect(drw, x, 0, w, bh, 1, 0, 1);
+ 		}
+ 	}
+@@ -807,7 +808,7 @@ focus(Client *c)
+ 		detachstack(c);
+ 		attachstack(c);
+ 		grabbuttons(c, 1);
+-		XSetWindowBorder(dpy, c->win, scheme[SchemeSel].border->pix);
++		XSetWindowBorder(dpy, c->win, scheme[1].border->pix);
+ 		setfocus(c);
+ 	} else {
+ 		XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime);
+@@ -1065,7 +1066,7 @@ manage(Window w, XWindowAttributes *wa)
+ 
+ 	wc.border_width = c->bw;
+ 	XConfigureWindow(dpy, w, CWBorderWidth, &wc);
+-	XSetWindowBorder(dpy, w, scheme[SchemeNorm].border->pix);
++	XSetWindowBorder(dpy, w, scheme[0].border->pix);
+ 	configure(c); /* propagates border_width, if size doesn't change */
+ 	updatewindowtype(c);
+ 	updatesizehints(c);
+@@ -1580,12 +1581,12 @@ setup(void)
+ 	cursor[CurResize] = drw_cur_create(drw, XC_sizing);
+ 	cursor[CurMove] = drw_cur_create(drw, XC_fleur);
+ 	/* init appearance */
+-	scheme[SchemeNorm].border = drw_clr_create(drw, normbordercolor);
+-	scheme[SchemeNorm].bg = drw_clr_create(drw, normbgcolor);
+-	scheme[SchemeNorm].fg = drw_clr_create(drw, normfgcolor);
+-	scheme[SchemeSel].border = drw_clr_create(drw, selbordercolor);
+-	scheme[SchemeSel].bg = drw_clr_create(drw, selbgcolor);
+-	scheme[SchemeSel].fg = drw_clr_create(drw, selfgcolor);
++	for(int i = 0; i < NUMCOLORS; i++){
++		scheme[i].border = drw_clr_create(drw, colors[i][0]);
++		scheme[i].fg = drw_clr_create(drw, colors[i][1]);
++		scheme[i].bg = drw_clr_create(drw, colors[i][2]);
++	}
++
+ 	/* init bars */
+ 	updatebars();
+ 	updatestatus();
+@@ -1745,7 +1746,7 @@ unfocus(Client *c, int setfocus)
+ 	if (!c)
+ 		return;
+ 	grabbuttons(c, 0);
+-	XSetWindowBorder(dpy, c->win, scheme[SchemeNorm].border->pix);
++	XSetWindowBorder(dpy, c->win, scheme[0].border->pix);
+ 	if (setfocus) {
+ 		XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime);
+ 		XDeleteProperty(dpy, root, netatom[NetActiveWindow]);