|
|
@ -68,12 +68,11 @@ struct Client {
|
|
|
|
char name[256];
|
|
|
|
char name[256];
|
|
|
|
int x, y, w, h;
|
|
|
|
int x, y, w, h;
|
|
|
|
int basew, baseh, incw, inch, maxw, maxh, minw, minh;
|
|
|
|
int basew, baseh, incw, inch, maxw, maxh, minw, minh;
|
|
|
|
int minax, maxax, minay, maxay;
|
|
|
|
float mina, maxa;
|
|
|
|
int bw, oldbw;
|
|
|
|
int bw, oldbw;
|
|
|
|
Bool isbanned, isfixed, isfloating, ismoved, isurgent;
|
|
|
|
Bool isbanned, isfixed, isfloating, ismoved, isurgent;
|
|
|
|
uint tags;
|
|
|
|
uint tags;
|
|
|
|
Client *next;
|
|
|
|
Client *next;
|
|
|
|
Client *prev;
|
|
|
|
|
|
|
|
Client *snext;
|
|
|
|
Client *snext;
|
|
|
|
Window win;
|
|
|
|
Window win;
|
|
|
|
};
|
|
|
|
};
|
|
|
@ -93,11 +92,19 @@ typedef struct {
|
|
|
|
} font;
|
|
|
|
} font;
|
|
|
|
} DC; /* draw context */
|
|
|
|
} DC; /* draw context */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef union {
|
|
|
|
|
|
|
|
const char *c;
|
|
|
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
uint ui;
|
|
|
|
|
|
|
|
float f;
|
|
|
|
|
|
|
|
void *aux;
|
|
|
|
|
|
|
|
} Arg;
|
|
|
|
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
typedef struct {
|
|
|
|
uint mod;
|
|
|
|
uint mod;
|
|
|
|
KeySym keysym;
|
|
|
|
KeySym keysym;
|
|
|
|
void (*func)(const void *arg);
|
|
|
|
void (*func)(const Arg *);
|
|
|
|
const void *arg;
|
|
|
|
const Arg arg;
|
|
|
|
} Key;
|
|
|
|
} Key;
|
|
|
|
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
typedef struct {
|
|
|
@ -114,87 +121,86 @@ typedef struct {
|
|
|
|
} Rule;
|
|
|
|
} Rule;
|
|
|
|
|
|
|
|
|
|
|
|
/* function declarations */
|
|
|
|
/* function declarations */
|
|
|
|
void applyrules(Client *c);
|
|
|
|
static void applyrules(Client *c);
|
|
|
|
void arrange(void);
|
|
|
|
static void arrange(void);
|
|
|
|
void attach(Client *c);
|
|
|
|
static void attach(Client *c);
|
|
|
|
void attachstack(Client *c);
|
|
|
|
static void attachstack(Client *c);
|
|
|
|
void buttonpress(XEvent *e);
|
|
|
|
static void buttonpress(XEvent *e);
|
|
|
|
void checkotherwm(void);
|
|
|
|
static void checkotherwm(void);
|
|
|
|
void cleanup(void);
|
|
|
|
static void cleanup(void);
|
|
|
|
void configure(Client *c);
|
|
|
|
static void configure(Client *c);
|
|
|
|
void configurenotify(XEvent *e);
|
|
|
|
static void configurenotify(XEvent *e);
|
|
|
|
void configurerequest(XEvent *e);
|
|
|
|
static void configurerequest(XEvent *e);
|
|
|
|
void destroynotify(XEvent *e);
|
|
|
|
static void destroynotify(XEvent *e);
|
|
|
|
void detach(Client *c);
|
|
|
|
static void detach(Client *c);
|
|
|
|
void detachstack(Client *c);
|
|
|
|
static void detachstack(Client *c);
|
|
|
|
void drawbar(void);
|
|
|
|
static void drawbar(void);
|
|
|
|
void drawsquare(Bool filled, Bool empty, Bool invert, ulong col[ColLast]);
|
|
|
|
static void drawsquare(Bool filled, Bool empty, Bool invert, ulong col[ColLast]);
|
|
|
|
void drawtext(const char *text, ulong col[ColLast], Bool invert);
|
|
|
|
static void drawtext(const char *text, ulong col[ColLast], Bool invert);
|
|
|
|
void enternotify(XEvent *e);
|
|
|
|
static void enternotify(XEvent *e);
|
|
|
|
void eprint(const char *errstr, ...);
|
|
|
|
static void eprint(const char *errstr, ...);
|
|
|
|
void expose(XEvent *e);
|
|
|
|
static void expose(XEvent *e);
|
|
|
|
void focus(Client *c);
|
|
|
|
static void focus(Client *c);
|
|
|
|
void focusin(XEvent *e);
|
|
|
|
static void focusin(XEvent *e);
|
|
|
|
void focusnext(const void *arg);
|
|
|
|
static void focusstack(const Arg *arg);
|
|
|
|
void focusprev(const void *arg);
|
|
|
|
static Client *getclient(Window w);
|
|
|
|
Client *getclient(Window w);
|
|
|
|
static ulong getcolor(const char *colstr);
|
|
|
|
ulong getcolor(const char *colstr);
|
|
|
|
static long getstate(Window w);
|
|
|
|
long getstate(Window w);
|
|
|
|
static Bool gettextprop(Window w, Atom atom, char *text, uint size);
|
|
|
|
Bool gettextprop(Window w, Atom atom, char *text, uint size);
|
|
|
|
static void grabbuttons(Client *c, Bool focused);
|
|
|
|
void grabbuttons(Client *c, Bool focused);
|
|
|
|
static void grabkeys(void);
|
|
|
|
void grabkeys(void);
|
|
|
|
static void initfont(const char *fontstr);
|
|
|
|
void initfont(const char *fontstr);
|
|
|
|
static Bool isoccupied(uint t);
|
|
|
|
Bool isoccupied(uint t);
|
|
|
|
static Bool isprotodel(Client *c);
|
|
|
|
Bool isprotodel(Client *c);
|
|
|
|
static Bool isurgent(uint t);
|
|
|
|
Bool isurgent(uint t);
|
|
|
|
static void keypress(XEvent *e);
|
|
|
|
void keypress(XEvent *e);
|
|
|
|
static void killclient(const Arg *arg);
|
|
|
|
void killclient(const void *arg);
|
|
|
|
static void manage(Window w, XWindowAttributes *wa);
|
|
|
|
void manage(Window w, XWindowAttributes *wa);
|
|
|
|
static void mappingnotify(XEvent *e);
|
|
|
|
void mappingnotify(XEvent *e);
|
|
|
|
static void maprequest(XEvent *e);
|
|
|
|
void maprequest(XEvent *e);
|
|
|
|
static void movemouse(Client *c);
|
|
|
|
void movemouse(Client *c);
|
|
|
|
static Client *nexttiled(Client *c);
|
|
|
|
Client *nexttiled(Client *c);
|
|
|
|
static void propertynotify(XEvent *e);
|
|
|
|
void propertynotify(XEvent *e);
|
|
|
|
static void quit(const Arg *arg);
|
|
|
|
void quit(const void *arg);
|
|
|
|
static void resize(Client *c, int x, int y, int w, int h, Bool sizehints);
|
|
|
|
void resize(Client *c, int x, int y, int w, int h, Bool sizehints);
|
|
|
|
static void resizemouse(Client *c);
|
|
|
|
void resizemouse(Client *c);
|
|
|
|
static void restack(void);
|
|
|
|
void restack(void);
|
|
|
|
static void run(void);
|
|
|
|
void run(void);
|
|
|
|
static void scan(void);
|
|
|
|
void scan(void);
|
|
|
|
static void setclientstate(Client *c, long state);
|
|
|
|
void setclientstate(Client *c, long state);
|
|
|
|
static void setmfact(const Arg *arg);
|
|
|
|
void setmfact(const void *arg);
|
|
|
|
static void setup(void);
|
|
|
|
void setup(void);
|
|
|
|
static void spawn(const Arg *arg);
|
|
|
|
void spawn(const void *arg);
|
|
|
|
static void tag(const Arg *arg);
|
|
|
|
void tag(const void *arg);
|
|
|
|
static int textnw(const char *text, uint len);
|
|
|
|
int textnw(const char *text, uint len);
|
|
|
|
static void tile(void);
|
|
|
|
void tile(void);
|
|
|
|
static void togglebar(const Arg *arg);
|
|
|
|
void togglebar(const void *arg);
|
|
|
|
static void togglefloating(const Arg *arg);
|
|
|
|
void togglefloating(const void *arg);
|
|
|
|
static void togglelayout(const Arg *arg);
|
|
|
|
void togglelayout(const void *arg);
|
|
|
|
static void togglemax(const Arg *arg);
|
|
|
|
void togglemax(const void *arg);
|
|
|
|
static void toggletag(const Arg *arg);
|
|
|
|
void toggletag(const void *arg);
|
|
|
|
static void toggleview(const Arg *arg);
|
|
|
|
void toggleview(const void *arg);
|
|
|
|
static void unmanage(Client *c);
|
|
|
|
void unmanage(Client *c);
|
|
|
|
static void unmapnotify(XEvent *e);
|
|
|
|
void unmapnotify(XEvent *e);
|
|
|
|
static void updatebar(void);
|
|
|
|
void updatebar(void);
|
|
|
|
static void updategeom(void);
|
|
|
|
void updategeom(void);
|
|
|
|
static void updatesizehints(Client *c);
|
|
|
|
void updatesizehints(Client *c);
|
|
|
|
static void updatetitle(Client *c);
|
|
|
|
void updatetitle(Client *c);
|
|
|
|
static void updatewmhints(Client *c);
|
|
|
|
void updatewmhints(Client *c);
|
|
|
|
static void view(const Arg *arg);
|
|
|
|
void view(const void *arg);
|
|
|
|
static int xerror(Display *dpy, XErrorEvent *ee);
|
|
|
|
int xerror(Display *dpy, XErrorEvent *ee);
|
|
|
|
static int xerrordummy(Display *dpy, XErrorEvent *ee);
|
|
|
|
int xerrordummy(Display *dpy, XErrorEvent *ee);
|
|
|
|
static int xerrorstart(Display *dpy, XErrorEvent *ee);
|
|
|
|
int xerrorstart(Display *dpy, XErrorEvent *ee);
|
|
|
|
static void zoom(const Arg *arg);
|
|
|
|
void zoom(const void *arg);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* variables */
|
|
|
|
/* variables */
|
|
|
|
char stext[256];
|
|
|
|
static char stext[256];
|
|
|
|
int screen, sx, sy, sw, sh;
|
|
|
|
static int screen, sx, sy, sw, sh;
|
|
|
|
int by, bh, blw, wx, wy, ww, wh;
|
|
|
|
static int by, bh, blw, wx, wy, ww, wh;
|
|
|
|
uint seltags = 0;
|
|
|
|
static uint seltags = 0;
|
|
|
|
int (*xerrorxlib)(Display *, XErrorEvent *);
|
|
|
|
static int (*xerrorxlib)(Display *, XErrorEvent *);
|
|
|
|
uint numlockmask = 0;
|
|
|
|
static uint numlockmask = 0;
|
|
|
|
void (*handler[LASTEvent]) (XEvent *) = {
|
|
|
|
static void (*handler[LASTEvent]) (XEvent *) = {
|
|
|
|
[ButtonPress] = buttonpress,
|
|
|
|
[ButtonPress] = buttonpress,
|
|
|
|
[ConfigureRequest] = configurerequest,
|
|
|
|
[ConfigureRequest] = configurerequest,
|
|
|
|
[ConfigureNotify] = configurenotify,
|
|
|
|
[ConfigureNotify] = configurenotify,
|
|
|
@ -208,24 +214,24 @@ void (*handler[LASTEvent]) (XEvent *) = {
|
|
|
|
[PropertyNotify] = propertynotify,
|
|
|
|
[PropertyNotify] = propertynotify,
|
|
|
|
[UnmapNotify] = unmapnotify
|
|
|
|
[UnmapNotify] = unmapnotify
|
|
|
|
};
|
|
|
|
};
|
|
|
|
Atom wmatom[WMLast], netatom[NetLast];
|
|
|
|
static Atom wmatom[WMLast], netatom[NetLast];
|
|
|
|
Bool ismax = False;
|
|
|
|
static Bool ismax = False;
|
|
|
|
Bool otherwm, readin;
|
|
|
|
static Bool otherwm, readin;
|
|
|
|
Bool running = True;
|
|
|
|
static Bool running = True;
|
|
|
|
uint tagset[] = {1, 1}; /* after start, first tag is selected */
|
|
|
|
static uint tagset[] = {1, 1}; /* after start, first tag is selected */
|
|
|
|
Client *clients = NULL;
|
|
|
|
static Client *clients = NULL;
|
|
|
|
Client *sel = NULL;
|
|
|
|
static Client *sel = NULL;
|
|
|
|
Client *stack = NULL;
|
|
|
|
static Client *stack = NULL;
|
|
|
|
Cursor cursor[CurLast];
|
|
|
|
static Cursor cursor[CurLast];
|
|
|
|
Display *dpy;
|
|
|
|
static Display *dpy;
|
|
|
|
DC dc = {0};
|
|
|
|
static DC dc = {0};
|
|
|
|
Layout layouts[];
|
|
|
|
static Window root, barwin;
|
|
|
|
Layout *lt = layouts;
|
|
|
|
|
|
|
|
Window root, barwin;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* configuration, allows nested code to access above variables */
|
|
|
|
/* configuration, allows nested code to access above variables */
|
|
|
|
#include "config.h"
|
|
|
|
#include "config.h"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static Layout *lt = layouts;
|
|
|
|
|
|
|
|
|
|
|
|
/* compile-time check if all tags fit into an uint bit array. */
|
|
|
|
/* compile-time check if all tags fit into an uint bit array. */
|
|
|
|
struct NumTags { char limitexceeded[sizeof(uint) * 8 < LENGTH(tags) ? -1 : 1]; };
|
|
|
|
struct NumTags { char limitexceeded[sizeof(uint) * 8 < LENGTH(tags) ? -1 : 1]; };
|
|
|
|
|
|
|
|
|
|
|
@ -282,8 +288,6 @@ arrange(void) {
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
void
|
|
|
|
attach(Client *c) {
|
|
|
|
attach(Client *c) {
|
|
|
|
if(clients)
|
|
|
|
|
|
|
|
clients->prev = c;
|
|
|
|
|
|
|
|
c->next = clients;
|
|
|
|
c->next = clients;
|
|
|
|
clients = c;
|
|
|
|
clients = c;
|
|
|
|
}
|
|
|
|
}
|
|
|
@ -309,15 +313,15 @@ buttonpress(XEvent *e) {
|
|
|
|
mask = 1 << i;
|
|
|
|
mask = 1 << i;
|
|
|
|
if(ev->button == Button1) {
|
|
|
|
if(ev->button == Button1) {
|
|
|
|
if(ev->state & MODKEY)
|
|
|
|
if(ev->state & MODKEY)
|
|
|
|
tag(&mask);
|
|
|
|
tag((Arg*)&mask);
|
|
|
|
else
|
|
|
|
else
|
|
|
|
view(&mask);
|
|
|
|
view((Arg*)&mask);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if(ev->button == Button3) {
|
|
|
|
else if(ev->button == Button3) {
|
|
|
|
if(ev->state & MODKEY)
|
|
|
|
if(ev->state & MODKEY)
|
|
|
|
toggletag(&mask);
|
|
|
|
toggletag((Arg*)&mask);
|
|
|
|
else
|
|
|
|
else
|
|
|
|
toggleview(&mask);
|
|
|
|
toggleview((Arg*)&mask);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
@ -359,8 +363,9 @@ checkotherwm(void) {
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
void
|
|
|
|
cleanup(void) {
|
|
|
|
cleanup(void) {
|
|
|
|
|
|
|
|
Arg a = {.i = ~0};
|
|
|
|
close(STDIN_FILENO);
|
|
|
|
close(STDIN_FILENO);
|
|
|
|
view((uint[]){~0});
|
|
|
|
view(&a);
|
|
|
|
while(stack)
|
|
|
|
while(stack)
|
|
|
|
unmanage(stack);
|
|
|
|
unmanage(stack);
|
|
|
|
if(dc.font.set)
|
|
|
|
if(dc.font.set)
|
|
|
@ -466,13 +471,16 @@ destroynotify(XEvent *e) {
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
void
|
|
|
|
detach(Client *c) {
|
|
|
|
detach(Client *c) {
|
|
|
|
if(c->prev)
|
|
|
|
Client *i;
|
|
|
|
c->prev->next = c->next;
|
|
|
|
|
|
|
|
if(c->next)
|
|
|
|
if (c != clients) {
|
|
|
|
c->next->prev = c->prev;
|
|
|
|
for(i = clients; i->next != c; i = i->next);
|
|
|
|
if(c == clients)
|
|
|
|
i->next = c->next;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
else {
|
|
|
|
clients = c->next;
|
|
|
|
clients = c->next;
|
|
|
|
c->next = c->prev = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
c->next = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
void
|
|
|
@ -640,30 +648,24 @@ focusin(XEvent *e) { /* there are some broken focus acquiring clients */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
void
|
|
|
|
focusnext(const void *arg) {
|
|
|
|
focusstack(const Arg *arg) {
|
|
|
|
Client *c;
|
|
|
|
Client *c = NULL, *i;
|
|
|
|
|
|
|
|
|
|
|
|
if(!sel)
|
|
|
|
if(!sel)
|
|
|
|
return;
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (arg->i > 0) {
|
|
|
|
for(c = sel->next; c && c->isbanned; c = c->next);
|
|
|
|
for(c = sel->next; c && c->isbanned; c = c->next);
|
|
|
|
if(!c)
|
|
|
|
if(!c)
|
|
|
|
for(c = clients; c && c->isbanned; c = c->next);
|
|
|
|
for(c = clients; c && c->isbanned; c = c->next);
|
|
|
|
if(c) {
|
|
|
|
|
|
|
|
focus(c);
|
|
|
|
|
|
|
|
restack();
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
|
|
|
|
for(i = clients; i != sel; i = i->next)
|
|
|
|
void
|
|
|
|
if (!i->isbanned)
|
|
|
|
focusprev(const void *arg) {
|
|
|
|
c = i;
|
|
|
|
Client *c;
|
|
|
|
if(!c)
|
|
|
|
|
|
|
|
for(; i; i = i->next)
|
|
|
|
if(!sel)
|
|
|
|
if (!i->isbanned)
|
|
|
|
return;
|
|
|
|
c = i;
|
|
|
|
for(c = sel->prev; c && c->isbanned; c = c->prev);
|
|
|
|
|
|
|
|
if(!c) {
|
|
|
|
|
|
|
|
for(c = clients; c && c->next; c = c->next);
|
|
|
|
|
|
|
|
for(; c && c->isbanned; c = c->prev);
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(c) {
|
|
|
|
if(c) {
|
|
|
|
focus(c);
|
|
|
|
focus(c);
|
|
|
@ -866,11 +868,11 @@ keypress(XEvent *e) {
|
|
|
|
if(keysym == keys[i].keysym
|
|
|
|
if(keysym == keys[i].keysym
|
|
|
|
&& CLEANMASK(keys[i].mod) == CLEANMASK(ev->state)
|
|
|
|
&& CLEANMASK(keys[i].mod) == CLEANMASK(ev->state)
|
|
|
|
&& keys[i].func)
|
|
|
|
&& keys[i].func)
|
|
|
|
keys[i].func(keys[i].arg);
|
|
|
|
keys[i].func(&(keys[i].arg));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
void
|
|
|
|
killclient(const void *arg) {
|
|
|
|
killclient(const Arg *arg) {
|
|
|
|
XEvent ev;
|
|
|
|
XEvent ev;
|
|
|
|
|
|
|
|
|
|
|
|
if(!sel)
|
|
|
|
if(!sel)
|
|
|
@ -1056,7 +1058,7 @@ propertynotify(XEvent *e) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
void
|
|
|
|
quit(const void *arg) {
|
|
|
|
quit(const Arg *arg) {
|
|
|
|
readin = running = False;
|
|
|
|
readin = running = False;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
@ -1074,12 +1076,11 @@ resize(Client *c, int x, int y, int w, int h, Bool sizehints) {
|
|
|
|
h -= c->baseh;
|
|
|
|
h -= c->baseh;
|
|
|
|
|
|
|
|
|
|
|
|
/* adjust for aspect limits */
|
|
|
|
/* adjust for aspect limits */
|
|
|
|
if(c->minax != c->maxax && c->minay != c->maxay
|
|
|
|
if(c->mina > 0 && c->maxa > 0) {
|
|
|
|
&& c->minax > 0 && c->maxax > 0 && c->minay > 0 && c->maxay > 0) {
|
|
|
|
if(c->maxa < (float) w/h)
|
|
|
|
if(w * c->maxay > h * c->maxax)
|
|
|
|
w = h * c->maxa;
|
|
|
|
w = h * c->maxax / c->maxay;
|
|
|
|
else if(c->mina > (float) h/w)
|
|
|
|
else if(w * c->minay < h * c->minax)
|
|
|
|
h = w * c->mina;
|
|
|
|
h = w * c->minay / c->minax;
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* adjust for increment value */
|
|
|
|
/* adjust for increment value */
|
|
|
@ -1295,15 +1296,15 @@ setclientstate(Client *c, long state) {
|
|
|
|
|
|
|
|
|
|
|
|
/* arg > 1.0 will set mfact absolutly */
|
|
|
|
/* arg > 1.0 will set mfact absolutly */
|
|
|
|
void
|
|
|
|
void
|
|
|
|
setmfact(const void *arg) {
|
|
|
|
setmfact(const Arg *arg) {
|
|
|
|
double d = *((double*) arg);
|
|
|
|
float f;
|
|
|
|
|
|
|
|
|
|
|
|
if(!d || !lt->arrange)
|
|
|
|
if(!arg || !lt->arrange)
|
|
|
|
return;
|
|
|
|
return;
|
|
|
|
d = d < 1.0 ? d + mfact : d - 1.0;
|
|
|
|
f = arg->f < 1.0 ? arg->f + mfact : arg->f - 1.0;
|
|
|
|
if(d < 0.1 || d > 0.9)
|
|
|
|
if(f < 0.1 || f > 0.9)
|
|
|
|
return;
|
|
|
|
return;
|
|
|
|
mfact = d;
|
|
|
|
mfact = f;
|
|
|
|
arrange();
|
|
|
|
arrange();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
@ -1386,7 +1387,7 @@ setup(void) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
void
|
|
|
|
spawn(const void *arg) {
|
|
|
|
spawn(const Arg *arg) {
|
|
|
|
static char *shell = NULL;
|
|
|
|
static char *shell = NULL;
|
|
|
|
|
|
|
|
|
|
|
|
if(!shell && !(shell = getenv("SHELL")))
|
|
|
|
if(!shell && !(shell = getenv("SHELL")))
|
|
|
@ -1398,8 +1399,8 @@ spawn(const void *arg) {
|
|
|
|
if(dpy)
|
|
|
|
if(dpy)
|
|
|
|
close(ConnectionNumber(dpy));
|
|
|
|
close(ConnectionNumber(dpy));
|
|
|
|
setsid();
|
|
|
|
setsid();
|
|
|
|
execl(shell, shell, "-c", (char *)arg, (char *)NULL);
|
|
|
|
execl(shell, shell, "-c", arg->c, (char *)NULL);
|
|
|
|
fprintf(stderr, "dwm: execl '%s -c %s'", shell, (char *)arg);
|
|
|
|
fprintf(stderr, "dwm: execl '%s -c %s'", shell, arg->c);
|
|
|
|
perror(" failed");
|
|
|
|
perror(" failed");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
exit(0);
|
|
|
|
exit(0);
|
|
|
@ -1408,9 +1409,9 @@ spawn(const void *arg) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
void
|
|
|
|
tag(const void *arg) {
|
|
|
|
tag(const Arg *arg) {
|
|
|
|
if(sel && *(int *)arg & TAGMASK) {
|
|
|
|
if(sel && arg->ui & TAGMASK) {
|
|
|
|
sel->tags = *(int *)arg & TAGMASK;
|
|
|
|
sel->tags = arg->ui & TAGMASK;
|
|
|
|
arrange();
|
|
|
|
arrange();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
@ -1461,7 +1462,7 @@ tile(void) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
void
|
|
|
|
togglebar(const void *arg) {
|
|
|
|
togglebar(const Arg *arg) {
|
|
|
|
showbar = !showbar;
|
|
|
|
showbar = !showbar;
|
|
|
|
updategeom();
|
|
|
|
updategeom();
|
|
|
|
updatebar();
|
|
|
|
updatebar();
|
|
|
@ -1469,7 +1470,7 @@ togglebar(const void *arg) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
void
|
|
|
|
togglefloating(const void *arg) {
|
|
|
|
togglefloating(const Arg *arg) {
|
|
|
|
if(!sel)
|
|
|
|
if(!sel)
|
|
|
|
return;
|
|
|
|
return;
|
|
|
|
sel->isfloating = !sel->isfloating || sel->isfixed;
|
|
|
|
sel->isfloating = !sel->isfloating || sel->isfixed;
|
|
|
@ -1479,16 +1480,16 @@ togglefloating(const void *arg) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
void
|
|
|
|
togglelayout(const void *arg) {
|
|
|
|
togglelayout(const Arg *arg) {
|
|
|
|
uint i;
|
|
|
|
uint i;
|
|
|
|
|
|
|
|
|
|
|
|
if(!arg) {
|
|
|
|
if(!arg->c) {
|
|
|
|
if(++lt == &layouts[LENGTH(layouts)])
|
|
|
|
if(++lt == &layouts[LENGTH(layouts)])
|
|
|
|
lt = &layouts[0];
|
|
|
|
lt = &layouts[0];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
else {
|
|
|
|
for(i = 0; i < LENGTH(layouts); i++)
|
|
|
|
for(i = 0; i < LENGTH(layouts); i++)
|
|
|
|
if(!strcmp((char *)arg, layouts[i].symbol))
|
|
|
|
if(!strcmp(arg->c, layouts[i].symbol))
|
|
|
|
break;
|
|
|
|
break;
|
|
|
|
if(i == LENGTH(layouts))
|
|
|
|
if(i == LENGTH(layouts))
|
|
|
|
return;
|
|
|
|
return;
|
|
|
@ -1501,26 +1502,22 @@ togglelayout(const void *arg) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
void
|
|
|
|
togglemax(const void *arg) {
|
|
|
|
togglemax(const Arg *arg) {
|
|
|
|
ismax = !ismax;
|
|
|
|
ismax = !ismax;
|
|
|
|
arrange();
|
|
|
|
arrange();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
void
|
|
|
|
toggletag(const void *arg) {
|
|
|
|
toggletag(const Arg *arg) {
|
|
|
|
if(sel && (sel->tags ^ ((*(int *)arg) & TAGMASK))) {
|
|
|
|
if(sel && (sel->tags ^= (arg->ui & TAGMASK)))
|
|
|
|
sel->tags ^= (*(int *)arg) & TAGMASK;
|
|
|
|
|
|
|
|
arrange();
|
|
|
|
arrange();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
void
|
|
|
|
toggleview(const void *arg) {
|
|
|
|
toggleview(const Arg *arg) {
|
|
|
|
if((tagset[seltags] ^ ((*(int *)arg) & TAGMASK))) {
|
|
|
|
if((tagset[seltags] ^= (arg->ui & TAGMASK)))
|
|
|
|
tagset[seltags] ^= (*(int *)arg) & TAGMASK;
|
|
|
|
|
|
|
|
arrange();
|
|
|
|
arrange();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
void
|
|
|
|
unmanage(Client *c) {
|
|
|
|
unmanage(Client *c) {
|
|
|
@ -1628,13 +1625,11 @@ updatesizehints(Client *c) {
|
|
|
|
else
|
|
|
|
else
|
|
|
|
c->minw = c->minh = 0;
|
|
|
|
c->minw = c->minh = 0;
|
|
|
|
if(size.flags & PAspect) {
|
|
|
|
if(size.flags & PAspect) {
|
|
|
|
c->minax = size.min_aspect.x;
|
|
|
|
c->mina = (float)size.min_aspect.y / (float)size.min_aspect.x;
|
|
|
|
c->maxax = size.max_aspect.x;
|
|
|
|
c->maxa = (float)size.max_aspect.x / (float)size.max_aspect.y;
|
|
|
|
c->minay = size.min_aspect.y;
|
|
|
|
|
|
|
|
c->maxay = size.max_aspect.y;
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
else
|
|
|
|
c->minax = c->maxax = c->minay = c->maxay = 0;
|
|
|
|
c->maxa = c->mina = 0.0;
|
|
|
|
c->isfixed = (c->maxw && c->minw && c->maxh && c->minh
|
|
|
|
c->isfixed = (c->maxw && c->minw && c->maxh && c->minh
|
|
|
|
&& c->maxw == c->minw && c->maxh == c->minh);
|
|
|
|
&& c->maxw == c->minw && c->maxh == c->minh);
|
|
|
|
}
|
|
|
|
}
|
|
|
@ -1659,10 +1654,10 @@ updatewmhints(Client *c) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
void
|
|
|
|
view(const void *arg) {
|
|
|
|
view(const Arg *arg) {
|
|
|
|
seltags ^= 1; /* toggle sel tagset */
|
|
|
|
seltags ^= 1; /* toggle sel tagset */
|
|
|
|
if(arg && (*(int *)arg & TAGMASK))
|
|
|
|
if(arg && (arg->ui & TAGMASK))
|
|
|
|
tagset[seltags] = *(int *)arg & TAGMASK;
|
|
|
|
tagset[seltags] = arg->i & TAGMASK;
|
|
|
|
arrange();
|
|
|
|
arrange();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
@ -1700,7 +1695,7 @@ xerrorstart(Display *dpy, XErrorEvent *ee) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
void
|
|
|
|
zoom(const void *arg) {
|
|
|
|
zoom(const Arg *arg) {
|
|
|
|
Client *c = sel;
|
|
|
|
Client *c = sel;
|
|
|
|
|
|
|
|
|
|
|
|
if(ismax || !lt->arrange || (sel && sel->isfloating))
|
|
|
|
if(ismax || !lt->arrange || (sel && sel->isfloating))
|
|
|
|