op public repos

Blob

Date:: Wed Jun 9 14:56:36 2004 UTC
Message:: let's try this
Actions:: History | Blame | Raw File
1 /* Copyright (c) 1994-1996 David Hogan, see README for licence details */
2 #include <stdio.h>
3 #include <stdlib.h>
4 #include <X11/X.h>
5 #include <X11/Xos.h>
6 #include <X11/Xlib.h>
7 #include <X11/Xutil.h>
8 #include <X11/Xatom.h>
9 #include <X11/extensions/shape.h>
10 #include "dat.h"
11 #include "fns.h"
12 #include "patchlevel.h"
13 
14 void
15 mainloop(int shape_event)
16 {
17 	XEvent ev;
18 
19 	for (;;) {
20 		getevent(&ev);
21 
22 #ifdef	DEBUG_EV
23 		if (debug) {
24 			ShowEvent(&ev);
25 			printf("\n");
26 		}
27 #endif
28 		switch (ev.type) {
29 		default:
30 #ifdef	SHAPE
31 			if (shape && ev.type == shape_event)
32 				shapenotify((XShapeEvent *)&ev);
33 			else
34 #endif
35 				fprintf(stderr, "rio: unknown ev.type %d\n", ev.type);
36 			break;
37 		case ButtonPress:
38 			button(&ev.xbutton);
39 			break;
40 		case ButtonRelease:
41 			break;
42 		case MapRequest:
43 			mapreq(&ev.xmaprequest);
44 			break;
45 		case ConfigureRequest:
46 			configurereq(&ev.xconfigurerequest);
47 			break;
48 		case CirculateRequest:
49 			circulatereq(&ev.xcirculaterequest);
50 			break;
51 		case UnmapNotify:
52 			unmap(&ev.xunmap);
53 			break;
54 		case CreateNotify:
55 			newwindow(&ev.xcreatewindow);
56 			break;
57 		case DestroyNotify:
58 			destroy(ev.xdestroywindow.window);
59 			break;
60 		case ClientMessage:
61 			clientmesg(&ev.xclient);
62 			break;
63 		case ColormapNotify:
64 			cmap(&ev.xcolormap);
65 			break;
66 		case PropertyNotify:
67 			property(&ev.xproperty);
68 			break;
69 		case SelectionClear:
70 			fprintf(stderr, "rio: SelectionClear (this should not happen)\n");
71 			break;
72 		case SelectionNotify:
73 			fprintf(stderr, "rio: SelectionNotify (this should not happen)\n");
74 			break;
75 		case SelectionRequest:
76 			fprintf(stderr, "rio: SelectionRequest (this should not happen)\n");
77 			break;
78 		case EnterNotify:
79 			enter(&ev.xcrossing);
80 			break;
81 		case LeaveNotify:
82 			leave(&ev.xcrossing);
83 			break;
84 		case ReparentNotify:
85 			reparent(&ev.xreparent);
86 			break;
87 		case FocusIn:
88 			focusin(&ev.xfocus);
89 			break;
90 		case MotionNotify:
91 			motionnotify(&ev.xmotion);
92 			break;
93 		case Expose:
94 		case NoExpose:
95 		case FocusOut:
96 		case ConfigureNotify:
97 		case MapNotify:
98 		case MappingNotify:
99 		case GraphicsExpose:
100 			/* not interested */
101 			trace("ignore", 0, &ev);
102 			break;
103 		}
104 	}
105 }
106 
107 
108 void
109 configurereq(XConfigureRequestEvent *e)
110 {
111 	XWindowChanges wc;
112 	Client *c;
113 
114 	/* we don't set curtime as nothing here uses it */
115 	c = getclient(e->window, 0);
116 	trace("configurereq", c, e);
117 
118 	e->value_mask &= ~CWSibling;
119 
120 	if (c) {
121 		gravitate(c, 1);
122 		if (e->value_mask & CWX)
123 			c->x = e->x;
124 		if (e->value_mask & CWY)
125 			c->y = e->y;
126 		if (e->value_mask & CWWidth)
127 			c->dx = e->width;
128 		if (e->value_mask & CWHeight)
129 			c->dy = e->height;
130 		if (e->value_mask & CWBorderWidth)
131 			c->border = e->border_width;
132 		gravitate(c, 0);
133 		if (e->value_mask & CWStackMode) {
134 			if (wc.stack_mode == Above)
135 				top(c);
136 			else
137 				e->value_mask &= ~CWStackMode;
138 		}
139 		if (c->parent != c->screen->root && c->window == e->window) {
140 			wc.x = c->x-BORDER;
141 			wc.y = c->y-BORDER;
142 			wc.width = c->dx+2*BORDER;
143 			wc.height = c->dy+2*BORDER;
144 			wc.border_width = 1;
145 			wc.sibling = None;
146 			wc.stack_mode = e->detail;
147 			XConfigureWindow(dpy, c->parent, e->value_mask, &wc);
148 			sendconfig(c);
149 			top(c);	
150 			active(c);
151 		}
152 	}
153 
154 	if (c && c->init) {
155 		wc.x = BORDER;
156 		wc.y = BORDER;
157 	}
158 	else {
159 		wc.x = e->x;
160 		wc.y = e->y;
161 	}
162 	wc.width = e->width;
163 	wc.height = e->height;
164 	wc.border_width = 0;
165 	wc.sibling = None;
166 	wc.stack_mode = Above;
167 	e->value_mask &= ~CWStackMode;
168 	e->value_mask |= CWBorderWidth;
169 
170 	XConfigureWindow(dpy, e->window, e->value_mask, &wc);
171 }
172 
173 void
174 mapreq(XMapRequestEvent *e)
175 {
176 	Client *c;
177 	int i;
178 
179 	curtime = CurrentTime;
180 	c = getclient(e->window, 0);
181 	trace("mapreq", c, e);
182 
183 	if (c == 0 || c->window != e->window) {
184 		/* workaround for stupid NCDware */
185 		fprintf(stderr, "rio: bad mapreq c %p w %x, rescanning\n",
186 			c, (int)e->window);
187 		for (i = 0; i < num_screens; i++)
188 			scanwins(&screens[i]);
189 		c = getclient(e->window, 0);
190 		if (c == 0 || c->window != e->window) {
191 			fprintf(stderr, "rio: window not found after rescan\n");
192 			return;
193 		}
194 	}
195 
196 	switch (c->state) {
197 	case WithdrawnState:
198 		if (c->parent == c->screen->root) {
199 			if (!manage(c, 0))
200 				return;
201 			break;
202 		}
203 		XReparentWindow(dpy, c->window, c->parent, BORDER-1, BORDER-1);
204 		XAddToSaveSet(dpy, c->window);
205 		/* fall through... */
206 	case NormalState:
207 		XMapWindow(dpy, c->window);
208 		XMapRaised(dpy, c->parent);
209 		top(c);
210 		setstate(c, NormalState);
211 		if (c->trans != None && current && c->trans == current->window)
212 				active(c);
213 		break;
214 	case IconicState:
215 		unhidec(c, 1);
216 		break;
217 	}
218 }
219 
220 void
221 unmap(XUnmapEvent *e)
222 {
223 	Client *c;
224 
225 	curtime = CurrentTime;
226 	c = getclient(e->window, 0);
227 	if (c) {
228 		switch (c->state) {
229 		case IconicState:
230 			if (e->send_event) {
231 				unhidec(c, 0);
232 				withdraw(c);
233 			}
234 			break;
235 		case NormalState:
236 			if (c == current)
237 				nofocus();
238 			if (!c->reparenting)
239 				withdraw(c);
240 			break;
241 		}
242 		c->reparenting = 0;
243 	}
244 }
245 
246 void
247 circulatereq(XCirculateRequestEvent *e)
248 {
249 	fprintf(stderr, "It must be the warlock Krill!\n");  /* ☺ */
250 }
251 
252 void
253 newwindow(XCreateWindowEvent *e)
254 {
255 	Client *c;
256 	ScreenInfo *s;
257 
258 	/* we don't set curtime as nothing here uses it */
259 	if (e->override_redirect)
260 		return;
261 	c = getclient(e->window, 1);
262 	if (c && c->window == e->window && (s = getscreen(e->parent))) {
263 		c->x = e->x;
264 		c->y = e->y;
265 		c->dx = e->width;
266 		c->dy = e->height;
267 		c->border = e->border_width;
268 		c->screen = s;
269 		if (c->parent == None)
270 			c->parent = c->screen->root;
271 	}
272 }
273 
274 void
275 destroy(Window w)
276 {
277 	Client *c;
278 
279 	curtime = CurrentTime;
280 	c = getclient(w, 0);
281 	if (c == 0)
282 		return;
283 
284 	rmclient(c);
285 
286 	/* flush any errors generated by the window's sudden demise */
287 	ignore_badwindow = 1;
288 	XSync(dpy, False);
289 	ignore_badwindow = 0;
290 }
291 
292 void
293 clientmesg(XClientMessageEvent *e)
294 {
295 	Client *c;
296 
297 	curtime = CurrentTime;
298 	if (e->message_type == exit_rio) {
299 		cleanup();
300 		exit(0);
301 	}
302 	if (e->message_type == restart_rio) {
303 		fprintf(stderr, "*** rio restarting ***\n");
304 		cleanup();
305 		execvp(myargv[0], myargv);
306 		perror("rio: exec failed");
307 		exit(1);
308 	}
309 	if (e->message_type == wm_change_state) {
310 		c = getclient(e->window, 0);
311 		if (e->format == 32 && e->data.l[0] == IconicState && c != 0) {
312 			if (normal(c))
313 				hide(c);
314 		}
315 		else
316 			fprintf(stderr, "rio: WM_CHANGE_STATE: format %d data %d w 0x%x\n",
317 				(int)e->format, (int)e->data.l[0], (int)e->window);
318 		return;
319 	}
320 	fprintf(stderr, "rio: strange ClientMessage, type 0x%x window 0x%x\n",
321 		(int)e->message_type, (int)e->window);
322 }
323 
324 void
325 cmap(XColormapEvent *e)
326 {
327 	Client *c;
328 	int i;
329 
330 	/* we don't set curtime as nothing here uses it */
331 	if (e->new) {
332 		c = getclient(e->window, 0);
333 		if (c) {
334 			c->cmap = e->colormap;
335 			if (c == current)
336 				cmapfocus(c);
337 		}
338 		else
339 			for (c = clients; c; c = c->next) {
340 				for (i = 0; i < c->ncmapwins; i++)
341 					if (c->cmapwins[i] == e->window) {
342 						c->wmcmaps[i] = e->colormap;
343 						if (c == current)
344 							cmapfocus(c);
345 						return;
346 					}
347 			}
348 	}
349 }
350 
351 void
352 property(XPropertyEvent *e)
353 {
354 	Atom a;
355 	int delete;
356 	Client *c;
357 	long msize;
358 
359 	/* we don't set curtime as nothing here uses it */
360 	a = e->atom;
361 	delete = (e->state == PropertyDelete);
362 	c = getclient(e->window, 0);
363 	if (c == 0)
364 		return;
365 
366 	switch (a) {
367 	case XA_WM_ICON_NAME:
368 		if (c->iconname != 0)
369 			XFree((char*) c->iconname);
370 		c->iconname = delete ? 0 : getprop(c->window, a);
371 		setlabel(c);
372 		renamec(c, c->label);
373 		return;
374 	case XA_WM_NAME:
375 		if (c->name != 0)
376 			XFree((char*) c->name);
377 		c->name = delete ? 0 : getprop(c->window, a);
378 		setlabel(c);
379 		renamec(c, c->label);
380 		return;
381 	case XA_WM_TRANSIENT_FOR:
382 		gettrans(c);
383 		return;
384 	case XA_WM_HINTS:
385 	case XA_WM_SIZE_HINTS:
386 	case XA_WM_ZOOM_HINTS:
387 		/* placeholders to not forget.  ignore for now.  -Axel */
388 		return;
389 	case XA_WM_NORMAL_HINTS:
390 		if (XGetWMNormalHints(dpy, c->window, &c->size, &msize) == 0 || c->size.flags == 0)
391 			c->size.flags = PSize;	/* not specified - punt */
392 		return;
393 	}
394 	if (a == _rio_hold_mode) {
395 		c->hold = getiprop(c->window, _rio_hold_mode);
396 		if (c == current)
397 			draw_border(c, 1);
398 	}
399 	else if (a == wm_colormaps) {
400 		getcmaps(c);
401 		if (c == current)
402 			cmapfocus(c);
403 	}
404 }
405 
406 void
407 reparent(XReparentEvent *e)
408 {
409 	Client *c;
410 	XWindowAttributes attr;
411 	ScreenInfo *s;
412 
413 	/* we don't set curtime as nothing here uses it */
414 	if (!getscreen(e->event) || e->override_redirect)
415 		return;
416 	if ((s = getscreen(e->parent)) != 0) {
417 		c = getclient(e->window, 1);
418 		if (c != 0 && (c->dx == 0 || c->dy == 0)) {
419 			/* flush any errors */
420 			ignore_badwindow = 1;
421 			XGetWindowAttributes(dpy, c->window, &attr);
422 			XSync(dpy, False);
423 			ignore_badwindow = 0;
424 
425 			c->x = attr.x;
426 			c->y = attr.y;
427 			c->dx = attr.width;
428 			c->dy = attr.height;
429 			c->border = attr.border_width;
430 			c->screen = s;
431 			if (c->parent == None)
432 				c->parent = c->screen->root;
433 		}
434 	}
435 	else {
436 		c = getclient(e->window, 0);
437 		if (c != 0 && (c->parent == c->screen->root || withdrawn(c)))
438 			rmclient(c);
439 	}
440 }
441 
442 #ifdef	SHAPE
443 void
444 shapenotify(XShapeEvent *e)
445 {
446 	Client *c;
447 
448 	/* we don't set curtime as nothing here uses it */
449 	c = getclient(e->window, 0);
450 	if (c == 0)
451 		return;
452 
453 	setshape(c);
454 }
455 #endif
456 
457 void
458 enter(XCrossingEvent *e)
459 {
460 	Client *c;
461 
462 	curtime = e->time;
463 	if (e->mode != NotifyGrab || e->detail != NotifyNonlinearVirtual)
464 		return;
465 	c = getclient(e->window, 0);
466 	if (c != 0 && c != current) {
467 		/* someone grabbed the pointer; make them current */
468 		XMapRaised(dpy, c->parent);
469 		top(c);
470 		active(c);
471 	}
472 }
473 
474 void
475 leave(XCrossingEvent *e)
476 {
477 	Client *c;
478 
479 	c = getclient(e->window, 0);
480 	if (c)
481 		XUndefineCursor(dpy, c->parent);
482 /* 	XDefineCursor(dpy, c->parent, c->screen->arrow); */
483 }
484 
485 void
486 focusin(XFocusChangeEvent *e)
487 {
488 	Client *c;
489 
490 	curtime = CurrentTime;
491 	if (e->detail != NotifyNonlinearVirtual)
492 		return;
493 	c = getclient(e->window, 0);
494 	if (c != 0 && c->window == e->window && c != current) {
495 		/* someone grabbed keyboard or seized focus; make them current */
496 		XMapRaised(dpy, c->parent);
497 		top(c);
498 		active(c);
499 	}
500 }
501 
502 BorderOrient
503 borderorient(Client *c, int x, int y)
504 {
505 	if (x <= BORDER) {
506 		if (y <= CORNER) {
507 			if (debug) fprintf(stderr, "topleft\n");
508 			return BorderWNW;
509 		}
510 		if (y >= (c->dy + 2*BORDER) - CORNER) {
511 			if (debug) fprintf(stderr, "botleft\n");
512 			return BorderWSW;
513 		}
514 		if (y > CORNER &&
515 	        y < (c->dy + 2*BORDER) - CORNER) {
516 			if (debug) fprintf(stderr, "left\n");
517 			return BorderW;
518 		}
519 	} else if (x <= CORNER) {
520 		if (y <= BORDER) {
521 			if (debug) fprintf(stderr, "topleft\n");
522 			return BorderNNW;
523 		}
524 		if  (y >= (c->dy + BORDER)) {
525 			if (debug) fprintf(stderr, "botleft\n");
526 			return BorderSSW;
527 		}
528 	} else if (x >= (c->dx + BORDER)) {
529 		if (y <= CORNER) {
530 			if (debug) fprintf(stderr, "topright\n");
531 			return BorderENE;
532 		}
533 		if (y >= (c->dy + 2*BORDER) - CORNER) {
534 			if (debug) fprintf(stderr, "botright\n");
535 			return BorderESE;
536 		}
537 		if (y > CORNER &&
538 			y < (c->dy + 2*BORDER) - CORNER) {
539 			if (debug) fprintf(stderr, "right\n");
540 			return BorderE;
541 		}
542 	} else if (x >= (c->dx + 2*BORDER) - CORNER) {
543 		if (y <= BORDER) {
544 			if (debug) fprintf(stderr, "topright\n");
545 			return BorderNNE;
546 		}
547 		if  (y >= (c->dy + BORDER)) {
548 			if (debug) fprintf(stderr, "botright\n");
549 			return BorderSSE;
550 		}
551 	} else if (x > CORNER &&
552 		       x < (c->dx + 2*BORDER) - CORNER) {
553 		if (y <= BORDER) {
554 			if (debug) fprintf(stderr, "top\n");
555 			return BorderN;
556 		}
557 		if (y >= (c->dy + BORDER)) {
558 			if (debug) fprintf(stderr, "bot\n");
559 			return BorderS;
560 		}
561 	}
562 	return BorderUnknown;
563 }
564 
565 void
566 motionnotify(XMotionEvent *e)
567 {
568 	Client *c;
569 	BorderOrient bl;
570 
571 	c = getclient(e->window, 0);
572 	if (c) {
573 		bl = borderorient(c, e->x, e->y);
574 		if (bl == BorderUnknown)
575 			XUndefineCursor(dpy, c->parent);
576 		else
577 			XDefineCursor(dpy, c->parent, c->screen->bordcurs[bl]);
578 	}
579 }