1 /* Copyright (c) 1994-1996 David Hogan, see README for licence details */
2 #include <stdio.h>
3 #include <signal.h>
4 #include <errno.h>
5 #include <stdlib.h>
6 #include <unistd.h>
7 #include <X11/X.h>
8 #include <X11/Xos.h>
9 #include <X11/Xlib.h>
10 #include <X11/Xutil.h>
11 #include <X11/Xatom.h>
12 #ifdef SHAPE
13 #include <X11/extensions/shape.h>
14 #endif
15 #include "dat.h"
16 #include "fns.h"
17 #include "patchlevel.h"
18 
19 char	*version[] =
20 {
21 	"rio version 1.0, Copyright (c) 1994-1996 David Hogan, (c) 2004 Russ Cox", 0
22 };
23 
24 Display 		*dpy;
25 ScreenInfo	*screens;
26 int 			initting;
27 XFontStruct 	*font;
28 int 			nostalgia;
29 char			**myargv;
30 char			*termprog;
31 char			*shell;
32 Bool			shape;
33 int 			_border = 4;
34 int 			_corner = 25;
35 int 			_inset = 1;
36 int 			curtime;
37 int 			debug;
38 int 			signalled;
39 int 			scrolling;
40 int 			num_screens;
41 int			solidsweep = 0;
42 int			numvirtuals = 0;
43 int			ffm = 0;
44 
45 Atom		exit_rio;
46 Atom		restart_rio;
47 Atom		wm_state;
48 Atom		wm_change_state;
49 Atom		wm_protocols;
50 Atom		wm_delete;
51 Atom		wm_take_focus;
52 Atom		wm_lose_focus;
53 Atom		wm_colormaps;
54 Atom		_rio_running;
55 Atom		_rio_hold_mode;
56 Atom		wm_state_fullscreen;
57 Atom		wm_state;
58 
59 char	*fontlist[] = {
60 	"lucm.latin1.9",
61 	"blit",
62 	"*-lucidatypewriter-bold-*-14-*-75-*",
63 	"*-lucidatypewriter-medium-*-12-*-75-*",
64 	"9x15bold",
65 	"fixed",
66 	"*",
67 	0
68 };
69 
70 void
71 usage(void)
72 {
73 	fprintf(stderr, "usage: rio [-grey] [-font fname] [-s] [-term prog] [-version] [-virtuals num] [exit|restart]\n");
74 	exit(1);
75 }
76 
77 int
78 main(int argc, char *argv[])
79 {
80 	int i, background, do_exit, do_restart;
81 	char *fname;
82 	int shape_event;
83 #ifdef SHAPE
84 	int dummy;
85 #endif
86 
87 	shape_event = 0;
88 	myargv = argv;			/* for restart */
89 
90 	do_exit = do_restart = 0;
91 	background = 0;
92 	font = 0;
93 	fname = 0;
94 	for(i = 1; i < argc; i++)
95 		if(strcmp(argv[i], "-nostalgia") == 0)
96 			nostalgia++;
97 		else if(strcmp(argv[i], "-grey") == 0)
98 			background = 1;
99 		else if(strcmp(argv[i], "-debug") == 0)
100 			debug++;
101 	/*
102 		else if(strcmp(argv[i], "-ffm") == 0)
103 			ffm++;
104 	*/
105 		else if(strcmp(argv[i], "-font") == 0 && i+1<argc){
106 			i++;
107 			fname = argv[i];
108 		}
109 		else if(strcmp(argv[i], "-term") == 0 && i+1<argc)
110 			termprog = argv[++i];
111 		else if(strcmp(argv[i], "-virtuals") == 0 && i+1<argc){
112 			numvirtuals = atoi(argv[++i]);
113 			if(numvirtuals < 0 || numvirtuals > 12){
114 				fprintf(stderr, "rio: wrong number of virtual displays, defaulting to 4\n");
115 				numvirtuals = 4;
116 			}
117 		} else if(strcmp(argv[i], "-version") == 0){
118 			fprintf(stderr, "%s", version[0]);
119 			if(PATCHLEVEL > 0)
120 				fprintf(stderr, "; patch level %d", PATCHLEVEL);
121 			fprintf(stderr, "\n");
122 			exit(0);
123 		}
124 		else if(strcmp(argv[i], "-s") == 0){
125 			scrolling = 1;
126 		}
127 		else if(argv[i][0] == '-')
128 			usage();
129 		else
130 			break;
131 	for(; i < argc; i++)
132 		if(strcmp(argv[i], "exit") == 0)
133 			do_exit++;
134 		else if(strcmp(argv[i], "restart") == 0)
135 			do_restart++;
136 		else
137 			usage();
138 
139 	if(do_exit && do_restart)
140 		usage();
141 
142 	shell = (char *)getenv("SHELL");
143 	if(shell == NULL)
144 		shell = DEFSHELL;
145 
146 	dpy = XOpenDisplay("");
147 	if(dpy == 0)
148 		fatal("can't open display");
149 
150 	initting = 1;
151 	XSetErrorHandler(handler);
152 	if(signal(SIGTERM, sighandler) == SIG_IGN)
153 		signal(SIGTERM, SIG_IGN);
154 	if(signal(SIGINT, sighandler) == SIG_IGN)
155 		signal(SIGINT, SIG_IGN);
156 	if(signal(SIGHUP, sighandler) == SIG_IGN)
157 		signal(SIGHUP, SIG_IGN);
158 
159 	exit_rio = XInternAtom(dpy, "9WM_EXIT", False);
160 	restart_rio = XInternAtom(dpy, "9WM_RESTART", False);
161 
162 	curtime = -1;		/* don't care */
163 	if(do_exit){
164 		sendcmessage(DefaultRootWindow(dpy), exit_rio, 0L, 1, 1);
165 		XSync(dpy, False);
166 		exit(0);
167 	}
168 	if(do_restart){
169 		sendcmessage(DefaultRootWindow(dpy), restart_rio, 0L, 1, 1);
170 		XSync(dpy, False);
171 		exit(0);
172 	}
173 
174 	if(0) XSynchronize(dpy, True);
175 
176 	wm_state = XInternAtom(dpy, "WM_STATE", False);
177 	wm_change_state = XInternAtom(dpy, "WM_CHANGE_STATE", False);
178 	wm_protocols = XInternAtom(dpy, "WM_PROTOCOLS", False);
179 	wm_delete = XInternAtom(dpy, "WM_DELETE_WINDOW", False);
180 	wm_take_focus = XInternAtom(dpy, "WM_TAKE_FOCUS", False);
181 	wm_lose_focus = XInternAtom(dpy, "_9WM_LOSE_FOCUS", False);
182 	wm_colormaps = XInternAtom(dpy, "WM_COLORMAP_WINDOWS", False);
183 	_rio_running = XInternAtom(dpy, "_9WM_RUNNING", False);
184 	_rio_hold_mode = XInternAtom(dpy, "_9WM_HOLD_MODE", False);
185 	wm_state = XInternAtom(dpy, "_NET_WM_STATE", False);
186 	wm_state_fullscreen = XInternAtom(dpy, "_NET_WM_STATE_FULLSCREEN", False);
187 
188 	if(fname != 0)
189 		if((font = XLoadQueryFont(dpy, fname)) == 0)
190 			fprintf(stderr, "rio: warning: can't load font %s\n", fname);
191 
192 	if(font == 0){
193 		i = 0;
194 		for(;;){
195 			fname = fontlist[i++];
196 			if(fname == 0){
197 				fprintf(stderr, "rio: warning: can't find a font\n");
198 				break;
199 			}
200 			font = XLoadQueryFont(dpy, fname);
201 			if(font != 0)
202 				break;
203 		}
204 	}
205 	if(nostalgia){
206 		_border--;
207 		_inset--;
208 	}
209 
210 #ifdef	SHAPE
211 	shape = XShapeQueryExtension(dpy, &shape_event, &dummy);
212 #endif
213 
214 	num_screens = ScreenCount(dpy);
215 	screens = (ScreenInfo *)malloc(sizeof(ScreenInfo) * num_screens);
216 
217 	for(i = 0; i < num_screens; i++)
218 		initscreen(&screens[i], i, background);
219 
220 	initb2menu(numvirtuals);
221 
222 	/* set selection so that 9term knows we're running */
223 	curtime = CurrentTime;
224 	XSetSelectionOwner(dpy, _rio_running, screens[0].menuwin, timestamp());
225 
226 	XSync(dpy, False);
227 	initting = 0;
228 
229 	nofocus();
230 
231 	for(i = 0; i < num_screens; i++)
232 		scanwins(&screens[i]);
233 
234 	keysetup();
235 	mainloop(shape_event);
236 	return 0;
237 }
238 
239 void
240 initscreen(ScreenInfo *s, int i, int background)
241 {
242 	char *ds, *colon, *dot1;
243 	unsigned long mask;
244 	unsigned long gmask;
245 	XGCValues gv;
246 	XSetWindowAttributes attr;
247 	XVisualInfo xvi;
248 	XSetWindowAttributes attrs;
249 
250 	s->num = i;
251 	s->root = RootWindow(dpy, i);
252 	s->def_cmap = DefaultColormap(dpy, i);
253 	s->min_cmaps = MinCmapsOfScreen(ScreenOfDisplay(dpy, i));
254 	s->depth = DefaultDepth(dpy, i);
255 
256 	/*
257 	 * Figure out underlying screen format.
258 	 */
259 	if(XMatchVisualInfo(dpy, i, 16, TrueColor, &xvi)
260 	|| XMatchVisualInfo(dpy, i, 16, DirectColor, &xvi)){
261 		s->vis = xvi.visual;
262 		s->depth = 16;
263 	}
264 	else
265 	if(XMatchVisualInfo(dpy, i, 15, TrueColor, &xvi)
266 	|| XMatchVisualInfo(dpy, i, 15, DirectColor, &xvi)){
267 		s->vis = xvi.visual;
268 		s->depth = 15;
269 	}
270 	else
271 	if(XMatchVisualInfo(dpy, i, 24, TrueColor, &xvi)
272 	|| XMatchVisualInfo(dpy, i, 24, DirectColor, &xvi)){
273 		s->vis = xvi.visual;
274 		s->depth = 24;
275 	}
276 	else
277 	if(XMatchVisualInfo(dpy, i, 8, PseudoColor, &xvi)
278 	|| XMatchVisualInfo(dpy, i, 8, StaticColor, &xvi)){
279 		s->vis = xvi.visual;
280 		s->depth = 8;
281 	}
282 	else{
283 		s->depth = DefaultDepth(dpy, i);
284 		if(s->depth != 8){
285 			fprintf(stderr, "can't understand depth %d screen", s->depth);
286 			exit(1);
287 		}
288 		s->vis = DefaultVisual(dpy, i);
289 	}
290 	if(DefaultDepth(dpy, i) != s->depth){
291 		s->def_cmap = XCreateColormap(dpy, s->root, s->vis, AllocNone);
292 	}
293 
294 	ds = DisplayString(dpy);
295 	colon = rindex(ds, ':');
296 	if(colon && num_screens > 1){
297 		strcpy(s->display, "DISPLAY=");
298 		strcat(s->display, ds);
299 		colon = s->display + 8 + (colon - ds);	/* use version in buf */
300 		dot1 = index(colon, '.');	/* first period after colon */
301 		if(!dot1)
302 			dot1 = colon + strlen(colon);	/* if not there, append */
303 		sprintf(dot1, ".%d", i);
304 	}
305 	else
306 		s->display[0] = '\0';
307 
308 	s->black = BlackPixel(dpy, i);
309 	s->white = WhitePixel(dpy, i);
310 	s->activeholdborder = colorpixel(dpy, s, s->depth, 0x000099, s->white);
311 	s->inactiveholdborder = colorpixel(dpy, s, s->depth, 0x005DBB, s->black);
312 	s->activeborder = colorpixel(dpy, s, s->depth, 0x55AAAA, s->black);
313 	s->inactiveborder = colorpixel(dpy, s, s->depth, 0x9EEEEE, s->white);
314 	s->red = colorpixel(dpy, s, s->depth, 0xDD0000, s->white);
315 	s->width = WidthOfScreen(ScreenOfDisplay(dpy, i));
316 	s->height = HeightOfScreen(ScreenOfDisplay(dpy, i));
317 	s->bkup[0] = XCreatePixmap(dpy, s->root, 2*s->width, BORDER, DefaultDepth(dpy, i));
318 	s->bkup[1] = XCreatePixmap(dpy, s->root, BORDER, 2*s->height, DefaultDepth(dpy, i));
319 
320 	gv.foreground = s->black^s->white;
321 	gv.background = s->white;
322 	gv.function = GXxor;
323 	gv.line_width = 0;
324 	gv.subwindow_mode = IncludeInferiors;
325 	gmask = GCForeground | GCBackground | GCFunction | GCLineWidth
326 		| GCSubwindowMode;
327 	if(font != 0){
328 		gv.font = font->fid;
329 		gmask |= GCFont;
330 	}
331 	s->gc = XCreateGC(dpy, s->root, gmask, &gv);
332 
333 	gv.function = GXcopy;
334 	s->gccopy = XCreateGC(dpy, s->root, gmask, &gv);
335 
336 	gv.foreground = s->red;
337 	s->gcred = XCreateGC(dpy, s->root, gmask, &gv);
338 
339 	gv.foreground = colorpixel(dpy, s, s->depth, 0xEEEEEE, s->black);
340 	s->gcsweep = XCreateGC(dpy, s->root, gmask, &gv);
341 
342 	initcurs(s);
343 
344 	attr.cursor = s->arrow;
345 	attr.event_mask = SubstructureRedirectMask
346 		| SubstructureNotifyMask | ColormapChangeMask
347 		| ButtonPressMask | ButtonReleaseMask | PropertyChangeMask
348 		| KeyPressMask | EnterWindowMask;
349 	mask = CWCursor|CWEventMask;
350 	XChangeWindowAttributes(dpy, s->root, mask, &attr);
351 	XSync(dpy, False);
352 
353 	if(background){
354 		XSetWindowBackgroundPixmap(dpy, s->root, s->root_pixmap);
355 		XClearWindow(dpy, s->root);
356 	} else
357 		system("xsetroot -solid grey30");
358 
359 	attrs.border_pixel =  colorpixel(dpy, s, s->depth, 0x88CC88, s->black);
360 	attrs.background_pixel =  colorpixel(dpy, s, s->depth, 0xE9FFE9, s->white);
361 	attrs.colormap = s->def_cmap;
362 
363 	s->menuwin = XCreateWindow(dpy, s->root, 0, 0, 1, 1, 2,
364 						s->depth,
365 						CopyFromParent,
366 						s->vis,
367 						CWBackPixel | CWBorderPixel | CWColormap,
368 						&attrs
369 						);
370 
371 
372 	gv.foreground = colorpixel(dpy, s, s->depth, 0xE9FFE9, s->white);
373 	s->gcmenubg = XCreateGC(dpy, s->menuwin, gmask, &gv);
374 
375 	gv.foreground = colorpixel(dpy, s, s->depth, 0x448844, s->black);
376 	s->gcmenubgs = XCreateGC(dpy, s->menuwin, gmask, &gv);
377 
378 	gv.foreground = s->black;
379 	gv.background = colorpixel(dpy, s, s->depth, 0xE9FFE9, s->white);
380 	s->gcmenufg = XCreateGC(dpy, s->menuwin, gmask, &gv);
381 
382 	gv.foreground = colorpixel(dpy, s, s->depth, 0xE9FFE9, s->white);
383 	gv.background = colorpixel(dpy, s, s->depth, 0x448844, s->black);
384 	s->gcmenufgs = XCreateGC(dpy, s->menuwin, gmask, &gv);
385 
386 	attrs.border_pixel =  s->red;
387 	attrs.background_pixel =  colorpixel(dpy, s, s->depth, 0xEEEEEE, s->black);
388 	attrs.colormap = s->def_cmap;
389 	s->sweepwin = XCreateWindow(dpy, s->root, 0, 0, 1, 1, 4,
390 						s->depth,
391 						CopyFromParent,
392 						s->vis,
393 						CWBackPixel | CWBorderPixel | CWColormap,
394 						&attrs
395 						);
396 }
397 
398 ScreenInfo*
399 getscreen(Window w)
400 {
401 	int i;
402 
403 	for(i = 0; i < num_screens; i++)
404 		if(screens[i].root == w)
405 			return &screens[i];
406 
407 	return 0;
408 }
409 
410 Time
411 timestamp(void)
412 {
413 	XEvent ev;
414 
415 	if(curtime == CurrentTime){
416 		XChangeProperty(dpy, screens[0].root, _rio_running, _rio_running, 8,
417 				PropModeAppend, (unsigned char *)"", 0);
418 		XMaskEvent(dpy, PropertyChangeMask, &ev);
419 		curtime = ev.xproperty.time;
420 	}
421 	return curtime;
422 }
423 
424 void
425 sendcmessage(Window w, Atom a, long x, int isroot, int usemask)
426 {
427 	XEvent ev;
428 	int status;
429 	long mask;
430 
431 	memset(&ev, 0, sizeof(ev));
432 	ev.xclient.type = ClientMessage;
433 	ev.xclient.window = w;
434 	ev.xclient.message_type = a;
435 	ev.xclient.format = 32;
436 	ev.xclient.data.l[0] = x;
437 	ev.xclient.data.l[1] = timestamp();
438 	mask = 0;
439 	if(usemask){
440 		mask |= KeyPressMask;	/* seems to be necessary */
441 		if(isroot)
442 			mask |= SubstructureRedirectMask;		/* magic! */
443 		else
444 			mask |= ExposureMask;	/* not really correct but so be it */
445 	}
446 	status = XSendEvent(dpy, w, False, mask, &ev);
447 	if(status == 0)
448 		fprintf(stderr, "rio: sendcmessage failed\n");
449 }
450 
451 void
452 sendconfig(Client *c)
453 {
454 	XConfigureEvent ce;
455 
456 	ce.type = ConfigureNotify;
457 	ce.event = c->window;
458 	ce.window = c->window;
459 	ce.x = c->x;
460 	ce.y = c->y;
461 	ce.width = c->dx;
462 	ce.height = c->dy;
463 	ce.border_width = c->border;
464 	ce.above = None;
465 	ce.override_redirect = 0;
466 	XSendEvent(dpy, c->window, False, StructureNotifyMask, (XEvent*)&ce);
467 }
468 
469 void
470 sighandler(void)
471 {
472 	signalled = 1;
473 }
474 
475 void
476 getevent(XEvent *e)
477 {
478 	int fd;
479 	fd_set rfds;
480 	struct timeval t;
481 
482 	if(!signalled){
483 		if(QLength(dpy) > 0){
484 			XNextEvent(dpy, e);
485 			return;
486 		}
487 		fd = ConnectionNumber(dpy);
488 		FD_ZERO(&rfds);
489 		FD_SET(fd, &rfds);
490 		t.tv_sec = t.tv_usec = 0;
491 		if(select(fd+1, &rfds, NULL, NULL, &t) == 1){
492 			XNextEvent(dpy, e);
493 			return;
494 		}
495 		XFlush(dpy);
496 		FD_SET(fd, &rfds);
497 		if(select(fd+1, &rfds, NULL, NULL, NULL) == 1){
498 			XNextEvent(dpy, e);
499 			return;
500 		}
501 		if(errno != EINTR || !signalled){
502 			perror("rio: select failed");
503 			exit(1);
504 		}
505 	}
506 	fprintf(stderr, "rio: exiting on signal\n");
507 	cleanup();
508 	exit(1);
509 }
510 
511 void
512 cleanup(void)
513 {
514 	Client *c, *cc[2], *next;
515 	XWindowChanges wc;
516 	int i;
517 
518 	/* order of un-reparenting determines final stacking order... */
519 	cc[0] = cc[1] = 0;
520 	for(c = clients; c; c = next){
521 		next = c->next;
522 		i = normal(c);
523 		c->next = cc[i];
524 		cc[i] = c;
525 	}
526 
527 	for(i = 0; i < 2; i++){
528 		for(c = cc[i]; c; c = c->next){
529 			if(!withdrawn(c)){
530 				XReparentWindow(dpy, c->window, c->screen->root,
531 						c->x, c->y);
532 			}
533 			wc.border_width = c->border;
534 			XConfigureWindow(dpy, c->window, CWBorderWidth, &wc);
535 		}
536 	}
537 
538 	XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, timestamp());
539 	for(i = 0; i < num_screens; i++)
540 		cmapnofocus(&screens[i]);
541 	XCloseDisplay(dpy);
542 }