Mercurial > gbwm

comparison gbwm.c @ 0:ee781c291790

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial
author Atarwn Gard <a@qwa.su>
date Fri, 10 Oct 2025 13:40:59 +0500
parents
children 286d4af85ebe
comparison
equal deleted inserted replaced
-1:000000000000 0:ee781c291790
1 /* eowm - grid-based tiling window manager */
2 #include <X11/Xlib.h>
3 #include <X11/Xatom.h>
4 #include <X11/Xft/Xft.h>
5 #include <X11/Xutil.h>
6 #include <X11/keysym.h>
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <string.h>
10 #include <unistd.h>
11 #include <signal.h>
12 #include <sys/wait.h>
13
14 #define MOD Mod4Mask
15 #define GRID_ROWS 4
16 #define GRID_COLS 7
17
18 // Grid 4 by 7
19 static const char grid_chars[GRID_ROWS][GRID_COLS+1] = {
20 "1234567",
21 "qwertyu",
22 "asdfghj",
23 "zxcvbnm"
24 };
25
26 typedef struct Client Client;
27 struct Client {
28 Window win;
29 int x, y, w, h;
30 int saved_x, saved_y, saved_w, saved_h; // Saved position before fullscreen
31 int isfullscreen;
32 Client *next;
33 };
34
35 typedef union {
36 int i;
37 unsigned int ui;
38 float f;
39 const void *v;
40 } Arg;
41
42 typedef struct {
43 unsigned int mod;
44 KeySym keysym;
45 void (*func)(const Arg *);
46 const Arg arg;
47 } Key;
48
49 // Configuration
50 static const int padding = 8;
51 static const int border_width = 2;
52 static const char *col_border_normal = "#444444";
53 static const char *col_border_focused = "#4a90e2";
54 static const char *col_bg = "#000000";
55 static const char *col_fg = "#ffffff";
56 static const char *col_sel = "#4a90e2";
57
58 static Display *dpy;
59 static Window root;
60 static Client *clients = NULL;
61 static Client *focused = NULL;
62 static int sw, sh;
63 static int overlay_mode = 0;
64 static char overlay_input[3] = {0};
65 static Window overlay_win = 0;
66 static GC gc;
67 static XftDraw *xftdraw = NULL;
68 static XftFont *font = NULL;
69 static XftColor xft_col_bg, xft_col_fg, xft_col_sel;
70 static unsigned long border_normal, border_focused;
71
72 // ICCCM atoms
73 static Atom wm_protocols, wm_delete_window, wm_state, wm_take_focus;
74
75 // Forward decls
76 static void arrange(void);
77 static void resize(Client *c, int x, int y, int w, int h);
78 static void focus(Client *c);
79 static void spawn(const Arg *arg);
80 static void killclient(const Arg *arg);
81 static void toggle_fullscreen(const Arg *arg);
82 static void enter_overlay(const Arg *arg);
83 static void process_overlay_input(void);
84 static void draw_overlay(void);
85 static void hide_overlay(void);
86 static void quit(const Arg *arg);
87 static void cycle_focus(const Arg *arg);
88 static void grabkeys(void);
89 static void setfullscreen(Client *c, int fullscreen);
90 static int sendevent(Client *c, Atom proto);
91 static void updateborder(Client *c);
92 static void find_next_free_cell(int *out_r, int *out_c);
93
94 // Commands
95 static const char *termcmd[] = { "alacritty", NULL };
96 static const char *menucmd[] = { "dmenu_run", NULL };
97
98 // Key bindings
99 static Key keys[] = {
100 /* modifier key function argument */
101 { MOD, XK_t, enter_overlay, {0} },
102 { MOD, XK_Return, spawn, {.v = termcmd} },
103 { MOD, XK_p, spawn, {.v = menucmd} },
104 { MOD, XK_q, killclient, {0} },
105 { MOD, XK_f, toggle_fullscreen, {0} },
106 { MOD, XK_Tab, cycle_focus, {0} },
107 { MOD|ShiftMask, XK_q, quit, {0} },
108 };
109
110 // Event handlers
111 static void buttonpress(XEvent *e) {
112 for (Client *c = clients; c; c = c->next)
113 if (c->win == e->xbutton.subwindow) {
114 focus(c);
115 break;
116 }
117 }
118
119 static void clientmessage(XEvent *e) {
120 XClientMessageEvent *cme = &e->xclient;
121 Client *c;
122 for (c = clients; c; c = c->next)
123 if (c->win == cme->window)
124 break;
125 if (!c)
126 return;
127
128 if (cme->message_type == wm_state && cme->data.l[1] == (long)XInternAtom(dpy, "_NET_WM_STATE_FULLSCREEN", False)) {
129 setfullscreen(c, cme->data.l[0] == 1 || (cme->data.l[0] == 2 && !c->isfullscreen));
130 }
131 }
132
133 static void maprequest(XEvent *e) {
134 XWindowAttributes wa;
135 if (!XGetWindowAttributes(dpy, e->xmaprequest.window, &wa)) return;
136 if (wa.override_redirect) return;
137
138 Client *c = calloc(1, sizeof(Client));
139 c->win = e->xmaprequest.window;
140 c->next = clients;
141 clients = c;
142
143 // ICCCM setup
144 XSetWindowBorderWidth(dpy, c->win, border_width);
145 XSelectInput(dpy, c->win, EnterWindowMask | FocusChangeMask | PropertyChangeMask | StructureNotifyMask);
146
147 // Set WM_STATE
148 long data[] = { NormalState, None };
149 XChangeProperty(dpy, c->win, wm_state, wm_state, 32, PropModeReplace, (unsigned char *)data, 2);
150
151 XMapWindow(dpy, c->win);
152 focus(c);
153 arrange();
154 }
155
156 static void unmapnotify(XEvent *e) {
157 Client **p;
158 for (p = &clients; *p && (*p)->win != e->xunmap.window; p = &(*p)->next);
159 if (*p) {
160 Client *c = *p;
161 if (focused == c) {
162 focused = c->next ? c->next : (clients == c ? NULL : clients);
163 }
164 *p = c->next;
165 free(c);
166 if (focused)
167 focus(focused);
168 arrange();
169 }
170 }
171
172 static void destroynotify(XEvent *e) {
173 unmapnotify(e);
174 }
175
176 static void enternotify(XEvent *e) {
177 if (e->xcrossing.mode != NotifyNormal || e->xcrossing.detail == NotifyInferior)
178 return;
179 for (Client *c = clients; c; c = c->next)
180 if (c->win == e->xcrossing.window) {
181 focus(c);
182 break;
183 }
184 }
185
186 static void expose(XEvent *e) {
187 if (e->xexpose.window == overlay_win && overlay_mode) {
188 draw_overlay();
189 }
190 }
191
192 static void keypress(XEvent *e) {
193 if (overlay_mode) {
194 KeySym k = XLookupKeysym(&e->xkey, 0);
195 if (k == XK_Escape) {
196 hide_overlay();
197 return;
198 }
199
200 char ch = 0;
201 if (k >= '0' && k <= '9') ch = (char)k;
202 else if (k >= 'a' && k <= 'z') ch = (char)k;
203 else if (k >= 'A' && k <= 'Z') ch = (char)(k - 'A' + 'a');
204 else return;
205
206 int found = 0;
207 for (int r = 0; r < GRID_ROWS && !found; r++)
208 for (int c = 0; c < GRID_COLS && !found; c++)
209 if (grid_chars[r][c] == ch) found = 1;
210 if (!found) return;
211
212 if (overlay_input[0] == 0) {
213 overlay_input[0] = ch;
214 draw_overlay();
215 } else if (overlay_input[1] == 0) {
216 overlay_input[1] = ch;
217 draw_overlay();
218 usleep(150000);
219 process_overlay_input();
220 hide_overlay();
221 }
222 return;
223 }
224
225 KeySym keysym = XLookupKeysym(&e->xkey, 0);
226 unsigned int state = e->xkey.state & ~(LockMask | Mod2Mask);
227
228 for (unsigned int i = 0; i < sizeof(keys) / sizeof(Key); i++) {
229 if (keysym == keys[i].keysym && state == keys[i].mod && keys[i].func) {
230 keys[i].func(&keys[i].arg);
231 return;
232 }
233 }
234 }
235
236 // Core logic
237 static void resize(Client *c, int x, int y, int w, int h) {
238 c->x = x; c->y = y; c->w = w; c->h = h;
239 XMoveResizeWindow(dpy, c->win, x, y, w, h);
240 }
241
242 static void updateborder(Client *c) {
243 XSetWindowBorder(dpy, c->win, c == focused ? border_focused : border_normal);
244 }
245
246 static void focus(Client *c) {
247 if (!c) return;
248
249 Client *old = focused;
250 focused = c;
251
252 if (old && old != c)
253 updateborder(old);
254
255 updateborder(c);
256 XRaiseWindow(dpy, c->win);
257 XSetInputFocus(dpy, c->win, RevertToPointerRoot, CurrentTime);
258 sendevent(c, wm_take_focus);
259 }
260
261 static int is_cell_free(int r, int c, int cell_w, int cell_h) {
262 int cell_x = padding + c * (cell_w + padding);
263 int cell_y = padding + r * (cell_h + padding);
264
265 // Check if any window overlaps with this cell
266 for (Client *cl = clients; cl; cl = cl->next) {
267 if (cl->isfullscreen) continue;
268
269 // Check for overlap
270 int cl_right = cl->x + cl->w;
271 int cl_bottom = cl->y + cl->h;
272 int cell_right = cell_x + cell_w;
273 int cell_bottom = cell_y + cell_h;
274
275 // If rectangles overlap
276 if (!(cl_right <= cell_x || cl->x >= cell_right ||
277 cl_bottom <= cell_y || cl->y >= cell_bottom)) {
278 return 0; // Cell is occupied
279 }
280 }
281
282 return 1; // Cell is free
283 }
284
285 static void find_next_free_cell(int *out_r, int *out_c) {
286 int cell_w = (sw - padding * (GRID_COLS + 1)) / GRID_COLS;
287 int cell_h = (sh - padding * (GRID_ROWS + 1)) / GRID_ROWS;
288
289 // First pass: look for any completely free cell
290 for (int r = 0; r < GRID_ROWS; r++) {
291 for (int c = 0; c < GRID_COLS; c++) {
292 if (is_cell_free(r, c, cell_w, cell_h)) {
293 *out_r = r;
294 *out_c = c;
295 return;
296 }
297 }
298 }
299
300 // Second pass: no free space found, check top-left for 1x1 windows
301 int cell_x = padding;
302 int cell_y = padding;
303
304 for (Client *cl = clients; cl; cl = cl->next) {
305 if (cl->isfullscreen) continue;
306 if (cl->x == cell_x && cl->y == cell_y &&
307 cl->w == cell_w && cl->h == cell_h) {
308 // Found a 1x1 window at top-left, find next free cell
309 for (int r = 0; r < GRID_ROWS; r++) {
310 for (int c = 0; c < GRID_COLS; c++) {
311 int check_x = padding + c * (cell_w + padding);
312 int check_y = padding + r * (cell_h + padding);
313
314 int found_1x1 = 0;
315 for (Client *check = clients; check; check = check->next) {
316 if (check->isfullscreen) continue;
317 if (check->x == check_x && check->y == check_y &&
318 check->w == cell_w && check->h == cell_h) {
319 found_1x1 = 1;
320 break;
321 }
322 }
323
324 if (!found_1x1) {
325 *out_r = r;
326 *out_c = c;
327 return;
328 }
329 }
330 }
331 break;
332 }
333 }
334
335 // Fallback to top-left
336 *out_r = 0;
337 *out_c = 0;
338 }
339
340 static void arrange(void) {
341 if (!clients) return;
342
343 if (!focused) focused = clients;
344
345 if (focused->isfullscreen) {
346 return;
347 }
348
349 // Default window location - find next free cell
350 int cell_w = (sw - padding * (GRID_COLS + 1)) / GRID_COLS;
351 int cell_h = (sh - padding * (GRID_ROWS + 1)) / GRID_ROWS;
352
353 if (focused->w == 0 || focused->h == 0) {
354 int r, c;
355 find_next_free_cell(&r, &c);
356 int x = padding + c * (cell_w + padding);
357 int y = padding + r * (cell_h + padding);
358 resize(focused, x, y, cell_w, cell_h);
359 }
360
361 // Update all borders
362 for (Client *c = clients; c; c = c->next)
363 updateborder(c);
364 }
365
366 static void draw_overlay(void) {
367 if (!overlay_win) return;
368
369 XClearWindow(dpy, overlay_win);
370
371 int cell_w = (sw - padding * (GRID_COLS + 1)) / GRID_COLS;
372 int cell_h = (sh - padding * (GRID_ROWS + 1)) / GRID_ROWS;
373
374 int r1 = -1, c1 = -1, r2 = -1, c2 = -1;
375 if (overlay_input[0]) {
376 for (int r = 0; r < GRID_ROWS; r++)
377 for (int c = 0; c < GRID_COLS; c++)
378 if (grid_chars[r][c] == overlay_input[0]) { r1 = r; c1 = c; }
379 }
380 if (overlay_input[1]) {
381 for (int r = 0; r < GRID_ROWS; r++)
382 for (int c = 0; c < GRID_COLS; c++)
383 if (grid_chars[r][c] == overlay_input[1]) { r2 = r; c2 = c; }
384 }
385
386 for (int r = 0; r < GRID_ROWS; r++) {
387 for (int c = 0; c < GRID_COLS; c++) {
388 int x = padding + c * (cell_w + padding);
389 int y = padding + r * (cell_h + padding);
390
391 int is_selected = 0;
392 if (r1 >= 0 && c1 >= 0) {
393 if (r2 >= 0 && c2 >= 0) {
394 int min_r = r1 < r2 ? r1 : r2;
395 int max_r = r1 > r2 ? r1 : r2;
396 int min_c = c1 < c2 ? c1 : c2;
397 int max_c = c1 > c2 ? c1 : c2;
398 if (r >= min_r && r <= max_r && c >= min_c && c <= max_c)
399 is_selected = 1;
400 } else if (r == r1 && c == c1) {
401 is_selected = 1;
402 }
403 }
404
405 if (is_selected) {
406 XSetForeground(dpy, gc, xft_col_sel.pixel);
407 XFillRectangle(dpy, overlay_win, gc, x, y, cell_w, cell_h);
408 }
409
410 XSetForeground(dpy, gc, xft_col_fg.pixel);
411 XDrawRectangle(dpy, overlay_win, gc, x, y, cell_w, cell_h);
412
413 if (font && xftdraw) {
414 char txt[2] = {grid_chars[r][c], 0};
415 XGlyphInfo extents;
416 XftTextExtentsUtf8(dpy, font, (FcChar8*)txt, strlen(txt), &extents);
417
418 int tx = x + (cell_w - extents.width) / 2;
419 int ty = y + (cell_h - extents.height) / 2 + extents.y;
420
421 XftDrawStringUtf8(xftdraw, &xft_col_fg, font, tx, ty,
422 (FcChar8*)txt, strlen(txt));
423 }
424 }
425 }
426
427 if (overlay_input[0] || overlay_input[1]) {
428 char status[64];
429 snprintf(status, sizeof(status), "Input: %c%c",
430 overlay_input[0] ? overlay_input[0] : ' ',
431 overlay_input[1] ? overlay_input[1] : ' ');
432
433 if (font && xftdraw) {
434 XftDrawStringUtf8(xftdraw, &xft_col_fg, font, 20, sh - 20,
435 (FcChar8*)status, strlen(status));
436 }
437 }
438
439 XFlush(dpy);
440 }
441
442 static void enter_overlay(const Arg *arg) {
443 if (!focused) return;
444
445 overlay_mode = 1;
446 memset(overlay_input, 0, sizeof(overlay_input));
447
448 if (!overlay_win) {
449 XSetWindowAttributes wa = {
450 .override_redirect = True,
451 .background_pixel = BlackPixel(dpy, DefaultScreen(dpy)),
452 .event_mask = ExposureMask | KeyPressMask
453 };
454 overlay_win = XCreateWindow(dpy, root, 0, 0, sw, sh, 0,
455 CopyFromParent, InputOutput, CopyFromParent,
456 CWOverrideRedirect | CWBackPixel | CWEventMask, &wa);
457
458 gc = XCreateGC(dpy, overlay_win, 0, NULL);
459
460 Visual *visual = DefaultVisual(dpy, DefaultScreen(dpy));
461 Colormap cmap = DefaultColormap(dpy, DefaultScreen(dpy));
462 xftdraw = XftDrawCreate(dpy, overlay_win, visual, cmap);
463
464 unsigned long opacity = (unsigned long)(0.85 * 0xffffffff);
465 Atom atom = XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False);
466 XChangeProperty(dpy, overlay_win, atom, XA_CARDINAL, 32,
467 PropModeReplace, (unsigned char *)&opacity, 1);
468 }
469
470 XMapRaised(dpy, overlay_win);
471 XSetInputFocus(dpy, overlay_win, RevertToPointerRoot, CurrentTime);
472 draw_overlay();
473 }
474
475 static void hide_overlay(void) {
476 overlay_mode = 0;
477 memset(overlay_input, 0, sizeof(overlay_input));
478 if (overlay_win) {
479 XUnmapWindow(dpy, overlay_win);
480 }
481 if (focused) {
482 XSetInputFocus(dpy, focused->win, RevertToPointerRoot, CurrentTime);
483 }
484 }
485
486 static void process_overlay_input(void) {
487 if (!focused || overlay_input[0] == 0 || overlay_input[1] == 0) return;
488
489 int r1 = -1, c1 = -1, r2 = -1, c2 = -1;
490 for (int r = 0; r < GRID_ROWS; r++) {
491 for (int c = 0; c < GRID_COLS; c++) {
492 if (grid_chars[r][c] == overlay_input[0]) { r1 = r; c1 = c; }
493 if (grid_chars[r][c] == overlay_input[1]) { r2 = r; c2 = c; }
494 }
495 }
496 if (r1 == -1 || r2 == -1) return;
497
498 if (r1 > r2) { int t = r1; r1 = r2; r2 = t; }
499 if (c1 > c2) { int t = c1; c1 = c2; c2 = t; }
500
501 int cols_span = c2 - c1 + 1;
502 int rows_span = r2 - r1 + 1;
503
504 int cell_w = (sw - padding * (GRID_COLS + 1)) / GRID_COLS;
505 int cell_h = (sh - padding * (GRID_ROWS + 1)) / GRID_ROWS;
506
507 int x = padding + c1 * (cell_w + padding);
508 int y = padding + r1 * (cell_h + padding);
509 int w = cols_span * cell_w + (cols_span - 1) * padding;
510 int h = rows_span * cell_h + (rows_span - 1) * padding;
511
512 resize(focused, x, y, w, h);
513 }
514
515 // Action functions
516 static int sendevent(Client *c, Atom proto) {
517 int n;
518 Atom *protocols;
519 int exists = 0;
520 XEvent ev;
521
522 if (XGetWMProtocols(dpy, c->win, &protocols, &n)) {
523 while (!exists && n--)
524 exists = protocols[n] == proto;
525 XFree(protocols);
526 }
527 if (exists) {
528 ev.type = ClientMessage;
529 ev.xclient.window = c->win;
530 ev.xclient.message_type = wm_protocols;
531 ev.xclient.format = 32;
532 ev.xclient.data.l[0] = proto;
533 ev.xclient.data.l[1] = CurrentTime;
534 XSendEvent(dpy, c->win, False, NoEventMask, &ev);
535 }
536 return exists;
537 }
538
539 static void killclient(const Arg *arg) {
540 if (!focused) return;
541 if (!sendevent(focused, wm_delete_window)) {
542 XGrabServer(dpy);
543 XSetCloseDownMode(dpy, DestroyAll);
544 XKillClient(dpy, focused->win);
545 XSync(dpy, False);
546 XUngrabServer(dpy);
547 }
548 }
549
550 static void setfullscreen(Client *c, int fullscreen) {
551 if (!c) return;
552
553 if (fullscreen && !c->isfullscreen) {
554 // Save current position before going fullscreen
555 c->saved_x = c->x;
556 c->saved_y = c->y;
557 c->saved_w = c->w;
558 c->saved_h = c->h;
559
560 c->isfullscreen = 1;
561
562 // Remove border and set to full screen
563 XSetWindowBorderWidth(dpy, c->win, 0);
564 resize(c, 0, 0, sw, sh);
565 XRaiseWindow(dpy, c->win);
566
567 } else if (!fullscreen && c->isfullscreen) {
568 // Restore saved position
569 c->isfullscreen = 0;
570
571 // Restore border
572 XSetWindowBorderWidth(dpy, c->win, border_width);
573
574 // Restore original position
575 resize(c, c->saved_x, c->saved_y, c->saved_w, c->saved_h);
576 }
577
578 // Update _NET_WM_STATE
579 XEvent ev;
580 ev.type = ClientMessage;
581 ev.xclient.window = c->win;
582 ev.xclient.message_type = XInternAtom(dpy, "_NET_WM_STATE", False);
583 ev.xclient.format = 32;
584 ev.xclient.data.l[0] = fullscreen ? 1 : 0;
585 ev.xclient.data.l[1] = XInternAtom(dpy, "_NET_WM_STATE_FULLSCREEN", False);
586 ev.xclient.data.l[2] = 0;
587 XSendEvent(dpy, root, False, SubstructureNotifyMask | SubstructureRedirectMask, &ev);
588 }
589
590 static void toggle_fullscreen(const Arg *arg) {
591 if (!focused) return;
592 setfullscreen(focused, !focused->isfullscreen);
593 }
594
595 static void spawn(const Arg *arg) {
596 if (fork() == 0) {
597 if (dpy)
598 close(ConnectionNumber(dpy));
599 setsid();
600 execvp(((char **)arg->v)[0], (char **)arg->v);
601 fprintf(stderr, "eowm: execvp %s failed\n", ((char **)arg->v)[0]);
602 exit(1);
603 }
604 }
605
606 static void quit(const Arg *arg) {
607 exit(0);
608 }
609
610 static void cycle_focus(const Arg *arg) {
611 if (!clients) return;
612
613 if (!focused) {
614 focus(clients);
615 return;
616 }
617
618 Client *next = focused->next;
619 if (!next) next = clients;
620
621 focus(next);
622 }
623
624 static void grabkeys(void) {
625 XUngrabKey(dpy, AnyKey, AnyModifier, root);
626 for (unsigned int i = 0; i < sizeof(keys) / sizeof(Key); i++) {
627 KeyCode code = XKeysymToKeycode(dpy, keys[i].keysym);
628 if (code) {
629 XGrabKey(dpy, code, keys[i].mod, root, True,
630 GrabModeAsync, GrabModeAsync);
631 XGrabKey(dpy, code, keys[i].mod | Mod2Mask, root, True,
632 GrabModeAsync, GrabModeAsync);
633 }
634 }
635 }
636
637 static void sigchld(int s) {
638 (void)s;
639 while (waitpid(-1, NULL, WNOHANG) > 0);
640 }
641
642 int xerror_handler(Display *dpy, XErrorEvent *ee) {
643 return 0;
644 }
645
646 static void setup_colors(void) {
647 Visual *visual = DefaultVisual(dpy, DefaultScreen(dpy));
648 Colormap cmap = DefaultColormap(dpy, DefaultScreen(dpy));
649
650 XftColorAllocName(dpy, visual, cmap, col_bg, &xft_col_bg);
651 XftColorAllocName(dpy, visual, cmap, col_fg, &xft_col_fg);
652 XftColorAllocName(dpy, visual, cmap, col_sel, &xft_col_sel);
653
654 font = XftFontOpenName(dpy, DefaultScreen(dpy), "monospace:size=48");
655
656 // Allocate border colors
657 XColor color;
658 XParseColor(dpy, cmap, col_border_normal, &color);
659 XAllocColor(dpy, cmap, &color);
660 border_normal = color.pixel;
661
662 XParseColor(dpy, cmap, col_border_focused, &color);
663 XAllocColor(dpy, cmap, &color);
664 border_focused = color.pixel;
665 }
666
667 static void setup_icccm(void) {
668 wm_protocols = XInternAtom(dpy, "WM_PROTOCOLS", False);
669 wm_delete_window = XInternAtom(dpy, "WM_DELETE_WINDOW", False);
670 wm_state = XInternAtom(dpy, "WM_STATE", False);
671 wm_take_focus = XInternAtom(dpy, "WM_TAKE_FOCUS", False);
672 }
673
674 int main(void) {
675 signal(SIGCHLD, sigchld);
676 if (!(dpy = XOpenDisplay(NULL))) {
677 fprintf(stderr, "eowm: cannot open display\n");
678 exit(1);
679 }
680 XSetErrorHandler(xerror_handler);
681
682 sw = DisplayWidth(dpy, DefaultScreen(dpy));
683 sh = DisplayHeight(dpy, DefaultScreen(dpy));
684 root = RootWindow(dpy, DefaultScreen(dpy));
685
686 setup_colors();
687 setup_icccm();
688
689 XSelectInput(dpy, root,
690 SubstructureRedirectMask | SubstructureNotifyMask |
691 EnterWindowMask | LeaveWindowMask | FocusChangeMask);
692
693 grabkeys();
694
695 XEvent ev;
696 while (1) {
697 XNextEvent(dpy, &ev);
698 switch (ev.type) {
699 case ButtonPress: buttonpress(&ev); break;
700 case ClientMessage: clientmessage(&ev); break;
701 case MapRequest: maprequest(&ev); break;
702 case UnmapNotify: unmapnotify(&ev); break;
703 case DestroyNotify: destroynotify(&ev); break;
704 case EnterNotify: enternotify(&ev); break;
705 case KeyPress: keypress(&ev); break;
706 case Expose: expose(&ev); break;
707 }
708 }
709
710 XCloseDisplay(dpy);
711 return 0;
712 }