event.c
changeset 75 f08271b7cb20
parent 74 5370ef170cc9
child 76 4bd49f404f10
equal deleted inserted replaced
74:5370ef170cc9 75:f08271b7cb20
    14 #include "dwm.h"
    14 #include "dwm.h"
    15 
    15 
    16 #define ButtonMask      (ButtonPressMask | ButtonReleaseMask)
    16 #define ButtonMask      (ButtonPressMask | ButtonReleaseMask)
    17 #define MouseMask       (ButtonMask | PointerMotionMask)
    17 #define MouseMask       (ButtonMask | PointerMotionMask)
    18 
    18 
       
    19 /********** CUSTOMIZE **********/
       
    20 
       
    21 const char *term[] = { 
       
    22 	"urxvtc", "-tr", "+sb", "-bg", "black", "-fg", "white", "-fn",
       
    23 	"-*-terminus-medium-*-*-*-13-*-*-*-*-*-iso10646-*",NULL
       
    24 };
       
    25 const char *browse[] = { "firefox", NULL };
       
    26 const char *xlock[] = { "xlock", NULL };
       
    27 
       
    28 Key key[] = {
       
    29 	/* modifier				key			function	arguments */
       
    30 	{ Mod1Mask,				XK_Return,	zoom,		{ 0 } },
       
    31 	{ Mod1Mask,				XK_k,		focusprev,		{ 0 } },
       
    32 	{ Mod1Mask,				XK_j,		focusnext,		{ 0 } }, 
       
    33 	{ Mod1Mask,				XK_m,		maximize,		{ 0 } }, 
       
    34 	{ Mod1Mask,				XK_0,		view,		{ .i = Tscratch } }, 
       
    35 	{ Mod1Mask,				XK_1,		view,		{ .i = Tdev } }, 
       
    36 	{ Mod1Mask,				XK_2,		view,		{ .i = Twww } }, 
       
    37 	{ Mod1Mask,				XK_3,		view,		{ .i = Twork } }, 
       
    38 	{ Mod1Mask,				XK_space,	dotile,		{ 0 } }, 
       
    39 	{ Mod1Mask|ShiftMask,	XK_space,	dofloat,	{ 0 } }, 
       
    40 	{ Mod1Mask|ShiftMask,	XK_0,		replacetag,		{ .i = Tscratch } }, 
       
    41 	{ Mod1Mask|ShiftMask,	XK_1,		replacetag,		{ .i = Tdev } }, 
       
    42 	{ Mod1Mask|ShiftMask,	XK_2,		replacetag,		{ .i = Twww } }, 
       
    43 	{ Mod1Mask|ShiftMask,	XK_3,		replacetag,		{ .i = Twork } }, 
       
    44 	{ Mod1Mask|ShiftMask,	XK_c,		killclient,		{ 0 } }, 
       
    45 	{ Mod1Mask|ShiftMask,	XK_q,		quit,		{ 0 } },
       
    46 	{ Mod1Mask|ShiftMask,	XK_Return,	spawn,		{ .argv = term } },
       
    47 	{ Mod1Mask|ShiftMask,	XK_w,		spawn,		{ .argv = browse } },
       
    48 	{ Mod1Mask|ShiftMask,	XK_l,		spawn,		{ .argv = xlock } },
       
    49 	{ ControlMask,			XK_0,		appendtag,	{ .i = Tscratch } }, 
       
    50 	{ ControlMask,			XK_1,		appendtag,	{ .i = Tdev } }, 
       
    51 	{ ControlMask,			XK_2,		appendtag,	{ .i = Twww } }, 
       
    52 	{ ControlMask,			XK_3,		appendtag,	{ .i = Twork } }, 
       
    53 };
       
    54 
       
    55 /********** CUSTOMIZE **********/
       
    56 
    19 /* local functions */
    57 /* local functions */
    20 static void buttonpress(XEvent *e);
    58 static void buttonpress(XEvent *e);
    21 static void configurerequest(XEvent *e);
    59 static void configurerequest(XEvent *e);
    22 static void destroynotify(XEvent *e);
    60 static void destroynotify(XEvent *e);
    23 static void enternotify(XEvent *e);
    61 static void enternotify(XEvent *e);
    24 static void leavenotify(XEvent *e);
    62 static void leavenotify(XEvent *e);
    25 static void expose(XEvent *e);
    63 static void expose(XEvent *e);
       
    64 static void keypress(XEvent *e);
    26 static void maprequest(XEvent *e);
    65 static void maprequest(XEvent *e);
    27 static void propertynotify(XEvent *e);
    66 static void propertynotify(XEvent *e);
    28 static void unmapnotify(XEvent *e);
    67 static void unmapnotify(XEvent *e);
    29 
    68 
    30 void (*handler[LASTEvent]) (XEvent *) = {
    69 void (*handler[LASTEvent]) (XEvent *) = {
    38 	[MapRequest] = maprequest,
    77 	[MapRequest] = maprequest,
    39 	[PropertyNotify] = propertynotify,
    78 	[PropertyNotify] = propertynotify,
    40 	[UnmapNotify] = unmapnotify
    79 	[UnmapNotify] = unmapnotify
    41 };
    80 };
    42 
    81 
    43 static void
    82 void
    44 mresize(Client *c)
    83 grabkeys()
       
    84 {
       
    85 	static unsigned int len = key ? sizeof(key) / sizeof(key[0]) : 0;
       
    86 	unsigned int i;
       
    87 	KeyCode code;
       
    88 
       
    89 	for(i = 0; i < len; i++) {
       
    90 		code = XKeysymToKeycode(dpy, key[i].keysym);
       
    91 		XUngrabKey(dpy, code, key[i].mod, root);
       
    92 		XGrabKey(dpy, code, key[i].mod, root, True,
       
    93 				GrabModeAsync, GrabModeAsync);
       
    94 	}
       
    95 }
       
    96 
       
    97 static void
       
    98 keypress(XEvent *e)
       
    99 {
       
   100 	XKeyEvent *ev = &e->xkey;
       
   101 	static unsigned int len = key ? sizeof(key) / sizeof(key[0]) : 0;
       
   102 	unsigned int i;
       
   103 	KeySym keysym;
       
   104 
       
   105 	keysym = XKeycodeToKeysym(dpy, (KeyCode)ev->keycode, 0);
       
   106 	for(i = 0; i < len; i++)
       
   107 		if((keysym == key[i].keysym) && (key[i].mod == ev->state)) {
       
   108 			if(key[i].func)
       
   109 				key[i].func(&key[i].arg);
       
   110 			return;
       
   111 		}
       
   112 }
       
   113 
       
   114 static void
       
   115 resizemouse(Client *c)
    45 {
   116 {
    46 	XEvent ev;
   117 	XEvent ev;
    47 	int ocx, ocy;
   118 	int ocx, ocy;
    48 
   119 
    49 	ocx = c->x;
   120 	ocx = c->x;
    73 		}
   144 		}
    74 	}
   145 	}
    75 }
   146 }
    76 
   147 
    77 static void
   148 static void
    78 mmove(Client *c)
   149 movemouse(Client *c)
    79 {
   150 {
    80 	XEvent ev;
   151 	XEvent ev;
    81 	int x1, y1, ocx, ocy, di;
   152 	int x1, y1, ocx, ocy, di;
    82 	unsigned int dui;
   153 	unsigned int dui;
    83 	Window dummy;
   154 	Window dummy;
   115 	Arg a;
   186 	Arg a;
   116 	XButtonPressedEvent *ev = &e->xbutton;
   187 	XButtonPressedEvent *ev = &e->xbutton;
   117 	Client *c;
   188 	Client *c;
   118 
   189 
   119 	if(barwin == ev->window) {
   190 	if(barwin == ev->window) {
   120 		x = (arrange == floating) ? textw("~") : 0;
   191 		x = (arrange == dofloat) ? textw("~") : 0;
   121 		for(a.i = 0; a.i < TLast; a.i++) {
   192 		for(a.i = 0; a.i < TLast; a.i++) {
   122 			x += textw(tags[a.i]);
   193 			x += textw(tags[a.i]);
   123 			if(ev->x < x) {
   194 			if(ev->x < x) {
   124 				view(&a);
   195 				view(&a);
   125 				break;
   196 				break;
   126 			}
   197 			}
   127 		}
   198 		}
   128 	}
   199 	}
   129 	else if((c = getclient(ev->window))) {
   200 	else if((c = getclient(ev->window))) {
   130 		if(arrange == tiling && !c->floating)
   201 		if(arrange == dotile && !c->dofloat)
   131 			return;
   202 			return;
   132 		higher(c);
   203 		higher(c);
   133 		switch(ev->button) {
   204 		switch(ev->button) {
   134 		default:
   205 		default:
   135 			break;
   206 			break;
   136 		case Button1:
   207 		case Button1:
   137 			mmove(c);
   208 			movemouse(c);
   138 			break;
   209 			break;
   139 		case Button2:
   210 		case Button2:
   140 			lower(c);
   211 			lower(c);
   141 			break;
   212 			break;
   142 		case Button3:
   213 		case Button3:
   143 			mresize(c);
   214 			resizemouse(c);
   144 			break;
   215 			break;
   145 		}
   216 		}
   146 	}
   217 	}
   147 }
   218 }
   148 
   219 
   224 	Client *c;
   295 	Client *c;
   225 
   296 
   226 	if(ev->count == 0) {
   297 	if(ev->count == 0) {
   227 		if(barwin == ev->window)
   298 		if(barwin == ev->window)
   228 			drawstatus();
   299 			drawstatus();
   229 		else if((c = gettitle(ev->window)))
   300 		else if((c = getctitle(ev->window)))
   230 			drawtitle(c);
   301 			drawtitle(c);
   231 	}
   302 	}
   232 }
   303 }
   233 
   304 
   234 static void
   305 static void
   260 	if(ev->state == PropertyDelete)
   331 	if(ev->state == PropertyDelete)
   261 		return; /* ignore */
   332 		return; /* ignore */
   262 
   333 
   263 	if((c = getclient(ev->window))) {
   334 	if((c = getclient(ev->window))) {
   264 		if(ev->atom == wm_atom[WMProtocols]) {
   335 		if(ev->atom == wm_atom[WMProtocols]) {
   265 			c->proto = proto(c->win);
   336 			c->proto = getproto(c->win);
   266 			return;
   337 			return;
   267 		}
   338 		}
   268 		switch (ev->atom) {
   339 		switch (ev->atom) {
   269 			default: break;
   340 			default: break;
   270 			case XA_WM_TRANSIENT_FOR:
   341 			case XA_WM_TRANSIENT_FOR:
   271 				XGetTransientForHint(dpy, c->win, &trans);
   342 				XGetTransientForHint(dpy, c->win, &trans);
   272 				if(!c->floating && (c->floating = (trans != 0)))
   343 				if(!c->dofloat && (c->dofloat = (trans != 0)))
   273 					arrange(NULL);
   344 					arrange(NULL);
   274 				break;
   345 				break;
   275 			case XA_WM_NORMAL_HINTS:
   346 			case XA_WM_NORMAL_HINTS:
   276 				setsize(c);
   347 				setsize(c);
   277 				break;
   348 				break;