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

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3
   4 #include <X11/Xlib.h>
   5 #include <X11/Xproto.h>
   6 #include <X11/keysym.h>
   7
   8 #include "util.h"
   9 #include "sys.h"
  10 #include "wm.h"
  11
  12 /* Internal structures */
  13 struct win_sys {
  14         Window   win;
  15         Display *dpy;
  16 };
  17
  18 typedef struct {
  19         Key_t key;
  20         int   sym;
  21 } keymap_t;
  22
  23 /* Conversion functions */
  24 keymap_t key2sym[] = {
  25         {key_left    , XK_Left },
  26         {key_right   , XK_Right},
  27         {key_up      , XK_Up   },
  28         {key_down    , XK_Down },
  29         {key_home    , XK_Home },
  30         {key_end     , XK_End  },
  31         {key_pageup  , XK_Prior},
  32         {key_pagedown, XK_Next },
  33         {key_f1      , XK_F1   },
  34         {key_f2      , XK_F2   },
  35         {key_f3      , XK_F3   },
  36         {key_f4      , XK_F4   },
  37         {key_f5      , XK_F5   },
  38         {key_f6      , XK_F6   },
  39         {key_f7      , XK_F7   },
  40         {key_f8      , XK_F8   },
  41         {key_f9      , XK_F9   },
  42         {key_f10     , XK_F10  },
  43         {key_f11     , XK_F11  },
  44         {key_f12     , XK_F12  },
  45 };
  46
  47 /* - Modifiers */
  48 mod_t x2mod(unsigned int state, int up)
  49 {
  50         return (mod_t){
  51                .alt   = !!(state & Mod1Mask   ),
  52                .ctrl  = !!(state & ControlMask),
  53                .shift = !!(state & ShiftMask  ),
  54                .win   = !!(state & Mod4Mask   ),
  55                .up    = up,
  56         };
  57 }
  58
  59 unsigned int mod2x(mod_t mod)
  60 {
  61         return mod.alt   ? Mod1Mask    : 0
  62              | mod.ctrl  ? ControlMask : 0
  63              | mod.shift ? ShiftMask   : 0
  64              | mod.win   ? Mod4Mask    : 0;
  65 }
  66
  67 /* - Keycodes */
  68 Key_t x2key(KeySym sym)
  69 {
  70         keymap_t *km = map_getr(key2sym,sym);
  71         return km ? km->key : sym;
  72 }
  73
  74 KeySym key2x(Key_t key)
  75 {
  76         keymap_t *km = map_get(key2sym,key);
  77         return km ? km->sym : key;
  78 }
  79
  80 Key_t x2btn(int btn)
  81 {
  82         return btn + key_mouse0;
  83 }
  84
  85 int btn2x(Key_t key)
  86 {
  87         return key - key_mouse0;
  88 }
  89
  90 /* - Pointers */
  91 ptr_t x2ptr(XEvent _ev)
  92 {
  93         XKeyEvent ev = _ev.xkey;
  94         return (ptr_t){ev.x, ev.y, ev.x_root, ev.y_root};
  95 }
  96
  97 /* Helper functions */
  98 win_t *win_new(Display *xdpy, Window xwin)
  99 {
 100         if (!xdpy || !xwin)
 101                 return NULL;
 102         XWindowAttributes attr;
 103         XGetWindowAttributes(xdpy, xwin, &attr);
 104         win_t *win    = new0(win_t);
 105         win->x        = attr.x;
 106         win->y        = attr.y;
 107         win->w        = attr.width;
 108         win->h        = attr.height;
 109         win->sys      = new0(win_sys_t);
 110         win->sys->dpy = xdpy;
 111         win->sys->win = xwin;
 112         return win;
 113 }
 114
 115 void win_free(win_t *win)
 116 {
 117         free(win->sys);
 118         free(win);
 119 }
 120
 121 /*****************
 122  * Sys functions *
 123  *****************/
 124 void sys_move(win_t *win, int x, int y, int w, int h)
 125 {
 126         printf("sys_move: %p - %d,%d  %dx%d\n", win, x, y, w, h);
 127         XMoveResizeWindow(win->sys->dpy, win->sys->win, x, y, w, h);
 128 }
 129
 130 void sys_raise(win_t *win)
 131 {
 132         printf("sys_raise: %p\n", win);
 133         XRaiseWindow(win->sys->dpy, win->sys->win);
 134 }
 135
 136 void sys_watch(win_t *win, Key_t key, mod_t mod)
 137 {
 138         if (key_mouse0 <= key && key <= key_mouse7)
 139                 XGrabButton(win->sys->dpy, btn2x(key), mod2x(mod), win->sys->win, True,
 140                                 mod.up ? ButtonReleaseMask : ButtonPressMask,
 141                                 GrabModeAsync, GrabModeAsync, None, None);
 142         else
 143                 XGrabKey(win->sys->dpy, XKeysymToKeycode(win->sys->dpy, key2x(key)),
 144                                 mod2x(mod), win->sys->win, True, GrabModeAsync, GrabModeAsync);
 145 }
 146
 147 win_t *sys_init(void)
 148 {
 149         Display *xdpy = XOpenDisplay(NULL);
 150         Window   xwin = DefaultRootWindow(xdpy);
 151         return win_new(xdpy, xwin);
 152 }
 153
 154 void sys_run(win_t *root)
 155 {
 156         Display *dpy = root->sys->dpy;
 157         for(;;)
 158         {
 159                 XEvent ev;
 160                 XNextEvent(dpy, &ev);
 161                 //printf("event: %d\n", ev.type);
 162                 if (ev.type == KeyPress) {
 163                         while (XCheckTypedEvent(dpy, KeyPress, &ev));
 164                         KeySym sym = XKeycodeToKeysym(dpy, ev.xkey.keycode, 0);
 165                         wm_handle_key(win_new(dpy, ev.xkey.subwindow),
 166                                         x2key(sym), x2mod(ev.xkey.state,0), x2ptr(ev));
 167                 }
 168                 else if (ev.type == ButtonPress) {
 169                         wm_handle_key(win_new(dpy, ev.xkey.subwindow),
 170                                         x2btn(ev.xbutton.button),
 171                                         x2mod(ev.xbutton.state,0), x2ptr(ev));
 172                         XGrabPointer(dpy, ev.xkey.subwindow, True,
 173                                         PointerMotionMask|ButtonReleaseMask, GrabModeAsync,
 174                                         GrabModeAsync, None, None, CurrentTime);
 175                 }
 176                 else if(ev.type == ButtonRelease) {
 177                         XUngrabPointer(dpy, CurrentTime);
 178                         wm_handle_key(win_new(dpy, ev.xkey.subwindow),
 179                                         x2btn(ev.xbutton.button),
 180                                         x2mod(ev.xbutton.state,1), x2ptr(ev));
 181                 }
 182                 else if(ev.type == MotionNotify) {
 183                         while (XCheckTypedEvent(dpy, MotionNotify, &ev));
 184                         wm_handle_ptr(win_new(dpy, ev.xkey.subwindow), x2ptr(ev));
 185                 }
 186         }
 187 }