Pileus Git - wmpus/blob - sys-x11.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <search.h>
   4
   5 #include <X11/Xlib.h>
   6 #include <X11/Xproto.h>
   7 #include <X11/keysym.h>
   8
   9 #include "util.h"
  10 #include "sys.h"
  11 #include "wm.h"
  12
  13 /* Internal structures */
  14 struct win_sys {
  15         Window   xid;
  16         Display *dpy;
  17 };
  18
  19 typedef struct {
  20         Key_t key;
  21         int   sym;
  22 } keymap_t;
  23
  24 typedef enum {
  25         wm_proto, wm_focus, natoms
  26 } atom_t;
  27
  28 Atom atoms[natoms];
  29
  30 /* Global data */
  31 void *win_cache = NULL;
  32
  33 /* Conversion functions */
  34 keymap_t key2sym[] = {
  35         {key_left    , XK_Left },
  36         {key_right   , XK_Right},
  37         {key_up      , XK_Up   },
  38         {key_down    , XK_Down },
  39         {key_home    , XK_Home },
  40         {key_end     , XK_End  },
  41         {key_pageup  , XK_Prior},
  42         {key_pagedown, XK_Next },
  43         {key_f1      , XK_F1   },
  44         {key_f2      , XK_F2   },
  45         {key_f3      , XK_F3   },
  46         {key_f4      , XK_F4   },
  47         {key_f5      , XK_F5   },
  48         {key_f6      , XK_F6   },
  49         {key_f7      , XK_F7   },
  50         {key_f8      , XK_F8   },
  51         {key_f9      , XK_F9   },
  52         {key_f10     , XK_F10  },
  53         {key_f11     , XK_F11  },
  54         {key_f12     , XK_F12  },
  55 };
  56
  57 /* - Modifiers */
  58 mod_t x2mod(unsigned int state, int up)
  59 {
  60         return (mod_t){
  61                .alt   = !!(state & Mod1Mask   ),
  62                .ctrl  = !!(state & ControlMask),
  63                .shift = !!(state & ShiftMask  ),
  64                .win   = !!(state & Mod4Mask   ),
  65                .up    = up,
  66         };
  67 }
  68
  69 unsigned int mod2x(mod_t mod)
  70 {
  71         return (mod.alt   ? Mod1Mask    : 0)
  72              | (mod.ctrl  ? ControlMask : 0)
  73              | (mod.shift ? ShiftMask   : 0)
  74              | (mod.win   ? Mod4Mask    : 0);
  75 }
  76
  77 /* - Keycodes */
  78 Key_t x2key(KeySym sym)
  79 {
  80         keymap_t *km = map_getr(key2sym,sym);
  81         return km ? km->key : sym;
  82 }
  83
  84 KeySym key2x(Key_t key)
  85 {
  86         keymap_t *km = map_get(key2sym,key);
  87         return km ? km->sym : key;
  88 }
  89
  90 Key_t x2btn(int btn)
  91 {
  92         return btn + key_mouse0;
  93 }
  94
  95 int btn2x(Key_t key)
  96 {
  97         return key - key_mouse0;
  98 }
  99
 100 /* - Pointers */
 101 ptr_t x2ptr(XEvent *_ev)
 102 {
 103         XKeyEvent *ev = &_ev->xkey;
 104         return (ptr_t){ev->x, ev->y, ev->x_root, ev->y_root};
 105 }
 106 Window getfocus(win_t *root, XEvent *event)
 107 {
 108         int revert;
 109         Window focus = PointerRoot;
 110         if (event->type == KeyPress || event->type == KeyRelease)
 111                 XGetInputFocus(root->sys->dpy, &focus, &revert);
 112         if (focus == PointerRoot)
 113                 focus = event->xkey.subwindow;
 114         if (focus == None)
 115                 focus = event->xkey.window;
 116         return focus;
 117 }
 118
 119 /* Helper functions */
 120 win_t *win_new(Display *dpy, Window xid)
 121 {
 122         XWindowAttributes attr;
 123         XGetWindowAttributes(dpy, xid, &attr);
 124         win_t *win    = new0(win_t);
 125         win->x        = attr.x;
 126         win->y        = attr.y;
 127         win->w        = attr.width;
 128         win->h        = attr.height;
 129         win->sys      = new0(win_sys_t);
 130         win->sys->dpy = dpy;
 131         win->sys->xid = xid;
 132         printf("win_new: %p = %p, %d\n", win, dpy, (int)xid);
 133         return win;
 134 }
 135
 136 int win_cmp(const void *_a, const void *_b)
 137 {
 138         const win_t *a = _a, *b = _b;
 139         if (a->sys->dpy < b->sys->dpy) return -1;
 140         if (a->sys->dpy > b->sys->dpy) return  1;
 141         if (a->sys->xid < b->sys->xid) return -1;
 142         if (a->sys->xid > b->sys->xid) return  1;
 143         return 0;
 144 }
 145
 146 win_t *win_find(Display *dpy, Window xid)
 147 {
 148         if (!dpy || !xid)
 149                 return NULL;
 150         //printf("win_find: %p, %d\n", dpy, (int)xid);
 151         win_sys_t sys = {.dpy=dpy, .xid=xid};
 152         win_t     tmp = {.sys=&sys};
 153         return *(win_t**)(tfind(&tmp, &win_cache, win_cmp) ?:
 154                 tsearch(win_new(dpy,xid), &win_cache, win_cmp));
 155 }
 156
 157 void win_remove(win_t *win)
 158 {
 159         tdelete(win, &win_cache, win_cmp);
 160         free(win->sys);
 161         free(win);
 162 }
 163
 164 /* Callbacks */
 165 void process_event(int type, XEvent *ev, win_t *root)
 166 {
 167         Display  *dpy = root->sys->dpy;
 168
 169         /* Common data for all these events ... */
 170         win_t *win = NULL; ptr_t ptr; mod_t mod;
 171         if (type == KeyPress    || type == KeyRelease    ||
 172             type == ButtonPress || type == ButtonRelease ||
 173             type == MotionNotify) {
 174                 Window xid = getfocus(root, ev);
 175                 win = win_find(dpy,xid);
 176                 ptr = x2ptr(ev);
 177                 mod = x2mod(ev->xkey.state, type==KeyRelease||type==ButtonRelease);
 178         }
 179
 180         /* Split based on event */
 181         //printf("event: %d\n", type);
 182         if (type == KeyPress) {
 183                 while (XCheckTypedEvent(dpy, KeyPress, ev));
 184                 KeySym sym = XKeycodeToKeysym(dpy, ev->xkey.keycode, 0);
 185                 wm_handle_key(win, x2key(sym), mod, ptr);
 186         }
 187         else if (type == KeyRelease) {
 188                 //printf("release: %d\n", type);
 189         }
 190         else if (type == ButtonPress) {
 191                 wm_handle_key(win, x2btn(ev->xbutton.button), mod, ptr);
 192                 XGrabPointer(dpy, win->sys->xid, True, PointerMotionMask|ButtonReleaseMask,
 193                                 GrabModeAsync, GrabModeAsync, None, None, CurrentTime);
 194         }
 195         else if (type == ButtonRelease) {
 196                 XUngrabPointer(dpy, CurrentTime);
 197                 wm_handle_key(win, x2btn(ev->xbutton.button), mod, ptr);
 198         }
 199         else if (type == MotionNotify) {
 200                 while (XCheckTypedEvent(dpy, MotionNotify, ev));
 201                 wm_handle_ptr(win, ptr);
 202         }
 203         else if (type == ConfigureNotify) {
 204                 //printf("configure: %d\n", type);
 205         }
 206         else if (type == MapNotify) {
 207                 //printf("map: %d\n", type);
 208         }
 209         else if (type == DestroyNotify) {
 210                 //printf("destory: %d\n", type);
 211                 win_remove(win_find(dpy,ev->xdestroywindow.window));
 212         }
 213         else if (type == UnmapNotify) {
 214                 //printf("unmap: %d\n", type);
 215                 wm_remove(win_find(dpy,ev->xmap.window));
 216         }
 217         else if (type == ConfigureRequest) {
 218                 XConfigureRequestEvent *cre = &ev->xconfigurerequest;
 219                 XWindowChanges wc = {
 220                         .x     = cre->x,     .y      = cre->y,
 221                         .width = cre->width, .height = cre->height,
 222                 };
 223                 printf("configure_req: %d - %x, (0x%lx) %dx%d @ %d,%d\n",
 224                                 type, (int)cre->window, cre->value_mask,
 225                                 cre->height, cre->width, cre->x, cre->y);
 226                 XConfigureWindow(dpy, cre->window, cre->value_mask, &wc);
 227         }
 228         else if (type == MapRequest) {
 229                 printf("map_req: %d\n", type);
 230                 wm_insert(win_find(dpy,ev->xmaprequest.window));
 231                 XMapWindow(dpy,ev->xmaprequest.window);
 232         }
 233         else {
 234                 printf("unknown event: %d\n", type);
 235         }
 236 }
 237
 238 /*****************
 239  * Sys functions *
 240  *****************/
 241 void sys_move(win_t *win, int x, int y, int w, int h)
 242 {
 243         //printf("sys_move: %p - %d,%d  %dx%d\n", win, x, y, w, h);
 244         win->x = x; win->y = y;
 245         win->w = w; win->h = h;
 246         XMoveResizeWindow(win->sys->dpy, win->sys->xid, x, y, w, h);
 247 }
 248
 249 void sys_raise(win_t *win)
 250 {
 251         //printf("sys_raise: %p\n", win);
 252         XRaiseWindow(win->sys->dpy, win->sys->xid);
 253 }
 254
 255 void sys_focus(win_t *win)
 256 {
 257         //printf("sys_raise: %p\n", win);
 258         XEvent ev = {
 259                 .type                 = ClientMessage,
 260                 .xclient.window       = win->sys->xid,
 261                 .xclient.message_type = atoms[wm_proto],
 262                 .xclient.format       = 32,
 263                 .xclient.data.l[0]    = atoms[wm_focus],
 264                 .xclient.data.l[1]    = CurrentTime,
 265         };
 266         XSetInputFocus(win->sys->dpy, win->sys->xid,
 267                         RevertToPointerRoot, CurrentTime);
 268         //XSetInputFocus(win->sys->dpy, PointerRoot,
 269         //              RevertToPointerRoot, CurrentTime);
 270         XSendEvent(win->sys->dpy, win->sys->xid, False, NoEventMask, &ev);
 271 }
 272
 273 void sys_watch(win_t *win, Key_t key, mod_t mod)
 274 {
 275         //printf("sys_watch: %p - %x %hhx\n", win, key, mod);
 276         if (key_mouse0 <= key && key <= key_mouse7)
 277                 XGrabButton(win->sys->dpy, btn2x(key), mod2x(mod), win->sys->xid, True,
 278                                 mod.up ? ButtonReleaseMask : ButtonPressMask,
 279                                 GrabModeAsync, GrabModeAsync, None, None);
 280         else
 281                 XGrabKey(win->sys->dpy, XKeysymToKeycode(win->sys->dpy, key2x(key)),
 282                                 mod2x(mod), win->sys->xid, True, GrabModeAsync, GrabModeAsync);
 283 }
 284
 285 win_t *sys_init(void)
 286 {
 287         Display *dpy = XOpenDisplay(NULL);
 288         Window   xid = DefaultRootWindow(dpy);
 289         atoms[wm_proto] = XInternAtom(dpy, "WM_PROTOCOLS",  False);
 290         atoms[wm_focus] = XInternAtom(dpy, "WM_TAKE_FOCUS", False);
 291         XSelectInput(dpy, xid, SubstructureNotifyMask|SubstructureRedirectMask);
 292         return win_find(dpy, xid);
 293 }
 294
 295 void sys_run(win_t *root)
 296 {
 297         /* Add each initial window */
 298         unsigned int nkids;
 299         Window par, win, *kids = NULL;
 300         if (XQueryTree(root->sys->dpy, root->sys->xid,
 301                                 &par, &win, &kids, &nkids))
 302                 for(int i = 0; i < nkids; i++)
 303                         wm_insert(win_find(root->sys->dpy, kids[i]));
 304
 305         /* Main loop */
 306         for(;;)
 307         {
 308                 XEvent ev;
 309                 XNextEvent(root->sys->dpy, &ev);
 310                 process_event(ev.type, &ev, root);
 311         }
 312 }