GopherProxy

	dwm-keymodes-vim-5.8.2.diff - sites - public wiki contents of suckless.org
	git clone git://git.suckless.org/sites
	Log
	Files
	Refs
	---
	dwm-keymodes-vim-5.8.2.diff (21593B)
	---
	1 diff -up ../dwm-5.8.2-1/config.def.h ./config.def.h
	2 --- ../dwm-5.8.2-1/config.def.h 2010-06-11 01:10:05.465026000 +02…
	3 +++ ./config.def.h 2010-06-11 01:13:49.211525000 +0200
	4 @@ -19,6 +19,9 @@ static const char *tags[] = { "1", "2",
	5 /* include(s) depending on the tags array */
	6 #include "flextile.h"
	7
	8 +/* include(s) defining functions */
	9 +#include "keymodes.pre.h"
	10 +
	11 static const Rule rules[] = {
	12 /* class instance title tags mask isfloating …
	13 { "Gimp", NULL, NULL, 0, True, …
	14 @@ -36,9 +39,9 @@ static const int layoutaxis[] = {
	15
	16 static const Layout layouts[] = {
	17 /* symbol arrange function */
	18 - { "[]=", tile }, /* first entry is default */
	19 + { "[M]", monocle }, /* first entry is default */
	20 + { "[]=", tile },
	21 { "><>", NULL }, /* no layout function means floating b…
	22 - { "[M]", monocle },
	23 };
	24
	25 /* key definitions */
	26 @@ -55,9 +58,11 @@ static const Layout layouts[] = {
	27 /* commands */
	28 static const char *dmenucmd[] = { "dmenu_run", "-fn", font, "-nb", norm…
	29 static const char *termcmd[] = { "uxterm", NULL };
	30 +static const char *helpcmd[] = { "uxterm", "-e", "man", "dwm", NULL };
	31
	32 static Key keys[] = {
	33 /* modifier key function argu…
	34 + { MODKEY, XK_Escape, setkeymode, {.ui…
	35 { MODKEY, XK_p, spawn, {.v …
	36 { MODKEY\|ShiftMask, XK_Return, spawn, {.v …
	37 { MODKEY, XK_b, togglebar, {0} …
	38 @@ -68,9 +73,9 @@ static Key keys[] = {
	39 { MODKEY, XK_Return, zoom, {0} …
	40 { MODKEY, XK_Tab, view, {0} …
	41 { MODKEY\|ShiftMask, XK_c, killclient, {0} …
	42 - { MODKEY, XK_t, setlayout, {.v …
	43 - { MODKEY, XK_f, setlayout, {.v …
	44 - { MODKEY, XK_m, setlayout, {.v …
	45 + { MODKEY, XK_m, setlayout, {.v …
	46 + { MODKEY, XK_t, setlayout, {.v …
	47 + { MODKEY, XK_f, setlayout, {.v …
	48 { MODKEY, XK_space, setlayout, {0} …
	49 { MODKEY\|ShiftMask, XK_space, togglefloating, {0} …
	50 { MODKEY, XK_0, view, {.ui…
	51 @@ -97,6 +102,54 @@ static Key keys[] = {
	52 { MODKEY\|ControlMask, XK_l, shiftmastersplit, {.…
	53 };
	54
	55 +static const int h_master[] = {+1, 2, 2};
	56 +static const int j_master[] = {-2, 1, 1};
	57 +static const int k_master[] = {+2, 1, 1};
	58 +static const int l_master[] = {-1, 2, 2};
	59 +
	60 +static Key cmdkeys[] = {
	61 + /* modifier keys functio…
	62 + { 0, XK_Escape, clearcm…
	63 + { ControlMask, XK_c, clearcm…
	64 + { 0, XK_i, setkeym…
	65 +};
	66 +static Command commands[] = {
	67 + /* modifier (4 keys) keysyms (4 keys) …
	68 + { {0, 0, 0, 0}, {XK_g, XK_t,…
	69 + { {0, ShiftMask, 0, 0}, {XK_g, XK_t,…
	70 + { {ControlMask, 0, 0, 0}, {XK_w, XK_c,…
	71 + { {ControlMask, 0, 0, 0}, {XK_w, XK_h,…
	72 + { {ControlMask, 0, 0, 0}, {XK_w, XK_j,…
	73 + { {ControlMask, 0, 0, 0}, {XK_w, XK_k,…
	74 + { {ControlMask, 0, 0, 0}, {XK_w, XK_l,…
	75 + { {ControlMask, ShiftMask, 0, 0}, {XK_w, XK_h,…
	76 + { {ControlMask, ShiftMask, 0, 0}, {XK_w, XK_j,…
	77 + { {ControlMask, ShiftMask, 0, 0}, {XK_w, XK_k,…
	78 + { {ControlMask, ShiftMask, 0, 0}, {XK_w, XK_l,…
	79 + { {ControlMask, 0, 0, 0}, {XK_w, XK_o,…
	80 + { {ControlMask, ShiftMask, 0, 0}, {XK_w, XK_o,…
	81 + { {ControlMask, 0, 0, 0}, {XK_w, XK_s,…
	82 + { {ControlMask, 0, 0, 0}, {XK_w, XK_t,…
	83 + { {ControlMask, ShiftMask, 0, 0}, {XK_w, XK_t,…
	84 + { {ControlMask, 0, 0, 0}, {XK_w, XK_v,…
	85 + { {ControlMask, 0, 0, 0}, {XK_w, XK_x,…
	86 + { {ControlMask, ShiftMask, 0, 0}, {XK_w, XK_x,…
	87 + { {ControlMask, 0, 0, 0}, {XK_w, XK_w,…
	88 + { {ControlMask, ShiftMask, 0, 0}, {XK_w, XK_w,…
	89 + { {ControlMask, 0, 0, 0}, {XK_w, XK_le…
	90 + { {ControlMask, ShiftMask, 0, 0}, {XK_w, XK_le…
	91 + { {ControlMask, 0, 0, 0}, {XK_w, XK_mi…
	92 + { {ControlMask, 0, 0, 0}, {XK_w, XK_pl…
	93 + { {ControlMask, ShiftMask, 0, 0}, {XK_w, XK_0,…
	94 + { {ShiftMask, 0, 0, 0}, {XK_period, XK_e,…
	95 + { {ShiftMask, 0, 0, 0}, {XK_period, XK_o,…
	96 + { {ShiftMask, 0, 0, 0}, {XK_period, XK_h,…
	97 + { {ShiftMask, 0, 0, 0}, {XK_period, XK_q,…
	98 + { {ShiftMask, 0, 0, 0}, {XK_period, XK_b,…
	99 + { {ShiftMask, 0, 0, 0}, {XK_period, XK_b,…
	100 + { {ShiftMask, 0, ShiftMask, 0}, {XK_period, XK_b,…
	101 +};
	102 +
	103 /* button definitions */
	104 /* click can be ClkLtSymbol, ClkStatusText, ClkWinTitle, ClkClientWin, …
	105 static Button buttons[] = {
	106 @@ -114,3 +167,5 @@ static Button buttons[] = {
	107 { ClkTagBar, MODKEY, Button3, togglet…
	108 };
	109
	110 +/* include(s) depending on the configuration variables */
	111 +#include "keymodes.post.h"
	112 diff -up ../dwm-5.8.2-1/dwm.c ./dwm.c
	113 --- ../dwm-5.8.2-1/dwm.c 2010-06-11 01:10:05.473958000 +0200
	114 +++ ./dwm.c 2010-06-11 01:13:49.226865000 +0200
	115 @@ -954,7 +954,7 @@ grabbuttons(Client *c, Bool focused) {
	116 }
	117
	118 void
	119 -grabkeys(void) {
	120 +grabdefkeys(void) {
	121 updatenumlockmask();
	122 {
	123 unsigned int i, j;
	124 @@ -1036,7 +1036,7 @@ isuniquegeom(XineramaScreenInfo *unique,
	125 #endif /* XINERAMA */
	126
	127 void
	128 -keypress(XEvent *e) {
	129 +defkeypress(XEvent *e) {
	130 unsigned int i;
	131 KeySym keysym;
	132 XKeyEvent *ev;
	133 diff -up ../dwm-5.8.2-1/keymodes.post.h ./keymodes.post.h
	134 --- ../dwm-5.8.2-1/keymodes.post.h 2010-06-11 01:12:53.000000000 …
	135 +++ ./keymodes.post.h 2010-06-11 01:13:49.287434000 +0200
	136 @@ -0,0 +1,409 @@
	137 +/* See LICENSE file for copyright and license details. */
	138 +/* © 2010 joten <[email protected]> */
	139 +
	140 +/* function implementations */
	141 +void
	142 +adjacenttag(const Arg *arg) {
	143 + int nexttag = selmon->curtag + arg->i;
	144 + Arg a;
	145 +
	146 + if(nexttag > LENGTH(tags))
	147 + nexttag = 1;
	148 + else if(nexttag < 1)
	149 + nexttag = LENGTH(tags);
	150 + a.ui = 1 << (nexttag - 1);
	151 + tag(&a);
	152 +}
	153 +
	154 +void
	155 +adjacentview(const Arg *arg) {
	156 + int nexttag = selmon->curtag + arg->i;
	157 + Arg a;
	158 +
	159 + if(nexttag > LENGTH(tags))
	160 + nexttag = 1;
	161 + else if(nexttag < 1)
	162 + nexttag = LENGTH(tags);
	163 + a.ui = 1 << (nexttag - 1);
	164 + view(&a);
	165 +}
	166 +
	167 +void
	168 +clearcmd(const Arg *arg) {
	169 + unsigned int i;
	170 +
	171 + for(i = 0; i < LENGTH(cmdkeysym); i++) {
	172 + cmdkeysym[i] = 0;
	173 + cmdmod[i] = 0;
	174 + }
	175 +}
	176 +
	177 +void
	178 +closewindow(const Arg *arg) {
	179 + unsigned int j, n;
	180 + Client *i;
	181 +
	182 + if(!selmon->sel \|\| selmon->sel->isfloating \|\| selmon->lt[selmon…
	183 + return;
	184 + for(n = 0, i = nexttiled(selmon->clients); i; i = nexttiled(i->…
	185 + if(i == selmon->sel)
	186 + j = n + 1;
	187 + if(j == 0 \|\| n < 2)
	188 + return;
	189 + if(j <= selmon->msplit) {
	190 + if(selmon->ltaxis[1] == 3 \|\| selmon->msplit == 1) {
	191 + selmon->msplits[selmon->curtag] = selmon->mspli…
	192 + selmon->ltaxes[selmon->curtag][1] = selmon->lta…
	193 + selmon->ltaxes[selmon->curtag][2] = selmon->lta…
	194 + } else if(j == selmon->msplit && (selmon->ltaxis[2] == …
	195 + selmon->msplits[selmon->curtag] = selmon->mspli…
	196 + selmon->ltaxes[selmon->curtag][2] = selmon->lta…
	197 + } else
	198 + selmon->ltaxes[selmon->curtag][1] = selmon->lta…
	199 + } else {
	200 + if(selmon->ltaxis[2] == 3 \|\| selmon->msplit == n - 1)
	201 + selmon->msplits[selmon->curtag] = selmon->mspli…
	202 + else if(j == selmon->msplit + 1 && (selmon->ltaxis[1] =…
	203 + selmon->msplits[selmon->curtag] = selmon->mspli…
	204 + selmon->ltaxes[selmon->curtag][1] = selmon->lta…
	205 + } else
	206 + selmon->ltaxes[selmon->curtag][2] = selmon->lta…
	207 + }
	208 + arrange(selmon);
	209 +}
	210 +
	211 +void
	212 +exchangewindow(const Arg *arg) {
	213 + int j = 0, n;
	214 + Client c, i, *sel = selmon->sel;
	215 +
	216 + if(!sel \|\| sel->isfloating \|\| selmon->lt[selmon->sellt]->arrang…
	217 + return;
	218 + for(n = 0, i = nexttiled(selmon->clients); i; i = nexttiled(i->…
	219 + if(i == selmon->sel)
	220 + j = n + 1;
	221 + if(j == 0 \|\| n < 2
	222 + \|\| (j <= selmon->msplit && selmon->ltaxis[1] == 3 && selmon->ms…
	223 + \|\| (j > selmon->msplit && selmon->ltaxis[2] == 3 && n - selmon-…
	224 + return;
	225 + if(arg->i < 0) {
	226 + if((c = prevtiled(sel))) {
	227 + /* attach before c */
	228 + detach(sel);
	229 + sel->next = c;
	230 + if(selmon->clients == c)
	231 + selmon->clients = sel;
	232 + else {
	233 + for(c = selmon->clients; c->next != sel…
	234 + c->next = sel;
	235 + }
	236 + } else {
	237 + /* move to the end */
	238 + for(c = sel; c->next; c = c->next);
	239 + detach(sel);
	240 + sel->next = NULL;
	241 + c->next = sel;
	242 + }
	243 + } else {
	244 + if((c = nexttiled(sel->next))) {
	245 + /* attach after c */
	246 + detach(sel);
	247 + sel->next = c->next;
	248 + c->next = sel;
	249 + } else {
	250 + /* move to the front */
	251 + detach(sel);
	252 + attach(sel);
	253 + }
	254 + }
	255 + focus(sel);
	256 + arrange(selmon);
	257 +}
	258 +
	259 +void
	260 +focustiled(const Arg *arg) {
	261 + float f;
	262 + unsigned int j = 0, k, n;
	263 + Client c = NULL, i;
	264 +
	265 + if(!selmon->sel \|\| selmon->sel->isfloating \|\| (selmon->lt[selmo…
	266 + return;
	267 + for(n = 0, i = nexttiled(selmon->clients); i; i = nexttiled(i->…
	268 + if(i == selmon->sel)
	269 + j = n + 1;
	270 + if(n < 2)
	271 + return;
	272 + if(arg->i < 0
	273 + && ((j > 1 && j <= selmon->msplit && selmon->ltaxis[1] == -(arg…
	274 + c = prevtiled(selmon->sel);
	275 + } else if(arg->i > 0
	276 + && ((j > 0 && j < selmon->msplit && selmon->ltaxis[1] == arg->i…
	277 + c = nexttiled(selmon->sel->next);
	278 + } else if(arg->i < 0
	279 + && n > selmon->msplit
	280 + && j > selmon->msplit && j <= n
	281 + && (selmon->ltaxis[2] - arg->i) == 3)
	282 + f = (float)(j - selmon->msplit) / (n - selmon->msplit) …
	283 + else if(arg->i > 0
	284 + && n > selmon->msplit
	285 + && j > 0 && j <= selmon->msplit
	286 + && (selmon->ltaxis[1] + arg->i) == 3)
	287 + f = selmon->msplit + (float)j / selmon->msplit * (n - s…
	288 + if(f > 0) {
	289 + k = (unsigned int)f;
	290 + if(f - k > 0)
	291 + k++;
	292 + for(j = 1, i = nexttiled(selmon->clients); i; i = nextt…
	293 + if(j == k)
	294 + c = i;
	295 + }
	296 + if(c) {
	297 + focus(c);
	298 + restack(selmon);
	299 + }
	300 +}
	301 +
	302 +void
	303 +focuswindow(const Arg *arg) {
	304 + unsigned int j = 0, k = 0, n;
	305 + Client c = NULL, i;
	306 +
	307 + if(!selmon->sel \|\| selmon->sel->isfloating \|\| selmon->lt[selmon…
	308 + return;
	309 + for(n = 0, i = nexttiled(selmon->clients); i; i = nexttiled(i->…
	310 + if(i == selmon->sel)
	311 + j = n + 1;
	312 + if(j == 0 \|\| n < 2 \|\| (selmon->msplit == n && selmon->ltaxis[1]…
	313 + return;
	314 + if(arg->i < 0) {
	315 + if((j > 1 && j <= selmon->msplit && selmon->ltaxis[1] =…
	316 + k = n;
	317 + } else if(j > selmon->msplit + 1 && j <= n && selmon->l…
	318 + k = selmon->msplit;
	319 + } else
	320 + c = prevtiled(selmon->sel);
	321 + } else {
	322 + if(j < selmon->msplit && selmon->ltaxis[1] == 3) {
	323 + k = selmon->msplit + 1;
	324 + } else if((j > selmon->msplit && j < n && selmon->ltaxi…
	325 + k = 1;
	326 + } else
	327 + c = nexttiled(selmon->sel->next);
	328 + }
	329 + if(!c && k)
	330 + for(j = 1, i = nexttiled(selmon->clients); i; i = nextt…
	331 + if(j == k)
	332 + c = i;
	333 + if(c) {
	334 + focus(c);
	335 + restack(selmon);
	336 + }
	337 +}
	338 +
	339 +void
	340 +grabkeys(void) {
	341 + if(keymode == INSERTMODE) {
	342 + grabdefkeys();
	343 + } else if(keymode == COMMANDMODE) {
	344 + XUngrabKey(dpy, AnyKey, AnyModifier, root);
	345 + XGrabKey(dpy, AnyKey, AnyModifier, root,
	346 + True, GrabModeAsync, GrabModeAsync);
	347 + }
	348 +}
	349 +
	350 +void
	351 +keypress(XEvent *e) {
	352 + unsigned int i, j;
	353 + Arg a = {0};
	354 + Bool ismatch = False, maybematch = False;
	355 + KeySym keysym;
	356 + XKeyEvent *ev;
	357 +
	358 + if(keymode == INSERTMODE)
	359 + defkeypress(e);
	360 + else if(keymode == COMMANDMODE) {
	361 + ev = &e->xkey;
	362 + keysym = XKeycodeToKeysym(dpy, (KeyCode)ev->keycode, 0);
	363 + if(keysym < XK_Shift_L \|\| keysym > XK_Hyper_R) {
	364 + for(i = 0; i < LENGTH(cmdkeys); i++)
	365 + if(keysym == cmdkeys[i].keysym
	366 + && CLEANMASK(cmdkeys[i].mod) == CLEANMA…
	367 + && cmdkeys[i].func) {
	368 + cmdkeys[i].func(&(cmdkeys[i].ar…
	369 + ismatch = True;
	370 + break;
	371 + }
	372 + if(!ismatch) {
	373 + for(j = 0; j < LENGTH(cmdkeysym); j++)
	374 + if(cmdkeysym[j] == 0) {
	375 + cmdkeysym[j] = keysym;
	376 + cmdmod[j] = ev->state;
	377 + break;
	378 + }
	379 + for(i = 0; i < LENGTH(commands); i++) {
	380 + for(j = 0; j < LENGTH(cmdkeysym…
	381 + if(cmdkeysym[j] == comm…
	382 + && CLEANMASK(cmdmod[j])…
	383 + ismatch = True;
	384 + else if(cmdkeysym[j] ==…
	385 + && cmdmod[j] == 0) {
	386 + ismatch = False;
	387 + maybematch = Tr…
	388 + break;
	389 + } else {
	390 + ismatch = False;
	391 + break;
	392 + }
	393 + }
	394 + if(ismatch) {
	395 + if(commands[i].func)
	396 + commands[i].fun…
	397 + clearcmd(&a);
	398 + break;
	399 + }
	400 +
	401 + }
	402 + if(!maybematch)
	403 + clearcmd(&a);
	404 + }
	405 + }
	406 + }
	407 +}
	408 +
	409 +void
	410 +onlyclient(const Arg *arg) {
	411 + Client *c;
	412 + XEvent ev;
	413 +
	414 + if(!selmon->sel)
	415 + return;
	416 + for(c = selmon->clients; c; c = c->next)
	417 + if(c != selmon->sel && ISVISIBLE(c)) {
	418 + if(isprotodel(c)) {
	419 + ev.type = ClientMessage;
	420 + ev.xclient.window = c->win;
	421 + ev.xclient.message_type = wmatom[WMProt…
	422 + ev.xclient.format = 32;
	423 + ev.xclient.data.l[0] = wmatom[WMDelete];
	424 + ev.xclient.data.l[1] = CurrentTime;
	425 + XSendEvent(dpy, c->win, False, NoEventM…
	426 + }
	427 + else {
	428 + XGrabServer(dpy);
	429 + XSetErrorHandler(xerrordummy);
	430 + XSetCloseDownMode(dpy, DestroyAll);
	431 + XKillClient(dpy, c->win);
	432 + XSync(dpy, False);
	433 + XSetErrorHandler(xerror);
	434 + XUngrabServer(dpy);
	435 + }
	436 + }
	437 +}
	438 +
	439 +Client *
	440 +prevtiled(Client *c) {
	441 + Client i, p;
	442 +
	443 + for(i = selmon->clients, p = NULL; i && i != c; i = i->next)
	444 + if(!i->isfloating && ISVISIBLE(i))
	445 + p = i;
	446 + return p;
	447 +}
	448 +
	449 +void
	450 +resizemaster(const Arg *arg) {
	451 + float f;
	452 + Arg a;
	453 +
	454 + if(!arg \|\| selmon->lt[selmon->sellt]->arrange != tile)
	455 + return;
	456 + f = (arg->f < 0 ? -arg->f : arg->f) - selmon->ltaxis[0] * 10;
	457 + if(f < 0 \|\| f > 1.9)
	458 + return;
	459 + a.f = arg->f / abs(arg->f) * f;
	460 + setmfact(&a);
	461 +}
	462 +
	463 +void
	464 +setkeymode(const Arg *arg) {
	465 + Arg a = {0};
	466 +
	467 + if(!arg)
	468 + return;
	469 + keymode = arg->ui;
	470 + clearcmd(&a);
	471 + grabkeys();
	472 +}
	473 +
	474 +void
	475 +setmaster(const Arg *arg) {
	476 + unsigned int i;
	477 + Arg a;
	478 +
	479 + if(!arg \|\| (selmon->lt[selmon->sellt]->arrange != monocle && se…
	480 + return;
	481 + for(i = 0; i < 3; i++)
	482 + selmon->ltaxes[selmon->curtag][i] = selmon->ltaxis[i] =…
	483 + selmon->msplits[selmon->curtag] = selmon->msplit = 1;
	484 + if(selmon->sel && !selmon->sel->isfloating && selmon->sel != ne…
	485 + detach(selmon->sel);
	486 + attach(selmon->sel);
	487 + focus(selmon->sel);
	488 + }
	489 + if(selmon->lt[selmon->sellt]->arrange == monocle) {
	490 + for(i = 0; i < LENGTH(layouts) && (&layouts[i])->arrang…
	491 + a.v = &layouts[i];
	492 + setlayout(&a);
	493 + if(!selmon->sel)
	494 + arrange(selmon);
	495 + } else
	496 + arrange(selmon);
	497 +}
	498 +
	499 +void
	500 +split(const Arg *arg) {
	501 + unsigned int j = 0, k, n;
	502 + Arg a;
	503 + Client *i;
	504 +
	505 + if(!arg \|\| !selmon->sel \|\| selmon->sel->isfloating \|\| (selmon->…
	506 + return;
	507 + for(n = 0, i = nexttiled(selmon->clients); i; i = nexttiled(i->…
	508 + if(i == selmon->sel)
	509 + j = n + 1;
	510 + if(j == 0 \|\| n < 2)
	511 + return;
	512 + if(selmon->lt[selmon->sellt]->arrange == monocle) {
	513 + selmon->ltaxes[selmon->curtag][0] = selmon->ltaxis[0] =…
	514 + selmon->ltaxes[selmon->curtag][1] = selmon->ltaxis[1] =…
	515 + selmon->ltaxes[selmon->curtag][2] = selmon->ltaxis[2] =…
	516 + for(k = 0; k < LENGTH(layouts) && (&layouts[k])->arrang…
	517 + a.v = &layouts[k];
	518 + setlayout(&a);
	519 + } else if(j <= selmon->msplit) {
	520 + if(selmon->ltaxis[1] == 3 \|\| selmon->msplit == 1) {
	521 + selmon->ltaxes[selmon->curtag][1] = selmon->lta…
	522 + if(selmon->ltaxis[2] == 3 \|\| selmon->msplit == …
	523 + selmon->msplits[selmon->curtag] = selmo…
	524 + arrange(selmon);
	525 + } else if(selmon->ltaxis[1] == arg->i && selmon->msplit…
	526 + selmon->msplits[selmon->curtag] = selmon->mspli…
	527 + arrange(selmon);
	528 + } else if(selmon->ltaxis[1] + arg->i == 3 && selmon->ms…
	529 + selmon->ltaxes[selmon->curtag][0] = selmon->lta…
	530 + selmon->ltaxes[selmon->curtag][2] = selmon->lta…
	531 + selmon->msplits[selmon->curtag] = selmon->mspli…
	532 + arrange(selmon);
	533 + }
	534 + } else if(n > 2) {
	535 + if(selmon->ltaxis[2] == 3 \|\| selmon->msplit == n - 1) {
	536 + selmon->ltaxes[selmon->curtag][2] = selmon->lta…
	537 + if(selmon->ltaxis[1] == 3 \|\| selmon->msplit == …
	538 + selmon->msplits[selmon->curtag] = selmo…
	539 + arrange(selmon);
	540 + } else if(selmon->ltaxis[2] == arg->i && selmon->msplit…
	541 + selmon->msplits[selmon->curtag] = selmon->mspli…
	542 + arrange(selmon);
	543 + }
	544 + }
	545 +}
	546 diff -up ../dwm-5.8.2-1/keymodes.pre.h ./keymodes.pre.h
	547 --- ../dwm-5.8.2-1/keymodes.pre.h 2010-06-11 01:12:49.000000000 +…
	548 +++ ./keymodes.pre.h 2010-06-11 01:13:50.660576000 +0200
	549 @@ -0,0 +1,34 @@
	550 +/* See LICENSE file for copyright and license details. */
	551 +/* © 2010 joten <[email protected]> */
	552 +
	553 +#define COMMANDMODE 1
	554 +#define INSERTMODE 2
	555 +
	556 +typedef struct {
	557 + unsigned int mod[4];
	558 + KeySym keysym[4];
	559 + void (func)(const Arg );
	560 + const Arg arg;
	561 +} Command;
	562 +
	563 +/* function declarations */
	564 +static void adjacenttag(const Arg *arg);
	565 +static void adjacentview(const Arg *arg);
	566 +static void clearcmd(const Arg *arg);
	567 +static void closewindow(const Arg *arg);
	568 +static void defkeypress(XEvent *e);
	569 +static void exchangewindow(const Arg *arg);
	570 +static void focustiled(const Arg *arg);
	571 +static void focuswindow(const Arg *arg);
	572 +static void grabdefkeys(void);
	573 +static void onlyclient(const Arg *arg);
	574 +static Client prevtiled(Client c);
	575 +static void resizemaster(const Arg *arg);
	576 +static void setkeymode(const Arg *arg);
	577 +static void setmaster(const Arg *arg);
	578 +static void split(const Arg *arg);
	579 +
	580 +/* variables */
	581 +static unsigned int cmdmod[4];
	582 +static unsigned int keymode = COMMANDMODE;
	583 +static KeySym cmdkeysym[4];