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