1 /* See LICENSE file for copyright and license details.
3 * dynamic window manager is designed like any other X client as well. It is
4 * driven through handling X events. In contrast to other X clients, a window
5 * manager selects for SubstructureRedirectMask on the root window, to receive
6 * events about window (dis-)appearance. Only one X connection at a time is
7 * allowed to select for this event mask.
9 * The event handlers of dwm are organized in an array which is accessed
10 * whenever a new event has been fetched. This allows event dispatching
13 * Each child of the root window is called a client, except windows which have
14 * set the override_redirect flag. Clients are organized in a linked client
15 * list on each monitor, the focus history is remembered through a stack list
16 * on each monitor. Each client contains a bit array to indicate the tags of a
19 * Keys and tagging rules are organized as arrays and defined in config.h.
21 * To understand everything else, start reading main().
23 #include <X11/Xatom.h>
25 #include <X11/Xproto.h>
26 #include <X11/Xutil.h>
27 #include <X11/cursorfont.h>
28 #include <X11/keysym.h>
36 #include <sys/types.h>
40 #include <X11/extensions/Xinerama.h>
42 #include <X11/Xft/Xft.h>
47 #define BUTTONMASK (ButtonPressMask|ButtonReleaseMask)
48 #define CLEANMASK(mask) (mask & ~(numlockmask|LockMask) & (ShiftMask|ControlMask|Mod1Mask|Mod2Mask|Mod3Mask|Mod4Mask|Mod5Mask))
49 #define INTERSECT(x,y,w,h,m) (MAX(0, MIN((x)+(w),(m)->wx+(m)->ww) - MAX((x),(m)->wx)) \
50 * MAX(0, MIN((y)+(h),(m)->wy+(m)->wh) - MAX((y),(m)->wy)))
51 #define ISVISIBLE(C) ((C->tags & C->mon->tagset[C->mon->seltags]))
52 #define LENGTH(X) (sizeof X / sizeof X[0])
53 #define MOUSEMASK (BUTTONMASK|PointerMotionMask)
54 #define WIDTH(X) ((X)->w + 2 * (X)->bw + gappx)
55 #define HEIGHT(X) ((X)->h + 2 * (X)->bw + gappx)
56 #define TAGMASK ((1 << LENGTH(tags)) - 1)
57 #define TEXTW(X) (drw_text(drw, 0, 0, 0, 0, (X), 0) + drw->fonts[0]->h)
62 enum { CurNormal
, CurResize
, CurMove
, CurLast
}; /* cursor */
63 enum { SchemeNorm
, SchemeSel
, SchemeLast
}; /* color schemes */
64 enum { NetSupported
, NetWMName
, NetWMState
,
65 NetWMFullscreen
, NetActiveWindow
, NetWMWindowType
,
66 NetWMWindowTypeDialog
, NetClientList
, NetLast
}; /* EWMH atoms */
67 enum { WMProtocols
, WMDelete
, WMState
, WMTakeFocus
, WMLast
}; /* default atoms */
68 enum { ClkTagBar
, ClkLtSymbol
, ClkStatusText
, ClkWinTitle
,
69 ClkClientWin
, ClkRootWin
, ClkLast
}; /* clicks */
82 void (*func
)(const Arg
*arg
);
86 typedef struct Monitor Monitor
;
87 typedef struct Client Client
;
92 int oldx
, oldy
, oldw
, oldh
;
93 int basew
, baseh
, incw
, inch
, maxw
, maxh
, minw
, minh
;
96 int isfixed
, isfloating
, isurgent
, neverfocus
, oldstate
, isfullscreen
;
106 void (*func
)(const Arg
*);
112 void (*arrange
)(Monitor
*);
120 int by
; /* bar geometry */
121 int mx
, my
, mw
, mh
; /* screen size */
122 int wx
, wy
, ww
, wh
; /* window area */
123 unsigned int seltags
;
125 unsigned int tagset
[2];
138 const char *instance
;
145 /* function declarations */
146 static void applyrules(Client
*c
);
147 static int applysizehints(Client
*c
, int *x
, int *y
, int *w
, int *h
, int interact
);
148 static void arrange(Monitor
*m
);
149 static void arrangemon(Monitor
*m
);
150 static void attach(Client
*c
);
151 static void attachstack(Client
*c
);
152 static void buttonpress(XEvent
*e
);
153 static void checkotherwm(void);
154 static void cleanup(void);
155 static void cleanupmon(Monitor
*mon
);
156 static void clearurgent(Client
*c
);
157 static void clientmessage(XEvent
*e
);
158 static void configure(Client
*c
);
159 static void configurenotify(XEvent
*e
);
160 static void configurerequest(XEvent
*e
);
161 static Monitor
*createmon(void);
162 static void destroynotify(XEvent
*e
);
163 static void detach(Client
*c
);
164 static void detachstack(Client
*c
);
165 static Monitor
*dirtomon(int dir
);
166 static void drawbar(Monitor
*m
);
167 static void drawbars(void);
168 static void enternotify(XEvent
*e
);
169 static void expose(XEvent
*e
);
170 static void focus(Client
*c
);
171 static void focusin(XEvent
*e
);
172 static void focusmon(const Arg
*arg
);
173 static void focusstack(const Arg
*arg
);
174 static int getrootptr(int *x
, int *y
);
175 static long getstate(Window w
);
176 static int gettextprop(Window w
, Atom atom
, char *text
, unsigned int size
);
177 static void grabbuttons(Client
*c
, int focused
);
178 static void grabkeys(void);
179 static void incnmaster(const Arg
*arg
);
180 static void keypress(XEvent
*e
);
181 static void killclient(const Arg
*arg
);
182 static void manage(Window w
, XWindowAttributes
*wa
);
183 static void mappingnotify(XEvent
*e
);
184 static void maprequest(XEvent
*e
);
185 static void monocle(Monitor
*m
);
186 static void motionnotify(XEvent
*e
);
187 static void movemouse(const Arg
*arg
);
188 static Client
*nexttiled(Client
*c
);
189 static void pop(Client
*);
190 static void propertynotify(XEvent
*e
);
191 static void quit(const Arg
*arg
);
192 static Monitor
*recttomon(int x
, int y
, int w
, int h
);
193 static void resize(Client
*c
, int x
, int y
, int w
, int h
, int interact
);
194 static void resizeclient(Client
*c
, int x
, int y
, int w
, int h
);
195 static void resizemouse(const Arg
*arg
);
196 static void restack(Monitor
*m
);
197 static void run(void);
198 static void scan(void);
199 static int sendevent(Client
*c
, Atom proto
);
200 static void sendmon(Client
*c
, Monitor
*m
);
201 static void setclientstate(Client
*c
, long state
);
202 static void setfocus(Client
*c
);
203 static void setfullscreen(Client
*c
, int fullscreen
);
204 static void setlayout(const Arg
*arg
);
205 static void setmfact(const Arg
*arg
);
206 static void setup(void);
207 static void showhide(Client
*c
);
208 static void sigchld(int unused
);
209 static void spawn(const Arg
*arg
);
210 static void tag(const Arg
*arg
);
211 static void tagmon(const Arg
*arg
);
212 static void tile(Monitor
*);
213 static void togglebar(const Arg
*arg
);
214 static void togglefloating(const Arg
*arg
);
215 static void toggletag(const Arg
*arg
);
216 static void toggleview(const Arg
*arg
);
217 static void unfocus(Client
*c
, int setfocus
);
218 static void unmanage(Client
*c
, int destroyed
);
219 static void unmapnotify(XEvent
*e
);
220 static int updategeom(void);
221 static void updatebarpos(Monitor
*m
);
222 static void updatebars(void);
223 static void updateclientlist(void);
224 static void updatenumlockmask(void);
225 static void updatesizehints(Client
*c
);
226 static void updatestatus(void);
227 static void updatewindowtype(Client
*c
);
228 static void updatetitle(Client
*c
);
229 static void updatewmhints(Client
*c
);
230 static void view(const Arg
*arg
);
231 static Client
*wintoclient(Window w
);
232 static Monitor
*wintomon(Window w
);
233 static int xerror(Display
*dpy
, XErrorEvent
*ee
);
234 static int xerrordummy(Display
*dpy
, XErrorEvent
*ee
);
235 static int xerrorstart(Display
*dpy
, XErrorEvent
*ee
);
236 static void xinitvisual();
237 static void zoom(const Arg
*arg
);
240 static const char broken
[] = "broken";
241 static char stext
[256];
243 static int sw
, sh
; /* X display screen geometry width, height */
244 static int bh
, blw
= 0; /* bar geometry */
245 static int (*xerrorxlib
)(Display
*, XErrorEvent
*);
246 static unsigned int numlockmask
= 0;
247 static void (*handler
[LASTEvent
]) (XEvent
*) = {
248 [ButtonPress
] = buttonpress
,
249 [ClientMessage
] = clientmessage
,
250 [ConfigureRequest
] = configurerequest
,
251 [ConfigureNotify
] = configurenotify
,
252 [DestroyNotify
] = destroynotify
,
253 [EnterNotify
] = enternotify
,
256 [KeyPress
] = keypress
,
257 [MappingNotify
] = mappingnotify
,
258 [MapRequest
] = maprequest
,
259 [MotionNotify
] = motionnotify
,
260 [PropertyNotify
] = propertynotify
,
261 [UnmapNotify
] = unmapnotify
263 static Atom wmatom
[WMLast
], netatom
[NetLast
];
264 static int running
= 1;
265 static Cur
*cursor
[CurLast
];
266 static ClrScheme scheme
[SchemeLast
];
269 static Monitor
*mons
, *selmon
;
272 static int useargb
= 0;
273 static Visual
*visual
;
275 static Colormap cmap
;
277 /* configuration, allows nested code to access above variables */
280 /* compile-time check if all tags fit into an unsigned int bit array. */
281 struct NumTags
{ char limitexceeded
[LENGTH(tags
) > 31 ? -1 : 1]; };
283 /* function implementations */
285 applyrules(Client
*c
)
287 const char *class, *instance
;
291 XClassHint ch
= { NULL
, NULL
};
296 XGetClassHint(dpy
, c
->win
, &ch
);
297 class = ch
.res_class
? ch
.res_class
: broken
;
298 instance
= ch
.res_name
? ch
.res_name
: broken
;
300 for (i
= 0; i
< LENGTH(rules
); i
++) {
302 if ((!r
->title
|| strstr(c
->name
, r
->title
))
303 && (!r
->class || strstr(class, r
->class))
304 && (!r
->instance
|| strstr(instance
, r
->instance
)))
306 c
->isfloating
= r
->isfloating
;
308 for (m
= mons
; m
&& m
->num
!= r
->monitor
; m
= m
->next
);
317 c
->tags
= c
->tags
& TAGMASK
? c
->tags
& TAGMASK
: c
->mon
->tagset
[c
->mon
->seltags
];
321 applysizehints(Client
*c
, int *x
, int *y
, int *w
, int *h
, int interact
)
326 /* set minimum possible */
334 if (*x
+ *w
+ 2 * c
->bw
< 0)
336 if (*y
+ *h
+ 2 * c
->bw
< 0)
339 if (*x
>= m
->wx
+ m
->ww
)
340 *x
= m
->wx
+ m
->ww
- WIDTH(c
);
341 if (*y
>= m
->wy
+ m
->wh
)
342 *y
= m
->wy
+ m
->wh
- HEIGHT(c
);
343 if (*x
+ *w
+ 2 * c
->bw
<= m
->wx
)
345 if (*y
+ *h
+ 2 * c
->bw
<= m
->wy
)
352 if (resizehints
|| c
->isfloating
|| !c
->mon
->lt
[c
->mon
->sellt
]->arrange
) {
353 /* see last two sentences in ICCCM 4.1.2.3 */
354 baseismin
= c
->basew
== c
->minw
&& c
->baseh
== c
->minh
;
355 if (!baseismin
) { /* temporarily remove base dimensions */
359 /* adjust for aspect limits */
360 if (c
->mina
> 0 && c
->maxa
> 0) {
361 if (c
->maxa
< (float)*w
/ *h
)
362 *w
= *h
* c
->maxa
+ 0.5;
363 else if (c
->mina
< (float)*h
/ *w
)
364 *h
= *w
* c
->mina
+ 0.5;
366 if (baseismin
) { /* increment calculation requires this */
370 /* adjust for increment value */
375 /* restore base dimensions */
376 *w
= MAX(*w
+ c
->basew
, c
->minw
);
377 *h
= MAX(*h
+ c
->baseh
, c
->minh
);
379 *w
= MIN(*w
, c
->maxw
);
381 *h
= MIN(*h
, c
->maxh
);
383 return *x
!= c
->x
|| *y
!= c
->y
|| *w
!= c
->w
|| *h
!= c
->h
;
391 else for (m
= mons
; m
; m
= m
->next
)
396 } else for (m
= mons
; m
; m
= m
->next
)
401 arrangemon(Monitor
*m
)
403 strncpy(m
->ltsymbol
, m
->lt
[m
->sellt
]->symbol
, sizeof m
->ltsymbol
);
404 if (m
->lt
[m
->sellt
]->arrange
)
405 m
->lt
[m
->sellt
]->arrange(m
);
411 c
->next
= c
->mon
->clients
;
416 attachstack(Client
*c
)
418 c
->snext
= c
->mon
->stack
;
423 buttonpress(XEvent
*e
)
425 unsigned int i
, x
, click
;
429 XButtonPressedEvent
*ev
= &e
->xbutton
;
432 /* focus monitor if necessary */
433 if ((m
= wintomon(ev
->window
)) && m
!= selmon
) {
434 unfocus(selmon
->sel
, 1);
438 if (ev
->window
== selmon
->barwin
) {
442 while (ev
->x
>= x
&& ++i
< LENGTH(tags
));
443 if (i
< LENGTH(tags
)) {
446 } else if (ev
->x
< x
+ blw
)
448 else if (ev
->x
> selmon
->ww
- TEXTW(stext
))
449 click
= ClkStatusText
;
452 } else if ((c
= wintoclient(ev
->window
))) {
454 click
= ClkClientWin
;
456 for (i
= 0; i
< LENGTH(buttons
); i
++)
457 if (click
== buttons
[i
].click
&& buttons
[i
].func
&& buttons
[i
].button
== ev
->button
458 && CLEANMASK(buttons
[i
].mask
) == CLEANMASK(ev
->state
))
459 buttons
[i
].func(click
== ClkTagBar
&& buttons
[i
].arg
.i
== 0 ? &arg
: &buttons
[i
].arg
);
465 xerrorxlib
= XSetErrorHandler(xerrorstart
);
466 /* this causes an error if some other window manager is running */
467 XSelectInput(dpy
, DefaultRootWindow(dpy
), SubstructureRedirectMask
);
469 XSetErrorHandler(xerror
);
477 Layout foo
= { "", NULL
};
482 selmon
->lt
[selmon
->sellt
] = &foo
;
483 for (m
= mons
; m
; m
= m
->next
)
485 unmanage(m
->stack
, 0);
486 XUngrabKey(dpy
, AnyKey
, AnyModifier
, root
);
489 for (i
= 0; i
< CurLast
; i
++)
490 drw_cur_free(drw
, cursor
[i
]);
491 for (i
= 0; i
< SchemeLast
; i
++) {
492 drw_clr_free(scheme
[i
].border
);
493 drw_clr_free(scheme
[i
].bg
);
494 drw_clr_free(scheme
[i
].fg
);
498 XSetInputFocus(dpy
, PointerRoot
, RevertToPointerRoot
, CurrentTime
);
499 XDeleteProperty(dpy
, root
, netatom
[NetActiveWindow
]);
503 cleanupmon(Monitor
*mon
)
510 for (m
= mons
; m
&& m
->next
!= mon
; m
= m
->next
);
513 XUnmapWindow(dpy
, mon
->barwin
);
514 XDestroyWindow(dpy
, mon
->barwin
);
519 clearurgent(Client
*c
)
524 if (!(wmh
= XGetWMHints(dpy
, c
->win
)))
526 wmh
->flags
&= ~XUrgencyHint
;
527 XSetWMHints(dpy
, c
->win
, wmh
);
532 clientmessage(XEvent
*e
)
534 XClientMessageEvent
*cme
= &e
->xclient
;
535 Client
*c
= wintoclient(cme
->window
);
539 if (cme
->message_type
== netatom
[NetWMState
]) {
540 if (cme
->data
.l
[1] == netatom
[NetWMFullscreen
] || cme
->data
.l
[2] == netatom
[NetWMFullscreen
])
541 setfullscreen(c
, (cme
->data
.l
[0] == 1 /* _NET_WM_STATE_ADD */
542 || (cme
->data
.l
[0] == 2 /* _NET_WM_STATE_TOGGLE */ && !c
->isfullscreen
)));
543 } else if (cme
->message_type
== netatom
[NetActiveWindow
]) {
545 c
->mon
->seltags
^= 1;
546 c
->mon
->tagset
[c
->mon
->seltags
] = c
->tags
;
557 ce
.type
= ConfigureNotify
;
565 ce
.border_width
= c
->bw
;
567 ce
.override_redirect
= False
;
568 XSendEvent(dpy
, c
->win
, False
, StructureNotifyMask
, (XEvent
*)&ce
);
572 configurenotify(XEvent
*e
)
575 XConfigureEvent
*ev
= &e
->xconfigure
;
578 /* TODO: updategeom handling sucks, needs to be simplified */
579 if (ev
->window
== root
) {
580 dirty
= (sw
!= ev
->width
|| sh
!= ev
->height
);
583 if (updategeom() || dirty
) {
584 drw_resize(drw
, sw
, bh
);
586 for (m
= mons
; m
; m
= m
->next
)
587 XMoveResizeWindow(dpy
, m
->barwin
, m
->wx
, m
->by
, m
->ww
, bh
);
595 configurerequest(XEvent
*e
)
599 XConfigureRequestEvent
*ev
= &e
->xconfigurerequest
;
602 if ((c
= wintoclient(ev
->window
))) {
603 if (ev
->value_mask
& CWBorderWidth
)
604 c
->bw
= ev
->border_width
;
605 else if (c
->isfloating
|| !selmon
->lt
[selmon
->sellt
]->arrange
) {
607 if (ev
->value_mask
& CWX
) {
609 c
->x
= m
->mx
+ ev
->x
;
611 if (ev
->value_mask
& CWY
) {
613 c
->y
= m
->my
+ ev
->y
;
615 if (ev
->value_mask
& CWWidth
) {
619 if (ev
->value_mask
& CWHeight
) {
623 if ((c
->x
+ c
->w
) > m
->mx
+ m
->mw
&& c
->isfloating
)
624 c
->x
= m
->mx
+ (m
->mw
/ 2 - WIDTH(c
) / 2); /* center in x direction */
625 if ((c
->y
+ c
->h
) > m
->my
+ m
->mh
&& c
->isfloating
)
626 c
->y
= m
->my
+ (m
->mh
/ 2 - HEIGHT(c
) / 2); /* center in y direction */
627 if ((ev
->value_mask
& (CWX
|CWY
)) && !(ev
->value_mask
& (CWWidth
|CWHeight
)))
630 XMoveResizeWindow(dpy
, c
->win
, c
->x
, c
->y
, c
->w
, c
->h
);
636 wc
.width
= ev
->width
;
637 wc
.height
= ev
->height
;
638 wc
.border_width
= ev
->border_width
;
639 wc
.sibling
= ev
->above
;
640 wc
.stack_mode
= ev
->detail
;
641 XConfigureWindow(dpy
, ev
->window
, ev
->value_mask
, &wc
);
651 m
= ecalloc(1, sizeof(Monitor
));
652 m
->tagset
[0] = m
->tagset
[1] = 1;
654 m
->nmaster
= nmaster
;
655 m
->showbar
= showbar
;
657 m
->lt
[0] = &layouts
[0];
658 m
->lt
[1] = &layouts
[1 % LENGTH(layouts
)];
659 strncpy(m
->ltsymbol
, layouts
[0].symbol
, sizeof m
->ltsymbol
);
664 destroynotify(XEvent
*e
)
667 XDestroyWindowEvent
*ev
= &e
->xdestroywindow
;
669 if ((c
= wintoclient(ev
->window
)))
678 for (tc
= &c
->mon
->clients
; *tc
&& *tc
!= c
; tc
= &(*tc
)->next
);
683 detachstack(Client
*c
)
687 for (tc
= &c
->mon
->stack
; *tc
&& *tc
!= c
; tc
= &(*tc
)->snext
);
690 if (c
== c
->mon
->sel
) {
691 for (t
= c
->mon
->stack
; t
&& !ISVISIBLE(t
); t
= t
->snext
);
702 if (!(m
= selmon
->next
))
704 } else if (selmon
== mons
)
705 for (m
= mons
; m
->next
; m
= m
->next
);
707 for (m
= mons
; m
->next
!= selmon
; m
= m
->next
);
715 unsigned int i
, occ
= 0, urg
= 0;
718 dx
= (drw
->fonts
[0]->ascent
+ drw
->fonts
[0]->descent
+ 2) / 4;
720 for (c
= m
->clients
; c
; c
= c
->next
) {
726 for (i
= 0; i
< LENGTH(tags
); i
++) {
728 drw_setscheme(drw
, m
->tagset
[m
->seltags
] & 1 << i
? &scheme
[SchemeSel
] : &scheme
[SchemeNorm
]);
729 drw_text(drw
, x
, 0, w
, bh
, tags
[i
], urg
& 1 << i
);
730 drw_rect(drw
, x
+ 1, 1, dx
, dx
, m
== selmon
&& selmon
->sel
&& selmon
->sel
->tags
& 1 << i
,
731 occ
& 1 << i
, urg
& 1 << i
);
734 w
= blw
= TEXTW(m
->ltsymbol
);
735 drw_setscheme(drw
, &scheme
[SchemeNorm
]);
736 drw_text(drw
, x
, 0, w
, bh
, m
->ltsymbol
, 0);
739 if (m
== selmon
) { /* status is only drawn on selected monitor */
746 drw_text(drw
, x
, 0, w
, bh
, stext
, 0);
749 if ((w
= x
- xx
) > bh
) {
752 drw_setscheme(drw
, m
== selmon
? &scheme
[SchemeSel
] : &scheme
[SchemeNorm
]);
753 drw_text(drw
, x
, 0, w
, bh
, m
->sel
->name
, 0);
754 drw_rect(drw
, x
+ 1, 1, dx
, dx
, m
->sel
->isfixed
, m
->sel
->isfloating
, 0);
756 drw_setscheme(drw
, &scheme
[SchemeNorm
]);
757 drw_rect(drw
, x
, 0, w
, bh
, 1, 0, 1);
760 drw_map(drw
, m
->barwin
, 0, 0, m
->ww
, bh
);
768 for (m
= mons
; m
; m
= m
->next
)
773 enternotify(XEvent
*e
)
777 XCrossingEvent
*ev
= &e
->xcrossing
;
779 if ((ev
->mode
!= NotifyNormal
|| ev
->detail
== NotifyInferior
) && ev
->window
!= root
)
781 c
= wintoclient(ev
->window
);
782 m
= c
? c
->mon
: wintomon(ev
->window
);
784 unfocus(selmon
->sel
, 1);
786 } else if (!c
|| c
== selmon
->sel
)
795 XExposeEvent
*ev
= &e
->xexpose
;
797 if (ev
->count
== 0 && (m
= wintomon(ev
->window
)))
804 if (!c
|| !ISVISIBLE(c
))
805 for (c
= selmon
->stack
; c
&& !ISVISIBLE(c
); c
= c
->snext
);
806 /* was if (selmon->sel) */
807 if (selmon
->sel
&& selmon
->sel
!= c
)
808 unfocus(selmon
->sel
, 0);
810 if (c
->mon
!= selmon
)
817 XSetWindowBorder(dpy
, c
->win
, scheme
[SchemeSel
].border
->pix
);
820 XSetInputFocus(dpy
, root
, RevertToPointerRoot
, CurrentTime
);
821 XDeleteProperty(dpy
, root
, netatom
[NetActiveWindow
]);
827 /* there are some broken focus acquiring clients */
831 XFocusChangeEvent
*ev
= &e
->xfocus
;
833 if (selmon
->sel
&& ev
->window
!= selmon
->sel
->win
)
834 setfocus(selmon
->sel
);
838 focusmon(const Arg
*arg
)
844 if ((m
= dirtomon(arg
->i
)) == selmon
)
846 unfocus(selmon
->sel
, 0); /* s/1/0/ fixes input focus issues
847 in gedit and anjuta */
853 focusstack(const Arg
*arg
)
855 Client
*c
= NULL
, *i
;
860 for (c
= selmon
->sel
->next
; c
&& !ISVISIBLE(c
); c
= c
->next
);
862 for (c
= selmon
->clients
; c
&& !ISVISIBLE(c
); c
= c
->next
);
864 for (i
= selmon
->clients
; i
!= selmon
->sel
; i
= i
->next
)
868 for (; i
; i
= i
->next
)
879 getatomprop(Client
*c
, Atom prop
)
883 unsigned char *p
= NULL
;
884 Atom da
, atom
= None
;
886 if (XGetWindowProperty(dpy
, c
->win
, prop
, 0L, sizeof atom
, False
, XA_ATOM
,
887 &da
, &di
, &dl
, &dl
, &p
) == Success
&& p
) {
895 getrootptr(int *x
, int *y
)
901 return XQueryPointer(dpy
, root
, &dummy
, &dummy
, x
, y
, &di
, &di
, &dui
);
909 unsigned char *p
= NULL
;
910 unsigned long n
, extra
;
913 if (XGetWindowProperty(dpy
, w
, wmatom
[WMState
], 0L, 2L, False
, wmatom
[WMState
],
914 &real
, &format
, &n
, &extra
, (unsigned char **)&p
) != Success
)
923 gettextprop(Window w
, Atom atom
, char *text
, unsigned int size
)
929 if (!text
|| size
== 0)
932 XGetTextProperty(dpy
, w
, &name
, atom
);
935 if (name
.encoding
== XA_STRING
)
936 strncpy(text
, (char *)name
.value
, size
- 1);
938 if (XmbTextPropertyToTextList(dpy
, &name
, &list
, &n
) >= Success
&& n
> 0 && *list
) {
939 strncpy(text
, *list
, size
- 1);
940 XFreeStringList(list
);
943 text
[size
- 1] = '\0';
949 grabbuttons(Client
*c
, int focused
)
954 unsigned int modifiers
[] = { 0, LockMask
, numlockmask
, numlockmask
|LockMask
};
955 XUngrabButton(dpy
, AnyButton
, AnyModifier
, c
->win
);
957 for (i
= 0; i
< LENGTH(buttons
); i
++)
958 if (buttons
[i
].click
== ClkClientWin
)
959 for (j
= 0; j
< LENGTH(modifiers
); j
++)
960 XGrabButton(dpy
, buttons
[i
].button
,
961 buttons
[i
].mask
| modifiers
[j
],
962 c
->win
, False
, BUTTONMASK
,
963 GrabModeAsync
, GrabModeSync
, None
, None
);
965 XGrabButton(dpy
, AnyButton
, AnyModifier
, c
->win
, False
,
966 BUTTONMASK
, GrabModeAsync
, GrabModeSync
, None
, None
);
976 unsigned int modifiers
[] = { 0, LockMask
, numlockmask
, numlockmask
|LockMask
};
979 XUngrabKey(dpy
, AnyKey
, AnyModifier
, root
);
980 for (i
= 0; i
< LENGTH(keys
); i
++)
981 if ((code
= XKeysymToKeycode(dpy
, keys
[i
].keysym
)))
982 for (j
= 0; j
< LENGTH(modifiers
); j
++)
983 XGrabKey(dpy
, code
, keys
[i
].mod
| modifiers
[j
], root
,
984 True
, GrabModeAsync
, GrabModeAsync
);
989 incnmaster(const Arg
*arg
)
991 selmon
->nmaster
= MAX(selmon
->nmaster
+ arg
->i
, 0);
997 isuniquegeom(XineramaScreenInfo
*unique
, size_t n
, XineramaScreenInfo
*info
)
1000 if (unique
[n
].x_org
== info
->x_org
&& unique
[n
].y_org
== info
->y_org
1001 && unique
[n
].width
== info
->width
&& unique
[n
].height
== info
->height
)
1005 #endif /* XINERAMA */
1015 keysym
= XKeycodeToKeysym(dpy
, (KeyCode
)ev
->keycode
, 0);
1016 for (i
= 0; i
< LENGTH(keys
); i
++)
1017 if (keysym
== keys
[i
].keysym
1018 && CLEANMASK(keys
[i
].mod
) == CLEANMASK(ev
->state
)
1020 keys
[i
].func(&(keys
[i
].arg
));
1024 killclient(const Arg
*arg
)
1028 if (!sendevent(selmon
->sel
, wmatom
[WMDelete
])) {
1030 XSetErrorHandler(xerrordummy
);
1031 XSetCloseDownMode(dpy
, DestroyAll
);
1032 XKillClient(dpy
, selmon
->sel
->win
);
1034 XSetErrorHandler(xerror
);
1040 manage(Window w
, XWindowAttributes
*wa
)
1042 Client
*c
, *t
= NULL
;
1043 Window trans
= None
;
1046 c
= ecalloc(1, sizeof(Client
));
1049 if (XGetTransientForHint(dpy
, w
, &trans
) && (t
= wintoclient(trans
))) {
1057 c
->x
= c
->oldx
= wa
->x
;
1058 c
->y
= c
->oldy
= wa
->y
;
1059 c
->w
= c
->oldw
= wa
->width
;
1060 c
->h
= c
->oldh
= wa
->height
;
1061 c
->oldbw
= wa
->border_width
;
1063 if (c
->x
+ WIDTH(c
) > c
->mon
->mx
+ c
->mon
->mw
)
1064 c
->x
= c
->mon
->mx
+ c
->mon
->mw
- WIDTH(c
);
1065 if (c
->y
+ HEIGHT(c
) > c
->mon
->my
+ c
->mon
->mh
)
1066 c
->y
= c
->mon
->my
+ c
->mon
->mh
- HEIGHT(c
);
1067 c
->x
= MAX(c
->x
, c
->mon
->mx
);
1068 /* only fix client y-offset, if the client center might cover the bar */
1069 c
->y
= MAX(c
->y
, ((c
->mon
->by
== c
->mon
->my
) && (c
->x
+ (c
->w
/ 2) >= c
->mon
->wx
)
1070 && (c
->x
+ (c
->w
/ 2) < c
->mon
->wx
+ c
->mon
->ww
)) ? bh
: c
->mon
->my
);
1073 wc
.border_width
= c
->bw
;
1074 XConfigureWindow(dpy
, w
, CWBorderWidth
, &wc
);
1075 XSetWindowBorder(dpy
, w
, scheme
[SchemeNorm
].border
->pix
);
1076 configure(c
); /* propagates border_width, if size doesn't change */
1077 updatewindowtype(c
);
1080 XSelectInput(dpy
, w
, EnterWindowMask
|FocusChangeMask
|PropertyChangeMask
|StructureNotifyMask
);
1083 c
->isfloating
= c
->oldstate
= trans
!= None
|| c
->isfixed
;
1085 XRaiseWindow(dpy
, c
->win
);
1088 XChangeProperty(dpy
, root
, netatom
[NetClientList
], XA_WINDOW
, 32, PropModeAppend
,
1089 (unsigned char *) &(c
->win
), 1);
1090 XMoveResizeWindow(dpy
, c
->win
, c
->x
+ 2 * sw
, c
->y
, c
->w
, c
->h
); /* some windows require this */
1091 setclientstate(c
, NormalState
);
1092 if (c
->mon
== selmon
)
1093 unfocus(selmon
->sel
, 0);
1096 XMapWindow(dpy
, c
->win
);
1101 mappingnotify(XEvent
*e
)
1103 XMappingEvent
*ev
= &e
->xmapping
;
1105 XRefreshKeyboardMapping(ev
);
1106 if (ev
->request
== MappingKeyboard
)
1111 maprequest(XEvent
*e
)
1113 static XWindowAttributes wa
;
1114 XMapRequestEvent
*ev
= &e
->xmaprequest
;
1116 if (!XGetWindowAttributes(dpy
, ev
->window
, &wa
))
1118 if (wa
.override_redirect
)
1120 if (!wintoclient(ev
->window
))
1121 manage(ev
->window
, &wa
);
1130 for (c
= m
->clients
; c
; c
= c
->next
)
1133 if (n
> 0) /* override layout symbol */
1134 snprintf(m
->ltsymbol
, sizeof m
->ltsymbol
, "[%d]", n
);
1135 for (c
= nexttiled(m
->clients
); c
; c
= nexttiled(c
->next
))
1136 resize(c
, m
->wx
, m
->wy
, m
->ww
- 2 * c
->bw
, m
->wh
- 2 * c
->bw
, 0);
1140 motionnotify(XEvent
*e
)
1142 static Monitor
*mon
= NULL
;
1144 XMotionEvent
*ev
= &e
->xmotion
;
1146 if (ev
->window
!= root
)
1148 if ((m
= recttomon(ev
->x_root
, ev
->y_root
, 1, 1)) != mon
&& mon
) {
1149 unfocus(selmon
->sel
, 1);
1157 movemouse(const Arg
*arg
)
1159 int x
, y
, ocx
, ocy
, nx
, ny
;
1165 if (!(c
= selmon
->sel
))
1167 if (c
->isfullscreen
) /* no support moving fullscreen windows by mouse */
1172 if (XGrabPointer(dpy
, root
, False
, MOUSEMASK
, GrabModeAsync
, GrabModeAsync
,
1173 None
, cursor
[CurMove
]->cursor
, CurrentTime
) != GrabSuccess
)
1175 if (!getrootptr(&x
, &y
))
1178 XMaskEvent(dpy
, MOUSEMASK
|ExposureMask
|SubstructureRedirectMask
, &ev
);
1180 case ConfigureRequest
:
1183 handler
[ev
.type
](&ev
);
1186 if ((ev
.xmotion
.time
- lasttime
) <= (1000 / 60))
1188 lasttime
= ev
.xmotion
.time
;
1190 nx
= ocx
+ (ev
.xmotion
.x
- x
);
1191 ny
= ocy
+ (ev
.xmotion
.y
- y
);
1192 if (nx
>= selmon
->wx
&& nx
<= selmon
->wx
+ selmon
->ww
1193 && ny
>= selmon
->wy
&& ny
<= selmon
->wy
+ selmon
->wh
) {
1194 if (abs(selmon
->wx
- nx
) < snap
)
1196 else if (abs((selmon
->wx
+ selmon
->ww
) - (nx
+ WIDTH(c
))) < snap
)
1197 nx
= selmon
->wx
+ selmon
->ww
- WIDTH(c
);
1198 if (abs(selmon
->wy
- ny
) < snap
)
1200 else if (abs((selmon
->wy
+ selmon
->wh
) - (ny
+ HEIGHT(c
))) < snap
)
1201 ny
= selmon
->wy
+ selmon
->wh
- HEIGHT(c
);
1202 if (!c
->isfloating
&& selmon
->lt
[selmon
->sellt
]->arrange
1203 && (abs(nx
- c
->x
) > snap
|| abs(ny
- c
->y
) > snap
))
1204 togglefloating(NULL
);
1206 if (!selmon
->lt
[selmon
->sellt
]->arrange
|| c
->isfloating
)
1207 resize(c
, nx
, ny
, c
->w
, c
->h
, 1);
1210 } while (ev
.type
!= ButtonRelease
);
1211 XUngrabPointer(dpy
, CurrentTime
);
1212 if ((m
= recttomon(c
->x
, c
->y
, c
->w
, c
->h
)) != selmon
) {
1220 nexttiled(Client
*c
)
1222 for (; c
&& (c
->isfloating
|| !ISVISIBLE(c
)); c
= c
->next
);
1236 propertynotify(XEvent
*e
)
1240 XPropertyEvent
*ev
= &e
->xproperty
;
1242 if ((ev
->window
== root
) && (ev
->atom
== XA_WM_NAME
))
1244 else if (ev
->state
== PropertyDelete
)
1245 return; /* ignore */
1246 else if ((c
= wintoclient(ev
->window
))) {
1249 case XA_WM_TRANSIENT_FOR
:
1250 if (!c
->isfloating
&& (XGetTransientForHint(dpy
, c
->win
, &trans
)) &&
1251 (c
->isfloating
= (wintoclient(trans
)) != NULL
))
1254 case XA_WM_NORMAL_HINTS
:
1262 if (ev
->atom
== XA_WM_NAME
|| ev
->atom
== netatom
[NetWMName
]) {
1264 if (c
== c
->mon
->sel
)
1267 if (ev
->atom
== netatom
[NetWMWindowType
])
1268 updatewindowtype(c
);
1273 quit(const Arg
*arg
)
1279 recttomon(int x
, int y
, int w
, int h
)
1281 Monitor
*m
, *r
= selmon
;
1284 for (m
= mons
; m
; m
= m
->next
)
1285 if ((a
= INTERSECT(x
, y
, w
, h
, m
)) > area
) {
1293 resize(Client
*c
, int x
, int y
, int w
, int h
, int interact
)
1295 if (applysizehints(c
, &x
, &y
, &w
, &h
, interact
))
1296 resizeclient(c
, x
, y
, w
, h
);
1300 resizeclient(Client
*c
, int x
, int y
, int w
, int h
)
1304 unsigned int gapoffset
;
1305 unsigned int gapincr
;
1308 wc
.border_width
= c
->bw
;
1310 /* Get number of clients for the selected monitor */
1311 for (n
= 0, nbc
= nexttiled(selmon
->clients
); nbc
; nbc
= nexttiled(nbc
->next
), n
++);
1313 /* Do nothing if layout is floating */
1314 if (c
->isfloating
|| selmon
->lt
[selmon
->sellt
]->arrange
== NULL
) {
1315 gapincr
= gapoffset
= 0;
1317 /* Remove border and gap if layout is monocle or only one client */
1318 if (selmon
->lt
[selmon
->sellt
]->arrange
== monocle
|| n
== 1) {
1320 gapincr
= -2 * borderpx
;
1321 wc
.border_width
= 0;
1324 gapincr
= 2 * gappx
;
1328 c
->oldx
= c
->x
; c
->x
= wc
.x
= x
+ gapoffset
;
1329 c
->oldy
= c
->y
; c
->y
= wc
.y
= y
+ gapoffset
;
1330 c
->oldw
= c
->w
; c
->w
= wc
.width
= w
- gapincr
;
1331 c
->oldh
= c
->h
; c
->h
= wc
.height
= h
- gapincr
;
1333 XConfigureWindow(dpy
, c
->win
, CWX
|CWY
|CWWidth
|CWHeight
|CWBorderWidth
, &wc
);
1339 resizemouse(const Arg
*arg
)
1341 int ocx
, ocy
, nw
, nh
;
1347 if (!(c
= selmon
->sel
))
1349 if (c
->isfullscreen
) /* no support resizing fullscreen windows by mouse */
1354 if (XGrabPointer(dpy
, root
, False
, MOUSEMASK
, GrabModeAsync
, GrabModeAsync
,
1355 None
, cursor
[CurResize
]->cursor
, CurrentTime
) != GrabSuccess
)
1357 XWarpPointer(dpy
, None
, c
->win
, 0, 0, 0, 0, c
->w
+ c
->bw
- 1, c
->h
+ c
->bw
- 1);
1359 XMaskEvent(dpy
, MOUSEMASK
|ExposureMask
|SubstructureRedirectMask
, &ev
);
1361 case ConfigureRequest
:
1364 handler
[ev
.type
](&ev
);
1367 if ((ev
.xmotion
.time
- lasttime
) <= (1000 / 60))
1369 lasttime
= ev
.xmotion
.time
;
1371 nw
= MAX(ev
.xmotion
.x
- ocx
- 2 * c
->bw
+ 1, 1);
1372 nh
= MAX(ev
.xmotion
.y
- ocy
- 2 * c
->bw
+ 1, 1);
1373 if (c
->mon
->wx
+ nw
>= selmon
->wx
&& c
->mon
->wx
+ nw
<= selmon
->wx
+ selmon
->ww
1374 && c
->mon
->wy
+ nh
>= selmon
->wy
&& c
->mon
->wy
+ nh
<= selmon
->wy
+ selmon
->wh
)
1376 if (!c
->isfloating
&& selmon
->lt
[selmon
->sellt
]->arrange
1377 && (abs(nw
- c
->w
) > snap
|| abs(nh
- c
->h
) > snap
))
1378 togglefloating(NULL
);
1380 if (!selmon
->lt
[selmon
->sellt
]->arrange
|| c
->isfloating
)
1381 resize(c
, c
->x
, c
->y
, nw
, nh
, 1);
1384 } while (ev
.type
!= ButtonRelease
);
1385 XWarpPointer(dpy
, None
, c
->win
, 0, 0, 0, 0, c
->w
+ c
->bw
- 1, c
->h
+ c
->bw
- 1);
1386 XUngrabPointer(dpy
, CurrentTime
);
1387 while (XCheckMaskEvent(dpy
, EnterWindowMask
, &ev
));
1388 if ((m
= recttomon(c
->x
, c
->y
, c
->w
, c
->h
)) != selmon
) {
1405 if (m
->sel
->isfloating
|| !m
->lt
[m
->sellt
]->arrange
)
1406 XRaiseWindow(dpy
, m
->sel
->win
);
1407 if (m
->lt
[m
->sellt
]->arrange
) {
1408 wc
.stack_mode
= Below
;
1409 wc
.sibling
= m
->barwin
;
1410 for (c
= m
->stack
; c
; c
= c
->snext
)
1411 if (!c
->isfloating
&& ISVISIBLE(c
)) {
1412 XConfigureWindow(dpy
, c
->win
, CWSibling
|CWStackMode
, &wc
);
1413 wc
.sibling
= c
->win
;
1417 while (XCheckMaskEvent(dpy
, EnterWindowMask
, &ev
));
1424 /* main event loop */
1426 while (running
&& !XNextEvent(dpy
, &ev
))
1427 if (handler
[ev
.type
])
1428 handler
[ev
.type
](&ev
); /* call handler */
1434 unsigned int i
, num
;
1435 Window d1
, d2
, *wins
= NULL
;
1436 XWindowAttributes wa
;
1438 if (XQueryTree(dpy
, root
, &d1
, &d2
, &wins
, &num
)) {
1439 for (i
= 0; i
< num
; i
++) {
1440 if (!XGetWindowAttributes(dpy
, wins
[i
], &wa
)
1441 || wa
.override_redirect
|| XGetTransientForHint(dpy
, wins
[i
], &d1
))
1443 if (wa
.map_state
== IsViewable
|| getstate(wins
[i
]) == IconicState
)
1444 manage(wins
[i
], &wa
);
1446 for (i
= 0; i
< num
; i
++) { /* now the transients */
1447 if (!XGetWindowAttributes(dpy
, wins
[i
], &wa
))
1449 if (XGetTransientForHint(dpy
, wins
[i
], &d1
)
1450 && (wa
.map_state
== IsViewable
|| getstate(wins
[i
]) == IconicState
))
1451 manage(wins
[i
], &wa
);
1459 sendmon(Client
*c
, Monitor
*m
)
1467 c
->tags
= m
->tagset
[m
->seltags
]; /* assign tags of target monitor */
1475 setclientstate(Client
*c
, long state
)
1477 long data
[] = { state
, None
};
1479 XChangeProperty(dpy
, c
->win
, wmatom
[WMState
], wmatom
[WMState
], 32,
1480 PropModeReplace
, (unsigned char *)data
, 2);
1484 sendevent(Client
*c
, Atom proto
)
1491 if (XGetWMProtocols(dpy
, c
->win
, &protocols
, &n
)) {
1492 while (!exists
&& n
--)
1493 exists
= protocols
[n
] == proto
;
1497 ev
.type
= ClientMessage
;
1498 ev
.xclient
.window
= c
->win
;
1499 ev
.xclient
.message_type
= wmatom
[WMProtocols
];
1500 ev
.xclient
.format
= 32;
1501 ev
.xclient
.data
.l
[0] = proto
;
1502 ev
.xclient
.data
.l
[1] = CurrentTime
;
1503 XSendEvent(dpy
, c
->win
, False
, NoEventMask
, &ev
);
1511 if (!c
->neverfocus
) {
1512 XSetInputFocus(dpy
, c
->win
, RevertToPointerRoot
, CurrentTime
);
1513 XChangeProperty(dpy
, root
, netatom
[NetActiveWindow
],
1514 XA_WINDOW
, 32, PropModeReplace
,
1515 (unsigned char *) &(c
->win
), 1);
1517 sendevent(c
, wmatom
[WMTakeFocus
]);
1521 setfullscreen(Client
*c
, int fullscreen
)
1523 if (fullscreen
&& !c
->isfullscreen
) {
1524 XChangeProperty(dpy
, c
->win
, netatom
[NetWMState
], XA_ATOM
, 32,
1525 PropModeReplace
, (unsigned char*)&netatom
[NetWMFullscreen
], 1);
1526 c
->isfullscreen
= 1;
1527 c
->oldstate
= c
->isfloating
;
1531 resizeclient(c
, c
->mon
->mx
, c
->mon
->my
, c
->mon
->mw
, c
->mon
->mh
);
1532 XRaiseWindow(dpy
, c
->win
);
1533 } else if (!fullscreen
&& c
->isfullscreen
){
1534 XChangeProperty(dpy
, c
->win
, netatom
[NetWMState
], XA_ATOM
, 32,
1535 PropModeReplace
, (unsigned char*)0, 0);
1536 c
->isfullscreen
= 0;
1537 c
->isfloating
= c
->oldstate
;
1543 resizeclient(c
, c
->x
, c
->y
, c
->w
, c
->h
);
1549 setlayout(const Arg
*arg
)
1551 if (!arg
|| !arg
->v
|| arg
->v
!= selmon
->lt
[selmon
->sellt
])
1554 selmon
->lt
[selmon
->sellt
] = (Layout
*)arg
->v
;
1555 strncpy(selmon
->ltsymbol
, selmon
->lt
[selmon
->sellt
]->symbol
, sizeof selmon
->ltsymbol
);
1562 /* arg > 1.0 will set mfact absolutly */
1564 setmfact(const Arg
*arg
)
1568 if (!arg
|| !selmon
->lt
[selmon
->sellt
]->arrange
)
1570 f
= arg
->f
< 1.0 ? arg
->f
+ selmon
->mfact
: arg
->f
- 1.0;
1571 if (f
< 0.1 || f
> 0.9)
1580 XSetWindowAttributes wa
;
1582 /* clean up any zombies immediately */
1586 screen
= DefaultScreen(dpy
);
1587 sw
= DisplayWidth(dpy
, screen
);
1588 sh
= DisplayHeight(dpy
, screen
);
1589 root
= RootWindow(dpy
, screen
);
1591 drw
= drw_create(dpy
, screen
, root
, sw
, sh
, visual
, depth
, cmap
);
1592 drw_load_fonts(drw
, fonts
, LENGTH(fonts
));
1593 if (!drw
->fontcount
)
1594 die("no fonts could be loaded.\n");
1595 bh
= drw
->fonts
[0]->h
+ 2;
1598 wmatom
[WMProtocols
] = XInternAtom(dpy
, "WM_PROTOCOLS", False
);
1599 wmatom
[WMDelete
] = XInternAtom(dpy
, "WM_DELETE_WINDOW", False
);
1600 wmatom
[WMState
] = XInternAtom(dpy
, "WM_STATE", False
);
1601 wmatom
[WMTakeFocus
] = XInternAtom(dpy
, "WM_TAKE_FOCUS", False
);
1602 netatom
[NetActiveWindow
] = XInternAtom(dpy
, "_NET_ACTIVE_WINDOW", False
);
1603 netatom
[NetSupported
] = XInternAtom(dpy
, "_NET_SUPPORTED", False
);
1604 netatom
[NetWMName
] = XInternAtom(dpy
, "_NET_WM_NAME", False
);
1605 netatom
[NetWMState
] = XInternAtom(dpy
, "_NET_WM_STATE", False
);
1606 netatom
[NetWMFullscreen
] = XInternAtom(dpy
, "_NET_WM_STATE_FULLSCREEN", False
);
1607 netatom
[NetWMWindowType
] = XInternAtom(dpy
, "_NET_WM_WINDOW_TYPE", False
);
1608 netatom
[NetWMWindowTypeDialog
] = XInternAtom(dpy
, "_NET_WM_WINDOW_TYPE_DIALOG", False
);
1609 netatom
[NetClientList
] = XInternAtom(dpy
, "_NET_CLIENT_LIST", False
);
1611 cursor
[CurNormal
] = drw_cur_create(drw
, XC_left_ptr
);
1612 cursor
[CurResize
] = drw_cur_create(drw
, XC_sizing
);
1613 cursor
[CurMove
] = drw_cur_create(drw
, XC_fleur
);
1614 /* init appearance */
1615 scheme
[SchemeNorm
].border
= drw_clr_create(drw
, normbordercolor
, borderalpha
);
1616 scheme
[SchemeNorm
].bg
= drw_clr_create(drw
, normbgcolor
, baralpha
);
1617 scheme
[SchemeNorm
].fg
= drw_clr_create(drw
, normfgcolor
, OPAQUE
);
1618 scheme
[SchemeSel
].border
= drw_clr_create(drw
, selbordercolor
, borderalpha
);
1619 scheme
[SchemeSel
].bg
= drw_clr_create(drw
, selbgcolor
, baralpha
);
1620 scheme
[SchemeSel
].fg
= drw_clr_create(drw
, selfgcolor
, OPAQUE
);
1624 /* EWMH support per view */
1625 XChangeProperty(dpy
, root
, netatom
[NetSupported
], XA_ATOM
, 32,
1626 PropModeReplace
, (unsigned char *) netatom
, NetLast
);
1627 XDeleteProperty(dpy
, root
, netatom
[NetClientList
]);
1628 /* select for events */
1629 wa
.cursor
= cursor
[CurNormal
]->cursor
;
1630 wa
.event_mask
= SubstructureRedirectMask
|SubstructureNotifyMask
|ButtonPressMask
|PointerMotionMask
1631 |EnterWindowMask
|LeaveWindowMask
|StructureNotifyMask
|PropertyChangeMask
;
1632 XChangeWindowAttributes(dpy
, root
, CWEventMask
|CWCursor
, &wa
);
1633 XSelectInput(dpy
, root
, wa
.event_mask
);
1644 /* show clients top down */
1645 XMoveWindow(dpy
, c
->win
, c
->x
, c
->y
);
1646 if ((!c
->mon
->lt
[c
->mon
->sellt
]->arrange
|| c
->isfloating
) && !c
->isfullscreen
)
1647 resize(c
, c
->x
, c
->y
, c
->w
, c
->h
, 0);
1650 /* hide clients bottom up */
1652 XMoveWindow(dpy
, c
->win
, WIDTH(c
) * -2, c
->y
);
1659 if (signal(SIGCHLD
, sigchld
) == SIG_ERR
)
1660 die("can't install SIGCHLD handler:");
1661 while (0 < waitpid(-1, NULL
, WNOHANG
));
1665 spawn(const Arg
*arg
)
1667 if (arg
->v
== dmenucmd
)
1668 dmenumon
[0] = '0' + selmon
->num
;
1671 close(ConnectionNumber(dpy
));
1673 execvp(((char **)arg
->v
)[0], (char **)arg
->v
);
1674 fprintf(stderr
, "dwm: execvp %s", ((char **)arg
->v
)[0]);
1683 if (selmon
->sel
&& arg
->ui
& TAGMASK
) {
1684 selmon
->sel
->tags
= arg
->ui
& TAGMASK
;
1691 tagmon(const Arg
*arg
)
1693 if (!selmon
->sel
|| !mons
->next
)
1695 sendmon(selmon
->sel
, dirtomon(arg
->i
));
1701 unsigned int i
, n
, h
, mw
, my
, ty
;
1704 for (n
= 0, c
= nexttiled(m
->clients
); c
; c
= nexttiled(c
->next
), n
++);
1709 mw
= m
->nmaster
? m
->ww
* m
->mfact
: 0;
1712 for (i
= my
= ty
= 0, c
= nexttiled(m
->clients
); c
; c
= nexttiled(c
->next
), i
++)
1713 if (i
< m
->nmaster
) {
1714 h
= (m
->wh
- my
) / (MIN(n
, m
->nmaster
) - i
);
1715 resize(c
, m
->wx
, m
->wy
+ my
, mw
- (2*c
->bw
), h
- (2*c
->bw
), 0);
1718 h
= (m
->wh
- ty
) / (n
- i
);
1719 resize(c
, m
->wx
+ mw
, m
->wy
+ ty
, m
->ww
- mw
- (2*c
->bw
), h
- (2*c
->bw
), 0);
1725 togglebar(const Arg
*arg
)
1727 selmon
->showbar
= !selmon
->showbar
;
1728 updatebarpos(selmon
);
1729 XMoveResizeWindow(dpy
, selmon
->barwin
, selmon
->wx
, selmon
->by
, selmon
->ww
, bh
);
1734 togglefloating(const Arg
*arg
)
1738 if (selmon
->sel
->isfullscreen
) /* no support for fullscreen windows */
1740 selmon
->sel
->isfloating
= !selmon
->sel
->isfloating
|| selmon
->sel
->isfixed
;
1741 if (selmon
->sel
->isfloating
)
1742 resize(selmon
->sel
, selmon
->sel
->x
, selmon
->sel
->y
,
1743 selmon
->sel
->w
, selmon
->sel
->h
, 0);
1748 toggletag(const Arg
*arg
)
1750 unsigned int newtags
;
1754 newtags
= selmon
->sel
->tags
^ (arg
->ui
& TAGMASK
);
1756 selmon
->sel
->tags
= newtags
;
1763 toggleview(const Arg
*arg
)
1765 unsigned int newtagset
= selmon
->tagset
[selmon
->seltags
] ^ (arg
->ui
& TAGMASK
);
1768 selmon
->tagset
[selmon
->seltags
] = newtagset
;
1775 unfocus(Client
*c
, int setfocus
)
1780 XSetWindowBorder(dpy
, c
->win
, scheme
[SchemeNorm
].border
->pix
);
1782 XSetInputFocus(dpy
, root
, RevertToPointerRoot
, CurrentTime
);
1783 XDeleteProperty(dpy
, root
, netatom
[NetActiveWindow
]);
1788 unmanage(Client
*c
, int destroyed
)
1790 Monitor
*m
= c
->mon
;
1793 /* The server grab construct avoids race conditions. */
1797 wc
.border_width
= c
->oldbw
;
1799 XSetErrorHandler(xerrordummy
);
1800 XConfigureWindow(dpy
, c
->win
, CWBorderWidth
, &wc
); /* restore border */
1801 XUngrabButton(dpy
, AnyButton
, AnyModifier
, c
->win
);
1802 setclientstate(c
, WithdrawnState
);
1804 XSetErrorHandler(xerror
);
1814 unmapnotify(XEvent
*e
)
1817 XUnmapEvent
*ev
= &e
->xunmap
;
1819 if ((c
= wintoclient(ev
->window
))) {
1821 setclientstate(c
, WithdrawnState
);
1831 XSetWindowAttributes wa
= {
1832 .override_redirect
= True
,
1833 .background_pixel
= 0,
1836 .event_mask
= ButtonPressMask
|ExposureMask
1838 for (m
= mons
; m
; m
= m
->next
) {
1841 m
->barwin
= XCreateWindow(dpy
, root
, m
->wx
, m
->by
, m
->ww
, bh
, 0, depth
,
1842 InputOutput
, visual
,
1843 CWOverrideRedirect
|CWBackPixel
|CWBorderPixel
|CWColormap
|CWEventMask
, &wa
);
1844 XDefineCursor(dpy
, m
->barwin
, cursor
[CurNormal
]->cursor
);
1845 XMapRaised(dpy
, m
->barwin
);
1850 updatebarpos(Monitor
*m
)
1856 m
->by
= m
->topbar
? m
->wy
: m
->wy
+ m
->wh
;
1857 m
->wy
= m
->topbar
? m
->wy
+ bh
: m
->wy
;
1868 XDeleteProperty(dpy
, root
, netatom
[NetClientList
]);
1869 for (m
= mons
; m
; m
= m
->next
)
1870 for (c
= m
->clients
; c
; c
= c
->next
)
1871 XChangeProperty(dpy
, root
, netatom
[NetClientList
],
1872 XA_WINDOW
, 32, PropModeAppend
,
1873 (unsigned char *) &(c
->win
), 1);
1882 if (XineramaIsActive(dpy
)) {
1886 XineramaScreenInfo
*info
= XineramaQueryScreens(dpy
, &nn
);
1887 XineramaScreenInfo
*unique
= NULL
;
1889 for (n
= 0, m
= mons
; m
; m
= m
->next
, n
++);
1890 /* only consider unique geometries as separate screens */
1891 unique
= ecalloc(nn
, sizeof(XineramaScreenInfo
));
1892 for (i
= 0, j
= 0; i
< nn
; i
++)
1893 if (isuniquegeom(unique
, j
, &info
[i
]))
1894 memcpy(&unique
[j
++], &info
[i
], sizeof(XineramaScreenInfo
));
1898 for (i
= 0; i
< (nn
- n
); i
++) { /* new monitors available */
1899 for (m
= mons
; m
&& m
->next
; m
= m
->next
);
1901 m
->next
= createmon();
1905 for (i
= 0, m
= mons
; i
< nn
&& m
; m
= m
->next
, i
++)
1907 || (unique
[i
].x_org
!= m
->mx
|| unique
[i
].y_org
!= m
->my
1908 || unique
[i
].width
!= m
->mw
|| unique
[i
].height
!= m
->mh
))
1912 m
->mx
= m
->wx
= unique
[i
].x_org
;
1913 m
->my
= m
->wy
= unique
[i
].y_org
;
1914 m
->mw
= m
->ww
= unique
[i
].width
;
1915 m
->mh
= m
->wh
= unique
[i
].height
;
1919 /* less monitors available nn < n */
1920 for (i
= nn
; i
< n
; i
++) {
1921 for (m
= mons
; m
&& m
->next
; m
= m
->next
);
1922 while (m
->clients
) {
1925 m
->clients
= c
->next
;
1938 #endif /* XINERAMA */
1939 /* default monitor setup */
1943 if (mons
->mw
!= sw
|| mons
->mh
!= sh
) {
1945 mons
->mw
= mons
->ww
= sw
;
1946 mons
->mh
= mons
->wh
= sh
;
1952 selmon
= wintomon(root
);
1958 updatenumlockmask(void)
1961 XModifierKeymap
*modmap
;
1964 modmap
= XGetModifierMapping(dpy
);
1965 for (i
= 0; i
< 8; i
++)
1966 for (j
= 0; j
< modmap
->max_keypermod
; j
++)
1967 if (modmap
->modifiermap
[i
* modmap
->max_keypermod
+ j
]
1968 == XKeysymToKeycode(dpy
, XK_Num_Lock
))
1969 numlockmask
= (1 << i
);
1970 XFreeModifiermap(modmap
);
1974 updatesizehints(Client
*c
)
1979 if (!XGetWMNormalHints(dpy
, c
->win
, &size
, &msize
))
1980 /* size is uninitialized, ensure that size.flags aren't used */
1982 if (size
.flags
& PBaseSize
) {
1983 c
->basew
= size
.base_width
;
1984 c
->baseh
= size
.base_height
;
1985 } else if (size
.flags
& PMinSize
) {
1986 c
->basew
= size
.min_width
;
1987 c
->baseh
= size
.min_height
;
1989 c
->basew
= c
->baseh
= 0;
1990 if (size
.flags
& PResizeInc
) {
1991 c
->incw
= size
.width_inc
;
1992 c
->inch
= size
.height_inc
;
1994 c
->incw
= c
->inch
= 0;
1995 if (size
.flags
& PMaxSize
) {
1996 c
->maxw
= size
.max_width
;
1997 c
->maxh
= size
.max_height
;
1999 c
->maxw
= c
->maxh
= 0;
2000 if (size
.flags
& PMinSize
) {
2001 c
->minw
= size
.min_width
;
2002 c
->minh
= size
.min_height
;
2003 } else if (size
.flags
& PBaseSize
) {
2004 c
->minw
= size
.base_width
;
2005 c
->minh
= size
.base_height
;
2007 c
->minw
= c
->minh
= 0;
2008 if (size
.flags
& PAspect
) {
2009 c
->mina
= (float)size
.min_aspect
.y
/ size
.min_aspect
.x
;
2010 c
->maxa
= (float)size
.max_aspect
.x
/ size
.max_aspect
.y
;
2012 c
->maxa
= c
->mina
= 0.0;
2013 c
->isfixed
= (c
->maxw
&& c
->minw
&& c
->maxh
&& c
->minh
2014 && c
->maxw
== c
->minw
&& c
->maxh
== c
->minh
);
2018 updatetitle(Client
*c
)
2020 if (!gettextprop(c
->win
, netatom
[NetWMName
], c
->name
, sizeof c
->name
))
2021 gettextprop(c
->win
, XA_WM_NAME
, c
->name
, sizeof c
->name
);
2022 if (c
->name
[0] == '\0') /* hack to mark broken clients */
2023 strcpy(c
->name
, broken
);
2029 if (!gettextprop(root
, XA_WM_NAME
, stext
, sizeof(stext
)))
2030 strcpy(stext
, "dwm-"VERSION
);
2035 updatewindowtype(Client
*c
)
2037 Atom state
= getatomprop(c
, netatom
[NetWMState
]);
2038 Atom wtype
= getatomprop(c
, netatom
[NetWMWindowType
]);
2040 if (state
== netatom
[NetWMFullscreen
])
2041 setfullscreen(c
, 1);
2042 if (wtype
== netatom
[NetWMWindowTypeDialog
])
2047 updatewmhints(Client
*c
)
2051 if ((wmh
= XGetWMHints(dpy
, c
->win
))) {
2052 if (c
== selmon
->sel
&& wmh
->flags
& XUrgencyHint
) {
2053 wmh
->flags
&= ~XUrgencyHint
;
2054 XSetWMHints(dpy
, c
->win
, wmh
);
2056 c
->isurgent
= (wmh
->flags
& XUrgencyHint
) ? 1 : 0;
2057 if (wmh
->flags
& InputHint
)
2058 c
->neverfocus
= !wmh
->input
;
2066 view(const Arg
*arg
)
2068 if ((arg
->ui
& TAGMASK
) == selmon
->tagset
[selmon
->seltags
])
2070 selmon
->seltags
^= 1; /* toggle sel tagset */
2071 if (arg
->ui
& TAGMASK
)
2072 selmon
->tagset
[selmon
->seltags
] = arg
->ui
& TAGMASK
;
2078 wintoclient(Window w
)
2083 for (m
= mons
; m
; m
= m
->next
)
2084 for (c
= m
->clients
; c
; c
= c
->next
)
2097 if (w
== root
&& getrootptr(&x
, &y
))
2098 return recttomon(x
, y
, 1, 1);
2099 for (m
= mons
; m
; m
= m
->next
)
2102 if ((c
= wintoclient(w
)))
2107 /* There's no way to check accesses to destroyed windows, thus those cases are
2108 * ignored (especially on UnmapNotify's). Other types of errors call Xlibs
2109 * default error handler, which may call exit. */
2111 xerror(Display
*dpy
, XErrorEvent
*ee
)
2113 if (ee
->error_code
== BadWindow
2114 || (ee
->request_code
== X_SetInputFocus
&& ee
->error_code
== BadMatch
)
2115 || (ee
->request_code
== X_PolyText8
&& ee
->error_code
== BadDrawable
)
2116 || (ee
->request_code
== X_PolyFillRectangle
&& ee
->error_code
== BadDrawable
)
2117 || (ee
->request_code
== X_PolySegment
&& ee
->error_code
== BadDrawable
)
2118 || (ee
->request_code
== X_ConfigureWindow
&& ee
->error_code
== BadMatch
)
2119 || (ee
->request_code
== X_GrabButton
&& ee
->error_code
== BadAccess
)
2120 || (ee
->request_code
== X_GrabKey
&& ee
->error_code
== BadAccess
)
2121 || (ee
->request_code
== X_CopyArea
&& ee
->error_code
== BadDrawable
))
2123 fprintf(stderr
, "dwm: fatal error: request code=%d, error code=%d\n",
2124 ee
->request_code
, ee
->error_code
);
2125 return xerrorxlib(dpy
, ee
); /* may call exit */
2129 xerrordummy(Display
*dpy
, XErrorEvent
*ee
)
2134 /* Startup Error handler to check if another window manager
2135 * is already running. */
2137 xerrorstart(Display
*dpy
, XErrorEvent
*ee
)
2139 die("dwm: another window manager is already running\n");
2147 XRenderPictFormat
*fmt
;
2156 long masks
= VisualScreenMask
| VisualDepthMask
| VisualClassMask
;
2158 infos
= XGetVisualInfo(dpy
, masks
, &tpl
, &nitems
);
2160 for(i
= 0; i
< nitems
; i
++) {
2161 fmt
= XRenderFindVisualFormat(dpy
, infos
[i
].visual
);
2162 if (fmt
->type
== PictTypeDirect
&& fmt
->direct
.alphaMask
) {
2163 visual
= infos
[i
].visual
;
2164 depth
= infos
[i
].depth
;
2165 cmap
= XCreateColormap(dpy
, root
, visual
, AllocNone
);
2174 visual
= DefaultVisual(dpy
, screen
);
2175 depth
= DefaultDepth(dpy
, screen
);
2176 cmap
= DefaultColormap(dpy
, screen
);
2181 zoom(const Arg
*arg
)
2183 Client
*c
= selmon
->sel
;
2185 if (!selmon
->lt
[selmon
->sellt
]->arrange
2186 || (selmon
->sel
&& selmon
->sel
->isfloating
))
2188 if (c
== nexttiled(selmon
->clients
))
2189 if (!c
|| !(c
= nexttiled(c
->next
)))
2195 main(int argc
, char *argv
[])
2197 if (argc
== 2 && !strcmp("-v", argv
[1]))
2198 die("dwm-"VERSION
"\n");
2200 die("usage: dwm [-v]\n");
2201 if (!setlocale(LC_CTYPE
, "") || !XSupportsLocale())
2202 fputs("warning: no locale support\n", stderr
);
2203 if (!(dpy
= XOpenDisplay(NULL
)))
2204 die("dwm: cannot open display\n");
2211 return EXIT_SUCCESS
;