Feature #51: Re-initialize when SIGUSR1 is received

- Create a session_t structure, to get rid of most global variables and
  let information pass in/out mostly through parameters. Huge changes,
  so bugs may very well appear. I'm worried about resource leakages, in
  particular.

- Add gcc attributes on various functions.

- Add Doxygen configuration.

- Replace much Xlib Bool with C99 bool.

- Add and adjust some comments.

- Drop unused parameters from some functions.

- Cache default Visual and Depth, mainly to shorten code.

- Rename some types, variables, and functions.

- Add win_ev_stop() and set_ignore_next() for convenience.

- Modify wid_get_prop_wintype() and wid_get_opacity_prop() to use
  wid_get_prop().

- Rename --respect-attr-shadow to --respect-prop-shadow.

- Fix a memory leak in --respect-prop-shadow.

- Many other small changes.

1 files changed, 1561 insertions, 1371 deletions

diff --git a/compton.c b/compton.c
index 080fd0a86..e10c4c2d2 100644
--- a/compton.c
+++ b/compton.c
@@ -10,16 +10,18 @@
 
 #include "compton.h"
 
-#define MSTR_(s)        #s
-#define MSTR(s)         MSTR_(s)
+// === Macros ===
+
+// #define MSTR_(s)        #s
+// #define MSTR(s)         MSTR_(s)
 
 // Use #s here to prevent macro expansion
+/// Macro used for shortening some debugging code.
 #define CASESTRRET(s)   case s: return #s
 
-/**
- * Shared
- */
+// === Global constants ===
 
