X-Git-Url: http://pileus.org/git/?p=wmpus;a=blobdiff_plain;f=sys-x11.c;h=7020e38deeb65b377e011be03b0078c6737486f8;hp=16cbe632ec799c53e9ef158e9ad12f5e7b72d84b;hb=6676472c287a8163d53b2ba14ca8ec39bf7443eb;hpb=d7d862c402564b4fe29f17e1a55cdbb2967aa6fd diff --git a/sys-x11.c b/sys-x11.c index 16cbe63..7020e38 100644 --- a/sys-x11.c +++ b/sys-x11.c @@ -1,170 +1,692 @@ +/* + * Copyright (c) 2011-2012, Andy Spencer + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + */ + +#define _GNU_SOURCE #include #include +#include #include #include +#include #include +#include #include "util.h" +#include "conf.h" #include "sys.h" #include "wm.h" +/* Configuration */ +static int border = 2; +static int no_capture = 0; + /* Internal structures */ struct win_sys { - Window win; + Window xid; Display *dpy; + struct { + int left, right, top, bottom; + } strut; + state_t state; }; +typedef struct { + event_t ev; + int sym; +} event_map_t; + +typedef enum { + WM_PROTO, WM_FOCUS, + NET_STATE, NET_FULL, NET_STRUT, + NATOMS +} atom_t; + +typedef enum { + CLR_FOCUS, CLR_UNFOCUS, CLR_URGENT, NCOLORS +} color_t; + +/* Global data */ +static int running; +static void *cache; +static Atom atoms[NATOMS]; +static int (*xerrorxlib)(Display *, XErrorEvent *); +static unsigned long colors[NCOLORS]; +static list_t *screens; +static list_t *struts; + /* Conversion functions */ -struct { - Key_t key; - int sym; -} key2sym[] = { - {key_left , XK_Left }, - {key_right , XK_Right}, - {key_up , XK_Up }, - {key_down , XK_Down }, - {key_home , XK_Home }, - {key_end , XK_End }, - {key_pageup , XK_Prior}, - {key_pagedown, XK_Next }, - {key_f1 , XK_F1 }, - {key_f2 , XK_F2 }, - {key_f3 , XK_F3 }, - {key_f4 , XK_F4 }, - {key_f5 , XK_F5 }, - {key_f6 , XK_F6 }, - {key_f7 , XK_F7 }, - {key_f8 , XK_F8 }, - {key_f9 , XK_F9 }, - {key_f10 , XK_F10 }, - {key_f11 , XK_F11 }, - {key_f12 , XK_F12 }, +static event_map_t ev2sym[] = { + {EV_LEFT , XK_Left }, + {EV_RIGHT , XK_Right}, + {EV_UP , XK_Up }, + {EV_DOWN , XK_Down }, + {EV_HOME , XK_Home }, + {EV_END , XK_End }, + {EV_PAGEUP , XK_Prior}, + {EV_PAGEDOWN, XK_Next }, + {EV_F1 , XK_F1 }, + {EV_F2 , XK_F2 }, + {EV_F3 , XK_F3 }, + {EV_F4 , XK_F4 }, + {EV_F5 , XK_F5 }, + {EV_F6 , XK_F6 }, + {EV_F7 , XK_F7 }, + {EV_F8 , XK_F8 }, + {EV_F9 , XK_F9 }, + {EV_F10 , XK_F10 }, + {EV_F11 , XK_F11 }, + {EV_F12 , XK_F12 }, }; -mod_t x2mod(unsigned int state) +/* - Modifiers */ +static mod_t x2mod(unsigned int state, int up) { return (mod_t){ .alt = !!(state & Mod1Mask ), .ctrl = !!(state & ControlMask), .shift = !!(state & ShiftMask ), .win = !!(state & Mod4Mask ), + .up = up, }; } -unsigned int mod2x(mod_t mod) + +static unsigned int mod2x(mod_t mod) { - return mod.alt ? Mod1Mask : 0 - | mod.ctrl ? ControlMask : 0 - | mod.shift ? ShiftMask : 0 - | mod.win ? Mod4Mask : 0; + return (mod.alt ? Mod1Mask : 0) + | (mod.ctrl ? ControlMask : 0) + | (mod.shift ? ShiftMask : 0) + | (mod.win ? Mod4Mask : 0); } -KeySym key2x(Key_t key) +/* - Keycodes */ +static event_t xk2ev(KeySym sym) { - return map_get(key2sym,key)->sym ?: key; + event_map_t *em = map_getr(ev2sym,sym); + return em ? em->ev : sym; } -Key_t x2key(KeySym sym) + +static KeySym ev2xk(event_t ev) { - return map_getr(key2sym,sym)->key ?: sym; + event_map_t *em = map_get(ev2sym,ev); + return em ? em->sym : ev; } -int btn2x(Key_t key) +static event_t xb2ev(int btn) { - return key - key_mouse0; + return btn + EV_MOUSE0; } -Key_t x2btn(int btn) + +static int ev2xb(event_t ev) { - return btn + key_mouse0; + return ev - EV_MOUSE0; } -ptr_t x2ptr(XEvent _ev) +/* - Pointers */ +static ptr_t x2ptr(XEvent *xe) { - XKeyEvent ev = _ev.xkey; - return (ptr_t){ev.x, ev.y, ev.x_root, ev.y_root}; + XKeyEvent *xke = &xe->xkey; + return (ptr_t){xke->x, xke->y, xke->x_root, xke->y_root}; } -/* Functions */ -void sys_move(win_t *win, int x, int y, int w, int h) +static Window getfocus(win_t *root, XEvent *xe) { - printf("sys_move: %p - %d,%d %dx%d\n", win, x, y, w, h); - XMoveResizeWindow(win->sys->dpy, win->sys->win, x, y, w, h); + int revert; + Window focus = PointerRoot; + if (xe->type == KeyPress || xe->type == KeyRelease) + XGetInputFocus(root->sys->dpy, &focus, &revert); + if (focus == PointerRoot) + focus = xe->xkey.subwindow; + if (focus == None) + focus = xe->xkey.window; + return focus; } -void sys_raise(win_t *win) +/* Strut functions + * Struts are spaces at the edges of the screen that are used by + * toolbars and statusbars such as dzen. */ +static int strut_copy(win_t *to, win_t *from, int scale) { - printf("sys_raise: %p\n", win); - XRaiseWindow(win->sys->dpy, win->sys->win); + int left = from->sys->strut.left; + int right = from->sys->strut.right; + int top = from->sys->strut.top; + int bottom = from->sys->strut.bottom; + if (left == 0 && right == 0 && top == 0 && bottom == 0) + return 0; + to->x += scale*(left ); + to->y += scale*(top ); + to->w -= scale*(left+right); + to->h -= scale*(top+bottom); + to->sys->strut.left += scale*left; + to->sys->strut.right += scale*right; + to->sys->strut.top += scale*top; + to->sys->strut.bottom += scale*bottom; + return 1; } -void sys_watch(win_t *win, Key_t key, mod_t mod) +static int strut_add(win_t *root, win_t *win) { - if (key_mouse0 <= key && key <= key_mouse7) - XGrabButton(win->sys->dpy, btn2x(key), mod2x(mod), win->sys->win, True, - mod.up ? ButtonReleaseMask : ButtonPressMask, - GrabModeAsync, GrabModeAsync, None, None); - else - XGrabKey(win->sys->dpy, XKeysymToKeycode(win->sys->dpy, key2x(key)), - mod2x(mod), win->sys->win, True, GrabModeAsync, GrabModeAsync); + /* Get X11 strut data */ + Atom ret_type; + int ret_size; + unsigned long ret_items, bytes_left; + unsigned char *xdata; + int status = XGetWindowProperty(win->sys->dpy, win->sys->xid, + atoms[NET_STRUT], 0L, 4L, False, XA_CARDINAL, + &ret_type, &ret_size, &ret_items, &bytes_left, &xdata); + if (status != Success || ret_size != 32 || ret_items != 4) + return 0; + + win->sys->strut.left = ((int*)xdata)[0]; + win->sys->strut.right = ((int*)xdata)[1]; + win->sys->strut.top = ((int*)xdata)[2]; + win->sys->strut.bottom = ((int*)xdata)[3]; + struts = list_insert(struts, win); + for (list_t *cur = screens; cur; cur = cur->next) + strut_copy(cur->data, win, 1); + return strut_copy(root, win, 1); } -win_t *win_new(Display *xdpy, Window xwin) +static int strut_del(win_t *root, win_t *win) +{ + list_t *lwin = list_find(struts, win); + if (lwin) + struts = list_remove(struts, lwin, 0); + for (list_t *cur = screens; cur; cur = cur->next) + strut_copy(cur->data, win, -1); + return strut_copy(root, win, -1); +} + +#if 0 +static int is_fullscreen(win_t *win) +{ + Atom ret_type; + int ret_size; + unsigned long ret_items, bytes_left; + unsigned char *xdata; + int status = XGetWindowProperty(win->sys->dpy, win->sys->xid, + atoms[NET_FULL], 0L, 1L, False, XA_ATOM, + &ret_type, &ret_size, &ret_items, &bytes_left, &xdata); + printf("is_fullscreen:\n"); + printf("\t%d\n", status); + printf("\t%d\n", ret_size); + printf("\t%ld\n", ret_items); + printf("\t%p\n", xdata); + if (xdata) + printf("\t%d\n", xdata[0]); + return status == Success && ret_size == 32 && ret_items == 1 && + xdata[0] == atoms[NET_FULL]; +} +#endif + +/* Window functions */ +static win_t *win_new(Display *dpy, Window xid) { - if (!xdpy || !xwin) - return NULL; XWindowAttributes attr; - XGetWindowAttributes(xdpy, xwin, &attr); + if (XGetWindowAttributes(dpy, xid, &attr)) + if (attr.override_redirect) + return NULL; win_t *win = new0(win_t); win->x = attr.x; win->y = attr.y; win->w = attr.width; win->h = attr.height; win->sys = new0(win_sys_t); - win->sys->dpy = xdpy; - win->sys->win = xwin; + win->sys->dpy = dpy; + win->sys->xid = xid; + printf("win_new: %p = %p, %d (%d,%d %dx%d)\n", + win, dpy, (int)xid, + win->x, win->y, win->w, win->h); return win; } -void win_free(win_t *win) + +static int win_cmp(const void *_a, const void *_b) +{ + const win_t *a = _a, *b = _b; + if (a->sys->dpy < b->sys->dpy) return -1; + if (a->sys->dpy > b->sys->dpy) return 1; + if (a->sys->xid < b->sys->xid) return -1; + if (a->sys->xid > b->sys->xid) return 1; + return 0; +} + +static win_t *win_find(Display *dpy, Window xid, int create) +{ + if (!dpy || !xid) + return NULL; + //printf("win_find: %p, %d\n", dpy, (int)xid); + win_sys_t sys = {.dpy=dpy, .xid=xid}; + win_t tmp = {.sys=&sys}; + win_t **old = NULL, *new = NULL; + if ((old = tfind(&tmp, &cache, win_cmp))) + return *old; + if (create && (new = win_new(dpy,xid))) + tsearch(new, &cache, win_cmp); + return new; +} + +static void win_free(win_t *win) { free(win->sys); free(win); } -win_t *sys_init(void) +static void win_remove(win_t *win) { - Display *xdpy = XOpenDisplay(NULL); - Window xwin = DefaultRootWindow(xdpy); - return win_new(xdpy, xwin); + tdelete(win, &cache, win_cmp); + win_free(win); } -void sys_run(win_t *root) +static int win_viewable(win_t *win) { - Display *dpy = root->sys->dpy; - for(;;) - { - XEvent ev; - XNextEvent(dpy, &ev); - //printf("event: %d\n", ev.type); - if (ev.type == KeyPress && ev.xkey.subwindow) { - while (XCheckTypedEvent(dpy, KeyPress, &ev)); - KeySym sym = XKeycodeToKeysym(dpy, ev.xkey.keycode, 0); - wm_handle_key(win_new(dpy, ev.xkey.subwindow), - x2key(sym), x2mod(ev.xkey.state), x2ptr(ev)); + XWindowAttributes attr; + if (XGetWindowAttributes(win->sys->dpy, win->sys->xid, &attr)) + return attr.map_state == IsViewable; + else + return True; +} + +/* Drawing functions */ +static unsigned long get_color(Display *dpy, const char *name) +{ + XColor color; + int screen = DefaultScreen(dpy); + Colormap cmap = DefaultColormap(dpy, screen); + XAllocNamedColor(dpy, cmap, name, &color, &color); + return color.pixel; +} + +/* Callbacks */ +static void process_event(int type, XEvent *xe, win_t *root) +{ + Display *dpy = root->sys->dpy; + win_t *win = NULL; + //printf("event: %d\n", type); + + /* Common data for all these events ... */ + ptr_t ptr = {}; mod_t mod = {}; + if (type == KeyPress || type == KeyRelease || + type == ButtonPress || type == ButtonRelease || + type == MotionNotify) { + Window xid = getfocus(root, xe); + if (!(win = win_find(dpy,xid,0))) + return; + ptr = x2ptr(xe); + mod = x2mod(xe->xkey.state, type==KeyRelease||type==ButtonRelease); + } + + /* Split based on event */ + if (type == KeyPress) { + while (XCheckTypedEvent(dpy, KeyPress, xe)); + KeySym sym = XKeycodeToKeysym(dpy, xe->xkey.keycode, 0); + printf("got xe %c %hhx\n", xk2ev(sym), mod2int(mod)); + wm_handle_event(win, xk2ev(sym), mod, ptr); + } + else if (type == KeyRelease) { + //printf("release: %d\n", type); + } + else if (type == ButtonPress) { + if (wm_handle_event(win, xb2ev(xe->xbutton.button), mod, ptr)) + XGrabPointer(dpy, xe->xbutton.root, True, PointerMotionMask|ButtonReleaseMask, + GrabModeAsync, GrabModeAsync, None, None, CurrentTime); + else + XAllowEvents(win->sys->dpy, ReplayPointer, CurrentTime); + } + else if (type == ButtonRelease) { + XUngrabPointer(dpy, CurrentTime); + wm_handle_event(win, xb2ev(xe->xbutton.button), mod, ptr); + } + else if (type == MotionNotify) { + while (XCheckTypedEvent(dpy, MotionNotify, xe)); + wm_handle_ptr(win, ptr); + } + else if (type == EnterNotify || type == LeaveNotify) { + printf("%s: %d\n", type==EnterNotify?"enter":"leave", type); + event_t ev = EnterNotify ? EV_ENTER : EV_LEAVE; + if ((win = win_find(dpy,xe->xcrossing.window,0))) + wm_handle_event(win, ev, MOD(), PTR()); + } + else if (type == FocusIn || type == FocusOut) { + //printf("focus: %d\n", type); + event_t ev = FocusIn ? EV_FOCUS : EV_UNFOCUS; + if ((win = win_find(dpy,xe->xfocus.window,0))) + wm_handle_event(win, ev, MOD(), PTR()); + } + else if (type == ConfigureNotify) { + printf("configure: %d\n", type); + } + else if (type == MapNotify) { + printf("map: %d\n", type); + } + else if (type == UnmapNotify) { + if ((win = win_find(dpy,xe->xunmap.window,0)) && + win->sys->state != ST_HIDE) { + if (!strut_del(root, win)) + wm_remove(win); + else + wm_update(); + win->sys->state = ST_HIDE; } - else if (ev.type == ButtonPress && ev.xbutton.subwindow) { - wm_handle_key(win_new(dpy, ev.xkey.subwindow), - x2btn(ev.xbutton.button), MOD(.up=0), x2ptr(ev)); - XGrabPointer(dpy, ev.xkey.subwindow, True, - PointerMotionMask|ButtonReleaseMask, GrabModeAsync, - GrabModeAsync, None, None, CurrentTime); + } + else if (type == DestroyNotify) { + //printf("destroy: %d\n", type); + if ((win = win_find(dpy,xe->xdestroywindow.window,0))) + win_remove(win); + } + else if (type == ConfigureRequest) { + XConfigureRequestEvent *cre = &xe->xconfigurerequest; + printf("configure_req: %d - %x, (0x%lx) %dx%d @ %d,%d\n", + type, (int)cre->window, cre->value_mask, + cre->height, cre->width, cre->x, cre->y); + if ((win = win_find(dpy,xe->xmaprequest.window,1))) { + XSendEvent(dpy, cre->window, False, StructureNotifyMask, &(XEvent){ + .xconfigure.type = ConfigureNotify, + .xconfigure.display = win->sys->dpy, + .xconfigure.event = win->sys->xid, + .xconfigure.window = win->sys->xid, + .xconfigure.x = win->x, + .xconfigure.y = win->y, + .xconfigure.width = win->w, + .xconfigure.height = win->h, + .xconfigure.border_width = border, + }); + XSync(win->sys->dpy, False); + } + } + else if (type == MapRequest) { + printf("map_req: %d\n", type); + if ((win = win_find(dpy,xe->xmaprequest.window,1))) { + XSelectInput(win->sys->dpy, win->sys->xid, PropertyChangeMask); + if (!strut_add(root, win)) + wm_insert(win); + else + wm_update(); + } + XMapWindow(dpy, xe->xmaprequest.window); + } + else if (type == ClientMessage) { + printf("msg: %d\n", type); + XClientMessageEvent *cme = &xe->xclient; + if ((win = win_find(dpy,cme->window,0)) && + (cme->message_type == atoms[NET_STATE]) && + (cme->data.l[1] == atoms[NET_FULL] || + cme->data.l[2] == atoms[NET_FULL])) { + if (cme->data.l[0] == 1 || /* _NET_WM_STATE_ADD */ + (cme->data.l[0] == 2 && /* _NET_WM_STATE_TOGGLE */ + win->sys->state != ST_FULL)) + sys_show(win, ST_FULL); + else + sys_show(win, ST_SHOW); + } + } + else if (type == PropertyNotify) { + printf("prop: %d\n", type); + } + else { + printf("unknown event: %d\n", type); + } +} + +static int xerror(Display *dpy, XErrorEvent *err) +{ + if (err->error_code == BadWindow || + (err->request_code == X_SetInputFocus && err->error_code == BadMatch ) || + (err->request_code == X_PolyText8 && err->error_code == BadDrawable) || + (err->request_code == X_PolyFillRectangle && err->error_code == BadDrawable) || + (err->request_code == X_PolySegment && err->error_code == BadDrawable) || + (err->request_code == X_ConfigureWindow && err->error_code == BadMatch ) || + (err->request_code == X_GrabButton && err->error_code == BadAccess ) || + (err->request_code == X_GrabKey && err->error_code == BadAccess ) || + (err->request_code == X_CopyArea && err->error_code == BadDrawable)) + return 0; + if (err->request_code == X_ChangeWindowAttributes && err->error_code == BadAccess) + error("Another window manager is already running"); + return xerrorxlib(dpy, err); +} + +/******************** + * System functions * + ********************/ +void sys_move(win_t *win, int x, int y, int w, int h) +{ + //printf("sys_move: %p - %d,%d %dx%d\n", win, x, y, w, h); + int b = 2*border; + win->x = x; win->y = y; + win->w = MAX(w,1+b); win->h = MAX(h,1+b); + w = MAX(w-b,1); h = MAX(h-b,1); + XMoveResizeWindow(win->sys->dpy, win->sys->xid, x, y, w, h); + + /* Flush events, so moving window doesn't cause re-focus + * There's probably a better way to do this */ + XEvent xe; + XSync(win->sys->dpy, False); + while (XCheckMaskEvent(win->sys->dpy, EnterWindowMask|LeaveWindowMask, &xe)) + printf("Skipping enter/leave event\n"); +} + +void sys_raise(win_t *win) +{ + //printf("sys_raise: %p\n", win); + XRaiseWindow(win->sys->dpy, win->sys->xid); + for (list_t *cur = struts; cur; cur = cur->next) + XRaiseWindow(((win_t*)cur->data)->sys->dpy, + ((win_t*)cur->data)->sys->xid); +} + +void sys_focus(win_t *win) +{ + printf("sys_focus: %p\n", win); + + /* Set actual focus */ + XSetInputFocus(win->sys->dpy, win->sys->xid, + RevertToPointerRoot, CurrentTime); + XSendEvent(win->sys->dpy, win->sys->xid, False, NoEventMask, &(XEvent){ + .type = ClientMessage, + .xclient.window = win->sys->xid, + .xclient.message_type = atoms[WM_PROTO], + .xclient.format = 32, + .xclient.data.l[0] = atoms[WM_FOCUS], + .xclient.data.l[1] = CurrentTime, + }); + + /* Set border on focused window */ + static win_t *last = NULL; + if (last) + XSetWindowBorder(last->sys->dpy, last->sys->xid, colors[CLR_UNFOCUS]); + XSync(win->sys->dpy, False); + XSetWindowBorder(win->sys->dpy, win->sys->xid, colors[CLR_FOCUS]); + last = win; +} + +void sys_show(win_t *win, state_t state) +{ + /* Restore from fullscreen */ + switch (state) { + case ST_SHOW: + printf("sys_show: show\n"); + if (win->sys->state == ST_FULL) + sys_move(win, win->x, win->y, win->w, win->h); + XSetWindowBorderWidth(win->sys->dpy, win->sys->xid, border); + XMapWindow(win->sys->dpy, win->sys->xid); + XSync(win->sys->dpy, False); + break; + case ST_FULL: + printf("sys_show: full\n"); + win_t *screen = NULL; + for (list_t *cur = screens; cur; cur = cur->next) { + screen = cur->data; + if (win->x >= screen->x && win->x <= screen->x+screen->w && + win->y >= screen->y && win->y <= screen->y+screen->h) + break; } - else if(ev.type == ButtonRelease) { - XUngrabPointer(dpy, CurrentTime); - wm_handle_key(win_new(dpy, ev.xkey.subwindow), - x2btn(ev.xbutton.button), MOD(.up=1), x2ptr(ev)); + XSetWindowBorderWidth(win->sys->dpy, win->sys->xid, 0); + XMapWindow(win->sys->dpy, win->sys->xid); + XMoveResizeWindow(win->sys->dpy, win->sys->xid, + screen->x - screen->sys->strut.left, + screen->y - screen->sys->strut.top, + screen->w + screen->sys->strut.left + screen->sys->strut.right, + screen->h + screen->sys->strut.top + screen->sys->strut.bottom); + XRaiseWindow(win->sys->dpy, win->sys->xid); + break; + case ST_SHADE: + printf("sys_show: shade\n"); + XMapWindow(win->sys->dpy, win->sys->xid); + break; + case ST_ICON: + printf("sys_show: icon\n"); + break; + case ST_HIDE: + printf("sys_show: hide\n"); + XUnmapWindow(win->sys->dpy, win->sys->xid); + break; + case ST_CLOSE: + printf("sys_show: close\n"); + XDestroyWindow(win->sys->dpy, win->sys->xid); + break; + } + win->sys->state = state; +} + +void sys_watch(win_t *win, event_t ev, mod_t mod) +{ + //printf("sys_watch: %p - %x %hhx\n", win, ev, mod); + XWindowAttributes attr; + XGetWindowAttributes(win->sys->dpy, win->sys->xid, &attr); + long mask = attr.your_event_mask; + if (EV_MOUSE0 <= ev && ev <= EV_MOUSE7) + XGrabButton(win->sys->dpy, ev2xb(ev), mod2x(mod), win->sys->xid, False, + mod.up ? ButtonReleaseMask : ButtonPressMask, + GrabModeSync, GrabModeAsync, None, None); + else if (ev == EV_ENTER) + XSelectInput(win->sys->dpy, win->sys->xid, EnterWindowMask|mask); + else if (ev == EV_LEAVE) + XSelectInput(win->sys->dpy, win->sys->xid, LeaveWindowMask|mask); + else if (ev == EV_FOCUS || ev == EV_UNFOCUS) + XSelectInput(win->sys->dpy, win->sys->xid, FocusChangeMask|mask); + else + XGrabKey(win->sys->dpy, XKeysymToKeycode(win->sys->dpy, ev2xk(ev)), + mod2x(mod), win->sys->xid, True, GrabModeAsync, GrabModeAsync); +} + +void sys_unwatch(win_t *win, event_t ev, mod_t mod) +{ + if (EV_MOUSE0 <= ev && ev <= EV_MOUSE7) + XUngrabButton(win->sys->dpy, ev2xb(ev), mod2x(mod), win->sys->xid); +} + +list_t *sys_info(win_t *win) +{ + /* Use global copy of screens so we can add struts */ + if (screens == NULL) { + /* Add Xinerama screens */ + int n = 0; + XineramaScreenInfo *info = NULL; + if (XineramaIsActive(win->sys->dpy)) + info = XineramaQueryScreens(win->sys->dpy, &n); + for (int i = 0; i < n; i++) { + win_t *screen = new0(win_t); + screen->x = info[i].x_org; + screen->y = info[i].y_org; + screen->w = info[i].width; + screen->h = info[i].height; + screen->sys = new0(win_sys_t); + screens = list_append(screens, screen); } - else if(ev.type == MotionNotify) { - while (XCheckTypedEvent(dpy, MotionNotify, &ev)); - wm_handle_ptr(win_new(dpy, ev.xkey.subwindow), x2ptr(ev)); + } + if (screens == NULL) { + /* No xinerama support */ + win_t *screen = new0(win_t); + *screen = *win; + screens = list_insert(NULL, screen); + } + return screens; +} + +win_t *sys_init(void) +{ + Display *dpy; + Window xid; + + /* Load configuration */ + border = conf_get_int("main.border", border); + no_capture = conf_get_int("main.no-capture", no_capture); + + /* Open the display */ + if (!(dpy = XOpenDisplay(NULL))) + error("Unable to get display"); + if (!(xid = DefaultRootWindow(dpy))) + error("Unable to get root window"); + + /* Setup X11 data */ + atoms[WM_PROTO] = XInternAtom(dpy, "WM_PROTOCOLS", False); + atoms[WM_FOCUS] = XInternAtom(dpy, "WM_TAKE_FOCUS", False); + atoms[NET_STATE] = XInternAtom(dpy, "_NET_WM_STATE", False); + atoms[NET_FULL] = XInternAtom(dpy, "_NET_WM_STATE_FULLSCREEN", False); + atoms[NET_STRUT] = XInternAtom(dpy, "_NET_WM_STRUT", False); + + colors[CLR_FOCUS] = get_color(dpy, "#a0a0ff"); + colors[CLR_UNFOCUS] = get_color(dpy, "#101066"); + colors[CLR_URGENT] = get_color(dpy, "#ff0000"); + //printf("colors = #%06lx #%06lx #%06lx\n", colors[0], colors[1], colors[2]); + + /* Select window management events */ + XSelectInput(dpy, xid, SubstructureRedirectMask|SubstructureNotifyMask); + xerrorxlib = XSetErrorHandler(xerror); + + return win_find(dpy, xid, 1); +} + +void sys_run(win_t *root) +{ + /* Add each initial window */ + if (!no_capture) { + unsigned int nkids; + Window par, xid, *kids = NULL; + if (XQueryTree(root->sys->dpy, root->sys->xid, + &par, &xid, &kids, &nkids)) { + for(int i = 0; i < nkids; i++) { + win_t *win = win_find(root->sys->dpy, kids[i], 1); + if (win && win_viewable(win) && !strut_add(root,win)) + wm_insert(win); + } + XFree(kids); } + wm_update(); // For struts + } + + /* Main loop */ + running = 1; + while (running) + { + XEvent xe; + XNextEvent(root->sys->dpy, &xe); + process_event(xe.type, &xe, root); + } +} + +void sys_exit(void) +{ + running = 0; +} + +void sys_free(win_t *root) +{ + XCloseDisplay(root->sys->dpy); + while (screens) { + win_free(screens->data); + screens = list_remove(screens, screens, 0); } + tdestroy(cache, (void(*)(void*))win_free); }