diff options
author | FreeArtMan <freeartman@wechall.net> | 2014-06-29 19:14:44 +0300 |
---|---|---|
committer | FreeArtMan <freeartman@wechall.net> | 2014-06-29 19:14:44 +0300 |
commit | 3bea9f44076cc399ce34085a874fdd09aea004cb (patch) | |
tree | 15af5652df82d83f0513817a1702c4f95414874e /dwm.c | |
download | dwm-fancy-3bea9f44076cc399ce34085a874fdd09aea004cb.tar.gz dwm-fancy-3bea9f44076cc399ce34085a874fdd09aea004cb.zip |
Initial commit
Diffstat (limited to 'dwm.c')
-rw-r--r-- | dwm.c | 2691 |
1 files changed, 2691 insertions, 0 deletions
@@ -0,0 +1,2691 @@ +/* See LICENSE file for copyright and license details. + * + * dynamic window manager is designed like any other X client as well. It is + * driven through handling X events. In contrast to other X clients, a window + * manager selects for SubstructureRedirectMask on the root window, to receive + * events about window (dis-)appearance. Only one X connection at a time is + * allowed to select for this event mask. + * + * The event handlers of dwm are organized in an array which is accessed + * whenever a new event has been fetched. This allows event dispatching + * in O(1) time. + * + * Each child of the root window is called a client, except windows which have + * set the override_redirect flag. Clients are organized in a linked client + * list on each monitor, the focus history is remembered through a stack list + * on each monitor. Each client contains a bit array to indicate the tags of a + * client. + * + * Keys and tagging rules are organized as arrays and defined in config.h. + * + * To understand everything else, start reading main(). + */ +#include <errno.h> +#include <locale.h> +#include <stdarg.h> +#include <signal.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <sys/types.h> +#include <sys/wait.h> +#include <X11/cursorfont.h> +#include <X11/keysym.h> +#include <X11/Xatom.h> +#include <X11/Xlib.h> +#include <X11/Xproto.h> +#include <X11/Xutil.h> +#ifdef XINERAMA +#include <X11/extensions/Xinerama.h> +#endif /* XINERAMA */ + + +#include "drw.h" +#include "util.h" +//#include "config.h" + +/* macros */ +#define BUTTONMASK (ButtonPressMask|ButtonReleaseMask) +#define CLEANMASK(mask) (mask & ~(numlockmask|LockMask) & (ShiftMask|ControlMask|Mod1Mask|Mod2Mask|Mod3Mask|Mod4Mask|Mod5Mask)) +#define INTERSECT(x,y,w,h,m) (MAX(0, MIN((x)+(w),(m)->wx+(m)->ww) - MAX((x),(m)->wx)) \ + * MAX(0, MIN((y)+(h),(m)->wy+(m)->wh) - MAX((y),(m)->wy))) +#define ISVISIBLE(C) ((C->tags & C->mon->tagset[C->mon->seltags])) +#define LENGTH(X) (sizeof X / sizeof X[0]) +#define MOUSEMASK (BUTTONMASK|PointerMotionMask) +#define WIDTH(X) ((X)->w + 2 * (X)->bw) +#define HEIGHT(X) ((X)->h + 2 * (X)->bw) +#define TAGMASK ((1 << LENGTH(tags)) - 1) +#define TEXTW(X) (drw_font_getexts_width(drw->font, X, strlen(X)) + drw->font->h) + +#ifdef CONFIG_DWM_SYSTEMTRAY +#define SYSTEM_TRAY_REQUEST_DOCK 0 +#define _NET_SYSTEM_TRAY_ORIENTATION_HORZ 0 + +/* XEMBED messages */ +#define XEMBED_EMBEDDED_NOTIFY 0 +#define XEMBED_WINDOW_ACTIVATE 1 +#define XEMBED_FOCUS_IN 4 +#define XEMBED_MODALITY_ON 10 + +#define XEMBED_MAPPED (1 << 0) +#define XEMBED_WINDOW_ACTIVATE 1 +#define XEMBED_WINDOW_DEACTIVATE 2 + +#define VERSION_MAJOR 0 +#define VERSION_MINOR 0 +#define XEMBED_EMBEDDED_VERSION (VERSION_MAJOR << 16) | VERSION_MINOR +#endif + +/* enums */ +enum { CurNormal, CurResize, CurMove, CurLast }; /* cursor */ +enum { SchemeNorm, SchemeSel, SchemeLast }; /* color schemes */ +enum { NetSupported, NetWMName, NetWMState, + NetWMFullscreen, NetActiveWindow, NetWMWindowType, +#ifdef CONFIG_DWM_OPACITY + NetWMWindowsOpacity, +#endif +#ifdef CONFIG_DWM_SYSTEMTRAY + NetSystemTray, NetSystemTrayOP, NetSystemTrayOrientation, +#endif + NetWMWindowTypeDialog, NetClientList, NetLast }; /* EWMH atoms */ +enum { WMProtocols, WMDelete, WMState, WMTakeFocus, WMLast }; /* default atoms */ +enum { ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle, + ClkClientWin, ClkRootWin, ClkLast }; /* clicks */ +#ifdef CONFIG_DWM_SYSTEMTRAY +enum { Manager, Xembed, XembedInfo, XLast }; /* Xembed atoms */ +#endif + + + +typedef union { + int i; + unsigned int ui; + float f; + const void *v; +} Arg; + +typedef struct { + unsigned int click; + unsigned int mask; + unsigned int button; + void (*func)(const Arg *arg); + const Arg arg; +} Button; + +typedef struct Monitor Monitor; +typedef struct Client Client; +struct Client { + char name[256]; + float mina, maxa; + int x, y, w, h; + int oldx, oldy, oldw, oldh; + int basew, baseh, incw, inch, maxw, maxh, minw, minh; + int bw, oldbw; + unsigned int tags; + Bool isfixed, isfloating, isurgent, neverfocus, oldstate, isfullscreen; + Client *next; + Client *snext; + Monitor *mon; + Window win; +}; + +typedef struct { + unsigned int mod; + KeySym keysym; + void (*func)(const Arg *); + const Arg arg; +} Key; + +typedef struct { + const char *symbol; + void (*arrange)(Monitor *); +} Layout; + + +#ifdef CONFIG_DWM_PERTAG + typedef struct Pertag Pertag; +#endif +struct Monitor { + char ltsymbol[16]; + float mfact; + int nmaster; + int num; + int by; /* bar geometry */ + int mx, my, mw, mh; /* screen size */ + int wx, wy, ww, wh; /* window area */ + unsigned int seltags; + unsigned int sellt; + unsigned int tagset[2]; + Bool showbar; + Bool topbar; + Client *clients; + Client *sel; + Client *stack; + Monitor *next; + Window barwin; + const Layout *lt[2]; + +#ifdef CONFIG_DWM_PERTAG + Pertag *pertag; +#endif +}; + +typedef struct { + const char *class; + const char *instance; + const char *title; + unsigned int tags; + Bool isfloating; + int monitor; +} Rule; + +#ifdef CONFIG_DWM_SYSTEMTRAY +typedef struct Systray Systray; +struct Systray { + Window win; + Client *icons; +}; +#endif + +/* function declarations */ +static void applyrules(Client *c); +static Bool applysizehints(Client *c, int *x, int *y, int *w, int *h, Bool interact); +static void arrange(Monitor *m); +static void arrangemon(Monitor *m); +static void attach(Client *c); +static void attachstack(Client *c); +static void buttonpress(XEvent *e); +static void checkotherwm(void); +static void cleanup(void); +static void cleanupmon(Monitor *mon); +static void clearurgent(Client *c); +static void clientmessage(XEvent *e); +static void configure(Client *c); +static void configurenotify(XEvent *e); +static void configurerequest(XEvent *e); +static Monitor *createmon(void); +static void destroynotify(XEvent *e); +static void detach(Client *c); +static void detachstack(Client *c); +static Monitor *dirtomon(int dir); +static void drawbar(Monitor *m); +static void drawbars(void); +static void enternotify(XEvent *e); +static void expose(XEvent *e); +static void focus(Client *c); +static void focusin(XEvent *e); +static void focusmon(const Arg *arg); +static void focusstack(const Arg *arg); +static Bool getrootptr(int *x, int *y); +static long getstate(Window w); +static Bool gettextprop(Window w, Atom atom, char *text, unsigned int size); +static void grabbuttons(Client *c, Bool focused); +static void grabkeys(void); +static void incnmaster(const Arg *arg); +static void keypress(XEvent *e); +static void killclient(const Arg *arg); +static void manage(Window w, XWindowAttributes *wa); +static void mappingnotify(XEvent *e); +static void maprequest(XEvent *e); +static void monocle(Monitor *m); +static void motionnotify(XEvent *e); +static void movemouse(const Arg *arg); +static Client *nexttiled(Client *c); +static void pop(Client *); +static void propertynotify(XEvent *e); +static void quit(const Arg *arg); +static Monitor *recttomon(int x, int y, int w, int h); +static void resize(Client *c, int x, int y, int w, int h, Bool interact); +static void resizeclient(Client *c, int x, int y, int w, int h); +static void resizemouse(const Arg *arg); +static void restack(Monitor *m); +static void run(void); +static void scan(void); +#ifdef CONFIG_DWM_SYSTEMTRAY +static Bool sendevent(Window w, Atom proto, int m, long d0, long d1, long d2, long d3, long d4); +#else +static Bool sendevent(Client *c, Atom proto); +#endif +static void sendmon(Client *c, Monitor *m); +static void setclientstate(Client *c, long state); +static void setfocus(Client *c); +static void setfullscreen(Client *c, Bool fullscreen); +static void setlayout(const Arg *arg); +static void setmfact(const Arg *arg); +static void setup(void); +static void showhide(Client *c); +static void sigchld(int unused); +static void spawn(const Arg *arg); +static void tag(const Arg *arg); +static void tagmon(const Arg *arg); +static void tile(Monitor *); +static void togglebar(const Arg *arg); +static void togglefloating(const Arg *arg); +static void toggletag(const Arg *arg); +static void toggleview(const Arg *arg); +static void unfocus(Client *c, Bool setfocus); +static void unmanage(Client *c, Bool destroyed); +static void unmapnotify(XEvent *e); +static Bool updategeom(void); +static void updatebarpos(Monitor *m); +static void updatebars(void); +static void updateclientlist(void); +static void updatenumlockmask(void); +static void updatesizehints(Client *c); +static void updatestatus(void); +static void updatewindowtype(Client *c); +static void updatetitle(Client *c); +static void updatewmhints(Client *c); +static void view(const Arg *arg); +static Client *wintoclient(Window w); +static Monitor *wintomon(Window w); +static int xerror(Display *dpy, XErrorEvent *ee); +static int xerrordummy(Display *dpy, XErrorEvent *ee); +static int xerrorstart(Display *dpy, XErrorEvent *ee); +static void zoom(const Arg *arg); +#ifdef CONFIG_DWM_OPACITY +static void opacity(Client *c, double opacity); +#endif +#ifdef CONFIG_DWM_SYSTEMTRAY +static Atom getatomprop(Client *c, Atom prop); +static unsigned int getsystraywidth(); +static void removesystrayicon(Client *i); +static void resizebarwin(Monitor *m); +static void resizerequest(XEvent *e); +static Monitor *systraytomon(Monitor *m); +static void updatesystray(void); +static void updatesystrayicongeom(Client *i, int w, int h); +static void updatesystrayiconstate(Client *i, XPropertyEvent *ev); +static Client *wintosystrayicon(Window w); +#endif + +/* variables */ +static const char broken[] = "broken"; +#ifdef CONFIG_DWM_PANGO +static char stext[512]; +#else +static char stext[256]; +#endif +static int screen; +static int sw, sh; /* X display screen geometry width, height */ +static int bh, blw = 0; /* bar geometry */ +static int (*xerrorxlib)(Display *, XErrorEvent *); +static unsigned int numlockmask = 0; +static void (*handler[LASTEvent]) (XEvent *) = { + [ButtonPress] = buttonpress, + [ClientMessage] = clientmessage, + [ConfigureRequest] = configurerequest, + [ConfigureNotify] = configurenotify, + [DestroyNotify] = destroynotify, + [EnterNotify] = enternotify, + [Expose] = expose, + [FocusIn] = focusin, + [KeyPress] = keypress, + [MappingNotify] = mappingnotify, + [MapRequest] = maprequest, + [MotionNotify] = motionnotify, + [PropertyNotify] = propertynotify, +#ifdef CONFIG_DWM_SYSTEMTRAY + [ResizeRequest] = resizerequest, +#endif + [UnmapNotify] = unmapnotify +}; +static Atom wmatom[WMLast], netatom[NetLast]; +static Bool running = True; +static Cur *cursor[CurLast]; +static ClrScheme scheme[SchemeLast]; +static Display *dpy; +static Drw *drw; +static Fnt *fnt; +static Monitor *mons, *selmon; +static Window root; +#ifdef CONFIG_DWM_SYSTEMTRAY +static Systray *systray = NULL; +static unsigned long systrayorientation = _NET_SYSTEM_TRAY_ORIENTATION_HORZ; +static Atom wmatom[WMLast], netatom[NetLast], xatom[XLast]; +#endif + + +/* configuration, allows nested code to access above variables */ +#include "config.h" + +#ifdef CONFIG_DWM_PERTAG +typedef struct Pertag { + unsigned int curtag, prevtag; /* current and previous tag */ + int nmasters[LENGTH(tags) + 1]; /* number of windows in master area */ + float mfacts[LENGTH(tags) + 1]; /* mfacts per tag */ + unsigned int sellts[LENGTH(tags) + 1]; /* selected layouts */ + const Layout *ltidxs[LENGTH(tags) + 1][2]; /* matrix of tags and layouts indexes */ + Bool showbars[LENGTH(tags) + 1]; /* display bar for the current tag */ + Client *prevzooms[LENGTH(tags) + 1]; /* store zoom information */ +} Pertag; +#endif + +/* compile-time check if all tags fit into an unsigned int bit array. */ +struct NumTags { char limitexceeded[LENGTH(tags) > 31 ? -1 : 1]; }; + +/* function implementations */ +void +applyrules(Client *c) { + const char *class, *instance; + unsigned int i; + const Rule *r; + Monitor *m; + XClassHint ch = { NULL, NULL }; + + /* rule matching */ + c->isfloating = c->tags = 0; + XGetClassHint(dpy, c->win, &ch); + class = ch.res_class ? ch.res_class : broken; + instance = ch.res_name ? ch.res_name : broken; + + for(i = 0; i < LENGTH(rules); i++) { + r = &rules[i]; + if((!r->title || strstr(c->name, r->title)) + && (!r->class || strstr(class, r->class)) + && (!r->instance || strstr(instance, r->instance))) + { + c->isfloating = r->isfloating; + c->tags |= r->tags; + for(m = mons; m && m->num != r->monitor; m = m->next); + if(m) + c->mon = m; + } + } + if(ch.res_class) + XFree(ch.res_class); + if(ch.res_name) + XFree(ch.res_name); + c->tags = c->tags & TAGMASK ? c->tags & TAGMASK : c->mon->tagset[c->mon->seltags]; +} + +Bool +applysizehints(Client *c, int *x, int *y, int *w, int *h, Bool interact) { + Bool baseismin; + Monitor *m = c->mon; + + /* set minimum possible */ + *w = MAX(1, *w); + *h = MAX(1, *h); + if(interact) { + if(*x > sw) + *x = sw - WIDTH(c); + if(*y > sh) + *y = sh - HEIGHT(c); + if(*x + *w + 2 * c->bw < 0) + *x = 0; + if(*y + *h + 2 * c->bw < 0) + *y = 0; + } + else { + if(*x >= m->wx + m->ww) + *x = m->wx + m->ww - WIDTH(c); + if(*y >= m->wy + m->wh) + *y = m->wy + m->wh - HEIGHT(c); + if(*x + *w + 2 * c->bw <= m->wx) + *x = m->wx; + if(*y + *h + 2 * c->bw <= m->wy) + *y = m->wy; + } + if(*h < bh) + *h = bh; + if(*w < bh) + *w = bh; + if(resizehints || c->isfloating || !c->mon->lt[c->mon->sellt]->arrange) { + /* see last two sentences in ICCCM 4.1.2.3 */ + baseismin = c->basew == c->minw && c->baseh == c->minh; + if(!baseismin) { /* temporarily remove base dimensions */ + *w -= c->basew; + *h -= c->baseh; + } + /* adjust for aspect limits */ + if(c->mina > 0 && c->maxa > 0) { + if(c->maxa < (float)*w / *h) + *w = *h * c->maxa + 0.5; + else if(c->mina < (float)*h / *w) + *h = *w * c->mina + 0.5; + } + if(baseismin) { /* increment calculation requires this */ + *w -= c->basew; + *h -= c->baseh; + } + /* adjust for increment value */ + if(c->incw) + *w -= *w % c->incw; + if(c->inch) + *h -= *h % c->inch; + /* restore base dimensions */ + *w = MAX(*w + c->basew, c->minw); + *h = MAX(*h + c->baseh, c->minh); + if(c->maxw) + *w = MIN(*w, c->maxw); + if(c->maxh) + *h = MIN(*h, c->maxh); + } + return *x != c->x || *y != c->y || *w != c->w || *h != c->h; +} + +void +arrange(Monitor *m) { + if(m) + showhide(m->stack); + else for(m = mons; m; m = m->next) + showhide(m->stack); + if(m) { + arrangemon(m); + restack(m); + } else for(m = mons; m; m = m->next) + arrangemon(m); +} + +void +arrangemon(Monitor *m) { + strncpy(m->ltsymbol, m->lt[m->sellt]->symbol, sizeof m->ltsymbol); + if(m->lt[m->sellt]->arrange) + m->lt[m->sellt]->arrange(m); +} + +void +attach(Client *c) { + c->next = c->mon->clients; + c->mon->clients = c; +} + +void +attachstack(Client *c) { + c->snext = c->mon->stack; + c->mon->stack = c; +} + +void +buttonpress(XEvent *e) { + unsigned int i, x, click; + Arg arg = {0}; + Client *c; + Monitor *m; + XButtonPressedEvent *ev = &e->xbutton; + + click = ClkRootWin; + /* focus monitor if necessary */ + if((m = wintomon(ev->window)) && m != selmon) { + unfocus(selmon->sel, True); + selmon = m; + focus(NULL); + } + if(ev->window == selmon->barwin) { + i = x = 0; + do + x += TEXTW(tags[i]); + while(ev->x >= x && ++i < LENGTH(tags)); + if(i < LENGTH(tags)) { + click = ClkTagBar; + arg.ui = 1 << i; + } + else if(ev->x < x + blw) + click = ClkLtSymbol; + else if(ev->x > selmon->ww - TEXTW(stext)) + click = ClkStatusText; + else + click = ClkWinTitle; + } + else if((c = wintoclient(ev->window))) { + focus(c); + click = ClkClientWin; + } + for(i = 0; i < LENGTH(buttons); i++) + if(click == buttons[i].click && buttons[i].func && buttons[i].button == ev->button + && CLEANMASK(buttons[i].mask) == CLEANMASK(ev->state)) + buttons[i].func(click == ClkTagBar && buttons[i].arg.i == 0 ? &arg : &buttons[i].arg); +} + +void +checkotherwm(void) { + xerrorxlib = XSetErrorHandler(xerrorstart); + /* this causes an error if some other window manager is running */ + XSelectInput(dpy, DefaultRootWindow(dpy), SubstructureRedirectMask); + XSync(dpy, False); + XSetErrorHandler(xerror); + XSync(dpy, False); +} + +void +cleanup(void) { + Arg a = {.ui = ~0}; + Layout foo = { "", NULL }; + Monitor *m; + + view(&a); + selmon->lt[selmon->sellt] = &foo; + for(m = mons; m; m = m->next) + while(m->stack) + unmanage(m->stack, False); + XUngrabKey(dpy, AnyKey, AnyModifier, root); + while(mons) + cleanupmon(mons); +#ifdef CONFIG_DWM_SYSTEMTRAY + if(showsystray) { + XUnmapWindow(dpy, systray->win); + XDestroyWindow(dpy, systray->win); + free(systray); + } +#endif + drw_cur_free(drw, cursor[CurNormal]); + drw_cur_free(drw, cursor[CurResize]); + drw_cur_free(drw, cursor[CurMove]); + drw_font_free(dpy, fnt); + drw_clr_free(scheme[SchemeNorm].border); + drw_clr_free(scheme[SchemeNorm].bg); + drw_clr_free(scheme[SchemeNorm].fg); + drw_clr_free(scheme[SchemeSel].border); + drw_clr_free(scheme[SchemeSel].bg); + drw_clr_free(scheme[SchemeSel].fg); + drw_free(drw); + XSync(dpy, False); + XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime); + XDeleteProperty(dpy, root, netatom[NetActiveWindow]); +} + +void +cleanupmon(Monitor *mon) { + Monitor *m; + + if(mon == mons) + mons = mons->next; + else { + for(m = mons; m && m->next != mon; m = m->next); + m->next = mon->next; + } + XUnmapWindow(dpy, mon->barwin); + XDestroyWindow(dpy, mon->barwin); + free(mon); +} + +void +clearurgent(Client *c) { + XWMHints *wmh; + + c->isurgent = False; + if(!(wmh = XGetWMHints(dpy, c->win))) + return; + wmh->flags &= ~XUrgencyHint; + XSetWMHints(dpy, c->win, wmh); + XFree(wmh); +} + +void +clientmessage(XEvent *e) { + XClientMessageEvent *cme = &e->xclient; + Client *c = wintoclient(cme->window); +#ifdef CONFIG_DWM_PERTAG + int i; +#endif +#ifdef CONFIG_DWM_SYSTEMTRAY + XWindowAttributes wa; + XSetWindowAttributes swa; +#endif +#ifdef CONFIG_DWM_SYSTEMTRAY + if(showsystray && cme->window == systray->win && cme->message_type == netatom[NetSystemTrayOP]) { + /* add systray icons */ + if(cme->data.l[1] == SYSTEM_TRAY_REQUEST_DOCK) { + if(!(c = (Client *)calloc(1, sizeof(Client)))) + die("fatal: could not malloc() %u bytes\n", sizeof(Client)); + c->win = cme->data.l[2]; + c->mon = selmon; + c->next = systray->icons; + systray->icons = c; + XGetWindowAttributes(dpy, c->win, &wa); + c->x = c->oldx = c->y = c->oldy = 0; + c->w = c->oldw = wa.width; + c->h = c->oldh = wa.height; + c->oldbw = wa.border_width; + c->bw = 0; + c->isfloating = True; + /* reuse tags field as mapped status */ + c->tags = 1; + updatesizehints(c); + updatesystrayicongeom(c, wa.width, wa.height); + XAddToSaveSet(dpy, c->win); + XSelectInput(dpy, c->win, StructureNotifyMask | PropertyChangeMask | ResizeRedirectMask); + XReparentWindow(dpy, c->win, systray->win, 0, 0); + /* use parents background color */ + swa.background_pixel = scheme[SchemeNorm].bg->rgb; + XChangeWindowAttributes(dpy, c->win, CWBackPixel, &swa); + sendevent(c->win, netatom[Xembed], StructureNotifyMask, CurrentTime, XEMBED_EMBEDDED_NOTIFY, 0 , systray->win, XEMBED_EMBEDDED_VERSION); + /* FIXME not sure if I have to send these events, too */ + sendevent(c->win, netatom[Xembed], StructureNotifyMask, CurrentTime, XEMBED_FOCUS_IN, 0 , systray->win, XEMBED_EMBEDDED_VERSION); + sendevent(c->win, netatom[Xembed], StructureNotifyMask, CurrentTime, XEMBED_WINDOW_ACTIVATE, 0 , systray->win, XEMBED_EMBEDDED_VERSION); + sendevent(c->win, netatom[Xembed], StructureNotifyMask, CurrentTime, XEMBED_MODALITY_ON, 0 , systray->win, XEMBED_EMBEDDED_VERSION); + XSync(dpy, False); + resizebarwin(selmon); + updatesystray(); + setclientstate(c, NormalState); + } + return; + } +#endif + if(!c) + return; + if(cme->message_type == netatom[NetWMState]) { + if(cme->data.l[1] == netatom[NetWMFullscreen] || cme->data.l[2] == netatom[NetWMFullscreen]) + setfullscreen(c, (cme->data.l[0] == 1 /* _NET_WM_STATE_ADD */ + || (cme->data.l[0] == 2 /* _NET_WM_STATE_TOGGLE */ && !c->isfullscreen))); + } + else if(cme->message_type == netatom[NetActiveWindow]) { + if(!ISVISIBLE(c)) { + c->mon->seltags ^= 1; + c->mon->tagset[c->mon->seltags] = c->tags; + #ifdef CONFIG_DWM_PERTAG + for(i=0; !(c->tags & 1 << i); i++); + view(&(Arg){.ui = 1 << i}); + #endif + } + pop(c); + } +} + +void +configure(Client *c) { + XConfigureEvent ce; + + ce.type = ConfigureNotify; + ce.display = dpy; + ce.event = c->win; + ce.window = c->win; + ce.x = c->x; + ce.y = c->y; + ce.width = c->w; + ce.height = c->h; + ce.border_width = c->bw; + ce.above = None; + ce.override_redirect = False; + XSendEvent(dpy, c->win, False, StructureNotifyMask, (XEvent *)&ce); +} + +void +configurenotify(XEvent *e) { + Monitor *m; + XConfigureEvent *ev = &e->xconfigure; + Bool dirty; + + // TODO: updategeom handling sucks, needs to be simplified + if(ev->window == root) { + dirty = (sw != ev->width || sh != ev->height); + sw = ev->width; + sh = ev->height; + if(updategeom() || dirty) { + drw_resize(drw, sw, bh); + updatebars(); + for(m = mons; m; m = m->next) + #ifdef CONFIG_DWM_SYSTEMTRAY + resizebarwin(m); + #else + XMoveResizeWindow(dpy, m->barwin, m->wx, m->by, m->ww, bh); + #endif + #ifdef CONFIG_DWM_PANGO + //XftDrawChange(drw->xft->drawable, drw->drawable); + #endif + focus(NULL); + arrange(NULL); + } + } +} + +void +configurerequest(XEvent *e) { + Client *c; + Monitor *m; + XConfigureRequestEvent *ev = &e->xconfigurerequest; + XWindowChanges wc; + + if((c = wintoclient(ev->window))) { + if(ev->value_mask & CWBorderWidth) + c->bw = ev->border_width; + else if(c->isfloating || !selmon->lt[selmon->sellt]->arrange) { + m = c->mon; + if(ev->value_mask & CWX) { + c->oldx = c->x; + c->x = m->mx + ev->x; + } + if(ev->value_mask & CWY) { + c->oldy = c->y; + c->y = m->my + ev->y; + } + if(ev->value_mask & CWWidth) { + c->oldw = c->w; + c->w = ev->width; + } + if(ev->value_mask & CWHeight) { + c->oldh = c->h; + c->h = ev->height; + } + if((c->x + c->w) > m->mx + m->mw && c->isfloating) + c->x = m->mx + (m->mw / 2 - WIDTH(c) / 2); /* center in x direction */ + if((c->y + c->h) > m->my + m->mh && c->isfloating) + c->y = m->my + (m->mh / 2 - HEIGHT(c) / 2); /* center in y direction */ + if((ev->value_mask & (CWX|CWY)) && !(ev->value_mask & (CWWidth|CWHeight))) + configure(c); + if(ISVISIBLE(c)) + XMoveResizeWindow(dpy, c->win, c->x, c->y, c->w, c->h); + } + else + configure(c); + } + else { + wc.x = ev->x; + wc.y = ev->y; + wc.width = ev->width; + wc.height = ev->height; + wc.border_width = ev->border_width; + wc.sibling = ev->above; + wc.stack_mode = ev->detail; + XConfigureWindow(dpy, ev->window, ev->value_mask, &wc); + } + XSync(dpy, False); +} + +Monitor * +createmon(void) { + Monitor *m; +#ifdef CONFIG_DWM_PERTAG + int i; +#endif + + if(!(m = (Monitor *)calloc(1, sizeof(Monitor)))) + die("fatal: could not malloc() %u bytes\n", sizeof(Monitor)); + m->tagset[0] = m->tagset[1] = 1; + m->mfact = mfact; + m->nmaster = nmaster; + m->showbar = showbar; + m->topbar = topbar; + m->lt[0] = &layouts[0]; + m->lt[1] = &layouts[1 % LENGTH(layouts)]; + strncpy(m->ltsymbol, layouts[0].symbol, sizeof m->ltsymbol); +#ifdef CONFIG_DWM_PERTAG + if(!(m->pertag = (Pertag *)calloc(1, sizeof(Pertag)))) + die("fatal: could not malloc() %u bytes\n", sizeof(Pertag)); + m->pertag->curtag = m->pertag->prevtag = 1; + for(i=0; i <= LENGTH(tags); i++) { + /* init nmaster */ + m->pertag->nmasters[i] = m->nmaster; + + /* init mfacts */ + m->pertag->mfacts[i] = m->mfact; + + /* init layouts */ + m->pertag->ltidxs[i][0] = m->lt[0]; + m->pertag->ltidxs[i][1] = m->lt[1]; + m->pertag->sellts[i] = m->sellt; + + /* init showbar */ + m->pertag->showbars[i] = m->showbar; + + /* swap focus and zoomswap*/ + m->pertag->prevzooms[i] = NULL; + } +#endif + return m; +} + +void +destroynotify(XEvent *e) { + Client *c; + XDestroyWindowEvent *ev = &e->xdestroywindow; + + if((c = wintoclient(ev->window))) + unmanage(c, True); +#ifdef CONFIG_DWM_SYSTEMTRAY + else if((c = wintosystrayicon(ev->window))) { + removesystrayicon(c); + resizebarwin(selmon); + updatesystray(); + } +#endif +} + +void +detach(Client *c) { + Client **tc; + + for(tc = &c->mon->clients; *tc && *tc != c; tc = &(*tc)->next); + *tc = c->next; +} + +void +detachstack(Client *c) { + Client **tc, *t; + + for(tc = &c->mon->stack; *tc && *tc != c; tc = &(*tc)->snext); + *tc = c->snext; + + if(c == c->mon->sel) { + for(t = c->mon->stack; t && !ISVISIBLE(t); t = t->snext); + c->mon->sel = t; + } +} + +Monitor * +dirtomon(int dir) { + Monitor *m = NULL; + + if(dir > 0) { + if(!(m = selmon->next)) + m = mons; + } + else if(selmon == mons) + for(m = mons; m->next; m = m->next); + else + for(m = mons; m->next != selmon; m = m->next); + return m; +} + +void +drawbar(Monitor *m) { + int x, xx, w; + unsigned int i, occ = 0, urg = 0; + Client *c; + +#ifdef CONFIG_DWM_SYSTEMTRAY + resizebarwin(m); +#endif + for(c = m->clients; c; c = c->next) { + occ |= c->tags; + if(c->isurgent) + urg |= c->tags; + } + x = 0; + for(i = 0; i < LENGTH(tags); i++) { + w = TEXTW(tags[i]); + drw_setscheme(drw, m->tagset[m->seltags] & 1 << i ? &scheme[SchemeSel] : &scheme[SchemeNorm]); + drw_text(drw, x, 0, w, bh, tags[i], urg & 1 << i); + drw_rect(drw, x, 0, w, bh, m == selmon && selmon->sel && selmon->sel->tags & 1 << i, + occ & 1 << i, urg & 1 << i); + x += w; + } + w = blw = TEXTW(m->ltsymbol); + drw_setscheme(drw, &scheme[SchemeNorm]); + drw_text(drw, x, 0, w, bh, m->ltsymbol, 0); + x += w; + xx = x; + if(m == selmon) { /* status is only drawn on selected monitor */ + w = TEXTW(stext); + x = m->ww - w; + if(x < xx) { + x = xx; + w = m->ww - xx; + } + drw_text(drw, x, 0, w, bh, stext, 0); + } + else + x = m->ww; +#ifdef CONFIG_DWM_SYSTEMTRAY + if(showsystray && m == systraytomon(m)) { + x -= getsystraywidth(); + } +#endif + if((w = x - xx) > bh) { + x = xx; + if(m->sel) { + drw_setscheme(drw, m == selmon ? &scheme[SchemeSel] : &scheme[SchemeNorm]); + drw_text(drw, x, 0, w, bh, m->sel->name, 0); + drw_rect(drw, x, 0, w, bh, m->sel->isfixed, m->sel->isfloating, 0); + } + else { + drw_setscheme(drw, &scheme[SchemeNorm]); + drw_text(drw, x, 0, w, bh, NULL, 0); + } + } + drw_map(drw, m->barwin, 0, 0, m->ww, bh); +} + +void +drawbars(void) { + Monitor *m; + + for(m = mons; m; m = m->next) + drawbar(m); +#ifdef CONFIG_DWM_SYSTEMTRAY + updatesystray(); +#endif +} + +void +enternotify(XEvent *e) { + Client *c; + Monitor *m; + XCrossingEvent *ev = &e->xcrossing; + + if((ev->mode != NotifyNormal || ev->detail == NotifyInferior) && ev->window != root) + return; + c = wintoclient(ev->window); + m = c ? c->mon : wintomon(ev->window); + if(m != selmon) { + unfocus(selmon->sel, True); + selmon = m; + } + else if(!c || c == selmon->sel) + return; + focus(c); +} + +void +expose(XEvent *e) { + Monitor *m; + XExposeEvent *ev = &e->xexpose; + + if(ev->count == 0 && (m = wintomon(ev->window))){ + drawbar(m); + #ifdef CONFIG_DWM_SYSTEMTRAY + if(m == selmon) + updatesystray(); + #endif + } +} + +void +focus(Client *c) { + if(!c || !ISVISIBLE(c)) + for(c = selmon->stack; c && !ISVISIBLE(c); c = c->snext); + /* was if(selmon->sel) */ + if(selmon->sel && selmon->sel != c) + unfocus(selmon->sel, False); + if(c) { + if(c->mon != selmon) + selmon = c->mon; + if(c->isurgent) + clearurgent(c); + detachstack(c); + attachstack(c); + grabbuttons(c, True); + XSetWindowBorder(dpy, c->win, scheme[SchemeSel].border->rgb); + setfocus(c); + } + else { + XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime); + XDeleteProperty(dpy, root, netatom[NetActiveWindow]); + } + selmon->sel = c; + drawbars(); +} + +void +focusin(XEvent *e) { /* there are some broken focus acquiring clients */ + XFocusChangeEvent *ev = &e->xfocus; + + if(selmon->sel && ev->window != selmon->sel->win) + setfocus(selmon->sel); +} + +void +focusmon(const Arg *arg) { + Monitor *m; + + if(!mons->next) + return; + if((m = dirtomon(arg->i)) == selmon) + return; + unfocus(selmon->sel, False); /* s/True/False/ fixes input focus issues + in gedit and anjuta */ + selmon = m; + focus(NULL); +} + +void +focusstack(const Arg *arg) { + Client *c = NULL, *i; + + if(!selmon->sel) + return; + if(arg->i > 0) { + for(c = selmon->sel->next; c && !ISVISIBLE(c); c = c->next); + if(!c) + for(c = selmon->clients; c && !ISVISIBLE(c); c = c->next); + } + else { + for(i = selmon->clients; i != selmon->sel; i = i->next) + if(ISVISIBLE(i)) + c = i; + if(!c) + for(; i; i = i->next) + if(ISVISIBLE(i)) + c = i; + } + if(c) { + focus(c); + restack(selmon); + } +} + +Atom +getatomprop(Client *c, Atom prop) { + int di; + unsigned long dl; + unsigned char *p = NULL; + Atom da, atom = None; +#ifdef CONFIG_DWM_SYSTEMTRAY + /* FIXME getatomprop should return the number of items and a pointer to + * the stored data instead of this workaround */ + Atom req = XA_ATOM; + if(prop == xatom[XembedInfo]) + req = xatom[XembedInfo]; +#endif + + if(XGetWindowProperty(dpy, c->win, prop, 0L, sizeof atom, False, +#ifdef CONFIG_DWM_SYSTEMTRAY + req, +#else + XA_ATOM, +#endif + &da, &di, &dl, &dl, &p) == Success && p) { + atom = *(Atom *)p; + #ifdef CONFIG_DWM_SYSTEMTRAY + if(da == xatom[XembedInfo] && dl == 2) + atom = ((Atom *)p)[1]; + #endif + XFree(p); + } + return atom; +} + +Bool +getrootptr(int *x, int *y) { + int di; + unsigned int dui; + Window dummy; + + return XQueryPointer(dpy, root, &dummy, &dummy, x, y, &di, &di, &dui); +} + +long +getstate(Window w) { + int format; + long result = -1; + unsigned char *p = NULL; + unsigned long n, extra; + Atom real; + + if(XGetWindowProperty(dpy, w, wmatom[WMState], 0L, 2L, False, wmatom[WMState], + &real, &format, &n, &extra, (unsigned char **)&p) != Success) + return -1; + if(n != 0) + result = *p; + XFree(p); + return result; +} + +Bool +gettextprop(Window w, Atom atom, char *text, unsigned int size) { + char **list = NULL; + int n; + XTextProperty name; + + if(!text || size == 0) + return False; + text[0] = '\0'; + XGetTextProperty(dpy, w, &name, atom); + if(!name.nitems) + return False; + if(name.encoding == XA_STRING) + strncpy(text, (char *)name.value, size - 1); + else { + if(XmbTextPropertyToTextList(dpy, &name, &list, &n) >= Success && n > 0 && *list) { + strncpy(text, *list, size - 1); + XFreeStringList(list); + } + } + text[size - 1] = '\0'; + XFree(name.value); + return True; +} + +void +grabbuttons(Client *c, Bool focused) { + updatenumlockmask(); + { + unsigned int i, j; + unsigned int modifiers[] = { 0, LockMask, numlockmask, numlockmask|LockMask }; + XUngrabButton(dpy, AnyButton, AnyModifier, c->win); + if(focused) { + for(i = 0; i < LENGTH(buttons); i++) + if(buttons[i].click == ClkClientWin) + for(j = 0; j < LENGTH(modifiers); j++) + XGrabButton(dpy, buttons[i].button, + buttons[i].mask | modifiers[j], + c->win, False, BUTTONMASK, + |