8 changed files with 2972 additions and 2039 deletions
Split View
Diff Options
-
+1 -1Makefile
-
+3 -2README.md
-
+287 -68config.def.h
-
+1 -1config.mk
-
+21 -63drw.c
-
+2168 -1904dwm.c
-
+431 -0layouts.c
-
+60 -0shiftview.c
+ 1
- 1
Makefile
View File
README → README.md
View File
| @ -1,13 +1,14 @@ | |||
| dwm - dynamic window manager | |||
| ============================ | |||
| dwm is an extremely fast, small, and dynamic window manager for X. | |||
| dwm is an extremely fast, small, and dynamic window manager for X. This is an fork and adapted version which contains my | |||
| keybindings and settings. | |||
| **Contact:** <revol-xut@protonmail.com> | |||
| Requirements | |||
| ------------ | |||
| In order to build dwm you need the Xlib header files. | |||
| Installation | |||
| ------------ | |||
| Edit config.mk to match your local setup (dwm is installed into | |||
+ 287
- 68
config.def.h
View File
+ 1
- 1
config.mk
View File
+ 21
- 63
drw.c
View File
+ 2168
- 1904
dwm.c
File diff suppressed because it is too large
View File
+ 431
- 0
layouts.c
View File
| @ -0,0 +1,431 @@ | |||
| /* Key binding functions */ | |||
| static void defaultgaps(const Arg *arg); | |||
| static void incrgaps(const Arg *arg); | |||
| static void togglegaps(const Arg *arg); | |||
| /* Layouts */ | |||
| static void bstack(Monitor *m); | |||
| static void centeredmaster(Monitor *m); | |||
| static void centeredfloatingmaster(Monitor *m); | |||
| static void deck(Monitor *m); | |||
| static void dwindle(Monitor *m); | |||
| static void fibonacci(Monitor *m, int s); | |||
| static void spiral(Monitor *m); | |||
| static void tile(Monitor *); | |||
| /* Internals */ | |||
| static void getgaps(Monitor *m, int *oh, int *ov, int *ih, int *iv, unsigned int *nc); | |||
| static void setgaps(int oh, int ov, int ih, int iv); | |||
| /* Settings */ | |||
| static int enablegaps = 1; | |||
| static void setgaps(int oh, int ov, int ih, int iv) { | |||
| if (oh < 0) oh = 0; | |||
| if (ov < 0) ov = 0; | |||
| if (ih < 0) ih = 0; | |||
| if (iv < 0) iv = 0; | |||
| selmon->gappoh = oh; | |||
| selmon->gappov = ov; | |||
| selmon->gappih = ih; | |||
| selmon->gappiv = iv; | |||
| arrange(selmon); | |||
| } | |||
| static void togglegaps(const Arg *arg) { | |||
| enablegaps = !enablegaps; | |||
| arrange(NULL); | |||
| } | |||
| static void defaultgaps(const Arg *arg) { | |||
| setgaps(gappoh, gappov, gappih, gappiv); | |||
| } | |||
| static void incrgaps(const Arg *arg) { | |||
| setgaps( | |||
| selmon->gappoh + arg->i, | |||
| selmon->gappov + arg->i, | |||
| selmon->gappih + arg->i, | |||
| selmon->gappiv + arg->i | |||
| ); | |||
| } | |||
| static void getgaps(Monitor *m, int *oh, int *ov, int *ih, int *iv, unsigned int *nc) { | |||
| unsigned int n, oe, ie; | |||
| oe = ie = enablegaps; | |||
| Client *c; | |||
| for (n = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), n++); | |||
| if (smartgaps && n == 1) { | |||
| oe = 0; // outer gaps disabled when only one client | |||
| } | |||
| *oh = m->gappoh * oe; // outer horizontal gap | |||
| *ov = m->gappov * oe; // outer vertical gap | |||
| *ih = m->gappih * ie; // inner horizontal gap | |||
| *iv = m->gappiv * ie; // inner vertical gap | |||
| *nc = n; // number of clients | |||
| } | |||
| void getfacts(Monitor *m, int msize, int ssize, float *mf, float *sf, int *mr, int *sr) { | |||
| unsigned int n; | |||
| float mfacts, sfacts; | |||
| int mtotal = 0, stotal = 0; | |||
| Client *c; | |||
| for (n = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), n++); | |||
| mfacts = MIN(n, m->nmaster); | |||
| sfacts = n - m->nmaster; | |||
| for (n = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), n++) | |||
| if (n < m->nmaster) | |||
| mtotal += msize / mfacts; | |||
| else | |||
| stotal += ssize / sfacts; | |||
| *mf = mfacts; // total factor of master area | |||
| *sf = sfacts; // total factor of stack area | |||
| *mr = msize - mtotal; // the remainder (rest) of pixels after an even master split | |||
| *sr = ssize - stotal; // the remainder (rest) of pixels after an even stack split | |||
| } | |||
| /*** | |||
| * Layouts | |||
| */ | |||
| /* | |||
| * Bottomstack layout + gaps | |||
| * https://dwm.suckless.org/patches/bottomstack/ | |||
| */ | |||
| static void bstack(Monitor *m) { | |||
| unsigned int i, n; | |||
| int mx = 0, my = 0, mh = 0, mw = 0; | |||
| int sx = 0, sy = 0, sh = 0, sw = 0; | |||
| float mfacts, sfacts; | |||
| int mrest, srest; | |||
| Client *c; | |||
| int oh, ov, ih, iv; | |||
| getgaps(m, &oh, &ov, &ih, &iv, &n); | |||
| if (n == 0) | |||
| return; | |||
| sx = mx = m->wx + ov; | |||
| sy = my = m->wy + oh; | |||
| sh = mh = m->wh - 2 * oh; | |||
| mw = m->ww - 2 * ov - iv * (MIN(n, m->nmaster) - 1); | |||
| sw = m->ww - 2 * ov - iv * (n - m->nmaster - 1); | |||
| if (m->nmaster && n > m->nmaster) { | |||
| sh = (mh - ih) * (1 - m->mfact); | |||
| mh = (mh - ih) * m->mfact; | |||
| sx = mx; | |||
| sy = my + mh + ih; | |||
| } | |||
| getfacts(m, mw, sw, &mfacts, &sfacts, &mrest, &srest); | |||
| for (i = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), i++) { | |||
| if (i < m->nmaster) { | |||
| resize(c, mx, my, (mw / mfacts) + (i < mrest ? 1 : 0) - (2 * c->bw), mh - (2 * c->bw), 0); | |||
| mx += WIDTH(c) + iv; | |||
| } else { | |||
| resize(c, sx, sy, (sw / sfacts) + ((i - m->nmaster) < srest ? 1 : 0) - (2 * c->bw), sh - (2 * c->bw), 0); | |||
| sx += WIDTH(c) + iv; | |||
| } | |||
| } | |||
| } | |||
| /* | |||
| * Centred master layout + gaps | |||
| * https://dwm.suckless.org/patches/centeredmaster/ | |||
| */ | |||
| void centeredmaster(Monitor *m) { | |||
| unsigned int i, n; | |||
| int mx = 0, my = 0, mh = 0, mw = 0; | |||
| int lx = 0, ly = 0, lw = 0, lh = 0; | |||
| int rx = 0, ry = 0, rw = 0, rh = 0; | |||
| float mfacts = 0, lfacts = 0, rfacts = 0; | |||
| int mtotal = 0, ltotal = 0, rtotal = 0; | |||
| int mrest = 0, lrest = 0, rrest = 0; | |||
| Client *c; | |||
| int oh, ov, ih, iv; | |||
| getgaps(m, &oh, &ov, &ih, &iv, &n); | |||
| if (n == 0) | |||
| return; | |||
| /* initialize areas */ | |||
| mx = m->wx + ov; | |||
| my = m->wy + oh; | |||
| mh = m->wh - 2 * oh - ih * ((!m->nmaster ? n : MIN(n, m->nmaster)) - 1); | |||
| mw = m->ww - 2 * ov; | |||
| lh = m->wh - 2 * oh - ih * (((n - m->nmaster) / 2) - 1); | |||
| rh = m->wh - 2 * oh - ih * (((n - m->nmaster) / 2) - ((n - m->nmaster) % 2 ? 0 : 1)); | |||
| if (m->nmaster && n > m->nmaster) { | |||
| /* go mfact box in the center if more than nmaster clients */ | |||
| if (n - m->nmaster > 1) { | |||
| /* ||<-S->|<---M--->|<-S->|| */ | |||
| mw = (m->ww - 2 * ov - 2 * iv) * m->mfact; | |||
| lw = (m->ww - mw - 2 * ov - 2 * iv) / 2; | |||
| mx += lw + iv; | |||
| } else { | |||
| /* ||<---M--->|<-S->|| */ | |||
| mw = (mw - iv) * m->mfact; | |||
| lw = m->ww - mw - iv - 2 * ov; | |||
| } | |||
| rw = lw; | |||
| lx = m->wx + ov; | |||
| ly = m->wy + oh; | |||
| rx = mx + mw + iv; | |||
| ry = m->wy + oh; | |||
| } | |||
| /* calculate facts */ | |||
| for (n = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), n++) { | |||
| if (!m->nmaster || n < m->nmaster) | |||
| mfacts += 1; | |||
| else if ((n - m->nmaster) % 2) | |||
| lfacts += 1; // total factor of left hand stack area | |||
| else | |||
| rfacts += 1; // total factor of right hand stack area | |||
| } | |||
| for (n = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), n++) | |||
| if (!m->nmaster || n < m->nmaster) | |||
| mtotal += mh / mfacts; | |||
| else if ((n - m->nmaster) % 2) | |||
| ltotal += lh / lfacts; | |||
| else | |||
| rtotal += rh / rfacts; | |||
| mrest = mh - mtotal; | |||
| lrest = lh - ltotal; | |||
| rrest = rh - rtotal; | |||
| for (i = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), i++) { | |||
| if (!m->nmaster || i < m->nmaster) { | |||
| /* nmaster clients are stacked vertically, in the center of the screen */ | |||
| resize(c, mx, my, mw - (2 * c->bw), (mh / mfacts) + (i < mrest ? 1 : 0) - (2 * c->bw), 0); | |||
| my += HEIGHT(c) + ih; | |||
| } else { | |||
| /* stack clients are stacked vertically */ | |||
| if ((i - m->nmaster) % 2) { | |||
| resize(c, lx, ly, lw - (2 * c->bw), | |||
| (lh / lfacts) + ((i - 2 * m->nmaster) < 2 * lrest ? 1 : 0) - (2 * c->bw), 0); | |||
| ly += HEIGHT(c) + ih; | |||
| } else { | |||
| resize(c, rx, ry, rw - (2 * c->bw), | |||
| (rh / rfacts) + ((i - 2 * m->nmaster) < 2 * rrest ? 1 : 0) - (2 * c->bw), 0); | |||
| ry += HEIGHT(c) + ih; | |||
| } | |||
| } | |||
| } | |||
| } | |||
| void centeredfloatingmaster(Monitor *m) { | |||
| unsigned int i, n; | |||
| float mfacts, sfacts; | |||
| int mrest, srest; | |||
| int mx = 0, my = 0, mh = 0, mw = 0; | |||
| int sx = 0, sy = 0, sh = 0, sw = 0; | |||
| Client *c; | |||
| float mivf = 1.0; // master inner vertical gap factor | |||
| int oh, ov, ih, iv; | |||
| getgaps(m, &oh, &ov, &ih, &iv, &n); | |||
| if (n == 0) | |||
| return; | |||
| sx = mx = m->wx + ov; | |||
| sy = my = m->wy + oh; | |||
| sh = mh = m->wh - 2 * oh; | |||
| mw = m->ww - 2 * ov - iv * (n - 1); | |||
| sw = m->ww - 2 * ov - iv * (n - m->nmaster - 1); | |||
| if (m->nmaster && n > m->nmaster) { | |||
| mivf = 0.8; | |||
| /* go mfact box in the center if more than nmaster clients */ | |||
| if (m->ww > m->wh) { | |||
| mw = m->ww * m->mfact - iv * mivf * (MIN(n, m->nmaster) - 1); | |||
| mh = m->wh * 0.9 - 2 * oh; | |||
| } else { | |||
| mw = m->ww * 0.9 - iv * mivf * (MIN(n, m->nmaster) - 1); | |||
| mh = m->wh * m->mfact; | |||
| } | |||
| mx = m->wx + (m->ww - mw) / 2; | |||
| my = m->wy + (m->wh - mh) / 2; | |||
| sx = m->wx + ov; | |||
| sy = m->wy + oh; | |||
| sh = m->wh - 2 * oh; | |||
| } | |||
| getfacts(m, mw, sw, &mfacts, &sfacts, &mrest, &srest); | |||
| for (i = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), i++) | |||
| if (i < m->nmaster) { | |||
| /* nmaster clients are stacked horizontally, in the center of the screen */ | |||
| resize(c, mx, my, (mw / mfacts) + (i < mrest ? 1 : 0) - (2 * c->bw), mh - (2 * c->bw), 0); | |||
| mx += WIDTH(c) + iv * mivf; | |||
| } else { | |||
| /* stack clients are stacked horizontally */ | |||
| resize(c, sx, sy, (sw / sfacts) + ((i - m->nmaster) < srest ? 1 : 0) - (2 * c->bw), sh - (2 * c->bw), 0); | |||
| sx += WIDTH(c) + iv; | |||
| } | |||
| } | |||
| /* | |||
| * Deck layout + gaps | |||
| * https://dwm.suckless.org/patches/deck/ | |||
| */ | |||
| static void deck(Monitor *m) { | |||
| unsigned int i, n; | |||
| int mx = 0, my = 0, mh = 0, mw = 0; | |||
| int sx = 0, sy = 0, sh = 0, sw = 0; | |||
| float mfacts, sfacts; | |||
| int mrest, srest; | |||
| Client *c; | |||
| int oh, ov, ih, iv; | |||
| getgaps(m, &oh, &ov, &ih, &iv, &n); | |||
| if (n == 0) | |||
| return; | |||
| sx = mx = m->wx + ov; | |||
| sy = my = m->wy + oh; | |||
| sh = mh = m->wh - 2 * oh - ih * (MIN(n, m->nmaster) - 1); | |||
| sw = mw = m->ww - 2 * ov; | |||
| if (m->nmaster && n > m->nmaster) { | |||
| sw = (mw - iv) * (1 - m->mfact); | |||
| mw = (mw - iv) * m->mfact; | |||
| sx = mx + mw + iv; | |||
| sh = m->wh - 2 * oh; | |||
| } | |||
| getfacts(m, mh, sh, &mfacts, &sfacts, &mrest, &srest); | |||
| if (n - m->nmaster > 0) /* override layout symbol */ | |||
| snprintf(m->ltsymbol, sizeof m->ltsymbol, "D %d", n - m->nmaster); | |||
| for (i = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), i++) | |||
| if (i < m->nmaster) { | |||
| resize(c, mx, my, mw - (2 * c->bw), (mh / mfacts) + (i < mrest ? 1 : 0) - (2 * c->bw), 0); | |||
| my += HEIGHT(c) + ih; | |||
| } else { | |||
| resize(c, sx, sy, sw - (2 * c->bw), sh - (2 * c->bw), 0); | |||
| } | |||
| } | |||
| /* | |||
| * Fibonacci layout + gaps | |||
| * https://dwm.suckless.org/patches/fibonacci/ | |||
| */ | |||
| static void fibonacci(Monitor *m, int s) { | |||
| unsigned int i, n; | |||
| int nx, ny, nw, nh; | |||
| int oh, ov, ih, iv; | |||
| Client *c; | |||
| getgaps(m, &oh, &ov, &ih, &iv, &n); | |||
| if (n == 0) | |||
| return; | |||
| nx = m->wx + ov; | |||
| ny = oh; | |||
| nw = m->ww - 2 * ov; | |||
| nh = m->wh - 2 * oh; | |||
| for (i = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next)) { | |||
| if ((i % 2 && nh / 2 > 2 * c->bw) | |||
| || (!(i % 2) && nw / 2 > 2 * c->bw)) { | |||
| if (i < n - 1) { | |||
| if (i % 2) | |||
| nh = (nh - ih) / 2; | |||
| else | |||
| nw = (nw - iv) / 2; | |||
| if ((i % 4) == 2 && !s) | |||
| nx += nw + iv; | |||
| else if ((i % 4) == 3 && !s) | |||
| ny += nh + ih; | |||
| } | |||
| if ((i % 4) == 0) { | |||
| if (s) | |||
| ny += nh + ih; | |||
| else | |||
| ny -= nh + ih; | |||
| } else if ((i % 4) == 1) | |||
| nx += nw + iv; | |||
| else if ((i % 4) == 2) | |||
| ny += nh + ih; | |||
| else if ((i % 4) == 3) { | |||
| if (s) | |||
| nx += nw + iv; | |||
| else | |||
| nx -= nw + iv; | |||
| } | |||
| if (i == 0) { | |||
| if (n != 1) | |||
| nw = (m->ww - 2 * ov - iv) * m->mfact; | |||
| ny = m->wy + oh; | |||
| } else if (i == 1) | |||
| nw = m->ww - nw - iv - 2 * ov; | |||
| i++; | |||
| } | |||
| resize(c, nx, ny, nw - (2 * c->bw), nh - (2 * c->bw), False); | |||
| } | |||
| } | |||
| static void dwindle(Monitor *m) { | |||
| fibonacci(m, 1); | |||
| } | |||
| static void spiral(Monitor *m) { | |||
| fibonacci(m, 0); | |||
| } | |||
| /* | |||
| * Default tile layout + gaps | |||
| */ | |||
| static void tile(Monitor *m) { | |||
| 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; | |||
| 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), 0); | |||
| if (my + HEIGHT(c) < m->wh) | |||
| 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), 0); | |||
| if (ty + HEIGHT(c) < m->wh) | |||
| ty += HEIGHT(c); | |||
| } | |||
| } | |||
+ 60
- 0
shiftview.c
View File
| @ -0,0 +1,60 @@ | |||
| /** Function to shift the current view to the left/right | |||
| * | |||
| * @param: "arg->i" stores the number of tags to shift right (positive value) | |||
| * or left (negative value) | |||
| */ | |||
| void shiftview(const Arg *arg) { | |||
| Arg shifted; | |||
| Client *c; | |||
| unsigned int tagmask = 0; | |||
| for (c = selmon->clients; c; c = c->next) | |||
| if (!(c->tags & SPTAGMASK)) | |||
| tagmask = tagmask | c->tags; | |||
| shifted.ui = selmon->tagset[selmon->seltags] & ~SPTAGMASK; | |||
| if (arg->i > 0) /* left circular shift */ | |||
| do { | |||
| shifted.ui = (shifted.ui << arg->i) | |||
| | (shifted.ui >> (LENGTH(tags) - arg->i)); | |||
| shifted.ui &= ~SPTAGMASK; | |||
| } while (tagmask && !(shifted.ui & tagmask)); | |||
| else /* right circular shift */ | |||
| do { | |||
| shifted.ui = (shifted.ui >> (- arg->i) | |||
| | shifted.ui << (LENGTH(tags) + arg->i)); | |||
| shifted.ui &= ~SPTAGMASK; | |||
| } while (tagmask && !(shifted.ui & tagmask)); | |||
| view(&shifted); | |||
| } | |||
| void shifttag(const Arg *arg) { | |||
| Arg a; | |||
| Client *c; | |||
| unsigned visible = 0; | |||
| int i = arg->i; | |||
| int count = 0; | |||
| int nextseltags, curseltags = selmon->tagset[selmon->seltags]; | |||
| do { | |||
| if(i > 0) // left circular shift | |||
| nextseltags = (curseltags << i) | (curseltags >> (LENGTH(tags) - i)); | |||
| else // right circular shift | |||
| nextseltags = curseltags >> (- i) | (curseltags << (LENGTH(tags) + i)); | |||
| // Check if tag is visible | |||
| for (c = selmon->clients; c && !visible; c = c->next) | |||
| if (nextseltags & c->tags) { | |||
| visible = 1; | |||
| break; | |||
| } | |||
| i += arg->i; | |||
| } while (!visible && ++count < 10); | |||
| if (count < 10) { | |||
| a.i = nextseltags; | |||
| tag(&a); | |||
| } | |||
| } | |||