dwm-local/event.c

368 lines
8.0 KiB
C
Raw Normal View History

/* © 2006-2007 Anselm R. Garbe <garbeam at gmail dot com>
* © 2006-2007 Sander van Dijk <a dot h dot vandijk at gmail dot com>
2007-04-13 10:32:38 +01:00
* See LICENSE file for license details. */
#include "dwm.h"
#include <stdio.h>
2006-07-10 21:16:48 +01:00
#include <stdlib.h>
#include <X11/keysym.h>
2006-07-11 15:14:22 +01:00
#include <X11/Xatom.h>
2006-07-10 21:16:48 +01:00
/* static */
2006-07-19 16:42:08 +01:00
typedef struct {
unsigned long mod;
KeySym keysym;
void (*func)(const char *arg);
const char *arg;
2006-07-19 16:42:08 +01:00
} Key;
KEYS
2006-07-20 14:17:52 +01:00
#define CLEANMASK(mask) (mask & ~(numlockmask | LockMask))
#define MOUSEMASK (BUTTONMASK | PointerMotionMask)
2006-07-14 21:33:38 +01:00
static Client *
getclient(Window w) {
Client *c;
for(c = clients; c && c->win != w; c = c->next);
return c;
}
2006-07-15 16:19:19 +01:00
static void
movemouse(Client *c) {
int x1, y1, ocx, ocy, di, nx, ny;
2006-07-15 16:19:19 +01:00
unsigned int dui;
Window dummy;
2006-07-20 11:18:06 +01:00
XEvent ev;
2006-07-15 16:19:19 +01:00
ocx = nx = c->x;
2007-02-16 15:51:27 +00:00
ocy = ny = c->y;
if(XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
2006-07-20 11:18:06 +01:00
None, cursor[CurMove], CurrentTime) != GrabSuccess)
2006-07-15 16:19:19 +01:00
return;
2006-09-22 13:00:54 +01:00
c->ismax = False;
2006-07-15 16:19:19 +01:00
XQueryPointer(dpy, root, &dummy, &dummy, &x1, &y1, &di, &di, &dui);
for(;;) {
XMaskEvent(dpy, MOUSEMASK | ExposureMask | SubstructureRedirectMask, &ev);
2006-07-15 16:19:19 +01:00
switch (ev.type) {
2006-09-25 20:28:00 +01:00
case ButtonRelease:
XUngrabPointer(dpy, CurrentTime);
return;
case ConfigureRequest:
2006-07-15 16:19:19 +01:00
case Expose:
case MapRequest:
handler[ev.type](&ev);
2006-07-15 16:19:19 +01:00
break;
case MotionNotify:
XSync(dpy, False);
nx = ocx + (ev.xmotion.x - x1);
ny = ocy + (ev.xmotion.y - y1);
if(abs(wax + nx) < SNAP)
nx = wax;
else if(abs((wax + waw) - (nx + c->w + 2 * c->border)) < SNAP)
nx = wax + waw - c->w - 2 * c->border;
if(abs(way - ny) < SNAP)
ny = way;
else if(abs((way + wah) - (ny + c->h + 2 * c->border)) < SNAP)
ny = way + wah - c->h - 2 * c->border;
resize(c, nx, ny, c->w, c->h, False);
2006-07-15 16:19:19 +01:00
break;
}
}
}
static void
resizemouse(Client *c) {
2006-07-15 16:19:19 +01:00
int ocx, ocy;
2006-08-14 07:43:19 +01:00
int nw, nh;
2006-07-20 11:18:06 +01:00
XEvent ev;
2006-07-15 16:19:19 +01:00
ocx = c->x;
ocy = c->y;
if(XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
None, cursor[CurResize], CurrentTime) != GrabSuccess)
2006-07-15 16:19:19 +01:00
return;
2006-09-22 13:00:54 +01:00
c->ismax = False;
XWarpPointer(dpy, None, c->win, 0, 0, 0, 0, c->w + c->border - 1, c->h + c->border - 1);
2006-07-15 16:19:19 +01:00
for(;;) {
XMaskEvent(dpy, MOUSEMASK | ExposureMask | SubstructureRedirectMask , &ev);
2006-07-15 16:19:19 +01:00
switch(ev.type) {
2006-09-25 20:28:00 +01:00
case ButtonRelease:
2007-02-12 09:19:52 +00:00
XWarpPointer(dpy, None, c->win, 0, 0, 0, 0,
c->w + c->border - 1, c->h + c->border - 1);
2006-09-25 20:28:00 +01:00
XUngrabPointer(dpy, CurrentTime);
2007-02-12 09:21:26 +00:00
while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
2006-09-25 20:28:00 +01:00
return;
case ConfigureRequest:
2006-07-15 16:19:19 +01:00
case Expose:
case MapRequest:
handler[ev.type](&ev);
2006-07-15 16:19:19 +01:00
break;
case MotionNotify:
XSync(dpy, False);
if((nw = ev.xmotion.x - ocx - 2 * c->border + 1) <= 0)
nw = 1;
if((nh = ev.xmotion.y - ocy - 2 * c->border + 1) <= 0)
nh = 1;
resize(c, c->x, c->y, nw, nh, True);
2006-07-15 16:19:19 +01:00
break;
}
}
}
2006-07-14 21:33:38 +01:00
2006-07-11 20:24:10 +01:00
static void
buttonpress(XEvent *e) {
static char buf[32];
unsigned int i, x;
2006-07-11 20:24:10 +01:00
Client *c;
2006-07-20 11:18:06 +01:00
XButtonPressedEvent *ev = &e->xbutton;
2006-07-11 20:24:10 +01:00
buf[0] = 0;
2006-07-14 21:33:38 +01:00
if(barwin == ev->window) {
2006-08-25 14:48:44 +01:00
x = 0;
for(i = 0; i < ntags; i++) {
x += textw(tags[i]);
2006-08-25 14:48:44 +01:00
if(ev->x < x) {
snprintf(buf, sizeof buf, "%d", i);
2006-09-01 14:31:59 +01:00
if(ev->button == Button1) {
2006-09-01 09:32:50 +01:00
if(ev->state & MODKEY)
tag(buf);
2006-09-01 09:32:50 +01:00
else
view(buf);
2006-09-01 14:31:59 +01:00
}
else if(ev->button == Button3) {
2006-09-01 09:32:50 +01:00
if(ev->state & MODKEY)
toggletag(buf);
2006-09-01 09:32:50 +01:00
else
toggleview(buf);
}
2006-08-25 14:48:44 +01:00
return;
2006-07-14 21:33:38 +01:00
}
}
2007-02-19 15:40:36 +00:00
if(ev->x < x + blw)
switch(ev->button) {
case Button1:
setlayout(NULL);
break;
}
2006-07-14 21:33:38 +01:00
}
else if((c = getclient(ev->window))) {
2006-08-01 11:32:33 +01:00
focus(c);
if(CLEANMASK(ev->state) != MODKEY)
return;
if(ev->button == Button1 && (lt->arrange == floating || c->isfloating)) {
2006-09-25 07:21:51 +01:00
restack();
2006-09-01 14:31:59 +01:00
movemouse(c);
}
else if(ev->button == Button2)
zoom(NULL);
else if(ev->button == Button3
&& (lt->arrange == floating || c->isfloating) && !c->isfixed)
{
2006-09-25 07:21:51 +01:00
restack();
2006-09-01 14:31:59 +01:00
resizemouse(c);
2006-07-11 20:24:10 +01:00
}
}
}
2006-07-10 21:16:48 +01:00
static void
configurerequest(XEvent *e) {
2006-07-20 11:18:06 +01:00
Client *c;
2006-07-10 21:16:48 +01:00
XConfigureRequestEvent *ev = &e->xconfigurerequest;
XWindowChanges wc;
2006-07-11 20:24:10 +01:00
if((c = getclient(ev->window))) {
2006-09-25 19:38:30 +01:00
c->ismax = False;
2007-04-13 11:22:00 +01:00
if(ev->value_mask & CWBorderWidth)
c->border = ev->border_width;
if(c->isfixed || c->isfloating || (lt->arrange == floating)) {
if(ev->value_mask & CWX)
c->x = ev->x;
if(ev->value_mask & CWY)
c->y = ev->y;
if(ev->value_mask & CWWidth)
c->w = ev->width;
if(ev->value_mask & CWHeight)
c->h = ev->height;
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);
}
2007-04-13 10:32:38 +01:00
else {
configure(c);
2007-04-13 10:32:38 +01:00
}
2007-04-13 11:22:00 +01:00
c->border = BORDERPX;
}
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);
}
2007-02-13 12:39:33 +00:00
XSync(dpy, False);
2006-07-10 21:16:48 +01:00
}
static void
destroynotify(XEvent *e) {
2006-07-10 21:16:48 +01:00
Client *c;
XDestroyWindowEvent *ev = &e->xdestroywindow;
2006-07-11 12:21:57 +01:00
if((c = getclient(ev->window)))
unmanage(c);
2006-07-10 21:16:48 +01:00
}
static void
enternotify(XEvent *e) {
2006-07-10 21:16:48 +01:00
Client *c;
2006-07-20 11:18:06 +01:00
XCrossingEvent *ev = &e->xcrossing;
2006-07-10 21:16:48 +01:00
2006-08-10 09:16:12 +01:00
if(ev->mode != NotifyNormal || ev->detail == NotifyInferior)
2006-07-10 21:16:48 +01:00
return;
2007-01-14 21:27:29 +00:00
if((c = getclient(ev->window)) && isvisible(c))
2006-07-11 15:14:22 +01:00
focus(c);
2006-08-10 10:26:32 +01:00
else if(ev->window == root) {
2007-01-23 16:12:15 +00:00
selscreen = True;
for(c = stack; c && !isvisible(c); c = c->snext);
focus(c);
2006-08-10 10:26:32 +01:00
}
2006-07-10 21:16:48 +01:00
}
static void
expose(XEvent *e) {
2006-07-20 11:18:06 +01:00
XExposeEvent *ev = &e->xexpose;
2006-07-10 21:16:48 +01:00
if(ev->count == 0) {
2006-07-14 17:46:12 +01:00
if(barwin == ev->window)
2006-07-14 21:54:09 +01:00
drawstatus();
2006-07-10 21:16:48 +01:00
}
}
static void
keypress(XEvent *e) {
static unsigned int len = sizeof key / sizeof key[0];
2006-11-27 16:49:58 +00:00
unsigned int i;
KeySym keysym;
2006-07-20 11:18:06 +01:00
XKeyEvent *ev = &e->xkey;
keysym = XKeycodeToKeysym(dpy, (KeyCode)ev->keycode, 0);
for(i = 0; i < len; i++)
if(keysym == key[i].keysym
&& CLEANMASK(key[i].mod) == CLEANMASK(ev->state))
2006-08-14 14:11:02 +01:00
{
2006-11-27 16:49:58 +00:00
if(key[i].func)
key[i].func(key[i].arg);
}
}
static void
leavenotify(XEvent *e) {
XCrossingEvent *ev = &e->xcrossing;
if((ev->window == root) && !ev->same_screen) {
2007-01-23 16:12:15 +00:00
selscreen = False;
focus(NULL);
}
}
static void
mappingnotify(XEvent *e) {
XMappingEvent *ev = &e->xmapping;
XRefreshKeyboardMapping(ev);
if(ev->request == MappingKeyboard)
grabkeys();
}
2006-07-10 21:16:48 +01:00
static void
maprequest(XEvent *e) {
2006-07-10 21:16:48 +01:00
static XWindowAttributes wa;
2006-07-20 11:18:06 +01:00
XMapRequestEvent *ev = &e->xmaprequest;
2006-07-10 21:16:48 +01:00
if(!XGetWindowAttributes(dpy, ev->window, &wa))
return;
if(wa.override_redirect)
2006-07-10 21:16:48 +01:00
return;
2006-07-11 12:02:22 +01:00
if(!getclient(ev->window))
manage(ev->window, &wa);
2006-07-10 21:16:48 +01:00
}
static void
propertynotify(XEvent *e) {
2006-07-10 21:16:48 +01:00
Client *c;
2006-07-20 11:18:06 +01:00
Window trans;
XPropertyEvent *ev = &e->xproperty;
2006-07-10 21:16:48 +01:00
if(ev->state == PropertyDelete)
return; /* ignore */
2006-07-11 15:14:22 +01:00
if((c = getclient(ev->window))) {
switch (ev->atom) {
default: break;
case XA_WM_TRANSIENT_FOR:
2006-07-13 20:42:17 +01:00
XGetTransientForHint(dpy, c->win, &trans);
if(!c->isfloating && (c->isfloating = (getclient(trans) != NULL)))
2007-02-19 15:40:36 +00:00
lt->arrange();
2006-07-11 15:14:22 +01:00
break;
case XA_WM_NORMAL_HINTS:
updatesizehints(c);
2006-07-11 15:14:22 +01:00
break;
}
2006-07-15 16:19:19 +01:00
if(ev->atom == XA_WM_NAME || ev->atom == netatom[NetWMName]) {
updatetitle(c);
if(c == sel)
drawstatus();
2006-07-11 15:14:22 +01:00
}
}
2006-07-10 21:16:48 +01:00
}
static void
unmapnotify(XEvent *e) {
2006-07-10 21:16:48 +01:00
Client *c;
XUnmapEvent *ev = &e->xunmap;
2006-07-11 12:02:22 +01:00
if((c = getclient(ev->window)))
unmanage(c);
2006-07-10 21:16:48 +01:00
}
/* extern */
void (*handler[LASTEvent]) (XEvent *) = {
[ButtonPress] = buttonpress,
[ConfigureRequest] = configurerequest,
[DestroyNotify] = destroynotify,
[EnterNotify] = enternotify,
[LeaveNotify] = leavenotify,
[Expose] = expose,
[KeyPress] = keypress,
[MappingNotify] = mappingnotify,
[MapRequest] = maprequest,
[PropertyNotify] = propertynotify,
[UnmapNotify] = unmapnotify
};
void
2006-09-25 07:21:51 +01:00
grabkeys(void) {
static unsigned int len = sizeof key / sizeof key[0];
unsigned int i;
KeyCode code;
XUngrabKey(dpy, AnyKey, AnyModifier, root);
for(i = 0; i < len; i++) {
code = XKeysymToKeycode(dpy, key[i].keysym);
XGrabKey(dpy, code, key[i].mod, root, True,
GrabModeAsync, GrabModeAsync);
2006-08-02 10:13:32 +01:00
XGrabKey(dpy, code, key[i].mod | LockMask, root, True,
GrabModeAsync, GrabModeAsync);
XGrabKey(dpy, code, key[i].mod | numlockmask, root, True,
GrabModeAsync, GrabModeAsync);
XGrabKey(dpy, code, key[i].mod | numlockmask | LockMask, root, True,
GrabModeAsync, GrabModeAsync);
}
}