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