split screen.c into layout.c and tag.c (because the view is an implicit mixture of both)
8012fcf3
5 file(s) · +345 −337
| 3 | 3 | ||
| 4 | 4 | include config.mk |
|
| 5 | 5 | ||
| 6 | - | SRC = client.c event.c main.c screen.c util.c |
|
| 6 | + | SRC = client.c event.c layout.c main.c tag.c util.c |
|
| 7 | 7 | OBJ = ${SRC:.c=.o} |
|
| 8 | 8 | ||
| 9 | 9 | all: options dwm |
| 120 | 120 | /* event.c */ |
|
| 121 | 121 | extern void grabkeys(void); /* grab all keys defined in config.h */ |
|
| 122 | 122 | ||
| 123 | + | /* layout.c */ |
|
| 124 | + | extern void incnmaster(Arg *arg); /* increments nmaster with arg's index value */ |
|
| 125 | + | extern void initlayouts(void); /* initialize layout array */ |
|
| 126 | + | extern void resizemaster(Arg *arg); /* resizes the master percent with arg's index value */ |
|
| 127 | + | extern void restack(void); /* restores z layers of all clients */ |
|
| 128 | + | extern void setlayout(Arg *arg); /* sets layout, -1 toggles */ |
|
| 129 | + | extern void toggleversatile(Arg *arg); /* toggles focusesd client between versatile/and non-versatile state */ |
|
| 130 | + | extern void versatile(void); /* arranges all windows versatile */ |
|
| 131 | + | ||
| 123 | 132 | /* main.c */ |
|
| 124 | 133 | extern void drawstatus(void); /* draw the bar */ |
|
| 125 | 134 | extern unsigned int textw(const char *text); /* return the width of text in px*/ |
|
| 127 | 136 | extern void sendevent(Window w, Atom a, long value); /* send synthetic event to w */ |
|
| 128 | 137 | extern int xerror(Display *dsply, XErrorEvent *ee); /* dwm's X error handler */ |
|
| 129 | 138 | ||
| 130 | - | /* screen.c */ |
|
| 139 | + | /* tag.c */ |
|
| 131 | 140 | extern void compileregs(void); /* initialize regexps of rules defined in config.h */ |
|
| 132 | - | extern void incnmaster(Arg *arg); /* increments nmaster with arg's index value */ |
|
| 133 | - | extern void initlayouts(void); /* initialize layout array */ |
|
| 134 | 141 | extern Bool isvisible(Client *c); /* returns True if client is visible */ |
|
| 135 | - | extern void resizemaster(Arg *arg); /* resizes the master percent with arg's index value */ |
|
| 136 | - | extern void restack(void); /* restores z layers of all clients */ |
|
| 137 | - | extern void setlayout(Arg *arg); /* sets layout, -1 toggles */ |
|
| 138 | 142 | extern void settags(Client *c, Client *trans); /* sets tags of c */ |
|
| 139 | 143 | extern void tag(Arg *arg); /* tags c with arg's index */ |
|
| 140 | - | extern void toggleversatile(Arg *arg); /* toggles focusesd client between versatile/and non-versatile state */ |
|
| 141 | 144 | extern void toggletag(Arg *arg); /* toggles c tags with arg's index */ |
|
| 142 | 145 | extern void toggleview(Arg *arg); /* toggles the tag with arg's index (in)visible */ |
|
| 143 | - | extern void versatile(void); /* arranges all windows versatile */ |
|
| 144 | 146 | extern void view(Arg *arg); /* views the tag with arg's index */ |
|
| 145 | 147 | ||
| 146 | 148 | /* util.c */ |
|
| 1 | + | /* (C)opyright MMVI-MMVII Anselm R. Garbe <garbeam at gmail dot com> |
|
| 2 | + | * See LICENSE file for license details. |
|
| 3 | + | */ |
|
| 4 | + | #include "dwm.h" |
|
| 5 | + | ||
| 6 | + | unsigned int master = MASTER; |
|
| 7 | + | unsigned int nmaster = NMASTER; |
|
| 8 | + | unsigned int blw = 0; |
|
| 9 | + | Layout *lt = NULL; |
|
| 10 | + | ||
| 11 | + | /* static */ |
|
| 12 | + | ||
| 13 | + | static unsigned int nlayouts = 0; |
|
| 14 | + | ||
| 15 | + | static void |
|
| 16 | + | tile(void) { |
|
| 17 | + | unsigned int i, n, nx, ny, nw, nh, mw, mh, tw, th; |
|
| 18 | + | Client *c; |
|
| 19 | + | ||
| 20 | + | for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next)) |
|
| 21 | + | n++; |
|
| 22 | + | /* window geoms */ |
|
| 23 | + | mh = (n > nmaster) ? wah / nmaster : wah / (n > 0 ? n : 1); |
|
| 24 | + | mw = (n > nmaster) ? (waw * master) / 1000 : waw; |
|
| 25 | + | th = (n > nmaster) ? wah / (n - nmaster) : 0; |
|
| 26 | + | tw = waw - mw; |
|
| 27 | + | ||
| 28 | + | for(i = 0, c = clients; c; c = c->next) |
|
| 29 | + | if(isvisible(c)) { |
|
| 30 | + | if(c->isbanned) |
|
| 31 | + | XMoveWindow(dpy, c->win, c->x, c->y); |
|
| 32 | + | c->isbanned = False; |
|
| 33 | + | if(c->isversatile) |
|
| 34 | + | continue; |
|
| 35 | + | c->ismax = False; |
|
| 36 | + | nx = wax; |
|
| 37 | + | ny = way; |
|
| 38 | + | if(i < nmaster) { |
|
| 39 | + | ny += i * mh; |
|
| 40 | + | nw = mw - 2 * BORDERPX; |
|
| 41 | + | nh = mh - 2 * BORDERPX; |
|
| 42 | + | } |
|
| 43 | + | else { /* tile window */ |
|
| 44 | + | nx += mw; |
|
| 45 | + | nw = tw - 2 * BORDERPX; |
|
| 46 | + | if(th > 2 * BORDERPX) { |
|
| 47 | + | ny += (i - nmaster) * th; |
|
| 48 | + | nh = th - 2 * BORDERPX; |
|
| 49 | + | } |
|
| 50 | + | else /* fallback if th <= 2 * BORDERPX */ |
|
| 51 | + | nh = wah - 2 * BORDERPX; |
|
| 52 | + | } |
|
| 53 | + | resize(c, nx, ny, nw, nh, False); |
|
| 54 | + | i++; |
|
| 55 | + | } |
|
| 56 | + | else { |
|
| 57 | + | c->isbanned = True; |
|
| 58 | + | XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y); |
|
| 59 | + | } |
|
| 60 | + | if(!sel || !isvisible(sel)) { |
|
| 61 | + | for(c = stack; c && !isvisible(c); c = c->snext); |
|
| 62 | + | focus(c); |
|
| 63 | + | } |
|
| 64 | + | restack(); |
|
| 65 | + | } |
|
| 66 | + | ||
| 67 | + | LAYOUTS |
|
| 68 | + | ||
| 69 | + | /* extern */ |
|
| 70 | + | ||
| 71 | + | void |
|
| 72 | + | incnmaster(Arg *arg) { |
|
| 73 | + | if((lt->arrange != tile) || (nmaster + arg->i < 1) |
|
| 74 | + | || (wah / (nmaster + arg->i) <= 2 * BORDERPX)) |
|
| 75 | + | return; |
|
| 76 | + | nmaster += arg->i; |
|
| 77 | + | if(sel) |
|
| 78 | + | lt->arrange(); |
|
| 79 | + | else |
|
| 80 | + | drawstatus(); |
|
| 81 | + | } |
|
| 82 | + | ||
| 83 | + | void |
|
| 84 | + | initlayouts(void) { |
|
| 85 | + | unsigned int i, w; |
|
| 86 | + | ||
| 87 | + | lt = &layout[0]; |
|
| 88 | + | nlayouts = sizeof layout / sizeof layout[0]; |
|
| 89 | + | for(blw = i = 0; i < nlayouts; i++) { |
|
| 90 | + | w = textw(layout[i].symbol); |
|
| 91 | + | if(w > blw) |
|
| 92 | + | blw = w; |
|
| 93 | + | } |
|
| 94 | + | } |
|
| 95 | + | ||
| 96 | + | void |
|
| 97 | + | resizemaster(Arg *arg) { |
|
| 98 | + | if(lt->arrange != tile) |
|
| 99 | + | return; |
|
| 100 | + | if(arg->i == 0) |
|
| 101 | + | master = MASTER; |
|
| 102 | + | else { |
|
| 103 | + | if(waw * (master + arg->i) / 1000 >= waw - 2 * BORDERPX |
|
| 104 | + | || waw * (master + arg->i) / 1000 <= 2 * BORDERPX) |
|
| 105 | + | return; |
|
| 106 | + | master += arg->i; |
|
| 107 | + | } |
|
| 108 | + | lt->arrange(); |
|
| 109 | + | } |
|
| 110 | + | ||
| 111 | + | void |
|
| 112 | + | restack(void) { |
|
| 113 | + | Client *c; |
|
| 114 | + | XEvent ev; |
|
| 115 | + | ||
| 116 | + | drawstatus(); |
|
| 117 | + | if(!sel) |
|
| 118 | + | return; |
|
| 119 | + | if(sel->isversatile || lt->arrange == versatile) |
|
| 120 | + | XRaiseWindow(dpy, sel->win); |
|
| 121 | + | if(lt->arrange != versatile) { |
|
| 122 | + | if(!sel->isversatile) |
|
| 123 | + | XLowerWindow(dpy, sel->win); |
|
| 124 | + | for(c = nexttiled(clients); c; c = nexttiled(c->next)) { |
|
| 125 | + | if(c == sel) |
|
| 126 | + | continue; |
|
| 127 | + | XLowerWindow(dpy, c->win); |
|
| 128 | + | } |
|
| 129 | + | } |
|
| 130 | + | XSync(dpy, False); |
|
| 131 | + | while(XCheckMaskEvent(dpy, EnterWindowMask, &ev)); |
|
| 132 | + | } |
|
| 133 | + | ||
| 134 | + | void |
|
| 135 | + | setlayout(Arg *arg) { |
|
| 136 | + | unsigned int i; |
|
| 137 | + | ||
| 138 | + | if(arg->i == -1) { |
|
| 139 | + | for(i = 0; i < nlayouts && lt != &layout[i]; i++); |
|
| 140 | + | if(i == nlayouts - 1) |
|
| 141 | + | lt = &layout[0]; |
|
| 142 | + | else |
|
| 143 | + | lt = &layout[++i]; |
|
| 144 | + | } |
|
| 145 | + | else { |
|
| 146 | + | if(arg->i < 0 || arg->i >= nlayouts) |
|
| 147 | + | return; |
|
| 148 | + | lt = &layout[arg->i]; |
|
| 149 | + | } |
|
| 150 | + | if(sel) |
|
| 151 | + | lt->arrange(); |
|
| 152 | + | else |
|
| 153 | + | drawstatus(); |
|
| 154 | + | } |
|
| 155 | + | ||
| 156 | + | void |
|
| 157 | + | toggleversatile(Arg *arg) { |
|
| 158 | + | if(!sel || lt->arrange == versatile) |
|
| 159 | + | return; |
|
| 160 | + | sel->isversatile = !sel->isversatile; |
|
| 161 | + | lt->arrange(); |
|
| 162 | + | } |
|
| 163 | + | ||
| 164 | + | void |
|
| 165 | + | versatile(void) { |
|
| 166 | + | Client *c; |
|
| 167 | + | ||
| 168 | + | for(c = clients; c; c = c->next) { |
|
| 169 | + | if(isvisible(c)) { |
|
| 170 | + | if(c->isbanned) |
|
| 171 | + | XMoveWindow(dpy, c->win, c->x, c->y); |
|
| 172 | + | c->isbanned = False; |
|
| 173 | + | resize(c, c->x, c->y, c->w, c->h, True); |
|
| 174 | + | } |
|
| 175 | + | else { |
|
| 176 | + | c->isbanned = True; |
|
| 177 | + | XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y); |
|
| 178 | + | } |
|
| 179 | + | } |
|
| 180 | + | if(!sel || !isvisible(sel)) { |
|
| 181 | + | for(c = stack; c && !isvisible(c); c = c->snext); |
|
| 182 | + | focus(c); |
|
| 183 | + | } |
|
| 184 | + | restack(); |
|
| 185 | + | } |
| 1 | - | /* (C)opyright MMVI-MMVII Anselm R. Garbe <garbeam at gmail dot com> |
|
| 2 | - | * See LICENSE file for license details. |
|
| 3 | - | */ |
|
| 4 | - | #include "dwm.h" |
|
| 5 | - | #include <regex.h> |
|
| 6 | - | #include <stdio.h> |
|
| 7 | - | #include <stdlib.h> |
|
| 8 | - | #include <string.h> |
|
| 9 | - | #include <sys/types.h> |
|
| 10 | - | #include <X11/Xutil.h> |
|
| 11 | - | ||
| 12 | - | unsigned int master = MASTER; |
|
| 13 | - | unsigned int nmaster = NMASTER; |
|
| 14 | - | unsigned int blw = 0; |
|
| 15 | - | Layout *lt = NULL; |
|
| 16 | - | ||
| 17 | - | /* static */ |
|
| 18 | - | ||
| 19 | - | typedef struct { |
|
| 20 | - | const char *prop; |
|
| 21 | - | const char *tags; |
|
| 22 | - | Bool isversatile; |
|
| 23 | - | } Rule; |
|
| 24 | - | ||
| 25 | - | typedef struct { |
|
| 26 | - | regex_t *propregex; |
|
| 27 | - | regex_t *tagregex; |
|
| 28 | - | } Regs; |
|
| 29 | - | ||
| 30 | - | TAGS |
|
| 31 | - | RULES |
|
| 32 | - | ||
| 33 | - | static Regs *regs = NULL; |
|
| 34 | - | static unsigned int nrules = 0; |
|
| 35 | - | static unsigned int nlayouts = 0; |
|
| 36 | - | ||
| 37 | - | static void |
|
| 38 | - | tile(void) { |
|
| 39 | - | unsigned int i, n, nx, ny, nw, nh, mw, mh, tw, th; |
|
| 40 | - | Client *c; |
|
| 41 | - | ||
| 42 | - | for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next)) |
|
| 43 | - | n++; |
|
| 44 | - | /* window geoms */ |
|
| 45 | - | mh = (n > nmaster) ? wah / nmaster : wah / (n > 0 ? n : 1); |
|
| 46 | - | mw = (n > nmaster) ? (waw * master) / 1000 : waw; |
|
| 47 | - | th = (n > nmaster) ? wah / (n - nmaster) : 0; |
|
| 48 | - | tw = waw - mw; |
|
| 49 | - | ||
| 50 | - | for(i = 0, c = clients; c; c = c->next) |
|
| 51 | - | if(isvisible(c)) { |
|
| 52 | - | if(c->isbanned) |
|
| 53 | - | XMoveWindow(dpy, c->win, c->x, c->y); |
|
| 54 | - | c->isbanned = False; |
|
| 55 | - | if(c->isversatile) |
|
| 56 | - | continue; |
|
| 57 | - | c->ismax = False; |
|
| 58 | - | nx = wax; |
|
| 59 | - | ny = way; |
|
| 60 | - | if(i < nmaster) { |
|
| 61 | - | ny += i * mh; |
|
| 62 | - | nw = mw - 2 * BORDERPX; |
|
| 63 | - | nh = mh - 2 * BORDERPX; |
|
| 64 | - | } |
|
| 65 | - | else { /* tile window */ |
|
| 66 | - | nx += mw; |
|
| 67 | - | nw = tw - 2 * BORDERPX; |
|
| 68 | - | if(th > 2 * BORDERPX) { |
|
| 69 | - | ny += (i - nmaster) * th; |
|
| 70 | - | nh = th - 2 * BORDERPX; |
|
| 71 | - | } |
|
| 72 | - | else /* fallback if th <= 2 * BORDERPX */ |
|
| 73 | - | nh = wah - 2 * BORDERPX; |
|
| 74 | - | } |
|
| 75 | - | resize(c, nx, ny, nw, nh, False); |
|
| 76 | - | i++; |
|
| 77 | - | } |
|
| 78 | - | else { |
|
| 79 | - | c->isbanned = True; |
|
| 80 | - | XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y); |
|
| 81 | - | } |
|
| 82 | - | if(!sel || !isvisible(sel)) { |
|
| 83 | - | for(c = stack; c && !isvisible(c); c = c->snext); |
|
| 84 | - | focus(c); |
|
| 85 | - | } |
|
| 86 | - | restack(); |
|
| 87 | - | } |
|
| 88 | - | ||
| 89 | - | LAYOUTS |
|
| 90 | - | ||
| 91 | - | /* extern */ |
|
| 92 | - | ||
| 93 | - | void |
|
| 94 | - | compileregs(void) { |
|
| 95 | - | unsigned int i; |
|
| 96 | - | regex_t *reg; |
|
| 97 | - | ||
| 98 | - | if(regs) |
|
| 99 | - | return; |
|
| 100 | - | nrules = sizeof rule / sizeof rule[0]; |
|
| 101 | - | regs = emallocz(nrules * sizeof(Regs)); |
|
| 102 | - | for(i = 0; i < nrules; i++) { |
|
| 103 | - | if(rule[i].prop) { |
|
| 104 | - | reg = emallocz(sizeof(regex_t)); |
|
| 105 | - | if(regcomp(reg, rule[i].prop, REG_EXTENDED)) |
|
| 106 | - | free(reg); |
|
| 107 | - | else |
|
| 108 | - | regs[i].propregex = reg; |
|
| 109 | - | } |
|
| 110 | - | if(rule[i].tags) { |
|
| 111 | - | reg = emallocz(sizeof(regex_t)); |
|
| 112 | - | if(regcomp(reg, rule[i].tags, REG_EXTENDED)) |
|
| 113 | - | free(reg); |
|
| 114 | - | else |
|
| 115 | - | regs[i].tagregex = reg; |
|
| 116 | - | } |
|
| 117 | - | } |
|
| 118 | - | } |
|
| 119 | - | ||
| 120 | - | void |
|
| 121 | - | incnmaster(Arg *arg) { |
|
| 122 | - | if((lt->arrange != tile) || (nmaster + arg->i < 1) |
|
| 123 | - | || (wah / (nmaster + arg->i) <= 2 * BORDERPX)) |
|
| 124 | - | return; |
|
| 125 | - | nmaster += arg->i; |
|
| 126 | - | if(sel) |
|
| 127 | - | lt->arrange(); |
|
| 128 | - | else |
|
| 129 | - | drawstatus(); |
|
| 130 | - | } |
|
| 131 | - | ||
| 132 | - | void |
|
| 133 | - | initlayouts(void) { |
|
| 134 | - | unsigned int i, w; |
|
| 135 | - | ||
| 136 | - | lt = &layout[0]; |
|
| 137 | - | nlayouts = sizeof layout / sizeof layout[0]; |
|
| 138 | - | for(blw = i = 0; i < nlayouts; i++) { |
|
| 139 | - | w = textw(layout[i].symbol); |
|
| 140 | - | if(w > blw) |
|
| 141 | - | blw = w; |
|
| 142 | - | } |
|
| 143 | - | } |
|
| 144 | - | ||
| 145 | - | Bool |
|
| 146 | - | isvisible(Client *c) { |
|
| 147 | - | unsigned int i; |
|
| 148 | - | ||
| 149 | - | for(i = 0; i < ntags; i++) |
|
| 150 | - | if(c->tags[i] && seltag[i]) |
|
| 151 | - | return True; |
|
| 152 | - | return False; |
|
| 153 | - | } |
|
| 154 | - | ||
| 155 | - | void |
|
| 156 | - | resizemaster(Arg *arg) { |
|
| 157 | - | if(lt->arrange != tile) |
|
| 158 | - | return; |
|
| 159 | - | if(arg->i == 0) |
|
| 160 | - | master = MASTER; |
|
| 161 | - | else { |
|
| 162 | - | if(waw * (master + arg->i) / 1000 >= waw - 2 * BORDERPX |
|
| 163 | - | || waw * (master + arg->i) / 1000 <= 2 * BORDERPX) |
|
| 164 | - | return; |
|
| 165 | - | master += arg->i; |
|
| 166 | - | } |
|
| 167 | - | lt->arrange(); |
|
| 168 | - | } |
|
| 169 | - | ||
| 170 | - | void |
|
| 171 | - | restack(void) { |
|
| 172 | - | Client *c; |
|
| 173 | - | XEvent ev; |
|
| 174 | - | ||
| 175 | - | drawstatus(); |
|
| 176 | - | if(!sel) |
|
| 177 | - | return; |
|
| 178 | - | if(sel->isversatile || lt->arrange == versatile) |
|
| 179 | - | XRaiseWindow(dpy, sel->win); |
|
| 180 | - | if(lt->arrange != versatile) { |
|
| 181 | - | if(!sel->isversatile) |
|
| 182 | - | XLowerWindow(dpy, sel->win); |
|
| 183 | - | for(c = nexttiled(clients); c; c = nexttiled(c->next)) { |
|
| 184 | - | if(c == sel) |
|
| 185 | - | continue; |
|
| 186 | - | XLowerWindow(dpy, c->win); |
|
| 187 | - | } |
|
| 188 | - | } |
|
| 189 | - | XSync(dpy, False); |
|
| 190 | - | while(XCheckMaskEvent(dpy, EnterWindowMask, &ev)); |
|
| 191 | - | } |
|
| 192 | - | ||
| 193 | - | void |
|
| 194 | - | setlayout(Arg *arg) { |
|
| 195 | - | unsigned int i; |
|
| 196 | - | ||
| 197 | - | if(arg->i == -1) { |
|
| 198 | - | for(i = 0; i < nlayouts && lt != &layout[i]; i++); |
|
| 199 | - | if(i == nlayouts - 1) |
|
| 200 | - | lt = &layout[0]; |
|
| 201 | - | else |
|
| 202 | - | lt = &layout[++i]; |
|
| 203 | - | } |
|
| 204 | - | else { |
|
| 205 | - | if(arg->i < 0 || arg->i >= nlayouts) |
|
| 206 | - | return; |
|
| 207 | - | lt = &layout[arg->i]; |
|
| 208 | - | } |
|
| 209 | - | if(sel) |
|
| 210 | - | lt->arrange(); |
|
| 211 | - | else |
|
| 212 | - | drawstatus(); |
|
| 213 | - | } |
|
| 214 | - | ||
| 215 | - | void |
|
| 216 | - | settags(Client *c, Client *trans) { |
|
| 217 | - | char prop[512]; |
|
| 218 | - | unsigned int i, j; |
|
| 219 | - | regmatch_t tmp; |
|
| 220 | - | Bool matched = trans != NULL; |
|
| 221 | - | XClassHint ch = { 0 }; |
|
| 222 | - | ||
| 223 | - | if(matched) |
|
| 224 | - | for(i = 0; i < ntags; i++) |
|
| 225 | - | c->tags[i] = trans->tags[i]; |
|
| 226 | - | else { |
|
| 227 | - | XGetClassHint(dpy, c->win, &ch); |
|
| 228 | - | snprintf(prop, sizeof prop, "%s:%s:%s", |
|
| 229 | - | ch.res_class ? ch.res_class : "", |
|
| 230 | - | ch.res_name ? ch.res_name : "", c->name); |
|
| 231 | - | for(i = 0; i < nrules; i++) |
|
| 232 | - | if(regs[i].propregex && !regexec(regs[i].propregex, prop, 1, &tmp, 0)) { |
|
| 233 | - | c->isversatile = rule[i].isversatile; |
|
| 234 | - | for(j = 0; regs[i].tagregex && j < ntags; j++) { |
|
| 235 | - | if(!regexec(regs[i].tagregex, tags[j], 1, &tmp, 0)) { |
|
| 236 | - | matched = True; |
|
| 237 | - | c->tags[j] = True; |
|
| 238 | - | } |
|
| 239 | - | } |
|
| 240 | - | } |
|
| 241 | - | if(ch.res_class) |
|
| 242 | - | XFree(ch.res_class); |
|
| 243 | - | if(ch.res_name) |
|
| 244 | - | XFree(ch.res_name); |
|
| 245 | - | } |
|
| 246 | - | if(!matched) |
|
| 247 | - | for(i = 0; i < ntags; i++) |
|
| 248 | - | c->tags[i] = seltag[i]; |
|
| 249 | - | } |
|
| 250 | - | ||
| 251 | - | void |
|
| 252 | - | tag(Arg *arg) { |
|
| 253 | - | unsigned int i; |
|
| 254 | - | ||
| 255 | - | if(!sel) |
|
| 256 | - | return; |
|
| 257 | - | for(i = 0; i < ntags; i++) |
|
| 258 | - | sel->tags[i] = (arg->i == -1) ? True : False; |
|
| 259 | - | if(arg->i >= 0 && arg->i < ntags) |
|
| 260 | - | sel->tags[arg->i] = True; |
|
| 261 | - | lt->arrange(); |
|
| 262 | - | } |
|
| 263 | - | ||
| 264 | - | void |
|
| 265 | - | toggletag(Arg *arg) { |
|
| 266 | - | unsigned int i; |
|
| 267 | - | ||
| 268 | - | if(!sel) |
|
| 269 | - | return; |
|
| 270 | - | sel->tags[arg->i] = !sel->tags[arg->i]; |
|
| 271 | - | for(i = 0; i < ntags && !sel->tags[i]; i++); |
|
| 272 | - | if(i == ntags) |
|
| 273 | - | sel->tags[arg->i] = True; |
|
| 274 | - | lt->arrange(); |
|
| 275 | - | } |
|
| 276 | - | ||
| 277 | - | void |
|
| 278 | - | toggleversatile(Arg *arg) { |
|
| 279 | - | if(!sel || lt->arrange == versatile) |
|
| 280 | - | return; |
|
| 281 | - | sel->isversatile = !sel->isversatile; |
|
| 282 | - | lt->arrange(); |
|
| 283 | - | } |
|
| 284 | - | ||
| 285 | - | void |
|
| 286 | - | toggleview(Arg *arg) { |
|
| 287 | - | unsigned int i; |
|
| 288 | - | ||
| 289 | - | seltag[arg->i] = !seltag[arg->i]; |
|
| 290 | - | for(i = 0; i < ntags && !seltag[i]; i++); |
|
| 291 | - | if(i == ntags) |
|
| 292 | - | seltag[arg->i] = True; /* cannot toggle last view */ |
|
| 293 | - | lt->arrange(); |
|
| 294 | - | } |
|
| 295 | - | ||
| 296 | - | void |
|
| 297 | - | versatile(void) { |
|
| 298 | - | Client *c; |
|
| 299 | - | ||
| 300 | - | for(c = clients; c; c = c->next) { |
|
| 301 | - | if(isvisible(c)) { |
|
| 302 | - | if(c->isbanned) |
|
| 303 | - | XMoveWindow(dpy, c->win, c->x, c->y); |
|
| 304 | - | c->isbanned = False; |
|
| 305 | - | resize(c, c->x, c->y, c->w, c->h, True); |
|
| 306 | - | } |
|
| 307 | - | else { |
|
| 308 | - | c->isbanned = True; |
|
| 309 | - | XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y); |
|
| 310 | - | } |
|
| 311 | - | } |
|
| 312 | - | if(!sel || !isvisible(sel)) { |
|
| 313 | - | for(c = stack; c && !isvisible(c); c = c->snext); |
|
| 314 | - | focus(c); |
|
| 315 | - | } |
|
| 316 | - | restack(); |
|
| 317 | - | } |
|
| 318 | - | ||
| 319 | - | void |
|
| 320 | - | view(Arg *arg) { |
|
| 321 | - | unsigned int i; |
|
| 322 | - | ||
| 323 | - | for(i = 0; i < ntags; i++) |
|
| 324 | - | seltag[i] = (arg->i == -1) ? True : False; |
|
| 325 | - | if(arg->i >= 0 && arg->i < ntags) |
|
| 326 | - | seltag[arg->i] = True; |
|
| 327 | - | lt->arrange(); |
|
| 328 | - | } |
| 1 | + | /* (C)opyright MMVI-MMVII Anselm R. Garbe <garbeam at gmail dot com> |
|
| 2 | + | * See LICENSE file for license details. |
|
| 3 | + | */ |
|
| 4 | + | #include "dwm.h" |
|
| 5 | + | #include <regex.h> |
|
| 6 | + | #include <stdio.h> |
|
| 7 | + | #include <X11/Xutil.h> |
|
| 8 | + | ||
| 9 | + | /* static */ |
|
| 10 | + | ||
| 11 | + | typedef struct { |
|
| 12 | + | const char *prop; |
|
| 13 | + | const char *tags; |
|
| 14 | + | Bool isversatile; |
|
| 15 | + | } Rule; |
|
| 16 | + | ||
| 17 | + | typedef struct { |
|
| 18 | + | regex_t *propregex; |
|
| 19 | + | regex_t *tagregex; |
|
| 20 | + | } Regs; |
|
| 21 | + | ||
| 22 | + | TAGS |
|
| 23 | + | RULES |
|
| 24 | + | ||
| 25 | + | static Regs *regs = NULL; |
|
| 26 | + | static unsigned int nrules = 0; |
|
| 27 | + | ||
| 28 | + | /* extern */ |
|
| 29 | + | ||
| 30 | + | void |
|
| 31 | + | compileregs(void) { |
|
| 32 | + | unsigned int i; |
|
| 33 | + | regex_t *reg; |
|
| 34 | + | ||
| 35 | + | if(regs) |
|
| 36 | + | return; |
|
| 37 | + | nrules = sizeof rule / sizeof rule[0]; |
|
| 38 | + | regs = emallocz(nrules * sizeof(Regs)); |
|
| 39 | + | for(i = 0; i < nrules; i++) { |
|
| 40 | + | if(rule[i].prop) { |
|
| 41 | + | reg = emallocz(sizeof(regex_t)); |
|
| 42 | + | if(regcomp(reg, rule[i].prop, REG_EXTENDED)) |
|
| 43 | + | free(reg); |
|
| 44 | + | else |
|
| 45 | + | regs[i].propregex = reg; |
|
| 46 | + | } |
|
| 47 | + | if(rule[i].tags) { |
|
| 48 | + | reg = emallocz(sizeof(regex_t)); |
|
| 49 | + | if(regcomp(reg, rule[i].tags, REG_EXTENDED)) |
|
| 50 | + | free(reg); |
|
| 51 | + | else |
|
| 52 | + | regs[i].tagregex = reg; |
|
| 53 | + | } |
|
| 54 | + | } |
|
| 55 | + | } |
|
| 56 | + | ||
| 57 | + | Bool |
|
| 58 | + | isvisible(Client *c) { |
|
| 59 | + | unsigned int i; |
|
| 60 | + | ||
| 61 | + | for(i = 0; i < ntags; i++) |
|
| 62 | + | if(c->tags[i] && seltag[i]) |
|
| 63 | + | return True; |
|
| 64 | + | return False; |
|
| 65 | + | } |
|
| 66 | + | ||
| 67 | + | void |
|
| 68 | + | settags(Client *c, Client *trans) { |
|
| 69 | + | char prop[512]; |
|
| 70 | + | unsigned int i, j; |
|
| 71 | + | regmatch_t tmp; |
|
| 72 | + | Bool matched = trans != NULL; |
|
| 73 | + | XClassHint ch = { 0 }; |
|
| 74 | + | ||
| 75 | + | if(matched) |
|
| 76 | + | for(i = 0; i < ntags; i++) |
|
| 77 | + | c->tags[i] = trans->tags[i]; |
|
| 78 | + | else { |
|
| 79 | + | XGetClassHint(dpy, c->win, &ch); |
|
| 80 | + | snprintf(prop, sizeof prop, "%s:%s:%s", |
|
| 81 | + | ch.res_class ? ch.res_class : "", |
|
| 82 | + | ch.res_name ? ch.res_name : "", c->name); |
|
| 83 | + | for(i = 0; i < nrules; i++) |
|
| 84 | + | if(regs[i].propregex && !regexec(regs[i].propregex, prop, 1, &tmp, 0)) { |
|
| 85 | + | c->isversatile = rule[i].isversatile; |
|
| 86 | + | for(j = 0; regs[i].tagregex && j < ntags; j++) { |
|
| 87 | + | if(!regexec(regs[i].tagregex, tags[j], 1, &tmp, 0)) { |
|
| 88 | + | matched = True; |
|
| 89 | + | c->tags[j] = True; |
|
| 90 | + | } |
|
| 91 | + | } |
|
| 92 | + | } |
|
| 93 | + | if(ch.res_class) |
|
| 94 | + | XFree(ch.res_class); |
|
| 95 | + | if(ch.res_name) |
|
| 96 | + | XFree(ch.res_name); |
|
| 97 | + | } |
|
| 98 | + | if(!matched) |
|
| 99 | + | for(i = 0; i < ntags; i++) |
|
| 100 | + | c->tags[i] = seltag[i]; |
|
| 101 | + | } |
|
| 102 | + | ||
| 103 | + | void |
|
| 104 | + | tag(Arg *arg) { |
|
| 105 | + | unsigned int i; |
|
| 106 | + | ||
| 107 | + | if(!sel) |
|
| 108 | + | return; |
|
| 109 | + | for(i = 0; i < ntags; i++) |
|
| 110 | + | sel->tags[i] = (arg->i == -1) ? True : False; |
|
| 111 | + | if(arg->i >= 0 && arg->i < ntags) |
|
| 112 | + | sel->tags[arg->i] = True; |
|
| 113 | + | lt->arrange(); |
|
| 114 | + | } |
|
| 115 | + | ||
| 116 | + | void |
|
| 117 | + | toggletag(Arg *arg) { |
|
| 118 | + | unsigned int i; |
|
| 119 | + | ||
| 120 | + | if(!sel) |
|
| 121 | + | return; |
|
| 122 | + | sel->tags[arg->i] = !sel->tags[arg->i]; |
|
| 123 | + | for(i = 0; i < ntags && !sel->tags[i]; i++); |
|
| 124 | + | if(i == ntags) |
|
| 125 | + | sel->tags[arg->i] = True; |
|
| 126 | + | lt->arrange(); |
|
| 127 | + | } |
|
| 128 | + | ||
| 129 | + | void |
|
| 130 | + | toggleview(Arg *arg) { |
|
| 131 | + | unsigned int i; |
|
| 132 | + | ||
| 133 | + | seltag[arg->i] = !seltag[arg->i]; |
|
| 134 | + | for(i = 0; i < ntags && !seltag[i]; i++); |
|
| 135 | + | if(i == ntags) |
|
| 136 | + | seltag[arg->i] = True; /* cannot toggle last view */ |
|
| 137 | + | lt->arrange(); |
|
| 138 | + | } |
|
| 139 | + | ||
| 140 | + | void |
|
| 141 | + | view(Arg *arg) { |
|
| 142 | + | unsigned int i; |
|
| 143 | + | ||
| 144 | + | for(i = 0; i < ntags; i++) |
|
| 145 | + | seltag[i] = (arg->i == -1) ? True : False; |
|
| 146 | + | if(arg->i >= 0 && arg->i < ntags) |
|
| 147 | + | seltag[arg->i] = True; |
|
| 148 | + | lt->arrange(); |
|
| 149 | + | } |