+/// Name strings for window types.
 const char *WINTYPES[NUM_WINTYPES] = {
   "unknown",
   "desktop",
@@ -38,207 +40,22 @@ const char *WINTYPES[NUM_WINTYPES] = {
   "dnd",
 };
 
-struct timeval time_start = { 0, 0 };
-
-win *list;
-Display *dpy = NULL;
-int scr;
-
-/// Root window.
-Window root = None;
-/// Damage of root window.
-Damage root_damage = None;
-/// X Composite overlay window. Used if --paint-on-overlay.
-Window overlay = None;
-
-/// Picture of root window. Destination of painting in no-DBE painting
-/// mode.
-Picture root_picture = None;
-/// A Picture acting as the painting target.
-Picture tgt_picture = None;
-/// Temporary buffer to paint to before sending to display.
-Picture tgt_buffer = None;
-/// DBE back buffer for root window. Used in DBE painting mode.
-XdbeBackBuffer root_dbe = None;
-
-Picture black_picture;
-Picture cshadow_picture;
-/// Picture used for dimming inactive windows.
-Picture dim_picture = 0;
-Picture root_tile;
-XserverRegion all_damage;
-Bool has_name_pixmap;
-int root_height, root_width;
-/// A region of the size of the screen.
-XserverRegion screen_reg = None;
-/// Current active window. Used by EWMH _NET_ACTIVE_WINDOW focus
-/// detection.
-win *active_win = NULL;
-/// Whether all windows are currently redirected.
-Bool redirected = False;
-/// Whether there's a highest fullscreen window, and all windows could
-/// be unredirected.
-Bool unredir_possible = False;
-
-/// Pregenerated alpha pictures.
-Picture *alpha_picts = NULL;
-/// Whether the program is idling. I.e. no fading, no potential window
-/// changes.
-Bool idling;
-/// Whether all reg_ignore of windows should expire in this paint.
-Bool reg_ignore_expire = False;
-/// Window ID of the window we register as a symbol.
-Window reg_win = 0;
-
-/// Currently used refresh rate. Used for sw_opti.
-short refresh_rate = 0;
-/// Interval between refresh in nanoseconds. Used for sw_opti.
-unsigned long refresh_intv = 0;
-/// Nanosecond-level offset of the first painting. Used for sw_opti.
-long paint_tm_offset = 0;
-
-#ifdef CONFIG_VSYNC_DRM
-/// File descriptor of DRI device file. Used for DRM VSync.
-int drm_fd = 0;
-#endif
-
-#ifdef CONFIG_VSYNC_OPENGL
-/// GLX context.
-GLXContext glx_context;
-
-/// Pointer to glXGetVideoSyncSGI function. Used by OpenGL VSync.
-f_GetVideoSync glx_get_video_sync = NULL;
-
-/// Pointer to glXWaitVideoSyncSGI function. Used by OpenGL VSync.
-f_WaitVideoSync glx_wait_video_sync = NULL;
-#endif
-
-/* errors */
-ignore *ignore_head = NULL, **ignore_tail = &ignore_head;
-int xfixes_event, xfixes_error;
-int damage_event, damage_error;
-int composite_event, composite_error;
-int render_event, render_error;
-int composite_opcode;
-
-/// Whether X Shape extension exists.
-Bool shape_exists = False;
-/// Event base number and error base number for X Shape extension.
-int shape_event, shape_error;
-
-/// Whether X RandR extension exists.
-Bool randr_exists = False;
-/// Event base number and error base number for X RandR extension.
-int randr_event, randr_error;
-
-#ifdef CONFIG_VSYNC_OPENGL
-/// Whether X GLX extension exists.
-Bool glx_exists = False;
-/// Event base number and error base number for X GLX extension.
-int glx_event, glx_error;
-#endif
-
-Bool dbe_exists = False;
-
-/* shadows */
-conv *gaussian_map;
-
-/* for shadow precomputation */
-int cgsize = -1;
-unsigned char *shadow_corner = NULL;
-unsigned char *shadow_top = NULL;
-
-/* for root tile */
-static const char *background_props[] = {
+/// Names of root window properties that could point to a pixmap of
+/// background.
+const char *background_props_str[] = {
   "_XROOTPMAP_ID",
   "_XSETROOT_ID",
   0,
 };
 
-/* for expose events */
-XRectangle *expose_rects = 0;
-int size_expose = 0;
-int n_expose = 0;
-
-// atoms
-Atom opacity_atom = None;
-Atom frame_extents_atom = None;
-Atom client_atom = None;
-Atom name_atom = None;
-Atom name_ewmh_atom = None;
-Atom class_atom = None;
-Atom transient_atom = None;
-Atom ewmh_active_win_atom = None;;
-Atom compton_shadow_atom = None;
-
-Atom win_type_atom;
-Atom win_type[NUM_WINTYPES];
+// === Global variables ===
 
-/**
- * Macros
- */
+/// Pointer to current session, as a global variable. Only used by
+/// <code>error()</code> and <code>reset_enable()</code>, which could not
+/// have a pointer to current session passed in.
+session_t *ps_g = NULL;
 
-#define HAS_FRAME_OPACITY(w) \
-  (frame_opacity && (w)->top_width)
-
-/**
- * Options
- */
-
-static options_t opts = {
-  .display = NULL,
-  .mark_wmwin_focused = False,
-  .mark_ovredir_focused = False,
-  .fork_after_register = False,
-  .synchronize = False,
-  .detect_rounded_corners = False,
-  .paint_on_overlay = False,
-  .unredir_if_possible = False,
-
-  .refresh_rate = 0,
-  .sw_opti = False,
-  .vsync = VSYNC_NONE,
-  .dbe = False,
-  .vsync_aggressive = False,
-
-  .wintype_shadow = { False },
-  .shadow_red = 0.0,
-  .shadow_green = 0.0,
-  .shadow_blue = 0.0,
-  .shadow_radius = 12,
-  .shadow_offset_x = -15,
-  .shadow_offset_y = -15,
-  .shadow_opacity = .75,
-  .clear_shadow = False,
-  .shadow_blacklist = NULL,
-  .shadow_ignore_shaped = False,
-  .respect_attr_shadow = False,
-
-  .wintype_fade = { False },
-  .fade_in_step = 0.028 * OPAQUE,
-  .fade_out_step = 0.03 * OPAQUE,
-  .fade_delta = 10,
-  .no_fading_openclose = False,
-  .fade_blacklist = NULL,
-
-  .wintype_opacity = { 0.0 },
-  .inactive_opacity = 0,
-  .inactive_opacity_override = False,
-  .frame_opacity = 0.0,
-  .detect_client_opacity = False,
-  .inactive_dim = 0.0,
-  .alpha_step = 0.03,
-  .use_ewmh_active_win = False,
-
-  .track_focus = False,
-  .track_wdata = False,
-};
-
-/**
- * Fades
- */
-
-unsigned long fade_time = 0;
+// === Fading ===
 
 /**
  * Get the time left before next fading point.
@@ -246,8 +63,8 @@ unsigned long fade_time = 0;
  * In milliseconds.
  */
 static int
-fade_timeout(void) {
-  int diff = opts.fade_delta - get_time_ms() + fade_time;
+fade_timeout(session_t *ps) {
+  int diff = ps->o.fade_delta - get_time_ms() + ps->fade_time;
 
   if (diff < 0)
     diff = 0;
@@ -261,7 +78,7 @@ fade_timeout(void) {
  * @param steps steps of fading
  */
 static void
-run_fade(Display *dpy, win *w, unsigned steps) {
+run_fade(session_t *ps, win *w, unsigned steps) {
   // If we have reached target opacity, return
   if (w->opacity == w->opacity_tgt) {
     return;
@@ -274,16 +91,16 @@ run_fade(Display *dpy, win *w, unsigned steps) {
     // calculations
     if (w->opacity < w->opacity_tgt)
       w->opacity = normalize_d_range(
-          (double) w->opacity + (double) opts.fade_in_step * steps,
+          (double) w->opacity + (double) ps->o.fade_in_step * steps,
           0.0, w->opacity_tgt);
     else
       w->opacity = normalize_d_range(
-          (double) w->opacity - (double) opts.fade_out_step * steps,
+          (double) w->opacity - (double) ps->o.fade_out_step * steps,
           w->opacity_tgt, OPAQUE);
   }
 
   if (w->opacity != w->opacity_tgt) {
-    idling = False;
+    ps->idling = false;
   }
 }
 
@@ -294,32 +111,30 @@ run_fade(Display *dpy, win *w, unsigned steps) {
  * @param exec_callback whether the previous callback is to be executed
  */
 static void
-set_fade_callback(Display *dpy, win *w,
-    void (*callback) (Display *dpy, win *w), Bool exec_callback) {
-  void (*old_callback) (Display *dpy, win *w) = w->fade_callback;
+set_fade_callback(session_t *ps, win *w,
+    void (*callback) (session_t *ps, win *w), bool exec_callback) {
+  void (*old_callback) (session_t *ps, win *w) = w->fade_callback;
 
   w->fade_callback = callback;
   // Must be the last line as the callback could destroy w!
   if (exec_callback && old_callback) {
-    old_callback(dpy, w);
+    old_callback(ps, w);
     // Although currently no callback function affects window state on
     // next paint, it could, in the future
-    idling = False;
+    ps->idling = false;
   }
 }
 
-/**
- * Shadows
- */
+// === Shadows ===
 
-static double
+static double __attribute__((const))
 gaussian(double r, double x, double y) {
   return ((1 / (sqrt(2 * M_PI * r))) *
     exp((- (x * x + y * y)) / (2 * r * r)));
 }
 
 static conv *
-make_gaussian_map(Display *dpy, double r) {
+make_gaussian_map(double r) {
   conv *c;
   int size = ((int) ceil((r * 3)) + 1) & ~1;
   int center = size / 2;
@@ -334,7 +149,7 @@ make_gaussian_map(Display *dpy, double r) {
 
   for (y = 0; y < size; y++) {
     for (x = 0; x < size; x++) {
-      g = gaussian(r, (double) (x - center), (double) (y - center));
+      g = gaussian(r, x - center, y - center);
       t += g;
       c->data[y * size + x] = g;
     }
@@ -420,54 +235,56 @@ sum_gaussian(conv *map, double opacity,
    to save time for large windows */
 
 static void
-presum_gaussian(conv *map) {
+presum_gaussian(session_t *ps, conv *map) {
   int center = map->size / 2;
   int opacity, x, y;
 
-  cgsize = map->size;
+  ps->cgsize = map->size;
 
-  if (shadow_corner) free((void *)shadow_corner);
-  if (shadow_top) free((void *)shadow_top);
+  if (ps->shadow_corner)
+    free(ps->shadow_corner);
+  if (ps->shadow_top)
+    free(ps->shadow_top);
 
-  shadow_corner = (unsigned char *)(malloc((cgsize + 1) * (cgsize + 1) * 26));
-  shadow_top = (unsigned char *)(malloc((cgsize + 1) * 26));
+  ps->shadow_corner = malloc((ps->cgsize + 1) * (ps->cgsize + 1) * 26);
+  ps->shadow_top = malloc((ps->cgsize + 1) * 26);
 
-  for (x = 0; x <= cgsize; x++) {
-    shadow_top[25 * (cgsize + 1) + x] =
-      sum_gaussian(map, 1, x - center, center, cgsize * 2, cgsize * 2);
+  for (x = 0; x <= ps->cgsize; x++) {
+    ps->shadow_top[25 * (ps->cgsize + 1) + x] =
+      sum_gaussian(map, 1, x - center, center, ps->cgsize * 2, ps->cgsize * 2);
 
     for (opacity = 0; opacity < 25; opacity++) {
-      shadow_top[opacity * (cgsize + 1) + x] =
-        shadow_top[25 * (cgsize + 1) + x] * opacity / 25;
+      ps->shadow_top[opacity * (ps->cgsize + 1) + x] =
+        ps->shadow_top[25 * (ps->cgsize + 1) + x] * opacity / 25;
     }
 
     for (y = 0; y <= x; y++) {
-      shadow_corner[25 * (cgsize + 1) * (cgsize + 1) + y * (cgsize + 1) + x]
-        = sum_gaussian(map, 1, x - center, y - center, cgsize * 2, cgsize * 2);
-      shadow_corner[25 * (cgsize + 1) * (cgsize + 1) + x * (cgsize + 1) + y]
-        = shadow_corner[25 * (cgsize + 1) * (cgsize + 1) + y * (cgsize + 1) + x];
+      ps->shadow_corner[25 * (ps->cgsize + 1) * (ps->cgsize + 1) + y * (ps->cgsize + 1) + x]
+        = sum_gaussian(map, 1, x - center, y - center, ps->cgsize * 2, ps->cgsize * 2);
+      ps->shadow_corner[25 * (ps->cgsize + 1) * (ps->cgsize + 1) + x * (ps->cgsize + 1) + y]
+        = ps->shadow_corner[25 * (ps->cgsize + 1) * (ps->cgsize + 1) + y * (ps->cgsize + 1) + x];
 
       for (opacity = 0; opacity < 25; opacity++) {
-        shadow_corner[opacity * (cgsize + 1) * (cgsize + 1)
-                      + y * (cgsize + 1) + x]
-          = shadow_corner[opacity * (cgsize + 1) * (cgsize + 1)
-                          + x * (cgsize + 1) + y]
-          = shadow_corner[25 * (cgsize + 1) * (cgsize + 1)
-                          + y * (cgsize + 1) + x] * opacity / 25;
+        ps->shadow_corner[opacity * (ps->cgsize + 1) * (ps->cgsize + 1)
+                      + y * (ps->cgsize + 1) + x]
+          = ps->shadow_corner[opacity * (ps->cgsize + 1) * (ps->cgsize + 1)
+                          + x * (ps->cgsize + 1) + y]
+          = ps->shadow_corner[25 * (ps->cgsize + 1) * (ps->cgsize + 1)
+                          + y * (ps->cgsize + 1) + x] * opacity / 25;
       }
     }
   }
 }
 
 static XImage *
-make_shadow(Display *dpy, double opacity,
-            int width, int height, Bool clear_shadow) {
+make_shadow(session_t *ps, double opacity,
+            int width, int height) {
   XImage *ximage;
   unsigned char *data;
   int ylimit, xlimit;
-  int swidth = width + cgsize;
-  int sheight = height + cgsize;
-  int center = cgsize / 2;
+  int swidth = width + ps->cgsize;
+  int sheight = height + ps->cgsize;
+  int center = ps->cgsize / 2;
   int x, y;
   unsigned char d;
   int x_diff;
@@ -476,10 +293,8 @@ make_shadow(Display *dpy, double opacity,
   data = malloc(swidth * sheight * sizeof(unsigned char));
   if (!data) return 0;
 
-  ximage = XCreateImage(
-    dpy, DefaultVisual(dpy, DefaultScreen(dpy)), 8,
-    ZPixmap, 0, (char *) data, swidth, sheight, 8,
-    swidth * sizeof(unsigned char));
+  ximage = XCreateImage(ps->dpy, ps->vis, 8,
+    ZPixmap, 0, (char *) data, swidth, sheight, 8, swidth * sizeof(char));
 
   if (!ximage) {
     free(data);
@@ -498,12 +313,12 @@ make_shadow(Display *dpy, double opacity,
   // later will be filled) could entirely cover the area of the shadow
   // that will be displayed, do not bother filling other pixels. If it
   // can't, we must fill the other pixels here.
-  /* if (!(clear_shadow && opts.shadow_offset_x <= 0 && opts.shadow_offset_x >= -cgsize
-        && opts.shadow_offset_y <= 0 && opts.shadow_offset_y >= -cgsize)) { */
-    if (cgsize > 0) {
-      d = shadow_top[opacity_int * (cgsize + 1) + cgsize];
+  /* if (!(clear_shadow && ps->o.shadow_offset_x <= 0 && ps->o.shadow_offset_x >= -ps->cgsize
+        && ps->o.shadow_offset_y <= 0 && ps->o.shadow_offset_y >= -ps->cgsize)) { */
+    if (ps->cgsize > 0) {
+      d = ps->shadow_top[opacity_int * (ps->cgsize + 1) + ps->cgsize];
     } else {
-      d = sum_gaussian(gaussian_map,
+      d = sum_gaussian(ps->gaussian_map,
         opacity, center, center, width, height);
     }
     memset(data, d, sheight * swidth);
@@ -513,19 +328,19 @@ make_shadow(Display *dpy, double opacity,
    * corners
    */
 
-  ylimit = cgsize;
+  ylimit = ps->cgsize;
   if (ylimit > sheight / 2) ylimit = (sheight + 1) / 2;
 
-  xlimit = cgsize;
+  xlimit = ps->cgsize;
   if (xlimit > swidth / 2) xlimit = (swidth + 1) / 2;
 
   for (y = 0; y < ylimit; y++) {
     for (x = 0; x < xlimit; x++) {
-      if (xlimit == cgsize && ylimit == cgsize) {
-        d = shadow_corner[opacity_int * (cgsize + 1) * (cgsize + 1)
-                          + y * (cgsize + 1) + x];
+      if (xlimit == ps->cgsize && ylimit == ps->cgsize) {
+        d = ps->shadow_corner[opacity_int * (ps->cgsize + 1) * (ps->cgsize + 1)
+                          + y * (ps->cgsize + 1) + x];
       } else {
-        d = sum_gaussian(gaussian_map,
+        d = sum_gaussian(ps->gaussian_map,
           opacity, x - center, y - center, width, height);
       }
       data[y * swidth + x] = d;
@@ -539,17 +354,17 @@ make_shadow(Display *dpy, double opacity,
    * top/bottom
    */
 
-  x_diff = swidth - (cgsize * 2);
+  x_diff = swidth - (ps->cgsize * 2);
   if (x_diff > 0 && ylimit > 0) {
     for (y = 0; y < ylimit; y++) {
-      if (ylimit == cgsize) {
-        d = shadow_top[opacity_int * (cgsize + 1) + y];
+      if (ylimit == ps->cgsize) {
+        d = ps->shadow_top[opacity_int * (ps->cgsize + 1) + y];
       } else {
-        d = sum_gaussian(gaussian_map,
+        d = sum_gaussian(ps->gaussian_map,
           opacity, center, y - center, width, height);
       }
-      memset(&data[y * swidth + cgsize], d, x_diff);
-      memset(&data[(sheight - y - 1) * swidth + cgsize], d, x_diff);
+      memset(&data[y * swidth + ps->cgsize], d, x_diff);
+      memset(&data[(sheight - y - 1) * swidth + ps->cgsize], d, x_diff);
     }
   }
 
@@ -558,28 +373,27 @@ make_shadow(Display *dpy, double opacity,
    */
 
   for (x = 0; x < xlimit; x++) {
-    if (xlimit == cgsize) {
-      d = shadow_top[opacity_int * (cgsize + 1) + x];
+    if (xlimit == ps->cgsize) {
+      d = ps->shadow_top[opacity_int * (ps->cgsize + 1) + x];
     } else {
-      d = sum_gaussian(gaussian_map,
+      d = sum_gaussian(ps->gaussian_map,
         opacity, x - center, center, width, height);
     }
-    for (y = cgsize; y < sheight - cgsize; y++) {
+    for (y = ps->cgsize; y < sheight - ps->cgsize; y++) {
       data[y * swidth + x] = d;
       data[y * swidth + (swidth - x - 1)] = d;
     }
   }
 
-  assert(!clear_shadow);
   /*
   if (clear_shadow) {
     // Clear the region in the shadow that the window would cover based
     // on shadow_offset_{x,y} user provides
-    int xstart = normalize_i_range(- (int) opts.shadow_offset_x, 0, swidth);
-    int xrange = normalize_i_range(width - (int) opts.shadow_offset_x,
+    int xstart = normalize_i_range(- (int) ps->o.shadow_offset_x, 0, swidth);
+    int xrange = normalize_i_range(width - (int) ps->o.shadow_offset_x,
         0, swidth) - xstart;
-    int ystart = normalize_i_range(- (int) opts.shadow_offset_y, 0, sheight);
-    int yend = normalize_i_range(height - (int) opts.shadow_offset_y,
+    int ystart = normalize_i_range(- (int) ps->o.shadow_offset_y, 0, sheight);
+    int yend = normalize_i_range(height - (int) ps->o.shadow_offset_y,
         0, sheight);
     int y;
 
@@ -592,48 +406,50 @@ make_shadow(Display *dpy, double opacity,
   return ximage;
 }
 
+/**
+ * Generate shadow <code>Picture</code> for a window.
+ */
 static Picture
-shadow_picture(Display *dpy, double opacity, int width, int height,
-    Bool clear_shadow) {
+shadow_picture(session_t *ps, double opacity, int width, int height) {
   XImage *shadow_image = NULL;
   Pixmap shadow_pixmap = None, shadow_pixmap_argb = None;
   Picture shadow_picture = None, shadow_picture_argb = None;
   GC gc = None;
 
-  shadow_image = make_shadow(dpy, opacity, width, height, clear_shadow);
+  shadow_image = make_shadow(ps, opacity, width, height);
   if (!shadow_image)
     return None;
 
-  shadow_pixmap = XCreatePixmap(dpy, root,
+  shadow_pixmap = XCreatePixmap(ps->dpy, ps->root,
     shadow_image->width, shadow_image->height, 8);
-  shadow_pixmap_argb = XCreatePixmap(dpy, root,
+  shadow_pixmap_argb = XCreatePixmap(ps->dpy, ps->root,
     shadow_image->width, shadow_image->height, 32);
 
   if (!shadow_pixmap || !shadow_pixmap_argb)
     goto shadow_picture_err;
 
-  shadow_picture = XRenderCreatePicture(dpy, shadow_pixmap,
-    XRenderFindStandardFormat(dpy, PictStandardA8), 0, 0);
-  shadow_picture_argb = XRenderCreatePicture(dpy, shadow_pixmap_argb,
-    XRenderFindStandardFormat(dpy, PictStandardARGB32), 0, 0);
+  shadow_picture = XRenderCreatePicture(ps->dpy, shadow_pixmap,
+    XRenderFindStandardFormat(ps->dpy, PictStandardA8), 0, 0);
+  shadow_picture_argb = XRenderCreatePicture(ps->dpy, shadow_pixmap_argb,
+    XRenderFindStandardFormat(ps->dpy, PictStandardARGB32), 0, 0);
   if (!shadow_picture || !shadow_picture_argb)
     goto shadow_picture_err;
 
-  gc = XCreateGC(dpy, shadow_pixmap, 0, 0);
+  gc = XCreateGC(ps->dpy, shadow_pixmap, 0, 0);
   if (!gc)
     goto shadow_picture_err;
 
-  XPutImage(dpy, shadow_pixmap, gc, shadow_image, 0, 0, 0, 0,
+  XPutImage(ps->dpy, shadow_pixmap, gc, shadow_image, 0, 0, 0, 0,
     shadow_image->width, shadow_image->height);
-  XRenderComposite(dpy, PictOpSrc, cshadow_picture, shadow_picture,
+  XRenderComposite(ps->dpy, PictOpSrc, ps->cshadow_picture, shadow_picture,
       shadow_picture_argb, 0, 0, 0, 0, 0, 0,
       shadow_image->width, shadow_image->height);
 
-  XFreeGC(dpy, gc);
+  XFreeGC(ps->dpy, gc);
   XDestroyImage(shadow_image);
-  XFreePixmap(dpy, shadow_pixmap);
-  XFreePixmap(dpy, shadow_pixmap_argb);
-  XRenderFreePicture(dpy, shadow_picture);
+  XFreePixmap(ps->dpy, shadow_pixmap);
+  XFreePixmap(ps->dpy, shadow_pixmap_argb);
+  XRenderFreePicture(ps->dpy, shadow_picture);
 
   return shadow_picture_argb;
 
@@ -641,39 +457,42 @@ shadow_picture_err:
   if (shadow_image)
     XDestroyImage(shadow_image);
   if (shadow_pixmap)
-    XFreePixmap(dpy, shadow_pixmap);
+    XFreePixmap(ps->dpy, shadow_pixmap);
   if (shadow_pixmap_argb)
-    XFreePixmap(dpy, shadow_pixmap_argb);
+    XFreePixmap(ps->dpy, shadow_pixmap_argb);
   if (shadow_picture)
-    XRenderFreePicture(dpy, shadow_picture);
+    XRenderFreePicture(ps->dpy, shadow_picture);
   if (shadow_picture_argb)
-    XRenderFreePicture(dpy, shadow_picture_argb);
+    XRenderFreePicture(ps->dpy, shadow_picture_argb);
   if (gc)
-    XFreeGC(dpy, gc);
+    XFreeGC(ps->dpy, gc);
   return None;
 }
 
+/**
+ * Generate a 1x1 <code>Picture</code> of a particular color.
+ */
 static Picture
-solid_picture(Display *dpy, Bool argb, double a,
+solid_picture(session_t *ps, bool argb, double a,
               double r, double g, double b) {
   Pixmap pixmap;
   Picture picture;
   XRenderPictureAttributes pa;
   XRenderColor c;
 
-  pixmap = XCreatePixmap(dpy, root, 1, 1, argb ? 32 : 8);
+  pixmap = XCreatePixmap(ps->dpy, ps->root, 1, 1, argb ? 32 : 8);
 
   if (!pixmap) return None;
 
   pa.repeat = True;
-  picture = XRenderCreatePicture(dpy, pixmap,
-    XRenderFindStandardFormat(dpy, argb
+  picture = XRenderCreatePicture(ps->dpy, pixmap,
+    XRenderFindStandardFormat(ps->dpy, argb
       ? PictStandardARGB32 : PictStandardA8),
     CPRepeat,
     &pa);
 
   if (!picture) {
-    XFreePixmap(dpy, pixmap);
+    XFreePixmap(ps->dpy, pixmap);
     return None;
   }
 
@@ -682,25 +501,23 @@ solid_picture(Display *dpy, Bool argb, double a,
   c.green = g * 0xffff;
   c.blue = b * 0xffff;
 
-  XRenderFillRectangle(dpy, PictOpSrc, picture, &c, 0, 0, 1, 1);
-  XFreePixmap(dpy, pixmap);
+  XRenderFillRectangle(ps->dpy, PictOpSrc, picture, &c, 0, 0, 1, 1);
+  XFreePixmap(ps->dpy, pixmap);
 
   return picture;
 }
 
-/**
- * Errors
- */
+// === Error handling ===
 
 static void
-discard_ignore(Display *dpy, unsigned long sequence) {
-  while (ignore_head) {
-    if ((long) (sequence - ignore_head->sequence) > 0) {
-      ignore  *next = ignore_head->next;
-      free(ignore_head);
-      ignore_head = next;
-      if (!ignore_head) {
-        ignore_tail = &ignore_head;
+discard_ignore(session_t *ps, unsigned long sequence) {
+  while (ps->ignore_head) {
+    if ((long) (sequence - ps->ignore_head->sequence) > 0) {
+      ignore_t *next = ps->ignore_head->next;
+      free(ps->ignore_head);
+      ps->ignore_head = next;
+      if (!ps->ignore_head) {
+        ps->ignore_tail = &ps->ignore_head;
       }
     } else {
       break;
@@ -709,37 +526,35 @@ discard_ignore(Display *dpy, unsigned long sequence) {
 }
 
 static void
-set_ignore(Display *dpy, unsigned long sequence) {
-  ignore *i = malloc(sizeof(ignore));
+set_ignore(session_t *ps, unsigned long sequence) {
+  ignore_t *i = malloc(sizeof(ignore_t));
   if (!i) return;
 
   i->sequence = sequence;
   i->next = 0;
-  *ignore_tail = i;
-  ignore_tail = &i->next;
+  *ps->ignore_tail = i;
+  ps->ignore_tail = &i->next;
 }
 
 static int
-should_ignore(Display *dpy, unsigned long sequence) {
-  discard_ignore(dpy, sequence);
-  return ignore_head && ignore_head->sequence == sequence;
+should_ignore(session_t *ps, unsigned long sequence) {
+  discard_ignore(ps, sequence);
+  return ps->ignore_head && ps->ignore_head->sequence == sequence;
 }
 
-/**
- * Windows
- */
+// === Windows ===
 
 /**
  * Check if a window has rounded corners.
  */
 static void
-win_rounded_corners(Display *dpy, win *w) {
+win_rounded_corners(session_t *ps, win *w) {
   if (!w->bounding_shaped)
     return;
 
   // Fetch its bounding region
   if (!w->border_size)
-    w->border_size = border_size(dpy, w);
+    w->border_size = border_size(ps, w);
 
   // Quit if border_size() returns None
   if (!w->border_size)
@@ -754,7 +569,7 @@ win_rounded_corners(Display *dpy, win *w) {
 
   // Get the rectangles in the bounding region
   int nrects = 0, i;
-  XRectangle *rects = XFixesFetchRegion(dpy, w->border_size, &nrects);
+  XRectangle *rects = XFixesFetchRegion(ps->dpy, w->border_size, &nrects);
   if (!rects)
     return;
 
@@ -762,12 +577,12 @@ win_rounded_corners(Display *dpy, win *w) {
   // having rounded corners
   for (i = 0; i < nrects; ++i)
     if (rects[i].width >= minwidth && rects[i].height >= minheight) {
-      w->rounded_corners = True;
+      w->rounded_corners = true;
       XFree(rects);
       return;
     }
 
-  w->rounded_corners = False;
+  w->rounded_corners = false;
   XFree(rects);
 }
 
@@ -777,7 +592,7 @@ win_rounded_corners(Display *dpy, win *w) {
  * @return true if matched, false otherwise.
  */
 static bool
-win_match_once(win *w, const wincond *cond) {
+win_match_once(win *w, const wincond_t *cond) {
   const char *target;
   bool matched = false;
 
@@ -866,7 +681,7 @@ win_match_once(win *w, const wincond *cond) {
  * @return true if matched, false otherwise.
  */
 static bool
-win_match(win *w, wincond *condlst, wincond **cache) {
+win_match(win *w, wincond_t *condlst, wincond_t **cache) {
   // Check if the cached entry matches firstly
   if (cache && *cache && win_match_once(w, *cache))
     return true;
@@ -886,22 +701,22 @@ win_match(win *w, wincond *condlst, wincond **cache) {
 /**
  * Add a pattern to a condition linked list.
  */
-static Bool
-condlst_add(wincond **pcondlst, const char *pattern) {
+static bool
+condlst_add(wincond_t **pcondlst, const char *pattern) {
   if (!pattern)
-    return False;
+    return false;
 
   unsigned plen = strlen(pattern);
-  wincond *cond;
+  wincond_t *cond;
   const char *pos;
 
   if (plen < 4 || ':' != pattern[1] || !strchr(pattern + 2, ':')) {
     printf("Pattern \"%s\": Format invalid.\n", pattern);
-    return False;
+    return false;
   }
 
   // Allocate memory for the new condition
-  cond = malloc(sizeof(wincond));
+  cond = malloc(sizeof(wincond_t));
 
   // Determine the pattern target
   switch (pattern[0]) {
@@ -918,7 +733,7 @@ condlst_add(wincond **pcondlst, const char *pattern) {
       printf("Pattern \"%s\": Target \"%c\" invalid.\n",
           pattern, pattern[0]);
       free(cond);
-      return False;
+      return false;
   }
 
   // Determine the pattern type
@@ -944,7 +759,7 @@ condlst_add(wincond **pcondlst, const char *pattern) {
       printf("Pattern \"%s\": Type \"%c\" invalid.\n",
           pattern, pattern[2]);
       free(cond);
-      return False;
+      return false;
   }
 
   // Determine the pattern flags
@@ -985,7 +800,7 @@ condlst_add(wincond **pcondlst, const char *pattern) {
       printf("Pattern \"%s\": PCRE regular expression parsing failed on "
           "offset %d: %s\n", pattern, erroffset, error);
       free(cond);
-      return False;
+      return false;
     }
 #ifdef CONFIG_REGEX_PCRE_JIT
     cond->regex_pcre_extra = pcre_study(cond->regex_pcre, PCRE_STUDY_JIT_COMPILE, &error);
@@ -1004,33 +819,39 @@ condlst_add(wincond **pcondlst, const char *pattern) {
   cond->next = *pcondlst;
   *pcondlst = cond;
 
-  return True;
+  return true;
 }
 
+/**
+ * Determine the event mask for a window.
+ */
 static long
-determine_evmask(Display *dpy, Window wid, win_evmode_t mode) {
+determine_evmask(session_t *ps, Window wid, win_evmode_t mode) {
   long evmask = NoEventMask;
 
-  if (WIN_EVMODE_FRAME == mode || find_win(wid)) {
+  if (WIN_EVMODE_FRAME == mode || find_win(ps, wid)) {
     evmask |= PropertyChangeMask;
-    if (opts.track_focus && !opts.use_ewmh_active_win)
+    if (ps->o.track_focus && !ps->o.use_ewmh_active_win)
       evmask |= FocusChangeMask;
   }
 
-  if (WIN_EVMODE_CLIENT == mode || find_toplevel(wid)) {
-    if (opts.frame_opacity || opts.track_wdata
-        || opts.detect_client_opacity)
+  if (WIN_EVMODE_CLIENT == mode || find_toplevel(ps, wid)) {
+    if (ps->o.frame_opacity || ps->o.track_wdata
+        || ps->o.detect_client_opacity)
       evmask |= PropertyChangeMask;
   }
 
   return evmask;
 }
 
+/**
+ * Find a window from window id in window linked list of the session.
+ */
 static win *
-find_win(Window id) {
+find_win(session_t *ps, Window id) {
   win *w;
 
-  for (w = list; w; w = w->next) {
+  for (w = ps->list; w; w = w->next) {
     if (w->id == id && !w->destroyed)
       return w;
   }
@@ -1045,10 +866,10 @@ find_win(Window id) {
  * @return struct _win object of the found window, NULL if not found
  */
 static win *
-find_toplevel(Window id) {
+find_toplevel(session_t *ps, Window id) {
   win *w;
 
-  for (w = list; w; w = w->next) {
+  for (w = ps->list; w; w = w->next) {
     if (w->client_win == id && !w->destroyed)
       return w;
   }
@@ -1059,16 +880,16 @@ find_toplevel(Window id) {
 /**
  * Find out the WM frame of a client window by querying X.
  *
- * @param dpy display to use
+ * @param ps current session
  * @param w window ID
  * @return struct _win object of the found window, NULL if not found
  */
 static win *
-find_toplevel2(Display *dpy, Window wid) {
+find_toplevel2(session_t *ps, Window wid) {
   win *w = NULL;
 
   // We traverse through its ancestors to find out the frame
-  while (wid && wid != root && !(w = find_win(wid))) {
+  while (wid && wid != ps->root && !(w = find_win(ps, wid))) {
     Window troot;
     Window parent;
     Window *tchildren;
@@ -1077,7 +898,7 @@ find_toplevel2(Display *dpy, Window wid) {
     // XQueryTree probably fails if you run compton when X is somehow
     // initializing (like add it in .xinitrc). In this case
     // just leave it alone.
-    if (!XQueryTree(dpy, wid, &troot, &parent, &tchildren,
+    if (!XQueryTree(ps->dpy, wid, &troot, &parent, &tchildren,
           &tnchildren)) {
       parent = 0;
       break;
@@ -1093,17 +914,17 @@ find_toplevel2(Display *dpy, Window wid) {
 
 /**
  * Recheck currently focused window and set its <code>w->focused</code>
- * to True.
+ * to true.
  *
- * @param dpy display to use
+ * @param ps current session
  * @return struct _win of currently focused window, NULL if not found
  */
 static win *
-recheck_focus(Display *dpy) {
+recheck_focus(session_t *ps) {
   // Use EWMH _NET_ACTIVE_WINDOW if enabled
-  if (opts.use_ewmh_active_win) {
-    update_ewmh_active_win(dpy);
-    return active_win;
+  if (ps->o.use_ewmh_active_win) {
+    update_ewmh_active_win(ps);
+    return ps->active_win;
   }
 
   // Determine the currently focused window so we can apply appropriate
@@ -1112,16 +933,16 @@ recheck_focus(Display *dpy) {
   int revert_to;
   win *w = NULL;
 
-  XGetInputFocus(dpy, &wid, &revert_to);
+  XGetInputFocus(ps->dpy, &wid, &revert_to);
 
   // Fallback to the old method if find_toplevel() fails
-  if (!(w = find_toplevel(wid))) {
-    w = find_toplevel2(dpy, wid);
+  if (!(w = find_toplevel(ps, wid))) {
+    w = find_toplevel2(ps, wid);
   }
 
   // And we set the focus state and opacity here
   if (w) {
-    set_focused(dpy, w, True);
+    set_focused(ps, w, true);
     return w;
   }
 
@@ -1129,41 +950,42 @@ recheck_focus(Display *dpy) {
 }
 
 static Picture
-root_tile_f(Display *dpy) {
+root_tile_f(session_t *ps) {
   /*
-  if (opts.paint_on_overlay) {
-    return root_picture;
+  if (ps->o.paint_on_overlay) {
+    return ps->root_picture;
   } */
 
   Picture picture;
   Pixmap pixmap;
-  Bool fill;
+  bool fill = false;
   XRenderPictureAttributes pa;
   int p;
 
   pixmap = None;
 
   // Get the values of background attributes
-  for (p = 0; background_props[p]; p++) {
-    winattr_t attr = wid_get_attr(dpy, root,
-        XInternAtom(dpy, background_props[p], False), 1L, XA_PIXMAP, 32);
-    if (attr.nitems) {
-      pixmap = *((long *) attr.data);
-      fill = False;
-      free_winattr(&attr);
+  for (p = 0; background_props_str[p]; p++) {
+    winprop_t prop = wid_get_prop(ps, ps->root,
+        XInternAtom(ps->dpy, background_props_str[p], false),
+        1L, XA_PIXMAP, 32);
+    if (prop.nitems) {
+      pixmap = *((long *) prop.data);
+      fill = false;
+      free_winprop(&prop);
       break;
     }
-    free_winattr(&attr);
+    free_winprop(&prop);
   }
 
   if (!pixmap) {
-    pixmap = XCreatePixmap(dpy, root, 1, 1, DefaultDepth(dpy, scr));
-    fill = True;
+    pixmap = XCreatePixmap(ps->dpy, ps->root, 1, 1, ps->depth);
+    fill = true;
   }
 
-  pa.repeat = True;
+  pa.repeat = true;
   picture = XRenderCreatePicture(
-    dpy, pixmap, XRenderFindVisualFormat(dpy, DefaultVisual(dpy, scr)),
+    ps->dpy, pixmap, XRenderFindVisualFormat(ps->dpy, ps->vis),
     CPRepeat, &pa);
 
   if (fill) {
@@ -1172,29 +994,32 @@ root_tile_f(Display *dpy) {
     c.red = c.green = c.blue = 0x8080;
     c.alpha = 0xffff;
     XRenderFillRectangle(
-      dpy, PictOpSrc, picture, &c, 0, 0, 1, 1);
+      ps->dpy, PictOpSrc, picture, &c, 0, 0, 1, 1);
   }
 
   return picture;
 }
 
+/**
+ * Paint root window content.
+ */
 static void
-paint_root(Display *dpy) {
-  if (!root_tile) {
-    root_tile = root_tile_f(dpy);
+paint_root(session_t *ps, Picture tgt_buffer) {
+  if (!ps->root_tile) {
+    ps->root_tile = root_tile_f(ps);
   }
 
   XRenderComposite(
-    dpy, PictOpSrc, root_tile, None,
+    ps->dpy, PictOpSrc, ps->root_tile, None,
     tgt_buffer, 0, 0, 0, 0, 0, 0,
-    root_width, root_height);
+    ps->root_width, ps->root_height);
 }
 
 /**
  * Get a rectangular region a window occupies, excluding shadow.
  */
 static XserverRegion
-win_get_region(Display *dpy, win *w) {
+win_get_region(session_t *ps, win *w) {
   XRectangle r;
 
   r.x = w->a.x;
@@ -1202,14 +1027,14 @@ win_get_region(Display *dpy, win *w) {
   r.width = w->widthb;
   r.height = w->heightb;
 
-  return XFixesCreateRegion(dpy, &r, 1);
+  return XFixesCreateRegion(ps->dpy, &r, 1);
 }
 
 /**
  * Get a rectangular region a window occupies, excluding frame and shadow.
  */
 static XserverRegion
-win_get_region_noframe(Display *dpy, win *w) {
+win_get_region_noframe(session_t *ps, win *w) {
   XRectangle r;
 
   r.x = w->a.x + w->a.border_width + w->left_width;
@@ -1218,9 +1043,9 @@ win_get_region_noframe(Display *dpy, win *w) {
   r.height = max_i(w->a.height - w->top_width - w->bottom_width, 0);
 
   if (r.width > 0 && r.height > 0)
-    return XFixesCreateRegion(dpy, &r, 1);
+    return XFixesCreateRegion(ps->dpy, &r, 1);
   else
-    return XFixesCreateRegion(dpy, NULL, 0);
+    return XFixesCreateRegion(ps->dpy, NULL, 0);
 }
 
 /**
@@ -1230,7 +1055,7 @@ win_get_region_noframe(Display *dpy, win *w) {
  * function.
  */
 static XserverRegion
-win_extents(Display *dpy, win *w) {
+win_extents(session_t *ps, win *w) {
   XRectangle r;
 
   r.x = w->a.x;
@@ -1265,13 +1090,16 @@ win_extents(Display *dpy, win *w) {
     }
   }
 
-  return XFixesCreateRegion(dpy, &r, 1);
+  return XFixesCreateRegion(ps->dpy, &r, 1);
 }
 
+/**
+ * Retrieve the bounding shape of a window.
+ */
 static XserverRegion
-border_size(Display *dpy, win *w) {
+border_size(session_t *ps, win *w) {
   // Start with the window rectangular region
-  XserverRegion fin = win_get_region(dpy, w);
+  XserverRegion fin = win_get_region(ps, w);
 
   // Only request for a bounding region if the window is shaped
   if (w->bounding_shaped) {
@@ -1284,29 +1112,32 @@ border_size(Display *dpy, win *w) {
      */
 
     XserverRegion border = XFixesCreateRegionFromWindow(
-      dpy, w->id, WindowRegionBounding);
+      ps->dpy, w->id, WindowRegionBounding);
 
     if (!border)
       return fin;
 
     // Translate the region to the correct place
-    XFixesTranslateRegion(dpy, border,
+    XFixesTranslateRegion(ps->dpy, border,
       w->a.x + w->a.border_width,
       w->a.y + w->a.border_width);
 
     // Intersect the bounding region we got with the window rectangle, to
     // make sure the bounding region is not bigger than the window
     // rectangle
-    XFixesIntersectRegion(dpy, fin, fin, border);
-    XFixesDestroyRegion(dpy, border);
+    XFixesIntersectRegion(ps->dpy, fin, fin, border);
+    XFixesDestroyRegion(ps->dpy, border);
   }
 
   return fin;
 }
 
+/**
+ * Look for the client window of a particular window.
+ */
 static Window
-find_client_win(Display *dpy, Window w) {
-  if (wid_has_attr(dpy, w, client_atom)) {
+find_client_win(session_t *ps, Window w) {
+  if (wid_has_attr(ps, w, ps->atom_client)) {
     return w;
   }
 
@@ -1315,12 +1146,12 @@ find_client_win(Display *dpy, Window w) {
   unsigned int i;
   Window ret = 0;
 
-  if (!wid_get_children(dpy, w, &children, &nchildren)) {
+  if (!wid_get_children(ps, w, &children, &nchildren)) {
     return 0;
   }
 
   for (i = 0; i < nchildren; ++i) {
-    if ((ret = find_client_win(dpy, children[i])))
+    if ((ret = find_client_win(ps, children[i])))
       break;
   }
 
@@ -1329,60 +1160,70 @@ find_client_win(Display *dpy, Window w) {
   return ret;
 }
 
+/**
+ * Retrieve frame extents from a window.
+ */
 static void
-get_frame_extents(Display *dpy, win *w, Window client) {
+get_frame_extents(session_t *ps, win *w, Window client) {
   w->left_width = 0;
   w->right_width = 0;
   w->top_width = 0;
   w->bottom_width = 0;
 
-  winattr_t attr = wid_get_attr(dpy, client, frame_extents_atom,
+  winprop_t prop = wid_get_prop(ps, client, ps->atom_frame_extents,
     4L, XA_CARDINAL, 32);
 
-  if (4 == attr.nitems) {
-    long *extents = (long *) attr.data;
+  if (4 == prop.nitems) {
+    long *extents = (long *) prop.data;
     w->left_width = extents[0];
     w->right_width = extents[1];
     w->top_width = extents[2];
     w->bottom_width = extents[3];
 
-    if (opts.frame_opacity)
-      update_reg_ignore_expire(w);
+    if (ps->o.frame_opacity)
+      update_reg_ignore_expire(ps, w);
   }
 
-  free_winattr(&attr);
+  free_winprop(&prop);
 }
 
+/**
+ * Get alpha <code>Picture</code> for an opacity in <code>double</code>.
+ */
 static inline Picture
-get_alpha_pict_d(double o) {
-  assert((lround(normalize_d(o) / opts.alpha_step)) <= lround(1.0 / opts.alpha_step));
-  return alpha_picts[lround(normalize_d(o) / opts.alpha_step)];
+get_alpha_pict_d(session_t *ps, double o) {
+  assert((lround(normalize_d(o) / ps->o.alpha_step)) <= lround(1.0 / ps->o.alpha_step));
+  return ps->alpha_picts[lround(normalize_d(o) / ps->o.alpha_step)];
 }
 
+/**
+ * Get alpha <code>Picture</code> for an opacity in
+ * <code>opacity_t</code>.
+ */
 static inline Picture
-get_alpha_pict_o(opacity_t o) {
-  return get_alpha_pict_d((double) o / OPAQUE);
+get_alpha_pict_o(session_t *ps, opacity_t o) {
+  return get_alpha_pict_d(ps, (double) o / OPAQUE);
 }
 
 static win *
-paint_preprocess(Display *dpy, win *list) {
+paint_preprocess(session_t *ps, win *list) {
   // Initialize unredir_possible
-  unredir_possible = False;
+  ps->unredir_possible = false;
 
   win *w;
   win *t = NULL, *next = NULL;
   // Trace whether it's the highest window to paint
-  Bool is_highest = True;
+  bool is_highest = true;
 
   // Fading step calculation
-  unsigned steps = (sub_unslong(get_time_ms(), fade_time)
-      + FADE_DELTA_TOLERANCE * opts.fade_delta) / opts.fade_delta;
-  fade_time += steps * opts.fade_delta;
+  unsigned steps = (sub_unslong(get_time_ms(), ps->fade_time)
+      + FADE_DELTA_TOLERANCE * ps->o.fade_delta) / ps->o.fade_delta;
+  ps->fade_time += steps * ps->o.fade_delta;
 
   XserverRegion last_reg_ignore = None;
 
   for (w = list; w; w = next) {
-    Bool to_paint = True;
+    bool to_paint = true;
     const winmode mode_old = w->mode;
 
     // In case calling the fade callback function destroys this window
@@ -1390,123 +1231,123 @@ paint_preprocess(Display *dpy, win *list) {
     opacity_t opacity_old = w->opacity;
 
     // Destroy reg_ignore on all windows if they should expire
-    if (reg_ignore_expire)
-      free_region(dpy, &w->reg_ignore);
+    if (ps->reg_ignore_expire)
+      free_region(ps, &w->reg_ignore);
 
     // Run fading
-    run_fade(dpy, w, steps);
+    run_fade(ps, w, steps);
 
     // Give up if it's not damaged or invisible, or it's unmapped and its
     // picture is gone (for example due to a ConfigureNotify)
     if (!w->damaged
         || w->a.x + w->a.width < 1 || w->a.y + w->a.height < 1
-        || w->a.x >= root_width || w->a.y >= root_height
-        || (IsUnmapped == w->a.map_state && !w->picture)) {
-      to_paint = False;
+        || w->a.x >= ps->root_width || w->a.y >= ps->root_height
+        || ((IsUnmapped == w->a.map_state || w->destroyed)
+          && !w->picture)) {
+      to_paint = false;
     }
 
     if (to_paint) {
       // If opacity changes
       if (w->opacity != opacity_old) {
-        determine_mode(dpy, w);
-        add_damage_win(dpy, w);
+        determine_mode(ps, w);
+        add_damage_win(ps, w);
       }
 
-      w->alpha_pict = get_alpha_pict_o(w->opacity);
+      w->alpha_pict = get_alpha_pict_o(ps, w->opacity);
 
       // End the game if we are using the 0 opacity alpha_pict
-      if (w->alpha_pict == alpha_picts[0]) {
-        to_paint = False;
+      if (w->alpha_pict == ps->alpha_picts[0]) {
+        to_paint = false;
       }
     }
 
     if (to_paint) {
       // Fetch bounding region
       if (!w->border_size) {
-        w->border_size = border_size(dpy, w);
+        w->border_size = border_size(ps, w);
       }
 
       // Fetch window extents
       if (!w->extents) {
-        w->extents = win_extents(dpy, w);
+        w->extents = win_extents(ps, w);
         // If w->extents does not exist, the previous add_damage_win()
         // call when opacity changes has no effect, so redo it here.
         if (w->opacity != opacity_old)
-          add_damage_win(dpy, w);
+          add_damage_win(ps, w);
       }
 
       // Calculate frame_opacity
       {
         double frame_opacity_old = w->frame_opacity;
 
-        if (opts.frame_opacity && 1.0 != opts.frame_opacity
+        if (ps->o.frame_opacity && 1.0 != ps->o.frame_opacity
             && win_has_frame(w))
-          w->frame_opacity = get_opacity_percent(dpy, w) *
-            opts.frame_opacity;
+          w->frame_opacity = get_opacity_percent(w) *
+            ps->o.frame_opacity;
         else
           w->frame_opacity = 0.0;
 
         if (w->to_paint && WINDOW_SOLID == mode_old
             && (0.0 == frame_opacity_old) != (0.0 == w->frame_opacity))
-          reg_ignore_expire = True;
+          ps->reg_ignore_expire = true;
       }
 
-      w->frame_alpha_pict = get_alpha_pict_d(w->frame_opacity);
+      w->frame_alpha_pict = get_alpha_pict_d(ps, w->frame_opacity);
 
       // Calculate shadow opacity
       if (w->frame_opacity)
-        w->shadow_opacity = opts.shadow_opacity * w->frame_opacity;
+        w->shadow_opacity = ps->o.shadow_opacity * w->frame_opacity;
       else
-        w->shadow_opacity = opts.shadow_opacity * get_opacity_percent(dpy, w);
+        w->shadow_opacity = ps->o.shadow_opacity * get_opacity_percent(w);
 
       // Rebuild shadow_pict if necessary
       if (w->flags & WFLAG_SIZE_CHANGE)
-        free_picture(dpy, &w->shadow_pict);
+        free_picture(ps, &w->shadow_pict);
 
       if (w->shadow && !w->shadow_pict) {
-        w->shadow_pict = shadow_picture(dpy, 1,
-            w->widthb, w->heightb, False);
+        w->shadow_pict = shadow_picture(ps, 1, w->widthb, w->heightb);
       }
 
-      w->shadow_alpha_pict = get_alpha_pict_d(w->shadow_opacity);
+      w->shadow_alpha_pict = get_alpha_pict_d(ps, w->shadow_opacity);
     }
 
     if ((to_paint && WINDOW_SOLID == w->mode)
         != (w->to_paint && WINDOW_SOLID == mode_old))
-      reg_ignore_expire = True;
+      ps->reg_ignore_expire = true;
 
     // Add window to damaged area if its painting status changes
     if (to_paint != w->to_paint)
-      add_damage_win(dpy, w);
+      add_damage_win(ps, w);
 
     if (to_paint) {
       // Generate ignore region for painting to reduce GPU load
-      if (reg_ignore_expire || !w->to_paint) {
-        free_region(dpy, &w->reg_ignore);
+      if (ps->reg_ignore_expire || !w->to_paint) {
+        free_region(ps, &w->reg_ignore);
 
         // If the window is solid, we add the window region to the
         // ignored region
         if (WINDOW_SOLID == w->mode) {
           if (!w->frame_opacity) {
             if (w->border_size)
-              w->reg_ignore = copy_region(dpy, w->border_size);
+              w->reg_ignore = copy_region(ps, w->border_size);
             else
-              w->reg_ignore = win_get_region(dpy, w);
+              w->reg_ignore = win_get_region(ps, w);
           }
           else {
-            w->reg_ignore = win_get_region_noframe(dpy, w);
+            w->reg_ignore = win_get_region_noframe(ps, w);
             if (w->border_size)
-              XFixesIntersectRegion(dpy, w->reg_ignore, w->reg_ignore,
+              XFixesIntersectRegion(ps->dpy, w->reg_ignore, w->reg_ignore,
                   w->border_size);
           }
 
           if (last_reg_ignore)
-            XFixesUnionRegion(dpy, w->reg_ignore, w->reg_ignore,
+            XFixesUnionRegion(ps->dpy, w->reg_ignore, w->reg_ignore,
                 last_reg_ignore);
         }
         // Otherwise we copy the last region over
         else if (last_reg_ignore)
-          w->reg_ignore = copy_region(dpy, last_reg_ignore);
+          w->reg_ignore = copy_region(ps, last_reg_ignore);
         else
           w->reg_ignore = None;
       }
@@ -1514,11 +1355,11 @@ paint_preprocess(Display *dpy, win *list) {
       last_reg_ignore = w->reg_ignore;
 
       if (is_highest && to_paint) {
-        is_highest = False;
+        is_highest = false;
         if (WINDOW_SOLID == w->mode
             && (!w->frame_opacity || !win_has_frame(w))
-            && win_is_fullscreen(w))
-          unredir_possible = True;
+            && win_is_fullscreen(ps, w))
+          ps->unredir_possible = true;
       }
 
       // Reset flags
@@ -1534,7 +1375,7 @@ paint_preprocess(Display *dpy, win *list) {
       t = w;
     }
     else {
-      check_fade_fin(dpy, w);
+      check_fade_fin(ps, w);
     }
 
     if (!destroyed)
@@ -1542,15 +1383,15 @@ paint_preprocess(Display *dpy, win *list) {
   }
 
   // If possible, unredirect all windows and stop painting
-  if (opts.unredir_if_possible && unredir_possible) {
-    redir_stop(dpy);
+  if (ps->o.unredir_if_possible && ps->unredir_possible) {
+    redir_stop(ps);
   }
   else {
-    redir_start(dpy);
+    redir_start(ps);
   }
 
   // Fetch pictures only if windows are redirected
-  if (redirected) {
+  if (ps->redirected) {
     for (w = t; w; w = w->prev_trans) {
       // Fetch the picture and pixmap if needed
       if (!w->picture) {
@@ -1558,16 +1399,16 @@ paint_preprocess(Display *dpy, win *list) {
         XRenderPictFormat *format;
         Drawable draw = w->id;
 
-        if (has_name_pixmap && !w->pixmap) {
-          set_ignore(dpy, NextRequest(dpy));
-          w->pixmap = XCompositeNameWindowPixmap(dpy, w->id);
+        if (ps->has_name_pixmap && !w->pixmap) {
+          set_ignore_next(ps);
+          w->pixmap = XCompositeNameWindowPixmap(ps->dpy, w->id);
         }
         if (w->pixmap) draw = w->pixmap;
 
-        format = XRenderFindVisualFormat(dpy, w->a.visual);
+        format = XRenderFindVisualFormat(ps->dpy, w->a.visual);
         pa.subwindow_mode = IncludeInferiors;
         w->picture = XRenderCreatePicture(
-          dpy, draw, format, CPSubwindowMode, &pa);
+          ps->dpy, draw, format, CPSubwindowMode, &pa);
       }
     }
   }
@@ -1579,9 +1420,9 @@ paint_preprocess(Display *dpy, win *list) {
  * Paint the shadow of a window.
  */
 static inline void
-win_paint_shadow(Display *dpy, win *w, Picture tgt_buffer) {
+win_paint_shadow(session_t *ps, win *w, Picture tgt_buffer) {
   XRenderComposite(
-    dpy, PictOpOver, w->shadow_pict, w->shadow_alpha_pict,
+    ps->dpy, PictOpOver, w->shadow_pict, w->shadow_alpha_pict,
     tgt_buffer, 0, 0, 0, 0,
     w->a.x + w->shadow_dx, w->a.y + w->shadow_dy,
     w->shadow_width, w->shadow_height);
@@ -1591,7 +1432,7 @@ win_paint_shadow(Display *dpy, win *w, Picture tgt_buffer) {
  * Paint a window itself and dim it if asked.
  */
 static inline void
-win_paint_win(Display *dpy, win *w, Picture tgt_buffer) {
+win_paint_win(session_t *ps, win *w, Picture tgt_buffer) {
   int x = w->a.x;
   int y = w->a.y;
   int wid = w->widthb;
@@ -1601,7 +1442,7 @@ win_paint_win(Display *dpy, win *w, Picture tgt_buffer) {
   int op = (w->mode == WINDOW_SOLID ? PictOpSrc: PictOpOver);
 
   if (!w->frame_opacity) {
-    XRenderComposite(dpy, op, w->picture, alpha_mask,
+    XRenderComposite(ps->dpy, op, w->picture, alpha_mask,
         tgt_buffer, 0, 0, 0, 0, x, y, wid, hei);
   }
   else {
@@ -1611,7 +1452,7 @@ win_paint_win(Display *dpy, win *w, Picture tgt_buffer) {
     int r = w->right_width;
 
 #define COMP_BDR(cx, cy, cwid, chei) \
-    XRenderComposite(dpy, PictOpOver, w->picture, w->frame_alpha_pict, \
+    XRenderComposite(ps->dpy, PictOpOver, w->picture, w->frame_alpha_pict, \
         tgt_buffer, (cx), (cy), 0, 0, x + (cx), y + (cy), (cwid), (chei))
 
     // The following complicated logic is required because some broken
@@ -1647,7 +1488,7 @@ win_paint_win(Display *dpy, win *w, Picture tgt_buffer) {
           pwid = wid - l - pwid;
           if (pwid > 0) {
             // body
-            XRenderComposite(dpy, op, w->picture, alpha_mask,
+            XRenderComposite(ps->dpy, op, w->picture, alpha_mask,
                 tgt_buffer, l, t, 0, 0, x + l, y + t, pwid, phei);
           }
         }
@@ -1659,7 +1500,7 @@ win_paint_win(Display *dpy, win *w, Picture tgt_buffer) {
 
   // Dimming the window if needed
   if (w->dim) {
-    XRenderComposite(dpy, PictOpOver, dim_picture, None,
+    XRenderComposite(ps->dpy, PictOpOver, ps->dim_picture, None,
         tgt_buffer, 0, 0, 0, 0, x, y, wid, hei);
   }
 }
@@ -1668,14 +1509,14 @@ win_paint_win(Display *dpy, win *w, Picture tgt_buffer) {
  * Rebuild cached <code>screen_reg</code>.
  */
 static void
-rebuild_screen_reg(Display *dpy) {
-  if (screen_reg)
-    XFixesDestroyRegion(dpy, screen_reg);
-  screen_reg = get_screen_region(dpy);
+rebuild_screen_reg(session_t *ps) {
+  if (ps->screen_reg)
+    XFixesDestroyRegion(ps->dpy, ps->screen_reg);
+  ps->screen_reg = get_screen_region(ps);
 }
 
 static void
-paint_all(Display *dpy, XserverRegion region, win *t) {
+paint_all(session_t *ps, XserverRegion region, win *t) {
 #ifdef DEBUG_REPAINT
   static struct timespec last_paint = { 0 };
 #endif
@@ -1684,67 +1525,67 @@ paint_all(Display *dpy, XserverRegion region, win *t) {
   XserverRegion reg_paint = None, reg_tmp = None, reg_tmp2 = None;
 
   if (!region) {
-    region = get_screen_region(dpy);
+    region = get_screen_region(ps);
   }
   else {
     // Remove the damaged area out of screen
-    XFixesIntersectRegion(dpy, region, region, screen_reg);
+    XFixesIntersectRegion(ps->dpy, region, region, ps->screen_reg);
   }
 
 #ifdef MONITOR_REPAINT
   // Note: MONITOR_REPAINT cannot work with DBE right now.
-  tgt_buffer = tgt_picture;
+  ps->tgt_buffer = ps->tgt_picture;
 #else
-  if (!tgt_buffer) {
+  if (!ps->tgt_buffer) {
     // DBE painting mode: Directly paint to a Picture of the back buffer
-    if (opts.dbe) {
-      tgt_buffer = XRenderCreatePicture(dpy, root_dbe,
-          XRenderFindVisualFormat(dpy, DefaultVisual(dpy, scr)),
+    if (ps->o.dbe) {
+      ps->tgt_buffer = XRenderCreatePicture(ps->dpy, ps->root_dbe,
+          XRenderFindVisualFormat(ps->dpy, ps->vis),
           0, 0);
     }
     // No-DBE painting mode: Paint to an intermediate Picture then paint
     // the Picture to root window
     else {
       Pixmap root_pixmap = XCreatePixmap(
-        dpy, root, root_width, root_height,
-        DefaultDepth(dpy, scr));
+        ps->dpy, ps->root, ps->root_width, ps->root_height,
+        ps->depth);
 
-      tgt_buffer = XRenderCreatePicture(dpy, root_pixmap,
-        XRenderFindVisualFormat(dpy, DefaultVisual(dpy, scr)),
+      ps->tgt_buffer = XRenderCreatePicture(ps->dpy, root_pixmap,
+        XRenderFindVisualFormat(ps->dpy, ps->vis),
         0, 0);
 
-      XFreePixmap(dpy, root_pixmap);
+      XFreePixmap(ps->dpy, root_pixmap);
     }
   }
 #endif
 
-  XFixesSetPictureClipRegion(dpy, tgt_picture, 0, 0, region);
+  XFixesSetPictureClipRegion(ps->dpy, ps->tgt_picture, 0, 0, region);
 
 #ifdef MONITOR_REPAINT
   XRenderComposite(
-    dpy, PictOpSrc, black_picture, None,
-    tgt_picture, 0, 0, 0, 0, 0, 0,
-    root_width, root_height);
+    ps->dpy, PictOpSrc, ps->black_picture, None,
+    ps->tgt_picture, 0, 0, 0, 0, 0, 0,
+    ps->root_width, ps->root_height);
 #endif
 
   if (t && t->reg_ignore) {
     // Calculate the region upon which the root window is to be painted
     // based on the ignore region of the lowest window, if available
-    reg_paint = reg_tmp = XFixesCreateRegion(dpy, NULL, 0);
-    XFixesSubtractRegion(dpy, reg_paint, region, t->reg_ignore);
+    reg_paint = reg_tmp = XFixesCreateRegion(ps->dpy, NULL, 0);
+    XFixesSubtractRegion(ps->dpy, reg_paint, region, t->reg_ignore);
   }
   else {
     reg_paint = region;
   }
 
-  XFixesSetPictureClipRegion(dpy, tgt_buffer, 0, 0, reg_paint);
+  XFixesSetPictureClipRegion(ps->dpy, ps->tgt_buffer, 0, 0, reg_paint);
 
-  paint_root(dpy);
+  paint_root(ps, ps->tgt_buffer);
 
   // Create temporary regions for use during painting
   if (!reg_tmp)
-    reg_tmp = XFixesCreateRegion(dpy, NULL, 0);
-  reg_tmp2 = XFixesCreateRegion(dpy, NULL, 0);
+    reg_tmp = XFixesCreateRegion(ps->dpy, NULL, 0);
+  reg_tmp2 = XFixesCreateRegion(ps->dpy, NULL, 0);
 
   for (w = t; w; w = w->prev_trans) {
     // Painting shadow
@@ -1756,28 +1597,28 @@ paint_all(Display *dpy, XserverRegion region, win *t) {
           // If it's the first cycle and reg_tmp2 is not ready, calculate
           // the paint region here
           reg_paint = reg_tmp;
-          XFixesSubtractRegion(dpy, reg_paint, region, w->reg_ignore);
+          XFixesSubtractRegion(ps->dpy, reg_paint, region, w->reg_ignore);
         }
         else {
           // Otherwise, used the cached region during last cycle
           reg_paint = reg_tmp2;
         }
-        XFixesIntersectRegion(dpy, reg_paint, reg_paint, w->extents);
+        XFixesIntersectRegion(ps->dpy, reg_paint, reg_paint, w->extents);
       }
       else {
         reg_paint = reg_tmp;
-        XFixesIntersectRegion(dpy, reg_paint, region, w->extents);
+        XFixesIntersectRegion(ps->dpy, reg_paint, region, w->extents);
       }
       // Clear the shadow here instead of in make_shadow() for saving GPU
       // power and handling shaped windows
-      if (opts.clear_shadow && w->border_size)
-        XFixesSubtractRegion(dpy, reg_paint, reg_paint, w->border_size);
+      if (ps->o.clear_shadow && w->border_size)
+        XFixesSubtractRegion(ps->dpy, reg_paint, reg_paint, w->border_size);
 
       // Detect if the region is empty before painting
-      if (region == reg_paint || !is_region_empty(dpy, reg_paint)) {
-        XFixesSetPictureClipRegion(dpy, tgt_buffer, 0, 0, reg_paint);
+      if (region == reg_paint || !is_region_empty(ps, reg_paint)) {
+        XFixesSetPictureClipRegion(ps->dpy, ps->tgt_buffer, 0, 0, reg_paint);
 
-        win_paint_shadow(dpy, w, tgt_buffer);
+        win_paint_shadow(ps, w, ps->tgt_buffer);
       }
     }
 
@@ -1785,77 +1626,77 @@ paint_all(Display *dpy, XserverRegion region, win *t) {
     // window and the bounding region
     reg_paint = reg_tmp;
     if (w->prev_trans && w->prev_trans->reg_ignore) {
-      XFixesSubtractRegion(dpy, reg_paint, region,
+      XFixesSubtractRegion(ps->dpy, reg_paint, region,
           w->prev_trans->reg_ignore);
       // Copy the subtracted region to be used for shadow painting in next
       // cycle
-      XFixesCopyRegion(dpy, reg_tmp2, reg_paint);
+      XFixesCopyRegion(ps->dpy, reg_tmp2, reg_paint);
 
       if (w->border_size)
-        XFixesIntersectRegion(dpy, reg_paint, reg_paint, w->border_size);
+        XFixesIntersectRegion(ps->dpy, reg_paint, reg_paint, w->border_size);
     }
     else {
       if (w->border_size)
-        XFixesIntersectRegion(dpy, reg_paint, region, w->border_size);
+        XFixesIntersectRegion(ps->dpy, reg_paint, region, w->border_size);
       else
         reg_paint = region;
     }
 
-    if (!is_region_empty(dpy, reg_paint)) {
-      XFixesSetPictureClipRegion(dpy, tgt_buffer, 0, 0, reg_paint);
+    if (!is_region_empty(ps, reg_paint)) {
+      XFixesSetPictureClipRegion(ps->dpy, ps->tgt_buffer, 0, 0, reg_paint);
 
       // Painting the window
-      win_paint_win(dpy, w, tgt_buffer);
+      win_paint_win(ps, w, ps->tgt_buffer);
     }
 
-    check_fade_fin(dpy, w);
+    check_fade_fin(ps, w);
   }
 
   // Free up all temporary regions
-  XFixesDestroyRegion(dpy, region);
-  XFixesDestroyRegion(dpy, reg_tmp);
-  XFixesDestroyRegion(dpy, reg_tmp2);
+  XFixesDestroyRegion(ps->dpy, region);
+  XFixesDestroyRegion(ps->dpy, reg_tmp);
+  XFixesDestroyRegion(ps->dpy, reg_tmp2);
 
   // Do this as early as possible
-  if (!opts.dbe)
-    XFixesSetPictureClipRegion(dpy, tgt_buffer, 0, 0, None);
+  if (!ps->o.dbe)
+    XFixesSetPictureClipRegion(ps->dpy, ps->tgt_buffer, 0, 0, None);
 
-  if (VSYNC_NONE != opts.vsync) {
+  if (VSYNC_NONE != ps->o.vsync) {
     // Make sure all previous requests are processed to achieve best
     // effect
-    XSync(dpy, False);
+    XSync(ps->dpy, False);
   }
 
   // Wait for VBlank. We could do it aggressively (send the painting
   // request and XFlush() on VBlank) or conservatively (send the request
   // only on VBlank).
-  if (!opts.vsync_aggressive)
-    vsync_wait();
+  if (!ps->o.vsync_aggressive)
+    vsync_wait(ps);
 
   // DBE painting mode, only need to swap the buffer
-  if (opts.dbe) {
+  if (ps->o.dbe) {
     XdbeSwapInfo swap_info = {
-      .swap_window = (opts.paint_on_overlay ? overlay: root),
+      .swap_window = (ps->o.paint_on_overlay ? ps->overlay: ps->root),
       // Is it safe to use XdbeUndefined?
       .swap_action = XdbeCopied
     };
-    XdbeSwapBuffers(dpy, &swap_info, 1);
+    XdbeSwapBuffers(ps->dpy, &swap_info, 1);
   }
   // No-DBE painting mode
-  else if (tgt_buffer != tgt_picture) {
+  else if (ps->tgt_buffer != ps->tgt_picture) {
     XRenderComposite(
-      dpy, PictOpSrc, tgt_buffer, None,
-      tgt_picture, 0, 0, 0, 0,
-      0, 0, root_width, root_height);
+      ps->dpy, PictOpSrc, ps->tgt_buffer, None,
+      ps->tgt_picture, 0, 0, 0, 0,
+      0, 0, ps->root_width, ps->root_height);
   }
 
-  if (opts.vsync_aggressive)
-    vsync_wait();
+  if (ps->o.vsync_aggressive)
+    vsync_wait(ps);
 
-  XFlush(dpy);
+  XFlush(ps->dpy);
 
 #ifdef DEBUG_REPAINT
-  print_timestamp();
+  print_timestamp(ps);
   struct timespec now = get_time_timespec();
   struct timespec diff = { 0 };
   timespec_subtract(&diff, &now, &last_paint);
@@ -1870,91 +1711,78 @@ paint_all(Display *dpy, XserverRegion region, win *t) {
 }
 
 static void
-add_damage(Display *dpy, XserverRegion damage) {
-  if (all_damage) {
-    XFixesUnionRegion(dpy, all_damage, all_damage, damage);
-    XFixesDestroyRegion(dpy, damage);
+add_damage(session_t *ps, XserverRegion damage) {
+  if (ps->all_damage) {
+    XFixesUnionRegion(ps->dpy, ps->all_damage, ps->all_damage, damage);
+    XFixesDestroyRegion(ps->dpy, damage);
   } else {
-    all_damage = damage;
+    ps->all_damage = damage;
   }
 }
 
 static void
-repair_win(Display *dpy, win *w) {
+repair_win(session_t *ps, win *w) {
   XserverRegion parts;
 
   if (!w->damaged) {
-    parts = win_extents(dpy, w);
-    set_ignore(dpy, NextRequest(dpy));
-    XDamageSubtract(dpy, w->damage, None, None);
+    parts = win_extents(ps, w);
+    set_ignore_next(ps);
+    XDamageSubtract(ps->dpy, w->damage, None, None);
   } else {
-    parts = XFixesCreateRegion(dpy, 0, 0);
-    set_ignore(dpy, NextRequest(dpy));
-    XDamageSubtract(dpy, w->damage, None, parts);
-    XFixesTranslateRegion(dpy, parts,
+    parts = XFixesCreateRegion(ps->dpy, 0, 0);
+    set_ignore_next(ps);
+    XDamageSubtract(ps->dpy, w->damage, None, parts);
+    XFixesTranslateRegion(ps->dpy, parts,
       w->a.x + w->a.border_width,
       w->a.y + w->a.border_width);
   }
 
   // Remove the part in the damage area that could be ignored
-  if (!reg_ignore_expire && w->prev_trans && w->prev_trans->reg_ignore)
-    XFixesSubtractRegion(dpy, parts, parts, w->prev_trans->reg_ignore);
+  if (!ps->reg_ignore_expire && w->prev_trans && w->prev_trans->reg_ignore)
+    XFixesSubtractRegion(ps->dpy, parts, parts, w->prev_trans->reg_ignore);
 
-  add_damage(dpy, parts);
+  add_damage(ps, parts);
   w->damaged = 1;
 }
 
-static wintype
-get_wintype_prop(Display *dpy, Window wid) {
-  Atom actual;
-  int format;
-  unsigned long n = 0, left, i;
-  long *data = NULL;
-  int j;
-
-  set_ignore(dpy, NextRequest(dpy));
-  if (Success != XGetWindowProperty(
-        dpy, wid, win_type_atom, 0L, 32L, False, XA_ATOM,
-        &actual, &format, &n, &left, (unsigned char **) &data)
-      || !data || !n) {
-    if (data)
-      XFree(data);
-    return WINTYPE_UNKNOWN;
-  }
-
-  for (i = 0; i < n; ++i) {
+static wintype_t
+wid_get_prop_wintype(session_t *ps, Window wid) {
+  int i, j;
+
+  set_ignore_next(ps);
+  winprop_t prop = wid_get_prop(ps, wid, ps->atom_win_type, 32L, XA_ATOM, 32);
+
+  for (i = 0; i < prop.nitems; ++i) {
     for (j = 1; j < NUM_WINTYPES; ++j) {
-      if (win_type[j] == (Atom) data[i]) {
-        XFree(data);
+      if (ps->atoms_wintypes[j] == (Atom) ((long *) prop.data)[i]) {
+        free_winprop(&prop);
         return j;
       }
     }
   }
 
-  XFree(data);
+  free_winprop(&prop);
 
   return WINTYPE_UNKNOWN;
 }
 
 static void
-map_win(Display *dpy, Window id,
-        unsigned long sequence, Bool fade,
-        Bool override_redirect) {
-  win *w = find_win(id);
+map_win(session_t *ps, Window id, bool override_redirect) {
+  win *w = find_win(ps, id);
 
   // Don't care about window mapping if it's an InputOnly window
   if (!w || InputOnly == w->a.class) return;
 
-  w->focused = False;
+  w->focused = false;
   w->a.map_state = IsViewable;
 
   // Call XSelectInput() before reading properties so that no property
   // changes are lost
-  XSelectInput(dpy, id, determine_evmask(dpy, id, WIN_EVMODE_FRAME));
+  XSelectInput(ps->dpy, id, determine_evmask(ps, id, WIN_EVMODE_FRAME));
 
   // Notify compton when the shape of a window changes
-  if (shape_exists) {
-    XShapeSelectInput(dpy, id, ShapeNotifyMask);
+  if (ps->shape_exists) {
+    XShapeSelectInput(ps->dpy, id, ShapeNotifyMask);
   }
 
   // Detect client window here instead of in add_win() as the client
@@ -1963,7 +1791,7 @@ map_win(Display *dpy, Window id,
     Window cw = 0;
     // Always recursively look for a window with WM_STATE, as Fluxbox
     // sets override-redirect flags on all frame windows.
-    cw = find_client_win(dpy, w->id);
+    cw = find_client_win(ps, w->id);
 #ifdef DEBUG_CLIENTWIN
     printf("find_client_win(%#010lx): client %#010lx\n", w->id, cw);
 #endif
@@ -1976,18 +1804,18 @@ map_win(Display *dpy, Window id,
 #endif
     }
     if (cw) {
-      mark_client_win(dpy, w, cw);
+      mark_client_win(ps, w, cw);
     }
   }
   else {
     // Re-mark client window here
-    mark_client_win(dpy, w, w->client_win);
+    mark_client_win(ps, w, w->client_win);
   }
 
   // Workaround for _NET_WM_WINDOW_TYPE for Openbox menus, which is
   // set on a non-override-redirect window with no WM_STATE either
   if (!w->client_win && WINTYPE_UNKNOWN == w->window_type)
-    w->window_type = get_wintype_prop(dpy, w->id);
+    w->window_type = wid_get_prop_wintype(ps, w->id);
 
 #ifdef DEBUG_WINTYPE
   printf("map_win(%#010lx): type %s\n",
@@ -1995,54 +1823,54 @@ map_win(Display *dpy, Window id,
 #endif
 
   // Detect if the window is shaped or has rounded corners
-  win_update_shape_raw(dpy, w);
+  win_update_shape_raw(ps, w);
 
   // Get window name and class if we are tracking them
-  if (opts.track_wdata) {
-    win_get_name(dpy, w);
-    win_get_class(dpy, w);
+  if (ps->o.track_wdata) {
+    win_get_name(ps, w);
+    win_get_class(ps, w);
   }
 
-  if (opts.track_focus) {
+  if (ps->o.track_focus) {
     // Occasionally compton does not seem able to get a FocusIn event from
     // a window just mapped. I suspect it's a timing issue again when the
     // XSelectInput() is called too late. We have to recheck the focused
     // window here. It makes no sense if we are using EWMH
     // _NET_ACTIVE_WINDOW.
-    if (!opts.use_ewmh_active_win)
-      recheck_focus(dpy);
+    if (!ps->o.use_ewmh_active_win)
+      recheck_focus(ps);
 
     // Consider a window without client window a WM window and mark it
     // focused if mark_wmwin_focused is on, or it's over-redirected and
     // mark_ovredir_focused is on
-    if ((opts.mark_wmwin_focused && !w->client_win)
-        || (opts.mark_ovredir_focused && w->id == w->client_win))
-      w->focused = True;
+    if ((ps->o.mark_wmwin_focused && !w->client_win)
+        || (ps->o.mark_ovredir_focused && w->id == w->client_win))
+      w->focused = true;
   }
 
   // Check for _COMPTON_SHADOW
-  if (opts.respect_attr_shadow)
-    win_update_attr_shadow_raw(dpy, w);
+  if (ps->o.respect_prop_shadow)
+    win_update_attr_shadow_raw(ps, w);
 
   // Many things above could affect shadow
-  determine_shadow(dpy, w);
+  determine_shadow(ps, w);
 
   // Fading in
-  calc_opacity(dpy, w, True);
+  calc_opacity(ps, w, true);
 
   // Set fading state
-  if (opts.no_fading_openclose) {
-    set_fade_callback(dpy, w, finish_map_win, True);
+  if (ps->o.no_fading_openclose) {
+    set_fade_callback(ps, w, finish_map_win, true);
     // Must be set after we execute the old fade callback, in case we
     // receive two continuous MapNotify for the same window
-    w->fade = False;
+    w->fade = false;
   }
   else {
-    set_fade_callback(dpy, w, NULL, True);
-    determine_fade(dpy, w);
+    set_fade_callback(ps, w, NULL, true);
+    determine_fade(ps, w);
   }
 
-  calc_dim(dpy, w);
+  calc_dim(ps, w);
 
   w->damaged = 1;
 
@@ -2051,42 +1879,42 @@ map_win(Display *dpy, Window id,
      the window was unmapped, then configure
      the window to its correct place */
   if (w->need_configure) {
-    configure_win(dpy, &w->queue_configure);
+    configure_win(ps, &w->queue_configure);
   }
 }
 
 static void
-finish_map_win(Display *dpy, win *w) {
-  if (opts.no_fading_openclose)
-    determine_fade(dpy, w);
+finish_map_win(session_t *ps, win *w) {
+  if (ps->o.no_fading_openclose)
+    determine_fade(ps, w);
 }
 
 static void
-finish_unmap_win(Display *dpy, win *w) {
+finish_unmap_win(session_t *ps, win *w) {
   w->damaged = 0;
 
-  update_reg_ignore_expire(w);
+  update_reg_ignore_expire(ps, w);
 
   if (w->extents != None) {
     /* destroys region */
-    add_damage(dpy, w->extents);
+    add_damage(ps, w->extents);
     w->extents = None;
   }
 
-  free_pixmap(dpy, &w->pixmap);
-  free_picture(dpy, &w->picture);
-  free_region(dpy, &w->border_size);
-  free_picture(dpy, &w->shadow_pict);
+  free_pixmap(ps, &w->pixmap);
+  free_picture(ps, &w->picture);
+  free_region(ps, &w->border_size);
+  free_picture(ps, &w->shadow_pict);
 }
 
 static void
-unmap_callback(Display *dpy, win *w) {
-  finish_unmap_win(dpy, w);
+unmap_callback(session_t *ps, win *w) {
+  finish_unmap_win(ps, w);
 }
 
 static void
-unmap_win(Display *dpy, Window id, Bool fade) {
-  win *w = find_win(id);
+unmap_win(session_t *ps, Window id) {
+  win *w = find_win(ps, id);
 
   if (!w || IsUnmapped == w->a.map_state) return;
 
@@ -2094,48 +1922,36 @@ unmap_win(Display *dpy, Window id, Bool fade) {
 
   // Fading out
   w->opacity_tgt = 0;
-  set_fade_callback(dpy, w, unmap_callback, False);
-  if (opts.no_fading_openclose)
-    w->fade = False;
+  set_fade_callback(ps, w, unmap_callback, false);
+  if (ps->o.no_fading_openclose)
+    w->fade = false;
 
   // don't care about properties anymore
-  // Will get BadWindow if the window is destroyed
-  set_ignore(dpy, NextRequest(dpy));
-  XSelectInput(dpy, w->id, 0);
-
-  if (w->client_win) {
-    set_ignore(dpy, NextRequest(dpy));
-    XSelectInput(dpy, w->client_win, 0);
-  }
+  win_ev_stop(ps, w);
 }
 
 static opacity_t
-wid_get_opacity_prop(Display *dpy, Window wid, opacity_t def) {
-  Atom actual;
-  int format;
-  unsigned long n, left;
+wid_get_opacity_prop(session_t *ps, Window wid, opacity_t def) {
+  opacity_t val = def;
 
-  unsigned char *data;
-  int result = XGetWindowProperty(
-    dpy, wid, opacity_atom, 0L, 1L, False,
-    XA_CARDINAL, &actual, &format, &n, &left, &data);
+  winprop_t prop = wid_get_prop(ps, wid, ps->atom_opacity, 1L,
+      XA_CARDINAL, 32);
 
-  if (result == Success && data != NULL) {
-    opacity_t i = *((opacity_t *) data);
-    XFree(data);
-    return i;
-  }
+  if (prop.nitems)
+    val = *((long *) prop.data);
+
+  free_winprop(&prop);
 
-  return def;
+  return val;
 }
 
 static double
-get_opacity_percent(Display *dpy, win *w) {
+get_opacity_percent(win *w) {
   return ((double) w->opacity) / OPAQUE;
 }
 
 static void
-determine_mode(Display *dpy, win *w) {
+determine_mode(session_t *ps, win *w) {
   winmode mode;
   XRenderPictFormat *format;
 
@@ -2144,7 +1960,7 @@ determine_mode(Display *dpy, win *w) {
   if (w->a.class == InputOnly) {
     format = 0;
   } else {
-    format = XRenderFindVisualFormat(dpy, w->a.visual);
+    format = XRenderFindVisualFormat(ps->dpy, w->a.visual);
   }
 
   if (format && format->type == PictTypeDirect
@@ -2180,7 +1996,7 @@ determine_mode(Display *dpy, win *w) {
  *    refetched
  */
 static void
-calc_opacity(Display *dpy, win *w, Bool refetch_prop) {
+calc_opacity(session_t *ps, win *w, bool refetch_prop) {
   opacity_t opacity;
 
   // Do nothing for unmapped window, calc_opacity() will be called
@@ -2191,42 +2007,45 @@ calc_opacity(Display *dpy, win *w, Bool refetch_prop) {
   // Do not refetch the opacity window attribute unless necessary, this
   // is probably an expensive operation in some cases
   if (refetch_prop) {
-    w->opacity_prop = wid_get_opacity_prop(dpy, w->id, OPAQUE);
-    if (!opts.detect_client_opacity || !w->client_win
+    w->opacity_prop = wid_get_opacity_prop(ps, w->id, OPAQUE);
+    if (!ps->o.detect_client_opacity || !w->client_win
         || w->id == w->client_win)
       w->opacity_prop_client = OPAQUE;
     else
-      w->opacity_prop_client = wid_get_opacity_prop(dpy, w->client_win,
+      w->opacity_prop_client = wid_get_opacity_prop(ps, w->client_win,
             OPAQUE);
   }
 
   if (OPAQUE == (opacity = w->opacity_prop)
       && OPAQUE == (opacity = w->opacity_prop_client)) {
-    opacity = opts.wintype_opacity[w->window_type] * OPAQUE;
+    opacity = ps->o.wintype_opacity[w->window_type] * OPAQUE;
   }
 
   // Respect inactive_opacity in some cases
-  if (opts.inactive_opacity && is_normal_win(w) && False == w->focused
-      && (OPAQUE == opacity || opts.inactive_opacity_override)) {
-    opacity = opts.inactive_opacity;
+  if (ps->o.inactive_opacity && is_normal_win(w) && false == w->focused
+      && (OPAQUE == opacity || ps->o.inactive_opacity_override)) {
+    opacity = ps->o.inactive_opacity;
   }
 
   w->opacity_tgt = opacity;
 }
 
+/**
+ * Determine whether a window is to be dimmed.
+ */
 static void
-calc_dim(Display *dpy, win *w) {
-  Bool dim;
+calc_dim(session_t *ps, win *w) {
+  bool dim;
 
-  if (opts.inactive_dim && is_normal_win(w) && !(w->focused)) {
-    dim = True;
+  if (ps->o.inactive_dim && is_normal_win(w) && !(w->focused)) {
+    dim = true;
   } else {
-    dim = False;
+    dim = false;
   }
 
   if (dim != w->dim) {
     w->dim = dim;
-    add_damage_win(dpy, w);
+    add_damage_win(ps, w);
   }
 }
 
@@ -2234,19 +2053,19 @@ calc_dim(Display *dpy, win *w) {
  * Determine if a window should fade on opacity change.
  */
 static void
-determine_fade(Display *dpy, win *w) {
-  w->fade = opts.wintype_fade[w->window_type];
+determine_fade(session_t *ps, win *w) {
+  w->fade = ps->o.wintype_fade[w->window_type];
 }
 
 /**
  * Update window-shape.
  */
 static void
-win_update_shape_raw(Display *dpy, win *w) {
-  if (shape_exists) {
-    w->bounding_shaped = wid_bounding_shaped(dpy, w->id);
-    if (w->bounding_shaped && opts.detect_rounded_corners)
-      win_rounded_corners(dpy, w);
+win_update_shape_raw(session_t *ps, win *w) {
+  if (ps->shape_exists) {
+    w->bounding_shaped = wid_bounding_shaped(ps, w->id);
+    if (w->bounding_shaped && ps->o.detect_rounded_corners)
+      win_rounded_corners(ps, w);
   }
 }
 
@@ -2254,20 +2073,20 @@ win_update_shape_raw(Display *dpy, win *w) {
  * Update window-shape related information.
  */
 static void
-win_update_shape(Display *dpy, win *w) {
-  if (shape_exists) {
-    // Bool bounding_shaped_old = w->bounding_shaped;
+win_update_shape(session_t *ps, win *w) {
+  if (ps->shape_exists) {
+    // bool bounding_shaped_old = w->bounding_shaped;
 
-    win_update_shape_raw(dpy, w);
+    win_update_shape_raw(ps, w);
 
     // Shadow state could be changed
-    determine_shadow(dpy, w);
+    determine_shadow(ps, w);
 
     /*
     // If clear_shadow state on the window possibly changed, destroy the old
     // shadow_pict
-    if (opts.clear_shadow && w->bounding_shaped != bounding_shaped_old)
-      free_picture(dpy, &w->shadow_pict);
+    if (ps->o.clear_shadow && w->bounding_shaped != bounding_shaped_old)
+      free_picture(ps, &w->shadow_pict);
     */
   }
 }
@@ -2278,18 +2097,18 @@ win_update_shape(Display *dpy, win *w) {
  * The property must be set on the outermost window, usually the WM frame.
  */
 static void
-win_update_attr_shadow_raw(Display *dpy, win *w) {
-  winattr_t attr = wid_get_attr(dpy, w->id, compton_shadow_atom, 1,
+win_update_attr_shadow_raw(session_t *ps, win *w) {
+  winprop_t prop = wid_get_prop(ps, w->id, ps->atom_compton_shadow, 1,
       XA_CARDINAL, 32);
-  
-  if (!attr.nitems) {
-    free_winattr(&attr);
-    w->attr_shadow = -1;
 
-    return;
+  if (!prop.nitems) {
+    w->attr_shadow = -1;
+  }
+  else {
+    w->attr_shadow = *((long *) prop.data);
   }
 
-  w->attr_shadow = *((long *) attr.data);
+  free_winprop(&prop);
 }
 
 /**
@@ -2297,13 +2116,13 @@ win_update_attr_shadow_raw(Display *dpy, win *w) {
  * things.
  */
 static void
-win_update_attr_shadow(Display *dpy, win *w) {
+win_update_attr_shadow(session_t *ps, win *w) {
   long attr_shadow_old = w->attr_shadow;
 
-  win_update_attr_shadow_raw(dpy, w);
+  win_update_attr_shadow_raw(ps, w);
 
   if (w->attr_shadow != attr_shadow_old)
-    determine_shadow(dpy, w);
+    determine_shadow(ps, w);
 }
 
 /**
@@ -2311,29 +2130,29 @@ win_update_attr_shadow(Display *dpy, win *w) {
  * on shadow state.
  */
 static void
-determine_shadow(Display *dpy, win *w) {
-  Bool shadow_old = w->shadow;
+determine_shadow(session_t *ps, win *w) {
+  bool shadow_old = w->shadow;
 
-  w->shadow = (opts.wintype_shadow[w->window_type]
-      && !win_match(w, opts.shadow_blacklist, &w->cache_sblst)
-      && !(opts.shadow_ignore_shaped && w->bounding_shaped
+  w->shadow = (ps->o.wintype_shadow[w->window_type]
+      && !win_match(w, ps->o.shadow_blacklist, &w->cache_sblst)
+      && !(ps->o.shadow_ignore_shaped && w->bounding_shaped
         && !w->rounded_corners)
-      && !(opts.respect_attr_shadow && 0 == w->attr_shadow));
+      && !(ps->o.respect_prop_shadow && 0 == w->attr_shadow));
 
   // Window extents need update on shadow state change
   if (w->shadow != shadow_old) {
     // Shadow geometry currently doesn't change on shadow state change
-    // calc_shadow_geometry(dpy, w);
+    // calc_shadow_geometry(ps, w);
     if (w->extents) {
       // Mark the old extents as damaged if the shadow is removed
       if (!w->shadow)
-        add_damage(dpy, w->extents);
+        add_damage(ps, w->extents);
       else
-        free_region(dpy, &w->extents);
-      w->extents = win_extents(dpy, w);
+        free_region(ps, &w->extents);
+      w->extents = win_extents(ps, w);
       // Mark the new extents as damaged if the shadow is added
       if (w->shadow)
-        add_damage_win(dpy, w);
+        add_damage_win(ps, w);
     }
   }
 }
@@ -2343,10 +2162,10 @@ determine_shadow(Display *dpy, win *w) {
  */
 
 static void
-calc_win_size(Display *dpy, win *w) {
+calc_win_size(session_t *ps, win *w) {
   w->widthb = w->a.width + w->a.border_width * 2;
   w->heightb = w->a.height + w->a.border_width * 2;
-  calc_shadow_geometry(dpy, w);
+  calc_shadow_geometry(ps, w);
   w->flags |= WFLAG_SIZE_CHANGE;
 }
 
@@ -2354,11 +2173,11 @@ calc_win_size(Display *dpy, win *w) {
  * Calculate and update geometry of the shadow of a window.
  */
 static void
-calc_shadow_geometry(Display *dpy, win *w) {
-  w->shadow_dx = opts.shadow_offset_x;
-  w->shadow_dy = opts.shadow_offset_y;
-  w->shadow_width = w->widthb + gaussian_map->size;
-  w->shadow_height = w->heightb + gaussian_map->size;
+calc_shadow_geometry(session_t *ps, win *w) {
+  w->shadow_dx = ps->o.shadow_offset_x;
+  w->shadow_dy = ps->o.shadow_offset_y;
+  w->shadow_width = w->widthb + ps->gaussian_map->size;
+  w->shadow_height = w->heightb + ps->gaussian_map->size;
 }
 
 /**
@@ -2369,27 +2188,27 @@ calc_shadow_geometry(Display *dpy, win *w) {
  * @param client window ID of the client window
  */
 static void
-mark_client_win(Display *dpy, win *w, Window client) {
+mark_client_win(session_t *ps, win *w, Window client) {
   w->client_win = client;
 
-  XSelectInput(dpy, client, determine_evmask(dpy, client, WIN_EVMODE_CLIENT));
+  XSelectInput(ps->dpy, client, determine_evmask(ps, client, WIN_EVMODE_CLIENT));
 
   // Get the frame width and monitor further frame width changes on client
   // window if necessary
-  if (opts.frame_opacity) {
-    get_frame_extents(dpy, w, client);
+  if (ps->o.frame_opacity) {
+    get_frame_extents(ps, w, client);
   }
 
   // Detect window type here
   if (WINTYPE_UNKNOWN == w->window_type)
-    w->window_type = get_wintype_prop(dpy, w->client_win);
+    w->window_type = wid_get_prop_wintype(ps, w->client_win);
 
   // Conform to EWMH standard, if _NET_WM_WINDOW_TYPE is not present, take
   // override-redirect windows or windows without WM_TRANSIENT_FOR as
   // _NET_WM_WINDOW_TYPE_NORMAL, otherwise as _NET_WM_WINDOW_TYPE_DIALOG.
   if (WINTYPE_UNKNOWN == w->window_type) {
     if (w->a.override_redirect
-        || !wid_has_attr(dpy, client, transient_atom))
+        || !wid_has_attr(ps, client, ps->atom_transient))
       w->window_type = WINTYPE_NORMAL;
     else
       w->window_type = WINTYPE_DIALOG;
@@ -2397,8 +2216,9 @@ mark_client_win(Display *dpy, win *w, Window client) {
 }
 
 static void
-add_win(Display *dpy, Window id, Window prev, Bool override_redirect) {
-  if (find_win(id)) {
+add_win(session_t *ps, Window id, Window prev, bool override_redirect) {
+  // Reject overlay window and already added windows
+  if (id == ps->overlay || find_win(ps, id)) {
     return;
   }
 
@@ -2408,24 +2228,24 @@ add_win(Display *dpy, Window id, Window prev, Bool override_redirect) {
   if (!new) return;
 
   if (prev) {
-    for (p = &list; *p; p = &(*p)->next) {
+    for (p = &ps->list; *p; p = &(*p)->next) {
       if ((*p)->id == prev && !(*p)->destroyed)
         break;
     }
   } else {
-    p = &list;
+    p = &ps->list;
   }
 
   new->id = id;
-  set_ignore(dpy, NextRequest(dpy));
+  set_ignore_next(ps);
 
-  if (!XGetWindowAttributes(dpy, id, &new->a)) {
+  if (!XGetWindowAttributes(ps->dpy, id, &new->a)) {
     free(new);
     return;
   }
 
   new->damaged = 0;
-  new->to_paint = False;
+  new->to_paint = false;
   new->pixmap = None;
   new->picture = None;
 
@@ -2433,9 +2253,9 @@ add_win(Display *dpy, Window id, Window prev, Bool override_redirect) {
     new->damage_sequence = 0;
     new->damage = None;
   } else {
-    new->damage_sequence = NextRequest(dpy);
-    set_ignore(dpy, NextRequest(dpy));
-    new->damage = XDamageCreate(dpy, id, XDamageReportNonEmpty);
+    new->damage_sequence = NextRequest(ps->dpy);
+    set_ignore_next(ps);
+    new->damage = XDamageCreate(ps->dpy, id, XDamageReportNonEmpty);
   }
 
   new->name = NULL;
@@ -2443,13 +2263,13 @@ add_win(Display *dpy, Window id, Window prev, Bool override_redirect) {
   new->class_general = NULL;
   new->cache_sblst = NULL;
   new->cache_fblst = NULL;
-  new->bounding_shaped = False;
-  new->rounded_corners = False;
+  new->bounding_shaped = false;
+  new->rounded_corners = false;
 
   new->border_size = None;
   new->reg_ignore = None;
   new->extents = None;
-  new->shadow = False;
+  new->shadow = false;
   new->shadow_opacity = 0.0;
   new->shadow_pict = None;
   new->shadow_alpha_pict = None;
@@ -2461,15 +2281,15 @@ add_win(Display *dpy, Window id, Window prev, Bool override_redirect) {
   new->opacity_tgt = 0;
   new->opacity_prop = OPAQUE;
   new->opacity_prop_client = OPAQUE;
-  new->fade = False;
+  new->fade = false;
   new->fade_callback = NULL;
   new->alpha_pict = None;
   new->frame_opacity = 1.0;
   new->frame_alpha_pict = None;
-  new->dim = False;
-  new->focused = False;
-  new->destroyed = False;
-  new->need_configure = False;
+  new->dim = false;
+  new->focused = false;
+  new->destroyed = false;
+  new->need_configure = false;
   new->window_type = WINTYPE_UNKNOWN;
   new->mode = WINDOW_TRANS;
   new->attr_shadow = -1;
@@ -2485,21 +2305,21 @@ add_win(Display *dpy, Window id, Window prev, Bool override_redirect) {
 
   new->flags = 0;
 
-  calc_win_size(dpy, new);
+  calc_win_size(ps, new);
 
   new->next = *p;
   *p = new;
 
   if (new->a.map_state == IsViewable) {
-    map_win(dpy, id, new->damage_sequence - 1, True, override_redirect);
+    map_win(ps, id, override_redirect);
   }
 }
 
 static void
-restack_win(Display *dpy, win *w, Window new_above) {
+restack_win(session_t *ps, win *w, Window new_above) {
   Window old_above;
 
-  update_reg_ignore_expire(w);
+  update_reg_ignore_expire(ps, w);
 
   if (w->next) {
     old_above = w->next->id;
@@ -2511,14 +2331,14 @@ restack_win(Display *dpy, win *w, Window new_above) {
     win **prev;
 
     /* unhook */
-    for (prev = &list; *prev; prev = &(*prev)->next) {
+    for (prev = &ps->list; *prev; prev = &(*prev)->next) {
       if ((*prev) == w) break;
     }
 
     *prev = w->next;
 
     /* rehook */
-    for (prev = &list; *prev; prev = &(*prev)->next) {
+    for (prev = &ps->list; *prev; prev = &(*prev)->next) {
       if ((*prev)->id == new_above && !(*prev)->destroyed)
         break;
     }
@@ -2531,7 +2351,7 @@ restack_win(Display *dpy, win *w, Window new_above) {
       const char *desc;
       char *window_name = NULL;
       bool to_free;
-      win* c = list;
+      win* c = ps->list;
 
       printf("restack_win(%#010lx, %#010lx): "
              "Window stack modified. Current stack:\n", w->id, new_above);
@@ -2539,7 +2359,7 @@ restack_win(Display *dpy, win *w, Window new_above) {
       for (; c; c = c->next) {
         window_name = "(Failed to get title)";
 
-        to_free = ev_window_name(dpy, c->id, &window_name);
+        to_free = ev_window_name(ps, c->id, &window_name);
 
         desc = "";
         if (c->destroyed) desc = "(D) ";
@@ -2557,21 +2377,21 @@ restack_win(Display *dpy, win *w, Window new_above) {
 }
 
 static void
-configure_win(Display *dpy, XConfigureEvent *ce) {
-  if (ce->window == root) {
-    if (tgt_buffer) {
-      XRenderFreePicture(dpy, tgt_buffer);
-      tgt_buffer = None;
+configure_win(session_t *ps, XConfigureEvent *ce) {
+  if (ce->window == ps->root) {
+    if (ps->tgt_buffer) {
+      XRenderFreePicture(ps->dpy, ps->tgt_buffer);
+      ps->tgt_buffer = None;
     }
-    root_width = ce->width;
-    root_height = ce->height;
+    ps->root_width = ce->width;
+    ps->root_height = ce->height;
 
-    rebuild_screen_reg(dpy);
+    rebuild_screen_reg(ps);
 
     return;
   }
 
-  win *w = find_win(ce->window);
+  win *w = find_win(ps, ce->window);
   XserverRegion damage = None;
 
   if (!w)
@@ -2579,38 +2399,38 @@ configure_win(Display *dpy, XConfigureEvent *ce) {
 
   if (w->a.map_state == IsUnmapped) {
     /* save the configure event for when the window maps */
-    w->need_configure = True;
+    w->need_configure = true;
     w->queue_configure = *ce;
-    restack_win(dpy, w, ce->above);
+    restack_win(ps, w, ce->above);
   } else {
     if (!(w->need_configure)) {
-      restack_win(dpy, w, ce->above);
+      restack_win(ps, w, ce->above);
     }
 
     // Windows restack (including window restacks happened when this
     // window is not mapped) could mess up all reg_ignore
-    reg_ignore_expire = True;
+    ps->reg_ignore_expire = true;
 
-    w->need_configure = False;
+    w->need_configure = false;
 
-    damage = XFixesCreateRegion(dpy, 0, 0);
+    damage = XFixesCreateRegion(ps->dpy, 0, 0);
     if (w->extents != None) {
-      XFixesCopyRegion(dpy, damage, w->extents);
+      XFixesCopyRegion(ps->dpy, damage, w->extents);
     }
 
     // If window geometry did not change, don't free extents here
     if (w->a.x != ce->x || w->a.y != ce->y
         || w->a.width != ce->width || w->a.height != ce->height) {
-      free_region(dpy, &w->extents);
-      free_region(dpy, &w->border_size);
+      free_region(ps, &w->extents);
+      free_region(ps, &w->border_size);
     }
 
     w->a.x = ce->x;
     w->a.y = ce->y;
 
     if (w->a.width != ce->width || w->a.height != ce->height) {
-      free_pixmap(dpy, &w->pixmap);
-      free_picture(dpy, &w->picture);
+      free_pixmap(ps, &w->pixmap);
+      free_picture(ps, &w->picture);
     }
 
     if (w->a.width != ce->width || w->a.height != ce->height
@@ -2618,19 +2438,19 @@ configure_win(Display *dpy, XConfigureEvent *ce) {
       w->a.width = ce->width;
       w->a.height = ce->height;
       w->a.border_width = ce->border_width;
-      calc_win_size(dpy, w);
+      calc_win_size(ps, w);
 
       // Rounded corner detection is affected by window size
-      if (shape_exists && opts.shadow_ignore_shaped
-          && opts.detect_rounded_corners && w->bounding_shaped)
-        win_update_shape(dpy, w);
+      if (ps->shape_exists && ps->o.shadow_ignore_shaped
+          && ps->o.detect_rounded_corners && w->bounding_shaped)
+        win_update_shape(ps, w);
     }
 
     if (damage) {
-      XserverRegion extents = win_extents(dpy, w);
-      XFixesUnionRegion(dpy, damage, damage, extents);
-      XFixesDestroyRegion(dpy, extents);
-      add_damage(dpy, damage);
+      XserverRegion extents = win_extents(ps, w);
+      XFixesUnionRegion(ps->dpy, damage, damage, extents);
+      XFixesDestroyRegion(ps->dpy, extents);
+      add_damage(ps, damage);
     }
   }
 
@@ -2638,40 +2458,35 @@ configure_win(Display *dpy, XConfigureEvent *ce) {
 }
 
 static void
-circulate_win(Display *dpy, XCirculateEvent *ce) {
-  win *w = find_win(ce->window);
+circulate_win(session_t *ps, XCirculateEvent *ce) {
+  win *w = find_win(ps, ce->window);
   Window new_above;
 
   if (!w) return;
 
   if (ce->place == PlaceOnTop) {
-    new_above = list->id;
+    new_above = ps->list->id;
   } else {
     new_above = None;
   }
 
-  restack_win(dpy, w, new_above);
+  restack_win(ps, w, new_above);
 }
 
 static void
-finish_destroy_win(Display *dpy, Window id) {
+finish_destroy_win(session_t *ps, Window id) {
   win **prev, *w;
 
-  for (prev = &list; (w = *prev); prev = &w->next) {
+  for (prev = &ps->list; (w = *prev); prev = &w->next) {
     if (w->id == id && w->destroyed) {
-      finish_unmap_win(dpy, w);
+      finish_unmap_win(ps, w);
       *prev = w->next;
 
       // Clear active_win if it's pointing to the destroyed window
-      if (active_win)
-        active_win = NULL;
+      if (ps->active_win)
+        ps->active_win = NULL;
 
-      free_picture(dpy, &w->shadow_pict);
-      free_damage(dpy, &w->damage);
-      free_region(dpy, &w->reg_ignore);
-      free(w->name);
-      free(w->class_instance);
-      free(w->class_general);
+      free_win_res(ps, w);
 
       free(w);
       break;
@@ -2680,67 +2495,72 @@ finish_destroy_win(Display *dpy, Window id) {
 }
 
 static void
-destroy_callback(Display *dpy, win *w) {
-  finish_destroy_win(dpy, w->id);
+destroy_callback(session_t *ps, win *w) {
+  finish_destroy_win(ps, w->id);
 }
 
 static void
-destroy_win(Display *dpy, Window id, Bool fade) {
-  win *w = find_win(id);
+destroy_win(session_t *ps, Window id) {
+  win *w = find_win(ps, id);
 
   if (w) {
-    w->destroyed = True;
+    w->destroyed = true;
 
     // Fading out the window
     w->opacity_tgt = 0;
-    set_fade_callback(dpy, w, destroy_callback, False);
+    set_fade_callback(ps, w, destroy_callback, false);
   }
 }
 
 static inline void
-root_damaged(void) {
-  if (root_tile) {
-    XClearArea(dpy, root, 0, 0, 0, 0, True);
-    // if (root_picture != root_tile) {
-      XRenderFreePicture(dpy, root_tile);
-      root_tile = None;
+root_damaged(session_t *ps) {
+  if (ps->root_tile) {
+    XClearArea(ps->dpy, ps->root, 0, 0, 0, 0, true);
+    // if (ps->root_picture != ps->root_tile) {
+      XRenderFreePicture(ps->dpy, ps->root_tile);
+      ps->root_tile = None;
     /* }
     if (root_damage) {
-      XserverRegion parts = XFixesCreateRegion(dpy, 0, 0);
-      XDamageSubtract(dpy, root_damage, None, parts);
-      add_damage(dpy, parts);
+      XserverRegion parts = XFixesCreateRegion(ps->dpy, 0, 0);
+      XDamageSubtract(ps->dpy, root_damage, None, parts);
+      add_damage(ps, parts);
     } */
   }
   // Mark screen damaged if we are painting on overlay
-  if (opts.paint_on_overlay)
-    add_damage(dpy, get_screen_region(dpy));
+  if (ps->o.paint_on_overlay)
+    add_damage(ps, get_screen_region(ps));
 }
 
 static void
-damage_win(Display *dpy, XDamageNotifyEvent *de) {
+damage_win(session_t *ps, XDamageNotifyEvent *de) {
   /*
-  if (root == de->drawable) {
+  if (ps->root == de->drawable) {
     root_damaged();
     return;
   } */
 
-  win *w = find_win(de->drawable);
+  win *w = find_win(ps, de->drawable);
 
   if (!w) return;
 
-  repair_win(dpy, w);
+  repair_win(ps, w);
 }
 
+/**
+ * Xlib error handler function.
+ */
 static int
 error(Display *dpy, XErrorEvent *ev) {
+  session_t * const ps = ps_g;
+
   int o;
   const char *name = "Unknown";
 
-  if (should_ignore(dpy, ev->serial)) {
+  if (should_ignore(ps, ev->serial)) {
     return 0;
   }
 
-  if (ev->request_code == composite_opcode
+  if (ev->request_code == ps->composite_opcode
       && ev->minor_code == X_CompositeRedirectSubwindows) {
     fprintf(stderr, "Another composite manager is already running\n");
     exit(1);
@@ -2748,17 +2568,17 @@ error(Display *dpy, XErrorEvent *ev) {
 
 #define CASESTRRET2(s)   case s: name = #s; break
 
-  o = ev->error_code - xfixes_error;
+  o = ev->error_code - ps->xfixes_error;
   switch (o) {
     CASESTRRET2(BadRegion);
   }
 
-  o = ev->error_code - damage_error;
+  o = ev->error_code - ps->damage_error;
   switch (o) {
     CASESTRRET2(BadDamage);
   }
 
-  o = ev->error_code - render_error;
+  o = ev->error_code - ps->render_error;
   switch (o) {
     CASESTRRET2(BadPictFormat);
     CASESTRRET2(BadPicture);
@@ -2789,7 +2609,7 @@ error(Display *dpy, XErrorEvent *ev) {
 
 #undef CASESTRRET2
 
-  print_timestamp();
+  print_timestamp(ps);
   printf("error %d (%s) request %d minor %d serial %lu\n",
     ev->error_code, name, ev->request_code,
     ev->minor_code, ev->serial);
@@ -2798,74 +2618,84 @@ error(Display *dpy, XErrorEvent *ev) {
 }
 
 static void
-expose_root(Display *dpy, XRectangle *rects, int nrects) {
-  XserverRegion region = XFixesCreateRegion(dpy, rects, nrects);
-  add_damage(dpy, region);
+expose_root(session_t *ps, XRectangle *rects, int nrects) {
+  XserverRegion region = XFixesCreateRegion(ps->dpy, rects, nrects);
+  add_damage(ps, region);
 }
 
-static Bool
-wid_get_text_prop(Display *dpy, Window wid, Atom prop,
+/**
+ * Get the value of a text property of a window.
+ */
+static bool
+wid_get_text_prop(session_t *ps, Window wid, Atom prop,
     char ***pstrlst, int *pnstr) {
   XTextProperty text_prop;
 
-  if (!(XGetTextProperty(dpy, wid, &text_prop, prop) && text_prop.value))
-    return False;
+  if (!(XGetTextProperty(ps->dpy, wid, &text_prop, prop) && text_prop.value))
+    return false;
 
   if (Success !=
-      XmbTextPropertyToTextList(dpy, &text_prop, pstrlst, pnstr)
+      XmbTextPropertyToTextList(ps->dpy, &text_prop, pstrlst, pnstr)
       || !*pnstr) {
     *pnstr = 0;
     if (*pstrlst)
       XFreeStringList(*pstrlst);
-    return False;
+    return false;
   }
 
-  return True;
+  return true;
 }
 
-static Bool
-wid_get_name(Display *dpy, Window wid, char **name) {
+/**
+ * Get the name of a window from window ID.
+ */
+static bool
+wid_get_name(session_t *ps, Window wid, char **name) {
   XTextProperty text_prop;
   char **strlst = NULL;
   int nstr = 0;
 
-  // set_ignore(dpy, NextRequest(dpy));
-  if (!(XGetTextProperty(dpy, wid, &text_prop, name_ewmh_atom)
+  // set_ignore_next(ps);
+  if (!(XGetTextProperty(ps->dpy, wid, &text_prop, ps->atom_name_ewmh)
       && text_prop.value)) {
-    // set_ignore(dpy, NextRequest(dpy));
+    // set_ignore_next(ps);
 #ifdef DEBUG_WINDATA
     printf("wid_get_name(%#010lx): _NET_WM_NAME unset, falling back to WM_NAME.\n", wid);
 #endif
 
-    if (!(XGetWMName(dpy, wid, &text_prop) && text_prop.value)) {
-      return False;
+    if (!(XGetWMName(ps->dpy, wid, &text_prop) && text_prop.value)) {
+      return false;
     }
   }
   if (Success !=
-      XmbTextPropertyToTextList(dpy, &text_prop, &strlst, &nstr)
+      XmbTextPropertyToTextList(ps->dpy, &text_prop, &strlst, &nstr)
       || !nstr || !strlst) {
     if (strlst)
       XFreeStringList(strlst);
-    return False;
+    return false;
   }
   *name = mstrcpy(strlst[0]);
 
   XFreeStringList(strlst);
 
-  return True;
+  return true;
 }
 
+/**
+ * Retrieve the name of a window and update its <code>win</code>
+ * structure.
+ */
 static int
-win_get_name(Display *dpy, win *w) {
-  Bool ret;
+win_get_name(session_t *ps, win *w) {
+  bool ret;
   char *name_old = w->name;
 
   // Can't do anything if there's no client window
   if (!w->client_win)
-    return False;
+    return false;
 
   // Get the name
-  ret = wid_get_name(dpy, w->client_win, &w->name);
+  ret = wid_get_name(ps, w->client_win, &w->name);
 
   // Return -1 if wid_get_name() failed, 0 if name didn't change, 1 if
   // it changes
@@ -2888,14 +2718,18 @@ win_get_name(Display *dpy, win *w) {
   return ret;
 }
 
-static Bool
-win_get_class(Display *dpy, win *w) {
+/**
+ * Retrieve the <code>WM_CLASS</code> of a window and update its
+ * <code>win</code> structure.
+ */
+static bool
+win_get_class(session_t *ps, win *w) {
   char **strlst = NULL;
   int nstr = 0;
 
   // Can't do anything if there's no client window
   if (!w->client_win)
-    return False;
+    return false;
 
   // Free and reset old strings
   free(w->class_instance);
@@ -2904,8 +2738,8 @@ win_get_class(Display *dpy, win *w) {
   w->class_general = NULL;
 
   // Retrieve the property string list
-  if (!wid_get_text_prop(dpy, w->client_win, class_atom, &strlst, &nstr))
-    return False;
+  if (!wid_get_text_prop(ps, w->client_win, ps->atom_class, &strlst, &nstr))
+    return false;
 
   // Copy the strings if successful
   w->class_instance = mstrcpy(strlst[0]);
@@ -2921,7 +2755,7 @@ win_get_class(Display *dpy, win *w) {
       w->id, w->client_win, w->class_instance, w->class_general);
 #endif
 
-  return True;
+  return true;
 }
 
 #ifdef DEBUG_EVENTS
@@ -2934,7 +2768,7 @@ ev_serial(XEvent *ev) {
 }
 
 static const char *
-ev_name(XEvent *ev) {
+ev_name(session_t *ps, XEvent *ev) {
   static char buf[128];
   switch (ev->type & 0x7f) {
     CASESTRRET(FocusIn);
@@ -2950,11 +2784,11 @@ ev_name(XEvent *ev) {
     CASESTRRET(PropertyNotify);
     CASESTRRET(ClientMessage);
     default:
-      if (ev->type == damage_event + XDamageNotify) {
+      if (ev->type == ps->damage_event + XDamageNotify) {
         return "Damage";
       }
 
-      if (shape_exists && ev->type == shape_event) {
+      if (ps->shape_exists && ev->type == ps->shape_event) {
         return "ShapeNotify";
       }
 
@@ -2965,7 +2799,7 @@ ev_name(XEvent *ev) {
 }
 
 static Window
-ev_window(XEvent *ev) {
+ev_window(session_t *ps, XEvent *ev) {
   switch (ev->type) {
     case FocusIn:
     case FocusOut:
@@ -2991,11 +2825,11 @@ ev_window(XEvent *ev) {
     case ClientMessage:
       return ev->xclient.window;
     default:
-      if (ev->type == damage_event + XDamageNotify) {
+      if (ev->type == ps->damage_event + XDamageNotify) {
         return ((XDamageNotifyEvent *)ev)->drawable;
       }
 
-      if (shape_exists && ev->type == shape_event) {
+      if (ps->shape_exists && ev->type == ps->shape_event) {
         return ((XShapeEvent *) ev)->window;
       }
 
@@ -3039,9 +2873,7 @@ ev_focus_report(XFocusChangeEvent* ev) {
 
 #endif
 
-/**
- * Events
- */
+// === Events ===
 
 /**
  * Determine whether we should respond to a <code>FocusIn/Out</code>
@@ -3054,7 +2886,7 @@ ev_focus_accept(XFocusChangeEvent *ev) {
 }
 
 inline static void
-ev_focus_in(XFocusChangeEvent *ev) {
+ev_focus_in(session_t *ps, XFocusChangeEvent *ev) {
 #ifdef DEBUG_EVENTS
   ev_focus_report(ev);
 #endif
@@ -3062,16 +2894,16 @@ ev_focus_in(XFocusChangeEvent *ev) {
   if (!ev_focus_accept(ev))
     return;
 
-  win *w = find_win(ev->window);
+  win *w = find_win(ps, ev->window);
 
   // To deal with events sent from windows just destroyed
   if (!w) return;
 
-  set_focused(dpy, w, True);
+  set_focused(ps, w, true);
 }
 
 inline static void
-ev_focus_out(XFocusChangeEvent *ev) {
+ev_focus_out(session_t *ps, XFocusChangeEvent *ev) {
 #ifdef DEBUG_EVENTS
   ev_focus_report(ev);
 #endif
@@ -3079,93 +2911,93 @@ ev_focus_out(XFocusChangeEvent *ev) {
   if (!ev_focus_accept(ev))
     return;
 
-  win *w = find_win(ev->window);
+  win *w = find_win(ps, ev->window);
 
   // To deal with events sent from windows just destroyed
   if (!w) return;
 
-  set_focused(dpy, w, False);
+  set_focused(ps, w, false);
 }
 
 inline static void
-ev_create_notify(XCreateWindowEvent *ev) {
-  assert(ev->parent == root);
-  add_win(dpy, ev->window, 0, ev->override_redirect);
+ev_create_notify(session_t *ps, XCreateWindowEvent *ev) {
+  assert(ev->parent == ps->root);
+  add_win(ps, ev->window, 0, ev->override_redirect);
 }
 
 inline static void
-ev_configure_notify(XConfigureEvent *ev) {
+ev_configure_notify(session_t *ps, XConfigureEvent *ev) {
 #ifdef DEBUG_EVENTS
   printf("  { send_event: %d, "
          " above: %#010lx, "
          " override_redirect: %d }\n",
          ev->send_event, ev->above, ev->override_redirect);
 #endif
-  configure_win(dpy, ev);
+  configure_win(ps, ev);
 }
 
 inline static void
-ev_destroy_notify(XDestroyWindowEvent *ev) {
-  destroy_win(dpy, ev->window, True);
+ev_destroy_notify(session_t *ps, XDestroyWindowEvent *ev) {
+  destroy_win(ps, ev->window);
 }
 
 inline static void
-ev_map_notify(XMapEvent *ev) {
-  map_win(dpy, ev->window, ev->serial, True, ev->override_redirect);
+ev_map_notify(session_t *ps, XMapEvent *ev) {
+  map_win(ps, ev->window, ev->override_redirect);
 }
 
 inline static void
-ev_unmap_notify(XUnmapEvent *ev) {
-  unmap_win(dpy, ev->window, True);
+ev_unmap_notify(session_t *ps, XUnmapEvent *ev) {
+  unmap_win(ps, ev->window);
 }
 
 inline static void
-ev_reparent_notify(XReparentEvent *ev) {
-  if (ev->parent == root) {
-    add_win(dpy, ev->window, 0, ev->override_redirect);
+ev_reparent_notify(session_t *ps, XReparentEvent *ev) {
+  if (ev->parent == ps->root) {
+    add_win(ps, ev->window, 0, ev->override_redirect);
   } else {
-    destroy_win(dpy, ev->window, True);
+    destroy_win(ps, ev->window);
     // Reset event mask in case something wrong happens
-    XSelectInput(dpy, ev->window,
-        determine_evmask(dpy, ev->window, WIN_EVMODE_UNKNOWN));
+    XSelectInput(ps->dpy, ev->window,
+        determine_evmask(ps, ev->window, WIN_EVMODE_UNKNOWN));
     /*
     // Check if the window is a client window of another
-    win *w_top = find_toplevel2(dpy, ev->window);
+    win *w_top = find_toplevel2(ps, ev->window);
     if (w_top && !(w_top->client_win)) {
-      mark_client_win(dpy, w_top, ev->window);
+      mark_client_win(ps, w_top, ev->window);
     } */
   }
 }
 
 inline static void
-ev_circulate_notify(XCirculateEvent *ev) {
-  circulate_win(dpy, ev);
+ev_circulate_notify(session_t *ps, XCirculateEvent *ev) {
+  circulate_win(ps, ev);
 }
 
 inline static void
-ev_expose(XExposeEvent *ev) {
-  if (ev->window == root || (overlay && ev->window == overlay)) {
+ev_expose(session_t *ps, XExposeEvent *ev) {
+  if (ev->window == ps->root || (ps->overlay && ev->window == ps->overlay)) {
     int more = ev->count + 1;
-    if (n_expose == size_expose) {
-      if (expose_rects) {
-        expose_rects = realloc(expose_rects,
-          (size_expose + more) * sizeof(XRectangle));
-        size_expose += more;
+    if (ps->n_expose == ps->size_expose) {
+      if (ps->expose_rects) {
+        ps->expose_rects = realloc(ps->expose_rects,
+          (ps->size_expose + more) * sizeof(XRectangle));
+        ps->size_expose += more;
       } else {
-        expose_rects = malloc(more * sizeof(XRectangle));
-        size_expose = more;
+        ps->expose_rects = malloc(more * sizeof(XRectangle));
+        ps->size_expose = more;
       }
     }
 
-    expose_rects[n_expose].x = ev->x;
-    expose_rects[n_expose].y = ev->y;
-    expose_rects[n_expose].width = ev->width;
-    expose_rects[n_expose].height = ev->height;
-    n_expose++;
+    ps->expose_rects[ps->n_expose].x = ev->x;
+    ps->expose_rects[ps->n_expose].y = ev->y;
+    ps->expose_rects[ps->n_expose].width = ev->width;
+    ps->expose_rects[ps->n_expose].height = ev->height;
+    ps->n_expose++;
 
     if (ev->count == 0) {
-      expose_root(dpy, expose_rects, n_expose);
-      n_expose = 0;
+      expose_root(ps, ps->expose_rects, ps->n_expose);
+      ps->n_expose = 0;
     }
   }
 }
@@ -3177,46 +3009,47 @@ ev_expose(XExposeEvent *ev) {
  * returned could not be found.
  */
 static void
-update_ewmh_active_win(Display *dpy) {
+update_ewmh_active_win(session_t *ps) {
   // Get the attribute firstly
-  winattr_t attr = wid_get_attr(dpy, root, ewmh_active_win_atom,
+  winprop_t prop = wid_get_prop(ps, ps->root, ps->atom_ewmh_active_win,
       1L, XA_WINDOW, 32);
-  if (!attr.nitems) {
-    free_winattr(&attr);
+  if (!prop.nitems) {
+    free_winprop(&prop);
     return;
   }
-  
+
   // Search for the window
-  Window wid = *((long *) attr.data);
+  Window wid = *((long *) prop.data);
   win *w = NULL;
-  free_winattr(&attr);
+  free_winprop(&prop);
 
-  if (!(w = find_toplevel(wid)))
-    if (!(w = find_win(wid)))
-      w = find_toplevel2(dpy, wid);
+  if (!(w = find_toplevel(ps, wid)))
+    if (!(w = find_win(ps, wid)))
+      w = find_toplevel2(ps, wid);
 
   // Mark the window focused
   if (w) {
     if (!w->focused)
-      set_focused(dpy, w, True);
-    if (active_win && w != active_win)
-      set_focused(dpy, active_win, False);
-    active_win = w;
+      set_focused(ps, w, true);
+    if (ps->active_win && w != ps->active_win)
+      set_focused(ps, ps->active_win, false);
+    ps->active_win = w;
   }
 }
 
 inline static void
-ev_property_notify(XPropertyEvent *ev) {
-  if (root == ev->window) {
-    if (opts.track_focus && opts.use_ewmh_active_win
-        && ewmh_active_win_atom == ev->atom) {
-      update_ewmh_active_win(dpy);
+ev_property_notify(session_t *ps, XPropertyEvent *ev) {
+  if (ps->root == ev->window) {
+    if (ps->o.track_focus && ps->o.use_ewmh_active_win
+        && ps->atom_ewmh_active_win == ev->atom) {
+      update_ewmh_active_win(ps);
     }
     else {
       // Destroy the root "image" if the wallpaper probably changed
-      for (int p = 0; background_props[p]; p++) {
-        if (ev->atom == XInternAtom(dpy, background_props[p], False)) {
-          root_damaged();
+      for (int p = 0; background_props_str[p]; p++) {
+        if (ev->atom ==
+            XInternAtom(ps->dpy, background_props_str[p], false)) {
+          root_damaged(ps);
           break;
         }
       }
@@ -3227,62 +3060,62 @@ ev_property_notify(XPropertyEvent *ev) {
   }
 
   // If _NET_WM_OPACITY changes
-  if (ev->atom == opacity_atom) {
+  if (ev->atom == ps->atom_opacity) {
     win *w = NULL;
-    if ((w = find_win(ev->window)))
-      w->opacity_prop = wid_get_opacity_prop(dpy, w->id, OPAQUE);
-    else if (opts.detect_client_opacity
-        && (w = find_toplevel(ev->window)))
-      w->opacity_prop_client = wid_get_opacity_prop(dpy, w->client_win,
+    if ((w = find_win(ps, ev->window)))
+      w->opacity_prop = wid_get_opacity_prop(ps, w->id, OPAQUE);
+    else if (ps->o.detect_client_opacity
+        && (w = find_toplevel(ps, ev->window)))
+      w->opacity_prop_client = wid_get_opacity_prop(ps, w->client_win,
             OPAQUE);
     if (w) {
-      calc_opacity(dpy, w, False);
+      calc_opacity(ps, w, false);
     }
   }
 
   // If frame extents property changes
-  if (opts.frame_opacity && ev->atom == frame_extents_atom) {
-    win *w = find_toplevel(ev->window);
+  if (ps->o.frame_opacity && ev->atom == ps->atom_frame_extents) {
+    win *w = find_toplevel(ps, ev->window);
     if (w) {
-      get_frame_extents(dpy, w, ev->window);
+      get_frame_extents(ps, w, ev->window);
       // If frame extents change, the window needs repaint
-      add_damage_win(dpy, w);
+      add_damage_win(ps, w);
     }
   }
 
   // If name changes
-  if (opts.track_wdata
-      && (name_atom == ev->atom || name_ewmh_atom == ev->atom)) {
-    win *w = find_toplevel(ev->window);
-    if (w && 1 == win_get_name(dpy, w))
-      determine_shadow(dpy, w);
+  if (ps->o.track_wdata
+      && (ps->atom_name == ev->atom || ps->atom_name_ewmh == ev->atom)) {
+    win *w = find_toplevel(ps, ev->window);
+    if (w && 1 == win_get_name(ps, w))
+      determine_shadow(ps, w);
   }
 
   // If class changes
-  if (opts.track_wdata && class_atom == ev->atom) {
-    win *w = find_toplevel(ev->window);
+  if (ps->o.track_wdata && ps->atom_class == ev->atom) {
+    win *w = find_toplevel(ps, ev->window);
     if (w) {
-      win_get_class(dpy, w);
-      determine_shadow(dpy, w);
+      win_get_class(ps, w);
+      determine_shadow(ps, w);
     }
   }
 
   // If _COMPTON_SHADOW changes
-  if (opts.respect_attr_shadow && compton_shadow_atom == ev->atom) {
-    win *w = find_win(ev->window);
+  if (ps->o.respect_prop_shadow && ps->atom_compton_shadow == ev->atom) {
+    win *w = find_win(ps, ev->window);
     if (w)
-      win_update_attr_shadow(dpy, w);
+      win_update_attr_shadow(ps, w);
   }
 }
 
 inline static void
-ev_damage_notify(XDamageNotifyEvent *ev) {
-  damage_win(dpy, ev);
+ev_damage_notify(session_t *ps, XDamageNotifyEvent *ev) {
+  damage_win(ps, ev);
 }
 
 inline static void
-ev_shape_notify(XShapeEvent *ev) {
-  win *w = find_win(ev->window);
+ev_shape_notify(session_t *ps, XShapeEvent *ev) {
+  win *w = find_win(ps, ev->window);
   if (!w || IsUnmapped == w->a.map_state) return;
 
   /*
@@ -3293,31 +3126,31 @@ ev_shape_notify(XShapeEvent *ev) {
    */
   if (w->border_size) {
     // Mark the old border_size as damaged
-    add_damage(dpy, w->border_size);
+    add_damage(ps, w->border_size);
 
-    w->border_size = border_size(dpy, w);
+    w->border_size = border_size(ps, w);
 
     // Mark the new border_size as damaged
-    add_damage(dpy, copy_region(dpy, w->border_size));
+    add_damage(ps, copy_region(ps, w->border_size));
   }
 
   // Redo bounding shape detection and rounded corner detection
-  win_update_shape(dpy, w);
+  win_update_shape(ps, w);
 
-  update_reg_ignore_expire(w);
+  update_reg_ignore_expire(ps, w);
 }
 
 /**
  * Handle ScreenChangeNotify events from X RandR extension.
  */
 static void
-ev_screen_change_notify(XRRScreenChangeNotifyEvent *ev) {
-  if (!opts.refresh_rate) {
-    update_refresh_rate(dpy);
-    if (!refresh_rate) {
+ev_screen_change_notify(session_t *ps, XRRScreenChangeNotifyEvent *ev) {
+  if (!ps->o.refresh_rate) {
+    update_refresh_rate(ps);
+    if (!ps->refresh_rate) {
       fprintf(stderr, "ev_screen_change_notify(): Refresh rate detection "
           "failed, software VSync disabled.");
-      opts.vsync = VSYNC_NONE;
+      ps->o.vsync = VSYNC_NONE;
     }
   }
 }
@@ -3327,26 +3160,26 @@ ev_screen_change_notify(XRRScreenChangeNotifyEvent *ev) {
  * Get a window's name from window ID.
  */
 static bool
-ev_window_name(Display *dpy, Window wid, char **name) {
+ev_window_name(session_t *ps, Window wid, char **name) {
   bool to_free = false;
 
   *name = "";
   if (wid) {
     *name = "(Failed to get title)";
-    if (root == wid)
+    if (ps->root == wid)
       *name = "(Root window)";
-    else if (overlay == wid)
+    else if (ps->overlay == wid)
       *name = "(Overlay)";
     else {
-      win *w = find_win(wid);
+      win *w = find_win(ps, wid);
       if (!w)
-        w = find_toplevel(wid);
+        w = find_toplevel(ps, wid);
 
       if (w && w->name)
         *name = w->name;
       else if (!(w && w->client_win
-            && (to_free = wid_get_name(dpy, w->client_win, name))))
-          to_free = wid_get_name(dpy, wid, name);
+            && (to_free = wid_get_name(ps, w->client_win, name))))
+          to_free = wid_get_name(ps, wid, name);
     }
   }
 
@@ -3355,22 +3188,22 @@ ev_window_name(Display *dpy, Window wid, char **name) {
 #endif
 
 static void
-ev_handle(XEvent *ev) {
+ev_handle(session_t *ps, XEvent *ev) {
   if ((ev->type & 0x7f) != KeymapNotify) {
-    discard_ignore(dpy, ev->xany.serial);
+    discard_ignore(ps, ev->xany.serial);
   }
 
 #ifdef DEBUG_EVENTS
-  if (ev->type != damage_event + XDamageNotify) {
-    Window wid = ev_window(ev);
+  if (ev->type != ps->damage_event + XDamageNotify) {
+    Window wid = ev_window(ps, ev);
     char *window_name = NULL;
-    Bool to_free = false;
+    bool to_free = false;
 
-    to_free = ev_window_name(dpy, wid, &window_name);
+    to_free = ev_window_name(ps, wid, &window_name);
 
-    print_timestamp();
+    print_timestamp(ps);
     printf("event %10.10s serial %#010x window %#010lx \"%s\"\n",
-      ev_name(ev), ev_serial(ev), wid, window_name);
+      ev_name(ps, ev), ev_serial(ev), wid, window_name);
 
     if (to_free) {
       XFree(window_name);
@@ -3382,57 +3215,55 @@ ev_handle(XEvent *ev) {
 
   switch (ev->type) {
     case FocusIn:
-      ev_focus_in((XFocusChangeEvent *)ev);
+      ev_focus_in(ps, (XFocusChangeEvent *)ev);
       break;
     case FocusOut:
-      ev_focus_out((XFocusChangeEvent *)ev);
+      ev_focus_out(ps, (XFocusChangeEvent *)ev);
       break;
     case CreateNotify:
-      ev_create_notify((XCreateWindowEvent *)ev);
+      ev_create_notify(ps, (XCreateWindowEvent *)ev);
       break;
     case ConfigureNotify:
-      ev_configure_notify((XConfigureEvent *)ev);
+      ev_configure_notify(ps, (XConfigureEvent *)ev);
       break;
     case DestroyNotify:
-      ev_destroy_notify((XDestroyWindowEvent *)ev);
+      ev_destroy_notify(ps, (XDestroyWindowEvent *)ev);
       break;
     case MapNotify:
-      ev_map_notify((XMapEvent *)ev);
+      ev_map_notify(ps, (XMapEvent *)ev);
       break;
     case UnmapNotify:
-      ev_unmap_notify((XUnmapEvent *)ev);
+      ev_unmap_notify(ps, (XUnmapEvent *)ev);
       break;
     case ReparentNotify:
-      ev_reparent_notify((XReparentEvent *)ev);
+      ev_reparent_notify(ps, (XReparentEvent *)ev);
       break;
     case CirculateNotify:
-      ev_circulate_notify((XCirculateEvent *)ev);
+      ev_circulate_notify(ps, (XCirculateEvent *)ev);
       break;
     case Expose:
-      ev_expose((XExposeEvent *)ev);
+      ev_expose(ps, (XExposeEvent *)ev);
       break;
     case PropertyNotify:
-      ev_property_notify((XPropertyEvent *)ev);
+      ev_property_notify(ps, (XPropertyEvent *)ev);
       break;
     default:
-      if (shape_exists && ev->type == shape_event) {
-        ev_shape_notify((XShapeEvent *) ev);
+      if (ps->shape_exists && ev->type == ps->shape_event) {
+        ev_shape_notify(ps, (XShapeEvent *) ev);
         break;
       }
-      if (randr_exists && ev->type == (randr_event + RRScreenChangeNotify)) {
-        ev_screen_change_notify((XRRScreenChangeNotifyEvent *) ev);
+      if (ps->randr_exists && ev->type == (ps->randr_event + RRScreenChangeNotify)) {
+        ev_screen_change_notify(ps, (XRRScreenChangeNotifyEvent *) ev);
         break;
       }
-      if (ev->type == damage_event + XDamageNotify) {
-        ev_damage_notify((XDamageNotifyEvent *)ev);
+      if (ev->type == ps->damage_event + XDamageNotify) {
+        ev_damage_notify(ps, (XDamageNotifyEvent *)ev);
       }
       break;
   }
 }
 
-/**
- * Main
- */
+// === Main ===
 
 /**
  * Print usage text and exit.
@@ -3541,7 +3372,7 @@ usage(void) {
     "--use-ewmh-active-win\n"
     "  Use _NET_WM_ACTIVE_WINDOW on the root window to determine which\n"
     "  window is focused instead of using FocusIn/Out events.\n"
-    "--respect-attr-shadow\n"
+    "--respect-prop-shadow\n"
     "  Respect _COMPTON_SHADOW. This a prototype-level feature, which\n"
     "  you must not rely on.\n"
     "--unredir-if-possible\n"
@@ -3573,7 +3404,7 @@ usage(void) {
  * Register a window as symbol, and initialize GLX context if wanted.
  */
 static void
-register_cm(Bool want_glxct) {
+register_cm(session_t *ps, bool want_glxct) {
   Atom a;
   char *buf;
   int len, s;
@@ -3582,10 +3413,10 @@ register_cm(Bool want_glxct) {
   // Create a window with the wanted GLX visual
   if (want_glxct) {
     XVisualInfo *pvi = NULL;
-    Bool ret = False;
+    bool ret = false;
     // Get visual for the window
     int attribs[] = { GLX_RGBA, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1, None };
-    pvi = glXChooseVisual(dpy, scr, attribs);
+    pvi = glXChooseVisual(ps->dpy, ps->scr, attribs);
 
     if (!pvi) {
       fprintf(stderr, "register_cm(): Failed to choose visual required "
@@ -3594,28 +3425,28 @@ register_cm(Bool want_glxct) {
     else {
       // Create the window
       XSetWindowAttributes swa = {
-        .colormap = XCreateColormap(dpy, root, pvi->visual, AllocNone),
+        .colormap = XCreateColormap(ps->dpy, ps->root, pvi->visual, AllocNone),
         .border_pixel = 0,
       };
 
-      pvi->screen = scr;
-      reg_win = XCreateWindow(dpy, root, 0, 0, 1, 1, 0, pvi->depth,
+      pvi->screen = ps->scr;
+      ps->reg_win = XCreateWindow(ps->dpy, ps->root, 0, 0, 1, 1, 0, pvi->depth,
           InputOutput, pvi->visual, CWBorderPixel | CWColormap, &swa);
 
-      if (!reg_win)
+      if (!ps->reg_win)
         fprintf(stderr, "register_cm(): Failed to create window required "
             "by fake OpenGL VSync. OpenGL VSync turned off.\n");
       else {
         // Get GLX context
-        glx_context = glXCreateContext(dpy, pvi, None, GL_TRUE);
-        if (!glx_context) {
+        ps->glx_context = glXCreateContext(ps->dpy, pvi, None, GL_TRUE);
+        if (!ps->glx_context) {
           fprintf(stderr, "register_cm(): Failed to get GLX context. "
               "OpenGL VSync turned off.\n");
-          opts.vsync = VSYNC_NONE;
+          ps->o.vsync = VSYNC_NONE;
         }
         else {
           // Attach GLX context
-          if (!(ret = glXMakeCurrent(dpy, reg_win, glx_context)))
+          if (!(ret = glXMakeCurrent(ps->dpy, ps->reg_win, ps->glx_context)))
             fprintf(stderr, "register_cm(): Failed to attach GLX context."
               " OpenGL VSync turned off.\n");
         }
@@ -3625,20 +3456,19 @@ register_cm(Bool want_glxct) {
       XFree(pvi);
 
     if (!ret)
-      opts.vsync = VSYNC_NONE;
+      ps->o.vsync = VSYNC_NONE;
   }
 #endif
-  
-  if (!reg_win)
-    reg_win = XCreateSimpleWindow(dpy, root, 0, 0, 1, 1, 0,
+
+  if (!ps->reg_win)
+    ps->reg_win = XCreateSimpleWindow(ps->dpy, ps->root, 0, 0, 1, 1, 0,
         None, None);
 
-  Xutf8SetWMProperties(
-    dpy, reg_win, "xcompmgr", "xcompmgr",
+  Xutf8SetWMProperties(ps->dpy, ps->reg_win, "xcompmgr", "xcompmgr",
     NULL, 0, NULL, NULL, NULL);
 
   len = strlen(REGISTER_PROP) + 2;
-  s = scr;
+  s = ps->scr;
 
   while (s >= 10) {
     ++len;
@@ -3646,14 +3476,17 @@ register_cm(Bool want_glxct) {
   }
 
   buf = malloc(len);
-  snprintf(buf, len, REGISTER_PROP"%d", scr);
+  snprintf(buf, len, REGISTER_PROP"%d", ps->scr);
 
-  a = XInternAtom(dpy, buf, False);
+  a = XInternAtom(ps->dpy, buf, false);
   free(buf);
 
-  XSetSelectionOwner(dpy, a, reg_win, 0);
+  XSetSelectionOwner(ps->dpy, a, ps->reg_win, 0);
 }
 
+/**
+ * Fork program to background and disable all I/O streams.
+ */
 static void
 fork_after(void) {
   if (getppid() == 1) return;
@@ -3769,7 +3602,7 @@ open_config_file(char *cpath, char **ppath) {
  * Parse a VSync option argument.
  */
 static inline void
-parse_vsync(const char *optarg) {
+parse_vsync(session_t *ps, const char *optarg) {
   const static char * const vsync_str[] = {
     "none",   // VSYNC_NONE
     "drm",    // VSYNC_DRM
@@ -3780,7 +3613,7 @@ parse_vsync(const char *optarg) {
 
   for (i = 0; i < (sizeof(vsync_str) / sizeof(vsync_str[0])); ++i)
     if (!strcasecmp(optarg, vsync_str[i])) {
-      opts.vsync = i;
+      ps->o.vsync = i;
       break;
     }
   if ((sizeof(vsync_str) / sizeof(vsync_str[0])) == i) {
@@ -3792,7 +3625,7 @@ parse_vsync(const char *optarg) {
  * Parse a configuration file from default location.
  */
 static void
-parse_config(char *cpath, struct options_tmp *pcfgtmp) {
+parse_config(session_t *ps, char *cpath, struct options_tmp *pcfgtmp) {
   char *path = NULL;
   FILE *f;
   config_t cfg;
@@ -3830,31 +3663,31 @@ parse_config(char *cpath, struct options_tmp *pcfgtmp) {
 
   // -D (fade_delta)
   if (lcfg_lookup_int(&cfg, "fade-delta", &ival))
-    opts.fade_delta = ival;
+    ps->o.fade_delta = ival;
   // -I (fade_in_step)
   if (config_lookup_float(&cfg, "fade-in-step", &dval))
-    opts.fade_in_step = normalize_d(dval) * OPAQUE;
+    ps->o.fade_in_step = normalize_d(dval) * OPAQUE;
   // -O (fade_out_step)
   if (config_lookup_float(&cfg, "fade-out-step", &dval))
-    opts.fade_out_step = normalize_d(dval) * OPAQUE;
+    ps->o.fade_out_step = normalize_d(dval) * OPAQUE;
   // -r (shadow_radius)
-  lcfg_lookup_int(&cfg, "shadow-radius", &opts.shadow_radius);
+  lcfg_lookup_int(&cfg, "shadow-radius", &ps->o.shadow_radius);
   // -o (shadow_opacity)
-  config_lookup_float(&cfg, "shadow-opacity", &opts.shadow_opacity);
+  config_lookup_float(&cfg, "shadow-opacity", &ps->o.shadow_opacity);
   // -l (shadow_offset_x)
-  lcfg_lookup_int(&cfg, "shadow-offset-x", &opts.shadow_offset_x);
+  lcfg_lookup_int(&cfg, "shadow-offset-x", &ps->o.shadow_offset_x);
   // -t (shadow_offset_y)
-  lcfg_lookup_int(&cfg, "shadow-offset-y", &opts.shadow_offset_y);
+  lcfg_lookup_int(&cfg, "shadow-offset-y", &ps->o.shadow_offset_y);
   // -i (inactive_opacity)
   if (config_lookup_float(&cfg, "inactive-opacity", &dval))
-    opts.inactive_opacity = normalize_d(dval) * OPAQUE;
+    ps->o.inactive_opacity = normalize_d(dval) * OPAQUE;
   // -e (frame_opacity)
-  config_lookup_float(&cfg, "frame-opacity", &opts.frame_opacity);
+  config_lookup_float(&cfg, "frame-opacity", &ps->o.frame_opacity);
   // -z (clear_shadow)
-  lcfg_lookup_bool(&cfg, "clear-shadow", &opts.clear_shadow);
+  lcfg_lookup_bool(&cfg, "clear-shadow", &ps->o.clear_shadow);
   // -c (shadow_enable)
   if (config_lookup_bool(&cfg, "shadow", &ival) && ival)
-    wintype_arr_enable(opts.wintype_shadow);
+    wintype_arr_enable(ps->o.wintype_shadow);
   // -C (no_dock_shadow)
   lcfg_lookup_bool(&cfg, "no-dock-shadow", &pcfgtmp->no_dock_shadow);
   // -G (no_dnd_shadow)
@@ -3863,53 +3696,53 @@ parse_config(char *cpath, struct options_tmp *pcfgtmp) {
   config_lookup_float(&cfg, "menu-opacity", &pcfgtmp->menu_opacity);
   // -f (fading_enable)
   if (config_lookup_bool(&cfg, "fading", &ival) && ival)
-    wintype_arr_enable(opts.wintype_fade);
+    wintype_arr_enable(ps->o.wintype_fade);
   // --no-fading-open-close
-  lcfg_lookup_bool(&cfg, "no-fading-openclose", &opts.no_fading_openclose);
+  lcfg_lookup_bool(&cfg, "no-fading-openclose", &ps->o.no_fading_openclose);
   // --shadow-red
-  config_lookup_float(&cfg, "shadow-red", &opts.shadow_red);
+  config_lookup_float(&cfg, "shadow-red", &ps->o.shadow_red);
   // --shadow-green
-  config_lookup_float(&cfg, "shadow-green", &opts.shadow_green);
+  config_lookup_float(&cfg, "shadow-green", &ps->o.shadow_green);
   // --shadow-blue
-  config_lookup_float(&cfg, "shadow-blue", &opts.shadow_blue);
+  config_lookup_float(&cfg, "shadow-blue", &ps->o.shadow_blue);
   // --inactive-opacity-override
   lcfg_lookup_bool(&cfg, "inactive-opacity-override",
-      &opts.inactive_opacity_override);
+      &ps->o.inactive_opacity_override);
   // --inactive-dim
-  config_lookup_float(&cfg, "inactive-dim", &opts.inactive_dim);
+  config_lookup_float(&cfg, "inactive-dim", &ps->o.inactive_dim);
   // --mark-wmwin-focused
-  lcfg_lookup_bool(&cfg, "mark-wmwin-focused", &opts.mark_wmwin_focused);
+  lcfg_lookup_bool(&cfg, "mark-wmwin-focused", &ps->o.mark_wmwin_focused);
   // --mark-ovredir-focused
   lcfg_lookup_bool(&cfg, "mark-ovredir-focused",
-      &opts.mark_ovredir_focused);
+      &ps->o.mark_ovredir_focused);
   // --shadow-ignore-shaped
   lcfg_lookup_bool(&cfg, "shadow-ignore-shaped",
-      &opts.shadow_ignore_shaped);
+      &ps->o.shadow_ignore_shaped);
   // --detect-rounded-corners
   lcfg_lookup_bool(&cfg, "detect-rounded-corners",
-      &opts.detect_rounded_corners);
+      &ps->o.detect_rounded_corners);
   // --detect-client-opacity
   lcfg_lookup_bool(&cfg, "detect-client-opacity",
-      &opts.detect_client_opacity);
+      &ps->o.detect_client_opacity);
   // --refresh-rate
-  lcfg_lookup_int(&cfg, "refresh-rate", &opts.refresh_rate);
+  lcfg_lookup_int(&cfg, "refresh-rate", &ps->o.refresh_rate);
   // --vsync
   if (config_lookup_string(&cfg, "vsync", &sval))
-    parse_vsync(sval);
+    parse_vsync(ps, sval);
   // --alpha-step
-  config_lookup_float(&cfg, "alpha-step", &opts.alpha_step);
+  config_lookup_float(&cfg, "alpha-step", &ps->o.alpha_step);
   // --dbe
-  lcfg_lookup_bool(&cfg, "dbe", &opts.dbe);
+  lcfg_lookup_bool(&cfg, "dbe", &ps->o.dbe);
   // --paint-on-overlay
-  lcfg_lookup_bool(&cfg, "paint-on-overlay", &opts.paint_on_overlay);
+  lcfg_lookup_bool(&cfg, "paint-on-overlay", &ps->o.paint_on_overlay);
   // --sw-opti
-  lcfg_lookup_bool(&cfg, "sw-opti", &opts.sw_opti);
+  lcfg_lookup_bool(&cfg, "sw-opti", &ps->o.sw_opti);
   // --use-ewmh-active-win
   lcfg_lookup_bool(&cfg, "use-ewmh-active-win",
-      &opts.use_ewmh_active_win);
+      &ps->o.use_ewmh_active_win);
   // --unredir-if-possible
   lcfg_lookup_bool(&cfg, "unredir-if-possible",
-      &opts.unredir_if_possible);
+      &ps->o.unredir_if_possible);
   // --shadow-exclude
   {
     config_setting_t *setting =
@@ -3919,20 +3752,20 @@ parse_config(char *cpath, struct options_tmp *pcfgtmp) {
       if (config_setting_is_array(setting)) {
         int i = config_setting_length(setting);
         while (i--) {
-          condlst_add(&opts.shadow_blacklist,
+          condlst_add(&ps->o.shadow_blacklist,
               config_setting_get_string_elem(setting, i));
         }
       }
       // Treat it as a single pattern if it's a string
       else if (CONFIG_TYPE_STRING == config_setting_type(setting)) {
-        condlst_add(&opts.shadow_blacklist,
+        condlst_add(&ps->o.shadow_blacklist,
             config_setting_get_string(setting));
       }
     }
   }
   // Wintype settings
   {
-    wintype i;
+    wintype_t i;
 
     for (i = 0; i < NUM_WINTYPES; ++i) {
       char *str = mstrjoin("wintypes.", WINTYPES[i]);
@@ -3940,11 +3773,11 @@ parse_config(char *cpath, struct options_tmp *pcfgtmp) {
       free(str);
       if (setting) {
         if (config_setting_lookup_bool(setting, "shadow", &ival))
-          opts.wintype_shadow[i] = (Bool) ival;
+          ps->o.wintype_shadow[i] = (bool) ival;
         if (config_setting_lookup_bool(setting, "fade", &ival))
-          opts.wintype_fade[i] = (Bool) ival;
+          ps->o.wintype_fade[i] = (bool) ival;
         config_setting_lookup_float(setting, "opacity",
-            &opts.wintype_opacity[i]);
+            &ps->o.wintype_opacity[i]);
       }
     }
   }
@@ -3957,7 +3790,7 @@ parse_config(char *cpath, struct options_tmp *pcfgtmp) {
  * Process arguments and configuration files.
  */
 static void
-get_cfg(int argc, char *const *argv) {
+get_cfg(session_t *ps, int argc, char *const *argv) {
   const static char *shortopts = "D:I:O:d:r:o:m:l:t:i:e:scnfFCaSzGb";
   const static struct option longopts[] = {
     { "config", required_argument, NULL, 256 },
@@ -3981,30 +3814,33 @@ get_cfg(int argc, char *const *argv) {
     { "sw-opti", no_argument, NULL, 274 },
     { "vsync-aggressive", no_argument, NULL, 275 },
     { "use-ewmh-active-win", no_argument, NULL, 276 },
-    { "respect-attr-shadow", no_argument, NULL, 277 },
+    { "respect-prop-shadow", no_argument, NULL, 277 },
     { "unredir-if-possible", no_argument, NULL, 278 },
     // Must terminate with a NULL entry
     { NULL, 0, NULL, 0 },
   };
 
   struct options_tmp cfgtmp = {
-    .no_dock_shadow = False,
-    .no_dnd_shadow = False,
+    .no_dock_shadow = false,
+    .no_dnd_shadow = false,
     .menu_opacity = 1.0,
   };
-  Bool shadow_enable = False, fading_enable = False;
+  bool shadow_enable = false, fading_enable = false;
   int o, longopt_idx, i;
   char *config_file = NULL;
   char *lc_numeric_old = mstrcpy(setlocale(LC_NUMERIC, NULL));
 
   for (i = 0; i < NUM_WINTYPES; ++i) {
-    opts.wintype_fade[i] = False;
-    opts.wintype_shadow[i] = False;
-    opts.wintype_opacity[i] = 1.0;
+    ps->o.wintype_fade[i] = false;
+    ps->o.wintype_shadow[i] = false;
+    ps->o.wintype_opacity[i] = 1.0;
   }
 
   // Pre-parse the commandline arguments to check for --config and invalid
   // switches
+  // Must reset optind to 0 here in case we reread the commandline
+  // arguments
+  optind = 1;
   while (-1 !=
       (o = getopt_long(argc, argv, shortopts, longopts, &longopt_idx))) {
     if (256 == o)
@@ -4014,7 +3850,7 @@ get_cfg(int argc, char *const *argv) {
   }
 
 #ifdef CONFIG_LIBCONFIG
-  parse_config(config_file, &cfgtmp);
+  parse_config(ps, config_file, &cfgtmp);
 #endif
 
   // Parse commandline arguments. Range checking will be done later.
@@ -4029,56 +3865,56 @@ get_cfg(int argc, char *const *argv) {
     switch (o) {
       // Short options
       case 'd':
-        opts.display = optarg;
+        ps->o.display = mstrcpy(optarg);
         break;
       case 'D':
-        opts.fade_delta = atoi(optarg);
+        ps->o.fade_delta = atoi(optarg);
         break;
       case 'I':
-        opts.fade_in_step = normalize_d(atof(optarg)) * OPAQUE;
+        ps->o.fade_in_step = normalize_d(atof(optarg)) * OPAQUE;
         break;
       case 'O':
-        opts.fade_out_step = normalize_d(atof(optarg)) * OPAQUE;
+        ps->o.fade_out_step = normalize_d(atof(optarg)) * OPAQUE;
         break;
       case 'c':
-        shadow_enable = True;
+        shadow_enable = true;
         break;
       case 'C':
-        cfgtmp.no_dock_shadow = True;
+        cfgtmp.no_dock_shadow = true;
         break;
       case 'G':
-        cfgtmp.no_dnd_shadow = True;
+        cfgtmp.no_dnd_shadow = true;
         break;
       case 'm':
         cfgtmp.menu_opacity = atof(optarg);
         break;
       case 'f':
       case 'F':
-        fading_enable = True;
+        fading_enable = true;
         break;
       case 'S':
-        opts.synchronize = True;
+        ps->o.synchronize = true;
         break;
       case 'r':
-        opts.shadow_radius = atoi(optarg);
+        ps->o.shadow_radius = atoi(optarg);
         break;
       case 'o':
-        opts.shadow_opacity = atof(optarg);
+        ps->o.shadow_opacity = atof(optarg);
         break;
       case 'l':
-        opts.shadow_offset_x = atoi(optarg);
+        ps->o.shadow_offset_x = atoi(optarg);
         break;
       case 't':
-        opts.shadow_offset_y = atoi(optarg);
+        ps->o.shadow_offset_y = atoi(optarg);
         break;
       case 'i':
-        opts.inactive_opacity = (normalize_d(atof(optarg)) * OPAQUE);
+        ps->o.inactive_opacity = (normalize_d(atof(optarg)) * OPAQUE);
         break;
       case 'e':
-        opts.frame_opacity = atof(optarg);
+        ps->o.frame_opacity = atof(optarg);
         break;
       case 'z':
-        opts.clear_shadow = True;
+        ps->o.clear_shadow = true;
         break;
       case 'n':
       case 'a':
@@ -4087,7 +3923,7 @@ get_cfg(int argc, char *const *argv) {
           "-n, -a, and -s have been removed.\n");
         break;
       case 'b':
-        opts.fork_after_register = True;
+        ps->o.fork_after_register = true;
         break;
       // Long options
       case 256:
@@ -4095,95 +3931,94 @@ get_cfg(int argc, char *const *argv) {
         break;
       case 257:
         // --shadow-red
-        opts.shadow_red = atof(optarg);
+        ps->o.shadow_red = atof(optarg);
         break;
       case 258:
         // --shadow-green
-        opts.shadow_green = atof(optarg);
+        ps->o.shadow_green = atof(optarg);
         break;
       case 259:
         // --shadow-blue
-        opts.shadow_blue = atof(optarg);
+        ps->o.shadow_blue = atof(optarg);
         break;
       case 260:
         // --inactive-opacity-override
-        opts.inactive_opacity_override = True;
+        ps->o.inactive_opacity_override = true;
         break;
       case 261:
         // --inactive-dim
-        opts.inactive_dim = atof(optarg);
+        ps->o.inactive_dim = atof(optarg);
         break;
       case 262:
         // --mark-wmwin-focused
-        opts.mark_wmwin_focused = True;
+        ps->o.mark_wmwin_focused = true;
         break;
       case 263:
         // --shadow-exclude
-        condlst_add(&opts.shadow_blacklist, optarg);
+        condlst_add(&ps->o.shadow_blacklist, optarg);
         break;
       case 264:
         // --mark-ovredir-focused
-        opts.mark_ovredir_focused = True;
+        ps->o.mark_ovredir_focused = true;
         break;
       case 265:
         // --no-fading-openclose
-        opts.no_fading_openclose = True;
+        ps->o.no_fading_openclose = true;
         break;
       case 266:
         // --shadow-ignore-shaped
-        opts.shadow_ignore_shaped = True;
+        ps->o.shadow_ignore_shaped = true;
         break;
       case 267:
         // --detect-rounded-corners
-        opts.detect_rounded_corners = True;
+        ps->o.detect_rounded_corners = true;
         break;
       case 268:
         // --detect-client-opacity
-        opts.detect_client_opacity = True;
+        ps->o.detect_client_opacity = true;
         break;
       case 269:
         // --refresh-rate
-        opts.refresh_rate = atoi(optarg);
+        ps->o.refresh_rate = atoi(optarg);
         break;
       case 270:
         // --vsync
-        parse_vsync(optarg);
+        parse_vsync(ps, optarg);
         break;
       case 271:
         // --alpha-step
-        opts.alpha_step = atof(optarg);
+        ps->o.alpha_step = atof(optarg);
         break;
       case 272:
         // --dbe
-        opts.dbe = True;
+        ps->o.dbe = true;
         break;
       case 273:
         // --paint-on-overlay
-        opts.paint_on_overlay = True;
+        ps->o.paint_on_overlay = true;
         break;
       case 274:
         // --sw-opti
-        opts.sw_opti = True;
+        ps->o.sw_opti = true;
         break;
       case 275:
         // --vsync-aggressive
-        opts.vsync_aggressive = True;
+        ps->o.vsync_aggressive = true;
         break;
       case 276:
         // --use-ewmh-active-win
-        opts.use_ewmh_active_win = True;
+        ps->o.use_ewmh_active_win = true;
         break;
       case 277:
-        // --respect-attr-shadow
-        opts.respect_attr_shadow = True;
+        // --respect-prop-shadow
+        ps->o.respect_prop_shadow = true;
         break;
       case 278:
         // --unredir-if-possible
-        opts.unredir_if_possible = True;
+        ps->o.unredir_if_possible = true;
         break;
       default:
         usage();
-        break;
     }
   }
 
@@ -4192,88 +4027,91 @@ get_cfg(int argc, char *const *argv) {
   free(lc_numeric_old);
 
   // Range checking and option assignments
-  opts.fade_delta = max_i(opts.fade_delta, 1);
-  opts.shadow_radius = max_i(opts.shadow_radius, 1);
-  opts.shadow_red = normalize_d(opts.shadow_red);
-  opts.shadow_green = normalize_d(opts.shadow_green);
-  opts.shadow_blue = normalize_d(opts.shadow_blue);
-  opts.inactive_dim = normalize_d(opts.inactive_dim);
-  opts.frame_opacity = normalize_d(opts.frame_opacity);
-  opts.shadow_opacity = normalize_d(opts.shadow_opacity);
+  ps->o.fade_delta = max_i(ps->o.fade_delta, 1);
+  ps->o.shadow_radius = max_i(ps->o.shadow_radius, 1);
+  ps->o.shadow_red = normalize_d(ps->o.shadow_red);
+  ps->o.shadow_green = normalize_d(ps->o.shadow_green);
+  ps->o.shadow_blue = normalize_d(ps->o.shadow_blue);
+  ps->o.inactive_dim = normalize_d(ps->o.inactive_dim);
+  ps->o.frame_opacity = normalize_d(ps->o.frame_opacity);
+  ps->o.shadow_opacity = normalize_d(ps->o.shadow_opacity);
   cfgtmp.menu_opacity = normalize_d(cfgtmp.menu_opacity);
-  opts.refresh_rate = normalize_i_range(opts.refresh_rate, 0, 300);
-  opts.alpha_step = normalize_d_range(opts.alpha_step, 0.01, 1.0);
-  if (OPAQUE == opts.inactive_opacity) {
-    opts.inactive_opacity = 0;
+  ps->o.refresh_rate = normalize_i_range(ps->o.refresh_rate, 0, 300);
+  ps->o.alpha_step = normalize_d_range(ps->o.alpha_step, 0.01, 1.0);
+  if (OPAQUE == ps->o.inactive_opacity) {
+    ps->o.inactive_opacity = 0;
   }
   if (shadow_enable)
-    wintype_arr_enable(opts.wintype_shadow);
-  opts.wintype_shadow[WINTYPE_DESKTOP] = False;
+    wintype_arr_enable(ps->o.wintype_shadow);
+  ps->o.wintype_shadow[WINTYPE_DESKTOP] = false;
   if (cfgtmp.no_dock_shadow)
-    opts.wintype_shadow[WINTYPE_DOCK] = False;
+    ps->o.wintype_shadow[WINTYPE_DOCK] = false;
   if (cfgtmp.no_dnd_shadow)
-    opts.wintype_shadow[WINTYPE_DND] = False;
+    ps->o.wintype_shadow[WINTYPE_DND] = false;
   if (fading_enable)
-    wintype_arr_enable(opts.wintype_fade);
+    wintype_arr_enable(ps->o.wintype_fade);
   if (1.0 != cfgtmp.menu_opacity) {
-    opts.wintype_opacity[WINTYPE_DROPDOWN_MENU] = cfgtmp.menu_opacity;
-    opts.wintype_opacity[WINTYPE_POPUP_MENU] = cfgtmp.menu_opacity;
+    ps->o.wintype_opacity[WINTYPE_DROPDOWN_MENU] = cfgtmp.menu_opacity;
+    ps->o.wintype_opacity[WINTYPE_POPUP_MENU] = cfgtmp.menu_opacity;
   }
 
   // Other variables determined by options
 
   // Determine whether we need to track focus changes
-  if (opts.inactive_opacity || opts.inactive_dim) {
-    opts.track_focus = True;
+  if (ps->o.inactive_opacity || ps->o.inactive_dim) {
+    ps->o.track_focus = true;
   }
 
   // Determine whether we need to track window name and class
-  if (opts.shadow_blacklist || opts.fade_blacklist)
-    opts.track_wdata = True;
+  if (ps->o.shadow_blacklist || ps->o.fade_blacklist)
+    ps->o.track_wdata = true;
 }
 
+/**
+ * Fetch all required atoms and save them to a session.
+ */
 static void
-get_atoms(void) {
-  opacity_atom = XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False);
-  frame_extents_atom = XInternAtom(dpy, "_NET_FRAME_EXTENTS", False);
-  client_atom = XInternAtom(dpy, "WM_STATE", False);
-  name_atom = XA_WM_NAME;
-  name_ewmh_atom = XInternAtom(dpy, "_NET_WM_NAME", False);
-  class_atom = XA_WM_CLASS;
-  transient_atom = XA_WM_TRANSIENT_FOR;
-  ewmh_active_win_atom = XInternAtom(dpy, "_NET_ACTIVE_WINDOW", False);
-  compton_shadow_atom = XInternAtom(dpy, "_COMPTON_SHADOW", False);
-
-  win_type_atom = XInternAtom(dpy,
+init_atoms(session_t *ps) {
+  ps->atom_opacity = XInternAtom(ps->dpy, "_NET_WM_WINDOW_OPACITY", False);
+  ps->atom_frame_extents = XInternAtom(ps->dpy, "_NET_FRAME_EXTENTS", False);
+  ps->atom_client = XInternAtom(ps->dpy, "WM_STATE", False);
+  ps->atom_name = XA_WM_NAME;
+  ps->atom_name_ewmh = XInternAtom(ps->dpy, "_NET_WM_NAME", False);
+  ps->atom_class = XA_WM_CLASS;
+  ps->atom_transient = XA_WM_TRANSIENT_FOR;
+  ps->atom_ewmh_active_win = XInternAtom(ps->dpy, "_NET_ACTIVE_WINDOW", False);
+  ps->atom_compton_shadow = XInternAtom(ps->dpy, "_COMPTON_SHADOW", False);
+
+  ps->atom_win_type = XInternAtom(ps->dpy,
     "_NET_WM_WINDOW_TYPE", False);
-  win_type[WINTYPE_UNKNOWN] = 0;
-  win_type[WINTYPE_DESKTOP] = XInternAtom(dpy,
+  ps->atoms_wintypes[WINTYPE_UNKNOWN] = 0;
+  ps->atoms_wintypes[WINTYPE_DESKTOP] = XInternAtom(ps->dpy,
     "_NET_WM_WINDOW_TYPE_DESKTOP", False);
-  win_type[WINTYPE_DOCK] = XInternAtom(dpy,
+  ps->atoms_wintypes[WINTYPE_DOCK] = XInternAtom(ps->dpy,
     "_NET_WM_WINDOW_TYPE_DOCK", False);
-  win_type[WINTYPE_TOOLBAR] = XInternAtom(dpy,
+  ps->atoms_wintypes[WINTYPE_TOOLBAR] = XInternAtom(ps->dpy,
     "_NET_WM_WINDOW_TYPE_TOOLBAR", False);
-  win_type[WINTYPE_MENU] = XInternAtom(dpy,
+  ps->atoms_wintypes[WINTYPE_MENU] = XInternAtom(ps->dpy,
     "_NET_WM_WINDOW_TYPE_MENU", False);
-  win_type[WINTYPE_UTILITY] = XInternAtom(dpy,
+  ps->atoms_wintypes[WINTYPE_UTILITY] = XInternAtom(ps->dpy,
     "_NET_WM_WINDOW_TYPE_UTILITY", False);
-  win_type[WINTYPE_SPLASH] = XInternAtom(dpy,
+  ps->atoms_wintypes[WINTYPE_SPLASH] = XInternAtom(ps->dpy,
     "_NET_WM_WINDOW_TYPE_SPLASH", False);
-  win_type[WINTYPE_DIALOG] = XInternAtom(dpy,
+  ps->atoms_wintypes[WINTYPE_DIALOG] = XInternAtom(ps->dpy,
     "_NET_WM_WINDOW_TYPE_DIALOG", False);
-  win_type[WINTYPE_NORMAL] = XInternAtom(dpy,
+  ps->atoms_wintypes[WINTYPE_NORMAL] = XInternAtom(ps->dpy,
     "_NET_WM_WINDOW_TYPE_NORMAL", False);
-  win_type[WINTYPE_DROPDOWN_MENU] = XInternAtom(dpy,
+  ps->atoms_wintypes[WINTYPE_DROPDOWN_MENU] = XInternAtom(ps->dpy,
     "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU", False);
-  win_type[WINTYPE_POPUP_MENU] = XInternAtom(dpy,
+  ps->atoms_wintypes[WINTYPE_POPUP_MENU] = XInternAtom(ps->dpy,
     "_NET_WM_WINDOW_TYPE_POPUP_MENU", False);
-  win_type[WINTYPE_TOOLTIP] = XInternAtom(dpy,
+  ps->atoms_wintypes[WINTYPE_TOOLTIP] = XInternAtom(ps->dpy,
     "_NET_WM_WINDOW_TYPE_TOOLTIP", False);
-  win_type[WINTYPE_NOTIFY] = XInternAtom(dpy,
+  ps->atoms_wintypes[WINTYPE_NOTIFY] = XInternAtom(ps->dpy,
     "_NET_WM_WINDOW_TYPE_NOTIFICATION", False);
-  win_type[WINTYPE_COMBO] = XInternAtom(dpy,
+  ps->atoms_wintypes[WINTYPE_COMBO] = XInternAtom(ps->dpy,
     "_NET_WM_WINDOW_TYPE_COMBO", False);
-  win_type[WINTYPE_DND] = XInternAtom(dpy,
+  ps->atoms_wintypes[WINTYPE_DND] = XInternAtom(ps->dpy,
     "_NET_WM_WINDOW_TYPE_DND", False);
 }
 
@@ -4281,49 +4119,49 @@ get_atoms(void) {
  * Update refresh rate info with X Randr extension.
  */
 static void
-update_refresh_rate(Display *dpy) {
+update_refresh_rate(session_t *ps) {
   XRRScreenConfiguration* randr_info;
 
-  if (!(randr_info = XRRGetScreenInfo(dpy, root)))
+  if (!(randr_info = XRRGetScreenInfo(ps->dpy, ps->root)))
     return;
-  refresh_rate = XRRConfigCurrentRate(randr_info);
+  ps->refresh_rate = XRRConfigCurrentRate(randr_info);
 
   XRRFreeScreenConfigInfo(randr_info);
 
-  if (refresh_rate)
-    refresh_intv = NS_PER_SEC / refresh_rate;
+  if (ps->refresh_rate)
+    ps->refresh_intv = NS_PER_SEC / ps->refresh_rate;
   else
-    refresh_intv = 0;
+    ps->refresh_intv = 0;
 }
 
 /**
  * Initialize refresh-rated based software optimization.
  *
- * @return True for success, False otherwise
+ * @return true for success, false otherwise
  */
-static Bool
-sw_opti_init(void) {
+static bool
+sw_opti_init(session_t *ps) {
   // Prepare refresh rate
   // Check if user provides one
-  refresh_rate = opts.refresh_rate;
-  if (refresh_rate)
-    refresh_intv = NS_PER_SEC / refresh_rate;
+  ps->refresh_rate = ps->o.refresh_rate;
+  if (ps->refresh_rate)
+    ps->refresh_intv = NS_PER_SEC / ps->refresh_rate;
 
   // Auto-detect refresh rate otherwise
-  if (!refresh_rate && randr_exists) {
-    update_refresh_rate(dpy);
+  if (!ps->refresh_rate && ps->randr_exists) {
+    update_refresh_rate(ps);
   }
 
   // Turn off vsync_sw if we can't get the refresh rate
-  if (!refresh_rate)
-    return False;
+  if (!ps->refresh_rate)
+    return false;
 
   // Monitor screen changes only if vsync_sw is enabled and we are using
   // an auto-detected refresh rate
-  if (randr_exists && !opts.refresh_rate)
-    XRRSelectInput(dpy, root, RRScreenChangeNotify);
+  if (ps->randr_exists && !ps->o.refresh_rate)
+    XRRSelectInput(ps->dpy, ps->root, RRScreenChangeNotify);
 
-  return True;
+  return true;
 }
 
 /**
@@ -4353,18 +4191,23 @@ lceil_ntimes(long dividend, long divisor) {
  *     problems
  */
 static int
-evpoll(struct pollfd *fd, int timeout) {
+evpoll(session_t *ps, int timeout) {
+  struct pollfd ufd = {
+    .fd = ConnectionNumber(ps->dpy),
+    .events = POLLIN
+  };
+
   // Always wait infinitely if asked so, to minimize CPU usage
   if (timeout < 0) {
-    int ret = poll(fd, 1, timeout);
-    // Reset fade_time so the fading steps during idling are not counted
-    fade_time = get_time_ms();
+    int ret = poll(&ufd, 1, timeout);
+    // Reset ps->fade_time so the fading steps during idling are not counted
+    ps->fade_time = get_time_ms();
     return ret;
   }
 
   // Just do a poll() if we are not using optimization
-  if (!opts.sw_opti)
-    return poll(fd, 1, timeout);
+  if (!ps->o.sw_opti)
+    return poll(&ufd, 1, timeout);
 
   // Convert the old timeout to struct timespec
   struct timespec next_paint_tmout = {
@@ -4374,7 +4217,7 @@ evpoll(struct pollfd *fd, int timeout) {
 
   // Get the nanosecond offset of the time when the we reach the timeout
   // I don't think a 32-bit long could overflow here.
-  long target_relative_offset = (next_paint_tmout.tv_nsec + get_time_timespec().tv_nsec - paint_tm_offset) % NS_PER_SEC;
+  long target_relative_offset = (next_paint_tmout.tv_nsec + get_time_timespec().tv_nsec - ps->paint_tm_offset) % NS_PER_SEC;
   if (target_relative_offset < 0)
     target_relative_offset += NS_PER_SEC;
 
@@ -4383,39 +4226,39 @@ evpoll(struct pollfd *fd, int timeout) {
   // If the target time is sufficiently close to a refresh time, don't add
   // an offset, to avoid certain blocking conditions.
   if ((target_relative_offset % NS_PER_SEC) < SW_OPTI_TOLERANCE)
-    return poll(fd, 1, timeout);
+    return poll(&ufd, 1, timeout);
 
   // Add an offset so we wait until the next refresh after timeout
-  next_paint_tmout.tv_nsec += lceil_ntimes(target_relative_offset, refresh_intv) - target_relative_offset;
+  next_paint_tmout.tv_nsec += lceil_ntimes(target_relative_offset, ps->refresh_intv) - target_relative_offset;
   if (next_paint_tmout.tv_nsec > NS_PER_SEC) {
     next_paint_tmout.tv_nsec -= NS_PER_SEC;
     ++next_paint_tmout.tv_sec;
   }
 
-  return ppoll(fd, 1, &next_paint_tmout, NULL);
+  return ppoll(&ufd, 1, &next_paint_tmout, NULL);
 }
 
 /**
  * Initialize DRM VSync.
  *
- * @return True for success, False otherwise
+ * @return true for success, false otherwise
  */
-static Bool
-vsync_drm_init(void) {
+static bool
+vsync_drm_init(session_t *ps) {
 #ifdef CONFIG_VSYNC_DRM
   // Should we always open card0?
-  if ((drm_fd = open("/dev/dri/card0", O_RDWR)) < 0) {
+  if ((ps->drm_fd = open("/dev/dri/card0", O_RDWR)) < 0) {
     fprintf(stderr, "vsync_drm_init(): Failed to open device.\n");
-    return False;
+    return false;
   }
 
-  if (vsync_drm_wait())
-    return False;
+  if (vsync_drm_wait(ps))
+    return false;
 
-  return True;
+  return true;
 #else
   fprintf(stderr, "Program not compiled with DRM VSync support.\n");
-  return False;
+  return false;
 #endif
 }
 
@@ -4426,7 +4269,7 @@ vsync_drm_init(void) {
  * Stolen from: https://github.com/MythTV/mythtv/blob/master/mythtv/libs/libmythtv/vsync.cpp
  */
 static int
-vsync_drm_wait(void) {
+vsync_drm_wait(session_t *ps) {
   int ret = -1;
   drm_wait_vblank_t vbl;
 
@@ -4434,7 +4277,7 @@ vsync_drm_wait(void) {
   vbl.request.sequence = 1;
 
   do {
-     ret = ioctl(drm_fd, DRM_IOCTL_WAIT_VBLANK, &vbl);
+     ret = ioctl(ps->drm_fd, DRM_IOCTL_WAIT_VBLANK, &vbl);
      vbl.request.type &= ~_DRM_VBLANK_RELATIVE;
   } while (ret && errno == EINTR);
 
@@ -4443,7 +4286,7 @@ vsync_drm_wait(void) {
         "unimplemented in this drmver?\n");
 
   return ret;
-  
+
 }
 #endif
 
@@ -4453,26 +4296,26 @@ vsync_drm_wait(void) {
  * Stolen from: http://git.tuxfamily.org/?p=ccm/cairocompmgr.git;a=commitdiff;h=efa4ceb97da501e8630ca7f12c99b1dce853c73e
  * Possible original source: http://www.inb.uni-luebeck.de/~boehme/xvideo_sync.html
  *
- * @return True for success, False otherwise
+ * @return true for success, false otherwise
  */
-static Bool
-vsync_opengl_init(void) {
+static bool
+vsync_opengl_init(session_t *ps) {
 #ifdef CONFIG_VSYNC_OPENGL
   // Get video sync functions
-  glx_get_video_sync = (f_GetVideoSync)
+  ps->glx_get_video_sync = (f_GetVideoSync)
     glXGetProcAddress ((const GLubyte *) "glXGetVideoSyncSGI");
-  glx_wait_video_sync = (f_WaitVideoSync)
+  ps->glx_wait_video_sync = (f_WaitVideoSync)
     glXGetProcAddress ((const GLubyte *) "glXWaitVideoSyncSGI");
-  if (!glx_wait_video_sync || !glx_get_video_sync) {
+  if (!ps->glx_wait_video_sync || !ps->glx_get_video_sync) {
     fprintf(stderr, "vsync_opengl_init(): "
         "Failed to get glXWait/GetVideoSyncSGI function.\n");
-    return False;
+    return false;
   }
-  
-  return True;
+
+  return true;
 #else
   fprintf(stderr, "Program not compiled with OpenGL VSync support.\n");
-  return False;
+  return false;
 #endif
 }
 
@@ -4481,11 +4324,11 @@ vsync_opengl_init(void) {
  * Wait for next VSync, OpenGL method.
  */
 static void
-vsync_opengl_wait(void) {
+vsync_opengl_wait(session_t *ps) {
   unsigned vblank_count;
 
-  glx_get_video_sync(&vblank_count);
-  glx_wait_video_sync(2, (vblank_count + 1) % 2, &vblank_count);
+  ps->glx_get_video_sync(&vblank_count);
+  ps->glx_wait_video_sync(2, (vblank_count + 1) % 2, &vblank_count);
   // I see some code calling glXSwapIntervalSGI(1) afterwards, is it required?
 }
 #endif
@@ -4494,20 +4337,20 @@ vsync_opengl_wait(void) {
  * Wait for next VSync.
  */
 static void
-vsync_wait(void) {
-  if (VSYNC_NONE == opts.vsync)
+vsync_wait(session_t *ps) {
+  if (VSYNC_NONE == ps->o.vsync)
     return;
 
 #ifdef CONFIG_VSYNC_DRM
-  if (VSYNC_DRM == opts.vsync) {
-    vsync_drm_wait();
+  if (VSYNC_DRM == ps->o.vsync) {
+    vsync_drm_wait(ps);
     return;
   }
 #endif
 
 #ifdef CONFIG_VSYNC_OPENGL
-  if (VSYNC_OPENGL == opts.vsync) {
-    vsync_opengl_wait();
+  if (VSYNC_OPENGL == ps->o.vsync) {
+    vsync_opengl_wait(ps);
     return;
   }
 #endif
@@ -4522,18 +4365,18 @@ vsync_wait(void) {
  * Pregenerate alpha pictures.
  */
 static void
-init_alpha_picts(Display *dpy) {
+init_alpha_picts(session_t *ps) {
   int i;
-  int num = lround(1.0 / opts.alpha_step) + 1;
+  int num = lround(1.0 / ps->o.alpha_step) + 1;
 
-  alpha_picts = malloc(sizeof(Picture) * num);
+  ps->alpha_picts = malloc(sizeof(Picture) * num);
 
   for (i = 0; i < num; ++i) {
-    double o = i * opts.alpha_step;
-    if ((1.0 - o) > opts.alpha_step)
-      alpha_picts[i] = solid_picture(dpy, False, o, 0, 0, 0);
+    double o = i * ps->o.alpha_step;
+    if ((1.0 - o) > ps->o.alpha_step)
+      ps->alpha_picts[i] = solid_picture(ps, false, o, 0, 0, 0);
     else
-      alpha_picts[i] = None;
+      ps->alpha_picts[i] = None;
   }
 }
 
@@ -4541,12 +4384,12 @@ init_alpha_picts(Display *dpy) {
  * Initialize double buffer.
  */
 static void
-init_dbe(void) {
-  if (!(root_dbe = XdbeAllocateBackBufferName(dpy,
-          (opts.paint_on_overlay ? overlay: root), XdbeCopied))) {
+init_dbe(session_t *ps) {
+  if (!(ps->root_dbe = XdbeAllocateBackBufferName(ps->dpy,
+          (ps->o.paint_on_overlay ? ps->overlay: ps->root), XdbeCopied))) {
     fprintf(stderr, "Failed to create double buffer. Double buffering "
         "turned off.\n");
-    opts.dbe = False;
+    ps->o.dbe = false;
     return;
   }
 }
@@ -4555,27 +4398,27 @@ init_dbe(void) {
  * Initialize X composite overlay window.
  */
 static void
-init_overlay(void) {
-  overlay = XCompositeGetOverlayWindow(dpy, root);
-  if (overlay) {
+init_overlay(session_t *ps) {
+  ps->overlay = XCompositeGetOverlayWindow(ps->dpy, ps->root);
+  if (ps->overlay) {
     // Set window region of the overlay window, code stolen from
     // compiz-0.8.8
-    XserverRegion region = XFixesCreateRegion (dpy, NULL, 0);
-    XFixesSetWindowShapeRegion(dpy, overlay, ShapeBounding, 0, 0, 0);
-    XFixesSetWindowShapeRegion(dpy, overlay, ShapeInput, 0, 0, region);
-    XFixesDestroyRegion (dpy, region);
+    XserverRegion region = XFixesCreateRegion(ps->dpy, NULL, 0);
+    XFixesSetWindowShapeRegion(ps->dpy, ps->overlay, ShapeBounding, 0, 0, 0);
+    XFixesSetWindowShapeRegion(ps->dpy, ps->overlay, ShapeInput, 0, 0, region);
+    XFixesDestroyRegion(ps->dpy, region);
 
     // Listen to Expose events on the overlay
-    XSelectInput(dpy, overlay, ExposureMask);
+    XSelectInput(ps->dpy, ps->overlay, ExposureMask);
 
     // Retrieve DamageNotify on root window if we are painting on an
     // overlay
-    // root_damage = XDamageCreate(dpy, root, XDamageReportNonEmpty);
+    // root_damage = XDamageCreate(ps->dpy, root, XDamageReportNonEmpty);
   }
   else {
     fprintf(stderr, "Cannot get X Composite overlay window. Falling "
         "back to painting on root window.\n");
-    opts.paint_on_overlay = False;
+    ps->o.paint_on_overlay = false;
   }
 }
 
@@ -4583,23 +4426,23 @@ init_overlay(void) {
  * Redirect all windows.
  */
 static void
-redir_start(Display *dpy) {
-  if (!redirected) {
+redir_start(session_t *ps) {
+  if (!ps->redirected) {
 #ifdef DEBUG_REDIR
     printf("redir_start(): Screen redirected.\n");
 #endif
 
     // Map overlay window. Done firstly according to this:
     // https://bugzilla.gnome.org/show_bug.cgi?id=597014
-    if (overlay)
-      XMapWindow(dpy, overlay);
+    if (ps->overlay)
+      XMapWindow(ps->dpy, ps->overlay);
 
-    XCompositeRedirectSubwindows(dpy, root, CompositeRedirectManual);
+    XCompositeRedirectSubwindows(ps->dpy, ps->root, CompositeRedirectManual);
 
     // Must call XSync() here
-    XSync(dpy, False);
+    XSync(ps->dpy, False);
 
-    redirected = True;
+    ps->redirected = true;
   }
 }
 
@@ -4607,103 +4450,252 @@ redir_start(Display *dpy) {
  * Unredirect all windows.
  */
 static void
-redir_stop(Display *dpy) {
-  if (redirected) {
+redir_stop(session_t *ps) {
+  if (ps->redirected) {
 #ifdef DEBUG_REDIR
     printf("redir_stop(): Screen unredirected.\n");
 #endif
     // Destroy all Pictures as they expire once windows are unredirected
     // If we don't destroy them here, looks like the resources are just
     // kept inaccessible somehow
-    for (win *w = list; w; w = w->next) {
-      free_pixmap(dpy, &w->pixmap);
-      free_picture(dpy, &w->picture);
+    for (win *w = ps->list; w; w = w->next) {
+      free_pixmap(ps, &w->pixmap);
+      free_picture(ps, &w->picture);
     }
 
-    XCompositeUnredirectSubwindows(dpy, root, CompositeRedirectManual);
-
+    XCompositeUnredirectSubwindows(ps->dpy, ps->root, CompositeRedirectManual);
     // Unmap overlay window
-    if (overlay)
-      XUnmapWindow(dpy, overlay);
+    if (ps->overlay)
+      XUnmapWindow(ps->dpy, ps->overlay);
 
     // Must call XSync() here
-    XSync(dpy, False);
-
-    redirected = False;
+    XSync(ps->dpy, False);
 
+    ps->redirected = false;
   }
 }
 
-int
-main(int argc, char **argv) {
-  XEvent ev;
-  Window root_return, parent_return;
-  Window *children;
-  unsigned int nchildren;
-  int i;
-  XRenderPictureAttributes pa;
-  struct pollfd ufd;
-  int composite_major, composite_minor;
-  win *t;
-
-  gettimeofday(&time_start, NULL);
-
-  // Set locale so window names with special characters are interpreted
-  // correctly
-  setlocale (LC_ALL, "");
+/**
+ * Initialize a session.
+ *
+ * @param ps_old old session, from which the function will take the X
+ *    connection, then free it
+ * @param argc number of commandline arguments
+ * @param argv commandline arguments
+ */
+static session_t *
+session_init(session_t *ps_old, int argc, char **argv) {
+  const static session_t s_def = {
+    .dpy = NULL,
+    .scr = 0,
+    .vis = NULL,
+    .depth = 0,
+    .root = None,
+    .root_height = 0,
+    .root_width = 0,
+    // .root_damage = None,
+    .overlay = None,
+    .root_tile = None,
+    .screen_reg = None,
+    .tgt_picture = None,
+    .tgt_buffer = None,
+    .root_dbe = None,
+    .reg_win = None,
+    .o = {
+      .display = NULL,
+      .mark_wmwin_focused = false,
+      .mark_ovredir_focused = false,
+      .fork_after_register = false,
+      .synchronize = false,
+      .detect_rounded_corners = false,
+      .paint_on_overlay = false,
+      .unredir_if_possible = false,
+
+      .refresh_rate = 0,
+      .sw_opti = false,
+      .vsync = VSYNC_NONE,
+      .dbe = false,
+      .vsync_aggressive = false,
+
+      .wintype_shadow = { false },
+      .shadow_red = 0.0,
+      .shadow_green = 0.0,
+      .shadow_blue = 0.0,
+      .shadow_radius = 12,
+      .shadow_offset_x = -15,
+      .shadow_offset_y = -15,
+      .shadow_opacity = .75,
+      .clear_shadow = false,
+      .shadow_blacklist = NULL,
+      .shadow_ignore_shaped = false,
+      .respect_prop_shadow = false,
+
+      .wintype_fade = { false },
+      .fade_in_step = 0.028 * OPAQUE,
+      .fade_out_step = 0.03 * OPAQUE,
+      .fade_delta = 10,
+      .no_fading_openclose = false,
+      .fade_blacklist = NULL,
+
+      .wintype_opacity = { 0.0 },
+      .inactive_opacity = 0,
+      .inactive_opacity_override = false,
+      .frame_opacity = 0.0,
+      .detect_client_opacity = false,
+      .inactive_dim = 0.0,
+      .alpha_step = 0.03,
+      .use_ewmh_active_win = false,
+
+      .track_focus = false,
+      .track_wdata = false,
+    },
+
+    .all_damage = None,
+    .time_start = { 0, 0 },
+    .redirected = false,
+    .unredir_possible = false,
+    .alpha_picts = NULL,
+    .reg_ignore_expire = false,
+    .idling = false,
+    .fade_time = 0,
+    .ignore_head = NULL,
+    .ignore_tail = NULL,
+    .reset = false,
+
+    .expose_rects = NULL,
+    .size_expose = 0,
+    .n_expose = 0,
+
+    .list = NULL,
+    .active_win = NULL,
+    .black_picture = None,
+    .dim_picture = None,
+    .cshadow_picture = None,
+    .gaussian_map = NULL,
+    .cgsize = 0,
+    .shadow_corner = NULL,
+    .shadow_top = NULL,
+
+    .refresh_rate = 0,
+    .refresh_intv = 0UL,
+    .paint_tm_offset = 0L,
+
+    .drm_fd = 0,
+
+    .glx_context = None,
+    .glx_get_video_sync = NULL,
+    .glx_wait_video_sync = NULL,
+
+    .xfixes_event = 0,
+    .xfixes_error = 0,
+    .damage_event = 0,
+    .damage_error = 0,
+    .render_event = 0,
+    .render_error = 0,
+    .composite_event = 0,
+    .composite_error = 0,
+    .composite_opcode = 0,
+    .has_name_pixmap = false,
+    .shape_exists = false,
+    .shape_event = 0,
+    .shape_error = 0,
+    .randr_exists = 0,
+    .randr_event = 0,
+    .randr_error = 0,
+    .glx_exists = false,
+    .glx_event = 0,
+    .glx_error = 0,
+    .dbe_exists = false,
+
+    .atom_opacity = None,
+    .atom_frame_extents = None,
+    .atom_client = None,
+    .atom_name = None,
+    .atom_name_ewmh = None,
+    .atom_class = None,
+    .atom_transient = None,
+    .atom_ewmh_active_win = None,
+    .atom_compton_shadow = None,
+    .atom_win_type = None,
+    .atoms_wintypes = { 0 }
+  };
 
-  get_cfg(argc, argv);
+  int i;
 
-  dpy = XOpenDisplay(opts.display);
-  if (!dpy) {
-    fprintf(stderr, "Can't open display\n");
-    exit(1);
+  // Allocate a session and copy default values into it
+  session_t *ps = malloc(sizeof(session_t));
+  memcpy(ps, &s_def, sizeof(session_t));
+  ps_g = ps;
+  ps->ignore_tail = &ps->ignore_head;
+  gettimeofday(&ps->time_start, NULL);
+
+  get_cfg(ps, argc, argv);
+
+  // Inherit old Display if possible, primarily for resource leak checking
+  if (ps_old && ps_old->dpy)
+    ps->dpy = ps_old->dpy;
+
+  // Open Display
+  if (!ps->dpy) {
+    ps->dpy = XOpenDisplay(ps->o.display);
+    if (!ps->dpy) {
+      fprintf(stderr, "Can't open display\n");
+      exit(1);
+    }
   }
 
   XSetErrorHandler(error);
-  if (opts.synchronize) {
-    XSynchronize(dpy, 1);
+  if (ps->o.synchronize) {
+    XSynchronize(ps->dpy, 1);
   }
 
-  scr = DefaultScreen(dpy);
-  root = RootWindow(dpy, scr);
+  ps->scr = DefaultScreen(ps->dpy);
+  ps->root = RootWindow(ps->dpy, ps->scr);
 
-  if (!XRenderQueryExtension(dpy, &render_event, &render_error)) {
+  ps->vis = DefaultVisual(ps->dpy, ps->scr);
+  ps->depth = DefaultDepth(ps->dpy, ps->scr);
+
+  if (!XRenderQueryExtension(ps->dpy,
+        &ps->render_event, &ps->render_error)) {
     fprintf(stderr, "No render extension\n");
     exit(1);
   }
 
-  if (!XQueryExtension(dpy, COMPOSITE_NAME, &composite_opcode,
-                       &composite_event, &composite_error)) {
+  if (!XQueryExtension(ps->dpy, COMPOSITE_NAME, &ps->composite_opcode,
+        &ps->composite_event, &ps->composite_error)) {
     fprintf(stderr, "No composite extension\n");
     exit(1);
   }
 
-  XCompositeQueryVersion(dpy, &composite_major, &composite_minor);
+  {
+    int composite_major = 0, composite_minor = 0;
+
+    XCompositeQueryVersion(ps->dpy, &composite_major, &composite_minor);
 
-  if (composite_major > 0 || composite_minor >= 2) {
-    has_name_pixmap = True;
+    if (composite_major > 0 || composite_minor >= 2) {
+      ps->has_name_pixmap = true;
+    }
   }
 
-  if (!XDamageQueryExtension(dpy, &damage_event, &damage_error)) {
+  if (!XDamageQueryExtension(ps->dpy, &ps->damage_event, &ps->damage_error)) {
     fprintf(stderr, "No damage extension\n");
     exit(1);
   }
 
-  if (!XFixesQueryExtension(dpy, &xfixes_event, &xfixes_error)) {
+  if (!XFixesQueryExtension(ps->dpy, &ps->xfixes_event, &ps->xfixes_error)) {
     fprintf(stderr, "No XFixes extension\n");
     exit(1);
   }
 
   // Query X Shape
-  if (XShapeQueryExtension(dpy, &shape_event, &shape_error)) {
-    shape_exists = True;
+  if (XShapeQueryExtension(ps->dpy, &ps->shape_event, &ps->shape_error)) {
+    ps->shape_exists = true;
   }
 
   // Query X RandR
-  if (opts.sw_opti && !opts.refresh_rate) {
-    if (XRRQueryExtension(dpy, &randr_event, &randr_error))
-      randr_exists = True;
+  if (ps->o.sw_opti && !ps->o.refresh_rate) {
+    if (XRRQueryExtension(ps->dpy, &ps->randr_event, &ps->randr_error))
+      ps->randr_exists = true;
     else
       fprintf(stderr, "No XRandR extension, automatic refresh rate "
           "detection impossible.\n");
@@ -4711,170 +4703,368 @@ main(int argc, char **argv) {
 
 #ifdef CONFIG_VSYNC_OPENGL
   // Query X GLX extension
-  if (VSYNC_OPENGL == opts.vsync) {
-    if (glXQueryExtension(dpy, &glx_event, &glx_error))
-      glx_exists = True;
+  if (VSYNC_OPENGL == ps->o.vsync) {
+    if (glXQueryExtension(ps->dpy, &ps->glx_event, &ps->glx_error))
+      ps->glx_exists = true;
     else {
       fprintf(stderr, "No GLX extension, OpenGL VSync impossible.\n");
-      opts.vsync = VSYNC_NONE;
+      ps->o.vsync = VSYNC_NONE;
     }
   }
 #endif
 
   // Query X DBE extension
-  if (opts.dbe) {
+  if (ps->o.dbe) {
     int dbe_ver_major = 0, dbe_ver_minor = 0;
-    if (XdbeQueryExtension(dpy, &dbe_ver_major, &dbe_ver_minor))
+    if (XdbeQueryExtension(ps->dpy, &dbe_ver_major, &dbe_ver_minor))
       if (dbe_ver_major >= 1)
-        dbe_exists = True;
+        ps->dbe_exists = true;
       else
         fprintf(stderr, "DBE extension version too low. Double buffering "
             "impossible.\n");
     else {
       fprintf(stderr, "No DBE extension. Double buffering impossible.\n");
     }
-    if (!dbe_exists)
-      opts.dbe = False;
+    if (!ps->dbe_exists)
+      ps->o.dbe = false;
   }
 
-  register_cm((VSYNC_OPENGL == opts.vsync));
+  register_cm(ps, (VSYNC_OPENGL == ps->o.vsync));
 
   // Initialize software optimization
-  if (opts.sw_opti)
-    opts.sw_opti = sw_opti_init();
+  if (ps->o.sw_opti)
+    ps->o.sw_opti = sw_opti_init(ps);
 
   // Initialize DRM/OpenGL VSync
-  if ((VSYNC_DRM == opts.vsync && !vsync_drm_init())
-      || (VSYNC_OPENGL == opts.vsync && !vsync_opengl_init()))
-    opts.vsync = VSYNC_NONE;
+  if ((VSYNC_DRM == ps->o.vsync && !vsync_drm_init(ps))
+      || (VSYNC_OPENGL == ps->o.vsync && !vsync_opengl_init(ps)))
+    ps->o.vsync = VSYNC_NONE;
 
   // Overlay must be initialized before double buffer
-  if (opts.paint_on_overlay)
-    init_overlay();
+  if (ps->o.paint_on_overlay)
+    init_overlay(ps);
 
-  if (opts.dbe)
-    init_dbe();
+  if (ps->o.dbe)
+    init_dbe(ps);
 
-  if (opts.fork_after_register) fork_after();
+  if (ps->o.fork_after_register) fork_after();
 
-  get_atoms();
-  init_alpha_picts(dpy);
+  init_atoms(ps);
+  init_alpha_picts(ps);
 
-  pa.subwindow_mode = IncludeInferiors;
+  ps->gaussian_map = make_gaussian_map(ps->o.shadow_radius);
+  presum_gaussian(ps, ps->gaussian_map);
 
-  gaussian_map = make_gaussian_map(dpy, opts.shadow_radius);
-  presum_gaussian(gaussian_map);
+  ps->root_width = DisplayWidth(ps->dpy, ps->scr);
+  ps->root_height = DisplayHeight(ps->dpy, ps->scr);
 
-  root_width = DisplayWidth(dpy, scr);
-  root_height = DisplayHeight(dpy, scr);
+  rebuild_screen_reg(ps);
 
-  rebuild_screen_reg(dpy);
+  {
+    XRenderPictureAttributes pa;
+    pa.subwindow_mode = IncludeInferiors;
 
-  root_picture = XRenderCreatePicture(dpy, root,
-      XRenderFindVisualFormat(dpy, DefaultVisual(dpy, scr)),
-      CPSubwindowMode, &pa);
-  if (opts.paint_on_overlay) {
-    tgt_picture = XRenderCreatePicture(dpy, overlay,
-        XRenderFindVisualFormat(dpy, DefaultVisual(dpy, scr)),
+    ps->root_picture = XRenderCreatePicture(ps->dpy, ps->root,
+        XRenderFindVisualFormat(ps->dpy, ps->vis),
         CPSubwindowMode, &pa);
-  }
-  else {
-    tgt_picture = root_picture;
+    if (ps->o.paint_on_overlay) {
+      ps->tgt_picture = XRenderCreatePicture(ps->dpy, ps->overlay,
+          XRenderFindVisualFormat(ps->dpy, ps->vis),
+          CPSubwindowMode, &pa);
+    }
+    else {
+      ps->tgt_picture = ps->root_picture;
+    }
   }
 
-  black_picture = solid_picture(dpy, True, 1, 0, 0, 0);
+  ps->black_picture = solid_picture(ps, true, 1, 0, 0, 0);
 
   // Generates another Picture for shadows if the color is modified by
   // user
-  if (!opts.shadow_red && !opts.shadow_green && !opts.shadow_blue) {
-    cshadow_picture = black_picture;
+  if (!ps->o.shadow_red && !ps->o.shadow_green && !ps->o.shadow_blue) {
+    ps->cshadow_picture = ps->black_picture;
   } else {
-    cshadow_picture = solid_picture(dpy, True, 1,
-        opts.shadow_red, opts.shadow_green, opts.shadow_blue);
+    ps->cshadow_picture = solid_picture(ps, true, 1,
+        ps->o.shadow_red, ps->o.shadow_green, ps->o.shadow_blue);
   }
 
   // Generates a picture for inactive_dim
-  if (opts.inactive_dim) {
-    dim_picture = solid_picture(dpy, True, opts.inactive_dim, 0, 0, 0);
+  if (ps->o.inactive_dim) {
+    ps->dim_picture = solid_picture(ps, true, ps->o.inactive_dim, 0, 0, 0);
   }
 
-  all_damage = None;
-  XGrabServer(dpy);
+  ps->all_damage = None;
+  XGrabServer(ps->dpy);
 
-  redir_start(dpy);
+  redir_start(ps);
 
-  XSelectInput(dpy, root,
+  XSelectInput(ps->dpy, ps->root,
     SubstructureNotifyMask
     | ExposureMask
     | StructureNotifyMask
     | PropertyChangeMask);
 
-  XQueryTree(dpy, root, &root_return,
-    &parent_return, &children, &nchildren);
+  {
+    Window root_return, parent_return;
+    Window *children;
+    unsigned int nchildren;
+
+    XQueryTree(ps->dpy, ps->root, &root_return,
+      &parent_return, &children, &nchildren);
+
+    for (i = 0; i < nchildren; i++) {
+      add_win(ps, children[i], i ? children[i-1] : None, false);
+    }
 
-  for (i = 0; i < nchildren; i++) {
-    add_win(dpy, children[i], i ? children[i-1] : None, False);
+    XFree(children);
   }
 
-  XFree(children);
 
-  if (opts.track_focus) {
-    recheck_focus(dpy);
+  if (ps->o.track_focus) {
+    recheck_focus(ps);
   }
 
-  XUngrabServer(dpy);
+  XUngrabServer(ps->dpy);
+
+  // Free the old session
+  if (ps_old)
+    free(ps_old);
+
+  return ps;
+}
+
+/**
+ * Destroy a session.
+ *
+ * Does not close the X connection or free the <code>session_t</code>
+ * structure, though.
+ *
+ * @param ps session to destroy
+ */
+static void
+session_destroy(session_t *ps) {
+  redir_stop(ps);
+
+  // Stop listening to events on root window
+  XSelectInput(ps->dpy, ps->root, 0);
 
-  ufd.fd = ConnectionNumber(dpy);
-  ufd.events = POLLIN;
+  // Free window linked list
+  {
+    win *next = NULL;
+    for (win *w = ps->list; w; w = next) {
+      // Must be put here to avoid segfault
+      next = w->next;
 
-  if (opts.sw_opti)
-    paint_tm_offset = get_time_timespec().tv_nsec;
+      if (IsViewable == w->a.map_state && !w->destroyed)
+        win_ev_stop(ps, w);
 
-  reg_ignore_expire = True;
+      free_win_res(ps, w);
+      free(w);
+    }
 
-  fade_time = get_time_ms();
+    ps->list = NULL;
+  }
 
-  t = paint_preprocess(dpy, list);
+  // Free alpha_picts
+  {
+    const int max = lround(1.0 / ps->o.alpha_step) + 1;
+    for (int i = 0; i < max; ++i)
+      free_picture(ps, &ps->alpha_picts[i]);
+    free(ps->alpha_picts);
+    ps->alpha_picts = NULL;
+  }
+
+  // Free blacklists
+  free_wincondlst(&ps->o.shadow_blacklist);
+  free_wincondlst(&ps->o.fade_blacklist);
+
+  // Free ignore linked list
+  {
+    ignore_t *next = NULL;
+    for (ignore_t *ign = ps->ignore_head; ign; ign = next) {
+      next = ign->next;
 
-  if (redirected)
-    paint_all(dpy, None, t);
+      free(ign);
+    }
+
+    // Reset head and tail
+    ps->ignore_head = NULL;
+    ps->ignore_tail = &ps->ignore_head;
+  }
+
+  // Free cshadow_picture and black_picture
+  if (ps->cshadow_picture == ps->black_picture)
+    ps->cshadow_picture = None;
+  else
+    free_picture(ps, &ps->cshadow_picture);
+
+  free_picture(ps, &ps->black_picture);
+
+  // Free tgt_{buffer,picture} and root_picture
+  if (ps->tgt_buffer == ps->tgt_picture)
+    ps->tgt_buffer = None;
+  else
+    free_picture(ps, &ps->tgt_buffer);
+
+  if (ps->tgt_picture == ps->root_picture)
+    ps->tgt_picture = None;
+  else
+    free_picture(ps, &ps->tgt_picture);
+
+  free_picture(ps, &ps->root_picture);
+
+  // Free other X resources
+  free_picture(ps, &ps->dim_picture);
+  free_picture(ps, &ps->root_tile);
+  free_region(ps, &ps->screen_reg);
+  free_region(ps, &ps->all_damage);
+  free(ps->expose_rects);
+  free(ps->shadow_corner);
+  free(ps->shadow_top);
+  free(ps->gaussian_map);
+  free(ps->o.display);
+
+  // Free reg_win and glx_context
+  if (ps->reg_win) {
+    XDestroyWindow(ps->dpy, ps->reg_win);
+    ps->reg_win = None;
+  }
+  if (ps->glx_context) {
+    glXDestroyContext(ps->dpy, ps->glx_context);
+    ps->glx_context = None;
+  }
+
+  // Free double buffer
+  if (ps->root_dbe) {
+    XdbeDeallocateBackBufferName(ps->dpy, ps->root_dbe);
+    ps->root_dbe = None;
+  }
+
+  // Close file opened for DRM VSync
+  if (ps->drm_fd) {
+    close(ps->drm_fd);
+    ps->drm_fd = 0;
+  }
+
+  // Release overlay window
+  if (ps->overlay) {
+    XCompositeReleaseOverlayWindow(ps->dpy, ps->overlay);
+    ps->overlay = None;
+  }
+
+  // Flush all events
+  XSync(ps->dpy, True);
+
+  if (ps == ps_g)
+    ps_g = NULL;
+}
+
+/**
+ * Do the actual work.
+ *
+ * @param ps current session
+ */
+static void
+session_run(session_t *ps) {
+  win *t;
+
+  if (ps->o.sw_opti)
+    ps->paint_tm_offset = get_time_timespec().tv_nsec;
+
+  ps->reg_ignore_expire = true;
+
+  ps->fade_time = get_time_ms();
+
+  t = paint_preprocess(ps, ps->list);
+
+  if (ps->redirected)
+    paint_all(ps, None, t);
 
   // Initialize idling
-  idling = False;
+  ps->idling = false;
 
   // Main loop
-  while (1) {
-    Bool ev_received = False;
+  while (!ps->reset) {
+    bool ev_received = false;
 
-    while (XEventsQueued(dpy, QueuedAfterReading)
-        || (evpoll(&ufd,
-            (ev_received ? 0: (idling ? -1: fade_timeout()))) > 0)) {
+    while (XEventsQueued(ps->dpy, QueuedAfterReading)
+        || (evpoll(ps,
+            (ev_received ? 0: (ps->idling ? -1: fade_timeout(ps)))) > 0)) {
       // Sometimes poll() returns 1 but no events are actually read,
       // causing XNextEvent() to block, I have no idea what's wrong, so we
       // check for the number of events here
-      if (XEventsQueued(dpy, QueuedAfterReading)) {
-        XNextEvent(dpy, &ev);
-        ev_handle((XEvent *) &ev);
-        ev_received = True;
+      if (XEventsQueued(ps->dpy, QueuedAfterReading)) {
+        XEvent ev;
+
+        XNextEvent(ps->dpy, &ev);
+        ev_handle(ps, &ev);
+        ev_received = true;
       }
     }
 
     // idling will be turned off during paint_preprocess() if needed
-    idling = True;
+    ps->idling = true;
 
-    t = paint_preprocess(dpy, list);
+    t = paint_preprocess(ps, ps->list);
 
     // If the screen is unredirected, free all_damage to stop painting
-    if (!redirected)
-      free_region(dpy, &all_damage);
+    if (!ps->redirected)
+      free_region(ps, &ps->all_damage);
 
-    if (all_damage && !is_region_empty(dpy, all_damage)) {
+    if (ps->all_damage && !is_region_empty(ps, ps->all_damage)) {
       static int paint;
-      paint_all(dpy, all_damage, t);
-      reg_ignore_expire = False;
+      paint_all(ps, ps->all_damage, t);
+      ps->reg_ignore_expire = false;
       paint++;
-      XSync(dpy, False);
-      all_damage = None;
+      XSync(ps->dpy, False);
+      ps->all_damage = None;
     }
   }
 }
+
+/**
+ * Turn on the program reset flag.
+ *
+ * This will result in compton resetting itself after next paint.
+ */
+static void
+reset_enable(int __attribute__((unused)) signum) {
+  session_t * const ps = ps_g;
+
+  ps->reset = true;
+}
+
+/**
+ * The function that everybody knows.
+ */
+int
+main(int argc, char **argv) {
+  // Set locale so window names with special characters are interpreted
+  // correctly
+  setlocale(LC_ALL, "");
+
+  // Set up SIGUSR1 signal handler to reset program
+  {
+    sigset_t block_mask;
+    sigemptyset(&block_mask);
+    const struct sigaction action= {
+      .sa_handler = reset_enable,
+      .sa_mask = block_mask,
+      .sa_flags = 0
+    };
+    sigaction(SIGUSR1, &action, NULL);
+  }
+
+  // Main loop
+  session_t *ps_old = ps_g;
+  while (1) {
+    ps_g = session_init(ps_old, argc, argv);
+    session_run(ps_g);
+    ps_old = ps_g;
+    session_destroy(ps_g);
+  }
+
+  free(ps_g);
+
+  return 0;
+}