diff --git a/Makefile b/Makefile
index e0be572..eaa971f 100644
--- a/Makefile
+++ b/Makefile
@@ -1,8 +1,8 @@
 CC	?= gcc
 STRIP ?= strip
-CFLAGS = -std=c99 -I/usr/include/freetype2 -Os
+CFLAGS = -Wall -std=c99 -I/usr/include/freetype2 -Os
 LDFLAGS = -lxcb -lxcb-xinerama -lxcb-randr -lX11 -lX11-xcb -lXft -lfreetype -lz -lfontconfig
-CFDEBUG = -g3 -pedantic -Wall -Wextra -Wunused-parameter -Wlong-long\
+CFDEBUG = -g3 -pedantic -Wall -Wunused-parameter -Wlong-long\
 		  -Wsign-conversion -Wconversion -Wimplicit-function-declaration
 
 EXEC = bar
diff --git a/README.pod b/README.pod
index b276dd5..2887a5b 100644
--- a/README.pod
+++ b/README.pod
@@ -84,6 +84,10 @@ Set the text background color. The parameter I<color> can be I<-> or a color in
 
 Set the text foreground color. The parameter I<color> can be I<-> or a color in one of the formats mentioned before. The special value I<-> resets the color to the default one.
 
+=item B<T>I<index>
+
+Set the font used to draw the following text. The parameter I<index> is a 1-based index of the font list supplied to bar. Any other value (for example I<->) resets bar to normal behaviour (matching the first font that can be used for that character). If the selected font can't be used to draw a character, bar will fall back to normal behaviour for that character.
+
 =item B<U>I<color>
 
 Set the text underline color. The parameter I<color> can be I<-> or a color in one of the formats mentioned before. The special value I<-> resets the color to the default one.
@@ -94,7 +98,11 @@ Create a clickable area starting from the current position, when the area is cli
 
 Eg. I<%{A:reboot:} Click here to reboot %{A}>
 
-The I<button> field is optional, it defaults to the left button, and it's a number ranging from 1 to 5 which maps to the left, middle, right, scroll down and scroll up movements. Your mileage may vary.
+The I<button> field is optional, it defaults to the left button, and it's a number ranging from 1 to 5 which maps to the left, middle, right, scroll up and scroll down movements. Your mileage may vary. 
+
+Nested clickable areas can trigger different commands.
+
+Eg. I<%{A:reboot:}%{A3:halt:} Left click to reboot, right click to shutdown %{A}%{A}>
 
 =item B<S>I<dir>
 
@@ -164,6 +172,6 @@ L<git repository|https://github.com/LemonBoy/bar>
 
 Xinerama support was kindly contributed by Stebalien
 
-RandR support was kindly contributed by jvvv 
+RandR support was kindly contributed by jvvv
 
 Clickable areas support was heavily based off u-ra contribution
diff --git a/bar.c b/bar.c
index e80dfd7..365a7d4 100644
--- a/bar.c
+++ b/bar.c
@@ -1,3 +1,4 @@
+// vim:sw=4:ts=4:et:
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdio.h>
@@ -10,6 +11,7 @@
 #include <unistd.h>
 #include <errno.h>
 #include <xcb/xcb.h>
+#include <xcb/xcbext.h>
 #include <xcb/xinerama.h>
 #include <xcb/randr.h>
 
@@ -36,18 +38,29 @@ typedef struct font_t {
 } font_t;
 
 typedef struct monitor_t {
-    int x, width;
+    int x, y, width;
     xcb_window_t window;
     xcb_pixmap_t pixmap;
     struct monitor_t *prev, *next;
 } monitor_t;
 
 typedef struct area_t {
+    bool active;
     int begin, end, align, button;
     xcb_window_t window;
     char *cmd;
 } area_t;
 
+typedef union rgba_t {
+    struct {
+        uint8_t b;
+        uint8_t g;
+        uint8_t r;
+        uint8_t a;
+    };
+    uint32_t v;
+} rgba_t;
+
 #define N 20
 
 typedef struct area_stack_t {
@@ -73,8 +86,6 @@ enum {
 };
 
 #define MAX_FONT_COUNT 5
-/* 0 <= FONT_CACHE_SIZE <= 65536 */
-#define FONT_CACHE_SIZE 256
 
 static Display *dpy;
 static xcb_connection_t *c;
@@ -88,18 +99,17 @@ static Visual *visual_ptr;
 static xcb_colormap_t colormap;
 
 
-
 static monitor_t *monhead, *montail;
 static font_t *font_list[MAX_FONT_COUNT];
-static char *font_names[MAX_FONT_COUNT];
-static font_t *font_cache[FONT_CACHE_SIZE];
+static int font_count = 0;
+static int font_index = -1;
 static uint32_t attrs = 0;
 static bool dock = false;
 static bool topbar = true;
 static int bw = -1, bh = -1, bx = 0, by = 0;
-static int bu = 1; /* Underline height */
-static uint32_t fgc, bgc, ugc;
-static uint32_t dfgc, dbgc;
+static int bu = 1; // Underline height
+static rgba_t fgc, bgc, ugc;
+static rgba_t dfgc, dbgc;
 static area_stack_t astack;
 
 static XftColor sel_fg;
@@ -113,19 +123,12 @@ static char    xft_width[MAX_WIDTHS];
 void
 update_gc (void)
 {
-    xcb_change_gc(c, gc[GC_DRAW], XCB_GC_BACKGROUND | XCB_GC_FOREGROUND, (const uint32_t []) {
-        fgc, bgc
-    });
-    xcb_change_gc(c, gc[GC_CLEAR], XCB_GC_FOREGROUND, (const uint32_t []) {
-        bgc
-    });
-    xcb_change_gc(c, gc[GC_ATTR], XCB_GC_FOREGROUND, (const uint32_t []) {
-        ugc
-    });
-
+    xcb_change_gc(c, gc[GC_DRAW], XCB_GC_FOREGROUND, (const uint32_t []){ fgc.v });
+    xcb_change_gc(c, gc[GC_CLEAR], XCB_GC_FOREGROUND, (const uint32_t []){ bgc.v });
+    xcb_change_gc(c, gc[GC_ATTR], XCB_GC_FOREGROUND, (const uint32_t []){ ugc.v });
     XftColorFree(dpy, visual_ptr, colormap , &sel_fg);
     char color[] = "#ffffff";
-    uint32_t nfgc = fgc & 0x00ffffff;
+    uint32_t nfgc = fgc.v & 0x00ffffff;
     snprintf(color, sizeof(color), "#%06X", nfgc);
     if (!XftColorAllocName (dpy, visual_ptr, colormap, color, &sel_fg)) {
         fprintf(stderr, "Couldn't allocate xft font color '%s'\n", color);
@@ -133,13 +136,81 @@ update_gc (void)
 }
 
 void
-fill_rect (xcb_drawable_t d, xcb_gcontext_t gc, int x, int y, int width, int height)
+fill_gradient (xcb_drawable_t d, int x, int y, int width, int height, rgba_t start, rgba_t stop)
 {
-    xcb_poly_fill_rectangle(c, d, gc, 1, (const xcb_rectangle_t []) {
-        {
-            x, y, width, height
-        }
-    });
+    float i;
+    const int K = 25; // The number of steps
+
+    for (i = 0.; i < 1.; i += (1. / K)) {
+        // Perform the linear interpolation magic
+        unsigned int rr = i * stop.r + (1. - i) * start.r;
+        unsigned int gg = i * stop.g + (1. - i) * start.g;
+        unsigned int bb = i * stop.b + (1. - i) * start.b;
+
+        // The alpha is ignored here
+        rgba_t step = {
+            .r = rr,
+            .g = gg,
+            .b = bb,
+            .a = 255,
+        };
+
+        xcb_change_gc(c, gc[GC_DRAW], XCB_GC_FOREGROUND, (const uint32_t []){ step.v });
+        xcb_poly_fill_rectangle(c, d, gc[GC_DRAW], 1,
+                               (const xcb_rectangle_t []){ { x, i * bh, width, bh / K + 1 } });
+    }
+
+    xcb_change_gc(c, gc[GC_DRAW], XCB_GC_FOREGROUND, (const uint32_t []){ fgc.v });
+}
+
+void
+fill_rect (xcb_drawable_t d, xcb_gcontext_t _gc, int x, int y, int width, int height)
+{
+    xcb_poly_fill_rectangle(c, d, _gc, 1, (const xcb_rectangle_t []){ { x, y, width, height } });
+}
+
+// Apparently xcb cannot seem to compose the right request for this call, hence we have to do it by
+// ourselves.
+// The funcion is taken from 'wmdia' (http://wmdia.sourceforge.net/)
+xcb_void_cookie_t xcb_poly_text_16_simple(xcb_connection_t * c,
+    xcb_drawable_t drawable, xcb_gcontext_t gc, int16_t x, int16_t y,
+    uint32_t len, const uint16_t *str)
+{
+    static const xcb_protocol_request_t xcb_req = {
+	    5,                // count
+	    0,                // ext
+	    XCB_POLY_TEXT_16, // opcode
+	    1                 // isvoid
+    };
+    struct iovec xcb_parts[7];
+    uint8_t xcb_lendelta[2];
+    xcb_void_cookie_t xcb_ret;
+    xcb_poly_text_8_request_t xcb_out;
+
+    xcb_out.pad0 = 0;
+    xcb_out.drawable = drawable;
+    xcb_out.gc = gc;
+    xcb_out.x = x;
+    xcb_out.y = y;
+
+    xcb_lendelta[0] = len;
+    xcb_lendelta[1] = 0;
+
+    xcb_parts[2].iov_base = (char *)&xcb_out;
+    xcb_parts[2].iov_len = sizeof(xcb_out);
+    xcb_parts[3].iov_base = 0;
+    xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3;
+
+    xcb_parts[4].iov_base = xcb_lendelta;
+    xcb_parts[4].iov_len = sizeof(xcb_lendelta);
+    xcb_parts[5].iov_base = (char *)str;
+    xcb_parts[5].iov_len = len * sizeof(int16_t);
+
+    xcb_parts[6].iov_base = 0;
+    xcb_parts[6].iov_len = -(xcb_parts[4].iov_len + xcb_parts[5].iov_len) & 3;
+
+    xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req);
+    return xcb_ret;
 }
 
 
@@ -173,7 +244,7 @@ int xft_char_width (wchar_t ch, font_t *cur_font)
 }
 
 int
-draw_char (monitor_t *mon, font_t *cur_font, int x, int align, wchar_t ch)
+draw_char (monitor_t *mon, font_t *cur_font, int x, int align, uint16_t ch)
 {
     int ch_width;
 
@@ -183,33 +254,41 @@ draw_char (monitor_t *mon, font_t *cur_font, int x, int align, wchar_t ch)
         ch_width = cur_font->width_lut[ch - cur_font->char_min].character_width;
     }
     switch (align) {
-    case ALIGN_C:
-        xcb_copy_area(c, mon->pixmap, mon->pixmap, gc[GC_DRAW], mon->width / 2 - x / 2, 0,
-                      mon->width / 2 - (x + ch_width) / 2, 0, x, bh);
-        x = mon->width / 2 - (x + ch_width) / 2 + x;
-        break;
-    case ALIGN_R:
-        xcb_copy_area(c, mon->pixmap, mon->pixmap, gc[GC_DRAW], mon->width - x, 0,
-                      mon->width - x - ch_width, 0, x, bh);
-        x = mon->width - ch_width;
-        break;
+        case ALIGN_C:
+            xcb_copy_area(c, mon->pixmap, mon->pixmap, gc[GC_DRAW],
+                    mon->width / 2 - x / 2, 0,
+                    mon->width / 2 - (x + ch_width) / 2, 0,
+                    x, bh);
+            x = mon->width / 2 - (x + ch_width) / 2 + x;
+            break;
+        case ALIGN_R:
+            xcb_copy_area(c, mon->pixmap, mon->pixmap, gc[GC_DRAW],
+                    mon->width - x, 0,
+                    mon->width - x - ch_width, 0,
+                    x, bh);
+            x = mon->width - ch_width;
+            break;
     }
-
-    /* Draw the background first */
+    
+        /* Draw the background first */
     fill_rect(mon->pixmap, gc[GC_CLEAR], x, 0, ch_width, bh);
 
     int y = bh / 2 + cur_font->height / 2- cur_font->descent;
     if (cur_font->xft_ft) {
-        XftDrawString32 (xft_draw, &sel_fg, cur_font->xft_ft, x,y,(const FcChar32*) &ch, 1);
+        XftDrawString16 (xft_draw, &sel_fg, cur_font->xft_ft, x,y, &ch, 1);
     } else {
         char c_ = ch > 127 ? ' ' : ch;
         /* xcb accepts string in UCS-2 BE, so swap */
         ch = (ch >> 8) | (ch << 8);
         /* String baseline coordinates */
         xcb_image_text_8(c, 1, mon->pixmap, gc[GC_DRAW], x,y, &c_);
+        // The coordinates here are those of the baseline
+        xcb_poly_text_16_simple(c, mon->pixmap, gc[GC_DRAW],
+                            x, bh / 2 + cur_font->height / 2 - cur_font->descent,
+                            1, &ch);
     }
 
-    /* We can render both at the same time */
+    // We can render both at the same time
     if (attrs & ATTR_OVERL)
         fill_rect(mon->pixmap, gc[GC_ATTR], x, 0, ch_width, bu);
     if (attrs & ATTR_UNDERL)
@@ -258,72 +337,76 @@ invalid:
     return rtn;
 }
 
-uint32_t
-parse_color (const char *str, char **end, const uint32_t def)
+rgba_t
+parse_color (const char *str, char **end, const rgba_t def)
 {
-    xcb_alloc_named_color_reply_t *nc_reply = 0;
-    int str_len;
-    uint32_t ret;
+    xcb_alloc_named_color_reply_t *nc_reply;
+    int string_len;
+    rgba_t ret;
+    char *ep;
 
     if (!str)
         return def;
 
-    /* Reset */
+    // Reset
     if (str[0] == '-') {
         if (end)
             *end = (char *)str + 1;
+
         return def;
     }
 
-    /* Hex representation */
+    // Hex representation
     if (str[0] == '#') {
         errno = 0;
-        uint32_t tmp = strtoul(str + 1, end, 16);
+        rgba_t tmp = (rgba_t)(uint32_t)strtoul(str + 1, &ep, 16);
 
-        /* Some error checking is definitely good */
-        if (errno)
-            tmp = def;
+        if (end)
+            *end = ep;
 
-        /* Xorg uses colors with premultiplied alpha */
-        unsigned int a = (tmp&0xff000000) >> 24;
-        unsigned int r = (tmp&0x00ff0000) >> 16;
-        unsigned int g = (tmp&0x0000ff00) >> 8;
-        unsigned int b = (tmp&0x000000ff);
-
-        ptrdiff_t len = *end - str;
-        if (len == 8) {
-            if (a == 0) {
-                r = g = b = 0;
-            } else {
-                r = (r * a) / 255;
-                g = (g * a) / 255;
-                b = (b * a) / 255;
-
-                /* Clamp on overflow */
-                if (r > 255) r = 255;
-                if (g > 255) g = 255;
-                if (b > 255) b = 255;
-            }
+        // Some error checking is definitely good
+        if (errno) {
+            fprintf(stderr, "Invalid color specified\n");
+            return def;
         }
 
-        uint32_t c = a << 24 | r << 16 | g << 8 | b;
-        return c;
+        string_len = ep - (str + 1);
+
+        // If the code is in #rrggbb form then assume it's opaque
+        if (string_len <= 6)
+            tmp.a = 255;
+
+        // Premultiply the alpha in
+        if (tmp.a) {
+            // The components are clamped automagically as the rgba_t is made of uint8_t
+            return (rgba_t){
+                .r = (tmp.r * tmp.a) / 255,
+                .g = (tmp.g * tmp.a) / 255,
+                .b = (tmp.b * tmp.a) / 255,
+                .a = tmp.a,
+            };
+        }
+
+        return (rgba_t)0U;
     }
 
-    /* Actual color name, resolve it */
-    str_len = 0;
-    while (isalpha(str[str_len]))
-        str_len++;
+    // Actual color name, resolve it
+    for (string_len = 0; isalpha(str[string_len]); string_len++)
+        ;
 
-    nc_reply = xcb_alloc_named_color_reply(c, xcb_alloc_named_color(c, colormap, str_len, str), NULL);
+    nc_reply = xcb_alloc_named_color_reply(c, xcb_alloc_named_color(c, colormap, string_len, str), NULL);
 
     if (!nc_reply)
-        fprintf(stderr, "Could not alloc color \"%.*s\"\n", str_len, str);
-    ret = (nc_reply) ? nc_reply->pixel : def;
+        fprintf(stderr, "Could not alloc color \"%.*s\"\n", string_len, str);
+
+    ret = nc_reply?
+        (rgba_t)nc_reply->pixel:
+        def;
+
     free(nc_reply);
 
     if (end)
-        *end = (char *)str + str_len;
+        *end = (char *)str + string_len;
 
     return ret;
 }
@@ -354,11 +437,15 @@ set_attribute (const char modifier, const char attribute)
 
 
 area_t *
-area_get (xcb_window_t win, const int x)
+area_get (xcb_window_t win, const int btn, const int x)
 {
-    for (int i = 0; i < astack.pos; i++)
-        if (astack.slot[i].window == win && x >= astack.slot[i].begin && x < astack.slot[i].end)
-            return &astack.slot[i];
+    // Looping backwards ensures that we get the innermost area first
+    for (int i = astack.pos; i >= 0; i--) {
+        area_t *a = &astack.slot[i];
+        if (a->window == win && a->button == btn
+                && x >= a->begin && x < a->end)
+            return a;
+    }
     return NULL;
 }
 
@@ -381,56 +468,74 @@ area_shift (xcb_window_t win, const int align, int delta)
 bool
 area_add (char *str, const char *optend, char **end, monitor_t *mon, const int x, const int align, const int button)
 {
-    char *p = str;
-    area_t *a = &astack.slot[astack.pos];
+    int i;
+    char *trail;
+    area_t *a;
 
-    if (astack.pos == N) {
-        fprintf(stderr, "astack overflow!\n");
-        return false;
-    }
+    // A wild close area tag appeared!
+    if (*str != ':') {
+        *end = str;
 
-    /* A wild close area tag appeared! */
-    if (*p != ':') {
-        *end = p;
+        // Find most recent unclosed area.
+        for (i = astack.pos - 1; i >= 0 && !astack.slot[i].active; i--)
+            ;
+        a = &astack.slot[i];
 
-        /* Basic safety checks */
+        // Basic safety checks
         if (!a->cmd || a->align != align || a->window != mon->window)
             return false;
 
         const int size = x - a->begin;
 
         switch (align) {
-        case ALIGN_L:
-            a->end = x;
-            break;
-        case ALIGN_C:
-            a->begin = mon->width / 2 - size / 2 + a->begin / 2;
-            a->end = a->begin + size;
-            break;
-        case ALIGN_R:
-            /* The newest is the rightmost one */
-            a->begin = mon->width - size;
-            a->end = mon->width;
-            break;
+            case ALIGN_L:
+                a->end = x;
+                break;
+            case ALIGN_C:
+                a->begin = mon->width / 2 - size / 2 + a->begin / 2;
+                a->end = a->begin + size;
+                break;
+            case ALIGN_R:
+                // The newest is the rightmost one
+                a->begin = mon->width - size;
+                a->end = mon->width;
+                break;
         }
 
-        astack.pos++;
-
+        a->active = false;
         return true;
     }
 
-    char *trail = strchr(++p, ':');
+    if (astack.pos >= N) {
+        fprintf(stderr, "astack overflow!\n");
+        return false;
+    }
+    a = &astack.slot[astack.pos++];
 
-    /* Find the trailing : and make sure it's whitin the formatting block, also reject empty commands */
-    if (!trail || p == trail || trail > optend) {
-        *end = p;
+    // Found the closing : and check if it's just an escaped one
+    for (trail = strchr(++str, ':'); trail && trail[-1] == '\\'; trail = strchr(trail + 1, ':'))
+        ;
+
+    // Find the trailing : and make sure it's within the formatting block, also reject empty commands
+    if (!trail || str == trail || trail > optend) {
+        *end = str;
         return false;
     }
 
     *trail = '\0';
 
-    /* This is a pointer to the string buffer allocated in the main */
-    a->cmd = p;
+    // Sanitize the user command by unescaping all the :
+    for (char *needle = str; *needle; needle++) {
+        int delta = trail - &needle[1];
+        if (needle[0] == '\\' && needle[1] == ':') {
+            memmove(&needle[0], &needle[1], delta);
+            needle[delta] = 0;
+        }
+    }
+
+    // This is a pointer to the string buffer allocated in the main
+    a->cmd = str;
+    a->active = true;
     a->align = align;
     a->begin = x;
     a->window = mon->window;
@@ -441,32 +546,34 @@ area_add (char *str, const char *optend, char **end, monitor_t *mon, const int x
     return true;
 }
 
-/* returns NULL if character cannot be printed */
-font_t *
-select_drawable_font (const wchar_t c)
+bool
+font_has_glyph (font_t *font, const uint16_t c)
 {
-    /* if the end is reached without finding an apropriate font, return NULL.
-     * If the font can draw the character, return it.
-     */
-    for (int i = 0; font_list[i] != NULL; i++) {
-        font_t *font = font_list[i];
-        if ((font->ptr && c >= font->char_min && c <= font->char_max &&
-                font->width_lut[c - font->char_min].character_width != 0)||
-                (font->xft_ft && XftCharExists(dpy, font->xft_ft, (FcChar32) c)))
-            return font;
+    return ((font->ptr &&
+             c >= font->char_min &&
+             c <= font->char_max &&
+             font->width_lut &&
+             font->width_lut[c - font->char_min].character_width) ||
+             (font->xft_ft && XftCharExists(dpy, font->xft_ft, (FcChar32) c))
+            );
+}
+
+font_t *
+select_drawable_font (const uint16_t c)
+{
+    // If the user has specified a font to use, try that first.
+    if (font_index != -1 && font_has_glyph(font_list[font_index - 1], c))
+        return font_list[font_index - 1];
+
+    // If the end is reached without finding an apropriate font, return NULL.
+    // If the font can draw the character, return it.
+    for (int i = 0; i < font_count; i++) {
+        if (font_has_glyph(font_list[i], c))
+            return font_list[i];
     }
     return NULL;
 }
 
-/* returns NULL if character cannot be printed */
-font_t *
-select_drawable_font_cache (wchar_t c)
-{
-    if (c < FONT_CACHE_SIZE)
-        return font_cache[c];
-    else
-        return select_drawable_font(c);
-}
 
 void
 parse (char *text)
@@ -474,8 +581,8 @@ parse (char *text)
     font_t *cur_font;
     monitor_t *cur_mon;
     int pos_x, align, button;
-    char *p = text, *end;
-    uint32_t tmp;
+    char *p = text, *block_end, *ep;
+    rgba_t tmp;
 
     pos_x = 0;
     align = ALIGN_L;
@@ -495,114 +602,124 @@ parse (char *text)
         if (*p == '\0' || *p == '\n')
 			break;
 
-        if (*p == '%' && *(p+1) == '{' && (end = strchr(p+2, '}'))) {
-            p += 2;
-            while (p < end) {
+        if (*p == '%' && p++ && *p == '{' && (block_end = strchr(p++, '}'))) {
+            while (p < block_end) {
                 while (isspace(*p))
                     p++;
 
                 switch (*p++) {
-                case '+':
-                    set_attribute('+', *p++);
-                    break;
-                case '-':
-                    set_attribute('-', *p++);
-                    break;
-                case '!':
-                    set_attribute('!', *p++);
-                    break;
+                    case '+': set_attribute('+', *p++); break;
+                    case '-': set_attribute('-', *p++); break;
+                    case '!': set_attribute('!', *p++); break;
 
-                case 'R':
-                    tmp = fgc;
-                    fgc = bgc;
-                    bgc = tmp;
-                    update_gc();
-                    break;
+                    case 'R':
+                              tmp = fgc;
+                              fgc = bgc;
+                              bgc = tmp;
+                              update_gc();
+                              break;
 
-                case 'l':
-                    pos_x = 0;
-                    align = ALIGN_L;
-                    break;
-                case 'c':
-                    pos_x = 0;
-                    align = ALIGN_C;
-                    break;
-                case 'r':
-                    pos_x = 0;
-                    align = ALIGN_R;
-                    break;
+                    case 'l': pos_x = 0; align = ALIGN_L; break;
+                    case 'c': pos_x = 0; align = ALIGN_C; break;
+                    case 'r': pos_x = 0; align = ALIGN_R; break;
 
-                case 'A':
-                    button = XCB_BUTTON_INDEX_1;
-                    /* The range is 1-5 */
-                    if (isdigit(*p) && (*p > '0' && *p < '6'))
-                        button = *p++ - '0';
-                    area_add(p, end, &p, cur_mon, pos_x, align, button);
-                    break;
+                    case 'A':
+                              button = XCB_BUTTON_INDEX_1;
+                              // The range is 1-5
+                              if (isdigit(*p) && (*p > '0' && *p < '6'))
+                                  button = *p++ - '0';
+                              area_add(p, block_end, &p, cur_mon, pos_x, align, button);
+                              break;
 
-                case 'B':
-                    bgc = parse_color(p, &p, dbgc);
-                    update_gc();
-                    break;
-                case 'F':
-                    fgc = parse_color(p, &p, dfgc);
-                    update_gc();
-                    break;
-                case 'U':
-                    ugc = parse_color(p, &p, dbgc);
-                    update_gc();
-                    break;
+                    case 'B': bgc = parse_color(p, &p, dbgc); update_gc(); break;
+                    case 'F': fgc = parse_color(p, &p, dfgc); update_gc(); break;
+                    case 'U': ugc = parse_color(p, &p, dbgc); update_gc(); break;
 
-                case 'S':
-                    if (*p == '+' && cur_mon->next)
-                    {
-                        cur_mon = cur_mon->next;
-                    }
-                    else if (*p == '-' && cur_mon->prev)
-                    {
-                        cur_mon = cur_mon->prev;
-                    }
-                    else if (*p == 'f')
-                    {
-                        cur_mon = monhead;
-                    }
-                    else if (*p == 'l')
-                    {
-                        cur_mon = montail ? montail : monhead;
-                    }
-                    else if (isdigit(*p))
-                    {   cur_mon = monhead;
-                        for (int i = 0; i != *p-'0' && cur_mon->next; i++)
-                            cur_mon = cur_mon->next;
-                    }
-                    else
-                    {
-                        p++;
-                        continue;
-                    }
-					XftDrawDestroy (xft_draw);
-					if (!(xft_draw = XftDrawCreate (dpy, cur_mon->pixmap, visual_ptr , colormap ))) {
-						fprintf(stderr, "Couldn't create xft drawable\n");
-					}
+                    case 'S':
+                              if (*p == '+' && cur_mon->next)
+                              { cur_mon = cur_mon->next; }
+                              else if (*p == '-' && cur_mon->prev)
+                              { cur_mon = cur_mon->prev; }
+                              else if (*p == 'f')
+                              { cur_mon = monhead; }
+                              else if (*p == 'l')
+                              { cur_mon = montail ? montail : monhead; }
+                              else if (isdigit(*p))
+                              { cur_mon = monhead;
+                                for (int i = 0; i != *p-'0' && cur_mon->next; i++)
+                                    cur_mon = cur_mon->next;
+                              }
+                              else
+                              { p++; continue; }
+					          XftDrawDestroy (xft_draw);
+					          if (!(xft_draw = XftDrawCreate (dpy, cur_mon->pixmap, visual_ptr , colormap ))) {
+						        fprintf(stderr, "Couldn't create xft drawable\n");
+					          }
 
-                    p++;
-                    pos_x = 0;
-                    break;
+                              p++;
+                              pos_x = 0;
+                              break;
 
-                /* In case of error keep parsing after the closing } */
-                default:
-                    p = end;
+                    case 'T':
+                              font_index = (int)strtoul(p, &ep, 10);
+                              // User-specified 'font_index' ∊ (0,font_count]
+                              // Otherwise just fallback to the automatic font selection
+                              if (!font_index || font_index > font_count)
+                                  font_index = -1;
+                              p = ep;
+                              break;
+
+                    // In case of error keep parsing after the closing }
+                    default:
+                        p = block_end;
                 }
             }
-            /* Eat the trailing } */
+            // Eat the trailing }
             p++;
-        } else { /* utf-8 -> ucs-2 */
+        } else { // utf-8 -> ucs-2
+            uint8_t *utf = (uint8_t *)p;
+            uint16_t ucs;
 
+            // ASCII
+            if (utf[0] < 0x80) {
+                ucs = utf[0];
+                p  += 1;
+            }
+            // Two byte utf8 sequence
+            else if ((utf[0] & 0xe0) == 0xc0) {
+                ucs = (utf[0] & 0x1f) << 6 | (utf[1] & 0x3f);
+                p += 2;
+            }
+            // Three byte utf8 sequence
+            else if ((utf[0] & 0xf0) == 0xe0) {
+                ucs = (utf[0] & 0xf) << 12 | (utf[1] & 0x3f) << 6 | (utf[2] & 0x3f);
+                p += 3;
+            }
+            // Four byte utf8 sequence
+            else if ((utf[0] & 0xf8) == 0xf0) {
+                ucs = 0xfffd;
+                p += 4;
+            }
+            // Five byte utf8 sequence
+            else if ((utf[0] & 0xfc) == 0xf8) {
+                ucs = 0xfffd;
+                p += 5;
+            }
+            // Siz byte utf8 sequence
+            else if ((utf[0] & 0xfe) == 0xfc) {
+                ucs = 0xfffd;
+                p += 6;
+            }
+            // Not a valid utf-8 sequence
+            else {
+                ucs = utf[0];
+                p += 1;
+            }
 
-            wchar_t t;
-            p += utf8decode(p, &t);
+//            wchar_t t;
+//            p += utf8decode(p, &t);
 
-            cur_font = select_drawable_font(t);
+            cur_font = select_drawable_font(ucs);
             if (!cur_font)
                 continue;
 
@@ -610,7 +727,7 @@ parse (char *text)
                 xcb_change_gc(c, gc[GC_DRAW] , XCB_GC_FONT, (const uint32_t []) {
                 cur_font->ptr
             });
-            int w = draw_char(cur_mon, cur_font, pos_x, align, t);
+            int w = draw_char(cur_mon, cur_font, pos_x, align, ucs);
 
             pos_x += w;
             area_shift(cur_mon->window, align, w);
@@ -645,7 +762,14 @@ font_load (const char *str)
         ret->height = font_info->font_ascent + font_info->font_descent;
         ret->char_max = font_info->max_byte1 << 8 | font_info->max_char_or_byte2;
         ret->char_min = font_info->min_byte1 << 8 | font_info->min_char_or_byte2;
-        ret->width_lut = xcb_query_font_char_infos(font_info);
+        // Copy over the width lut as it's part of font_info
+        int lut_size = sizeof(xcb_charinfo_t) * xcb_query_font_char_infos_length(font_info);
+        if (lut_size) {
+            ret->width_lut = malloc(lut_size);
+            memcpy(ret->width_lut, xcb_query_font_char_infos(font_info), lut_size);
+        }
+
+        free(font_info);
     } else if ((ret->xft_ft = XftFontOpenName (dpy, scr_nbr, str))) {
         ret->ptr = 0;
         ret->ascent = ret->xft_ft->ascent;
@@ -655,7 +779,6 @@ font_load (const char *str)
         fprintf(stderr, "Could not load font %s\n", str);
         return NULL;
     }
-
     return ret;
 }
 
@@ -680,7 +803,7 @@ set_ewmh_atoms (void)
         "_NET_WM_STRUT_PARTIAL",
         "_NET_WM_STRUT",
         "_NET_WM_STATE",
-        /* Leave those at the end since are batch-set */
+        // Leave those at the end since are batch-set
         "_NET_WM_STATE_STICKY",
         "_NET_WM_STATE_ABOVE",
     };
@@ -689,8 +812,8 @@ set_ewmh_atoms (void)
     xcb_atom_t atom_list[atoms];
     xcb_intern_atom_reply_t *atom_reply;
 
-    /* As suggested fetch all the cookies first (yum!) and then retrieve the
-     * atoms to exploit the async'ness */
+    // As suggested fetch all the cookies first (yum!) and then retrieve the
+    // atoms to exploit the async'ness
     for (int i = 0; i < atoms; i++)
         atom_cookie[i] = xcb_intern_atom(c, 0, strlen(atom_names[i]), atom_names[i]);
 
@@ -702,7 +825,7 @@ set_ewmh_atoms (void)
         free(atom_reply);
     }
 
-    /* Prepare the strut array */
+    // Prepare the strut array
     for (monitor_t *mon = monhead; mon; mon = mon->next) {
         int strut[12] = {0};
         if (topbar) {
@@ -722,6 +845,7 @@ set_ewmh_atoms (void)
         } );
         xcb_change_property(c, XCB_PROP_MODE_REPLACE, mon->window, atom_list[NET_WM_STRUT_PARTIAL], XCB_ATOM_CARDINAL, 32, 12, strut);
         xcb_change_property(c, XCB_PROP_MODE_REPLACE, mon->window, atom_list[NET_WM_STRUT], XCB_ATOM_CARDINAL, 32, 4, strut);
+        xcb_change_property(c, XCB_PROP_MODE_REPLACE, mon->window, XCB_ATOM_WM_NAME, XCB_ATOM_STRING, 8, 3, "bar");
     }
 }
 
@@ -737,18 +861,17 @@ monitor_new (int x, int y, int width, int height)
     }
 
     ret->x = x;
+    ret->y = (topbar ? by : height - bh - by) + y;
     ret->width = width;
     ret->next = ret->prev = NULL;
-
-    int win_y = (topbar ? by : height - bh - by) + y;
     ret->window = xcb_generate_id(c);
 
     xcb_create_window(c, XCB_COPY_FROM_PARENT, ret->window, scr->root,
-                      x, win_y, width, bh, 0,
+                      ret->x, ret->y, width, bh, 0,
                       XCB_WINDOW_CLASS_INPUT_OUTPUT, visual,
                       XCB_CW_BACK_PIXEL | XCB_CW_BORDER_PIXEL | XCB_CW_OVERRIDE_REDIRECT | XCB_CW_EVENT_MASK | XCB_CW_COLORMAP,
     (const uint32_t []) {
-        bgc, bgc, dock, XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_BUTTON_PRESS, colormap
+        bgc.v, bgc.v, dock, XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_BUTTON_PRESS, colormap
     });
 
     ret->pixmap = xcb_generate_id(c);
@@ -794,14 +917,14 @@ monitor_create_chain (xcb_rectangle_t *rects, const int num)
     int width = 0, height = 0;
     int left = bx;
 
-    /* Sort before use */
-    qsort(rects, (size_t) num, sizeof(xcb_rectangle_t), rect_sort_cb);
+    // Sort before use
+    qsort(rects, num, sizeof(xcb_rectangle_t), rect_sort_cb);
 
     for (i = 0; i < num; i++) {
         int h = rects[i].y + rects[i].height;
-        /* Accumulated width of all monitors */
+        // Accumulated width of all monitors
         width += rects[i].width;
-        /* Get height of screen from y_offset + height of lowest monitor */
+        // Get height of screen from y_offset + height of lowest monitor
         if (h >= height)
             height = h;
     }
@@ -809,16 +932,17 @@ monitor_create_chain (xcb_rectangle_t *rects, const int num)
     if (bw < 0)
         bw = width - bx;
 
+    // Use the first font height as all the font heights have been set to the biggest of the set
     if (bh < 0 || bh > height)
         bh = font_list[0]->height + bu + 2;
 
-    /* Check the geometry */
+    // Check the geometry
     if (bx + bw > width || by + bh > height) {
         fprintf(stderr, "The geometry specified doesn't fit the screen!\n");
         exit(EXIT_FAILURE);
     }
 
-    /* Left is a positive number or zero therefore monitors with zero width are excluded */
+    // Left is a positive number or zero therefore monitors with zero width are excluded
     width = bw;
     for (i = 0; i < num; i++) {
         if (rects[i].y + rects[i].height < by)
@@ -830,11 +954,14 @@ monitor_create_chain (xcb_rectangle_t *rects, const int num)
                                  min(width, rects[i].width - left),
                                  rects[i].height);
 
+            if (!mon)
+                break;
+
             monitor_add(mon);
 
             width -= rects[i].width - left;
 
-            /* No need to check for other monitors */
+            // No need to check for other monitors
             if (width <= 0)
                 break;
         }
@@ -865,7 +992,7 @@ get_randr_monitors (void)
     outputs = xcb_randr_get_screen_resources_current_outputs(rres_reply);
 
 
-    /* There should be at least one output */
+    // There should be at least one output
     if (num < 1) {
         free(rres_reply);
         return;
@@ -873,15 +1000,16 @@ get_randr_monitors (void)
 
     xcb_rectangle_t rects[num];
 
-    /* Get all outputs */
+    // Get all outputs
     for (i = 0; i < num; i++) {
         xcb_randr_get_output_info_reply_t *oi_reply;
         xcb_randr_get_crtc_info_reply_t *ci_reply;
 
         oi_reply = xcb_randr_get_output_info_reply(c, xcb_randr_get_output_info(c, outputs[i], XCB_CURRENT_TIME), NULL);
 
-        /* Output disconnected or not attached to any CRTC ? */
+        // Output disconnected or not attached to any CRTC ?
         if (!oi_reply || oi_reply->crtc == XCB_NONE || oi_reply->connection != XCB_RANDR_CONNECTION_CONNECTED) {
+            free(oi_reply);
             rects[i].width = 0;
             continue;
         }
@@ -897,10 +1025,8 @@ get_randr_monitors (void)
             return;
         }
 
-        /* There's no need to handle rotated screens here (see #69) */
-        rects[i] = (xcb_rectangle_t) {
-            ci_reply->x, ci_reply->y, ci_reply->width, ci_reply->height
-        };
+        // There's no need to handle rotated screens here (see #69)
+        rects[i] = (xcb_rectangle_t){ ci_reply->x, ci_reply->y, ci_reply->width, ci_reply->height };
 
         free(ci_reply);
 
@@ -909,13 +1035,13 @@ get_randr_monitors (void)
 
     free(rres_reply);
 
-    /* Check for clones and inactive outputs */
+    // Check for clones and inactive outputs
     for (i = 0; i < num; i++) {
         if (rects[i].width == 0)
             continue;
 
         for (j = 0; j < num; j++) {
-            /* Does I countain J ? */
+            // Does I countain J ?
 
             if (i != j && rects[j].width) {
                 if (rects[j].x >= rects[i].x && rects[j].x + rects[j].width <= rects[i].x + rects[i].width &&
@@ -932,7 +1058,6 @@ get_randr_monitors (void)
         return;
     }
 
-
     xcb_rectangle_t r[valid];
 
     for (i = j = 0; i < num && j < valid; i++)
@@ -957,7 +1082,7 @@ get_xinerama_monitors (void)
 
     xcb_rectangle_t rects[screens];
 
-    /* Fetch all the screens first */
+    // Fetch all the screens first
     for (int i = 0; iter.rem; i++) {
         rects[i].x = iter.data->x_org;
         rects[i].y = iter.data->y_org;
@@ -978,6 +1103,99 @@ get_visual (void)
 	return scr->root_visual; //scr->root_visual;
 }
 
+// Parse an X-styled geometry string, we don't support signed offsets tho.
+bool
+parse_geometry_string (char *str, int *tmp)
+{
+    char *p = str;
+    int i = 0, j;
+
+    if (!str || !str[0])
+        return false;
+
+    // The leading = is optional
+    if (*p == '=')
+        p++;
+
+    while (*p) {
+        // A geometry string has only 4 fields
+        if (i >= 4) {
+            fprintf(stderr, "Invalid geometry specified\n");
+            return false;
+        }
+        // Move on if we encounter a 'x' or '+'
+        if (*p == 'x') {
+            if (i > 0) // The 'x' must precede '+'
+                break;
+            i++; p++; continue;
+        }
+        if (*p == '+') {
+            if (i < 1) // Stray '+', skip the first two fields
+                i = 2;
+            else
+                i++;
+            p++; continue;
+        }
+        // A digit must follow
+        if (!isdigit(*p)) {
+            fprintf(stderr, "Invalid geometry specified\n");
+            return false;
+        }
+        // Try to parse the number
+        errno = 0;
+        j = strtoul(p, &p, 10);
+        if (errno) {
+            fprintf(stderr, "Invalid geometry specified\n");
+            return false;
+        }
+        tmp[i] = j;
+    }
+
+    return true;
+}
+
+void
+parse_font_list (char *str)
+{
+    char *tok, *end;
+
+    if (!str)
+        return;
+
+    tok = strtok(str, ",");
+
+    while (tok) {
+        if (font_count > MAX_FONT_COUNT - 1) {
+            fprintf(stderr, "Too many fonts; maximum %i\n", MAX_FONT_COUNT);
+            return;
+        }
+
+        // Strip the leading and trailing whitespaces
+        while (isspace(*tok) || iscntrl(*tok))
+            tok++;
+
+        end = tok + strlen(tok) - 1;
+
+        while ((end > tok && isspace(*end)) || iscntrl(*end))
+            end--;
+
+        *(end + 1) = '\0';
+
+        if (tok[0]) {
+            // Load the selected font
+            font_t *font = font_load(tok);
+            if (font)
+                font_list[font_count++] = font;
+        }
+        else
+            fprintf(stderr, "Empty font name, skipping...\n");
+
+        tok = strtok(NULL, ",");
+    }
+}
+
+
+
 void
 xconn (void)
 {
@@ -992,118 +1210,116 @@ xconn (void)
 
 	XSetEventQueueOwner(dpy, XCBOwnsEventQueue);
 
+    if (xcb_connection_has_error(c)) {
+        fprintf(stderr, "Couldn't connect to X\n");
+        exit(EXIT_FAILURE);
+    }
+
     /* Grab infos from the first screen */
     scr = xcb_setup_roots_iterator(xcb_get_setup(c)).data;
 
     /* Try to get a RGBA visual and build the colormap for that */
 	visual = get_visual();
 	colormap = DefaultColormap(dpy, scr_nbr);
-
 }
 
 void
 init (void)
 {
-    /* Load the fonts */
-    for (int i = 0; font_names[i]; i++) {
-        font_list[i] = font_load(font_names[i]);
-        if (!font_list[i])
-            exit(EXIT_FAILURE);
-    }
+    // This has to be declared as an array because otherwise the compiler would turn it into a const
+    // string, making strtok choke very hard on this
+    char fallback_font[] = "fixed";
 
-    if (!font_list[0])
-        font_list[0] = font_load("fixed");
+    // Try to load a default font
+    if (!font_count)
+        parse_font_list(fallback_font);
 
-    if (!font_list[0])
+    // We tried and failed hard, there's something wrong
+    if (!font_count)
         exit(EXIT_FAILURE);
 
-    for (uint16_t i = 0; i < FONT_CACHE_SIZE; i++)
-        font_cache[i] = select_drawable_font(i);
-
-    /* To make the alignment uniform, find maximum height */
+    // To make the alignment uniform, find maximum height
     int maxh = font_list[0]->height;
-    for (int i = 1; font_list[i]; i++)
+    for (int i = 1; i < font_count; i++)
         maxh = max(maxh, font_list[i]->height);
 
-    /* Set maximum height to all fonts */
-    for (int i = 0; font_list[i]; i++)
+    // Set maximum height to all fonts
+    for (int i = 0; i < font_count; i++)
         font_list[i]->height = maxh;
 
-    /* Generate a list of screens */
+    // Generate a list of screens
     const xcb_query_extension_reply_t *qe_reply;
 
-    /* Initialiaze monitor list head and tail */
+    // Initialiaze monitor list head and tail
     monhead = montail = NULL;
 
-    /* Check if RandR is present */
+    // Check if RandR is present
     qe_reply = xcb_get_extension_data(c, &xcb_randr_id);
 
     if (qe_reply && qe_reply->present) {
 		get_randr_monitors();
     } else {
-		qe_reply = xcb_get_extension_data(c, &xcb_xinerama_id);
-    
-		/* Check if Xinerama extension is present and active */
-		if (qe_reply && qe_reply->present) {
-			xcb_xinerama_is_active_reply_t *xia_reply;
-			xia_reply = xcb_xinerama_is_active_reply(c, xcb_xinerama_is_active(c), NULL);
-    
-			if (xia_reply && xia_reply->state)
-				get_xinerama_monitors();
-    
-			free(xia_reply);
-		}
-	}
+        qe_reply = xcb_get_extension_data(c, &xcb_xinerama_id);
+
+        // Check if Xinerama extension is present and active
+        if (qe_reply && qe_reply->present) {
+            xcb_xinerama_is_active_reply_t *xia_reply;
+            xia_reply = xcb_xinerama_is_active_reply(c, xcb_xinerama_is_active(c), NULL);
+
+            if (xia_reply && xia_reply->state)
+                get_xinerama_monitors();
+
+            free(xia_reply);
+        }
+    }
 
     if (!monhead) {
-        /* If I fits I sits */
+        // If I fits I sits
         if (bw < 0)
             bw = scr->width_in_pixels - bx;
 
-        /* Adjust the height */
+        // Adjust the height
         if (bh < 0 || bh > scr->height_in_pixels)
             bh = maxh + bu + 2;
 
-        /* Check the geometry */
+        // Check the geometry
         if (bx + bw > scr->width_in_pixels || by + bh > scr->height_in_pixels) {
             fprintf(stderr, "The geometry specified doesn't fit the screen!\n");
             exit(EXIT_FAILURE);
         }
 
-        /* If no RandR outputs or Xinerama screens, fall back to using whole screen */
+        // If no RandR outputs or Xinerama screens, fall back to using whole screen
         monhead = monitor_new(0, 0, bw, scr->height_in_pixels);
     }
 
     if (!monhead)
         exit(EXIT_FAILURE);
 
-    /* For WM that support EWMH atoms */
+    // For WM that support EWMH atoms
     set_ewmh_atoms();
 
-    /* Create the gc for drawing */
+    // Create the gc for drawing
     gc[GC_DRAW] = xcb_generate_id(c);
-    xcb_create_gc(c, gc[GC_DRAW], monhead->pixmap, XCB_GC_FOREGROUND | XCB_GC_BACKGROUND, (const uint32_t []) {
-        fgc, bgc
-    });
+    xcb_create_gc(c, gc[GC_DRAW], monhead->pixmap, XCB_GC_FOREGROUND, (const uint32_t []){ fgc.v });
 
     gc[GC_CLEAR] = xcb_generate_id(c);
-    xcb_create_gc(c, gc[GC_CLEAR], monhead->pixmap, XCB_GC_FOREGROUND, (const uint32_t []) {
-        bgc
-    });
+    xcb_create_gc(c, gc[GC_CLEAR], monhead->pixmap, XCB_GC_FOREGROUND, (const uint32_t []){ bgc.v });
 
     gc[GC_ATTR] = xcb_generate_id(c);
-    xcb_create_gc(c, gc[GC_ATTR], monhead->pixmap, XCB_GC_FOREGROUND, (const uint32_t []) {
-        ugc
-    });
+    xcb_create_gc(c, gc[GC_ATTR], monhead->pixmap, XCB_GC_FOREGROUND, (const uint32_t []){ ugc.v });
 
-    /* Make the bar visible and clear the pixmap */
+    // Make the bar visible and clear the pixmap
     for (monitor_t *mon = monhead; mon; mon = mon->next) {
         fill_rect(mon->pixmap, gc[GC_CLEAR], 0, 0, mon->width, bh);
         xcb_map_window(c, mon->window);
+
+        // Make sure that the window really gets in the place it's supposed to be
+        // Some WM such as Openbox need this
+        xcb_configure_window(c, mon->window, XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y, (const uint32_t []){ mon->x, mon->y });
     }
 
     char color[] = "#ffffff";
-    uint32_t nfgc = fgc & 0x00ffffff;
+    uint32_t nfgc = fgc.v & 0x00ffffff;
     snprintf(color, sizeof(color), "#%06X", nfgc);
 
     if (!XftColorAllocName (dpy, visual_ptr, colormap, color, &sel_fg)) {
@@ -1121,9 +1337,9 @@ cleanup (void)
         }
         else {
             xcb_close_font(c, font_list[i]->ptr);
+            free(font_list[i]->width_lut);
         }
         free(font_list[i]);
-        font_list[i] = NULL;
     }
 
     while (monhead) {
@@ -1153,80 +1369,7 @@ sighandle (int signal)
         exit(EXIT_SUCCESS);
 }
 
-/* Parse an X-styled geometry string, we don't support signed offsets tho. */
-bool
-parse_geometry_string (char *str, int *tmp)
-{
-    char *p = str;
-    int i = 0, j;
 
-    if (!str || !str[0])
-        return false;
-
-    /* The leading = is optional */
-    if (*p == '=')
-        p++;
-
-    while (*p) {
-        /* A geometry string has only 4 fields */
-        if (i >= 4) {
-            fprintf(stderr, "Invalid geometry specified\n");
-            return false;
-        }
-        /* Move on if we encounter a 'x' or '+' */
-        if (*p == 'x') {
-            if (i > 0) /* The 'x' must precede '+' */
-                break;
-            i++;
-            p++;
-            continue;
-        }
-        if (*p == '+') {
-            if (i < 1) /* Stray '+', skip the first two fields */
-                i = 2;
-            else
-                i++;
-            p++;
-            continue;
-        }
-        /* A digit must follow */
-        if (!isdigit(*p)) {
-            fprintf(stderr, "Invalid geometry specified\n");
-            return false;
-        }
-        /* Try to parse the number */
-        errno = 0;
-        j = strtoul(p, &p, 10);
-        if (errno) {
-            fprintf(stderr, "Invalid geometry specified\n");
-            return false;
-        }
-        tmp[i] = j;
-    }
-
-    return true;
-}
-
-void
-parse_font_list (char *str)
-{
-    char *tok;
-
-    if (!str)
-        return;
-
-    tok = strtok(str, ",");
-
-    for (int i = 0; tok; i++) {
-        if (i >= MAX_FONT_COUNT) {
-            fprintf(stderr, "Too many fonts; maximum %i\n", MAX_FONT_COUNT);
-            return;
-        }
-
-        font_names[i] = tok;
-        tok = strtok(NULL, ",");
-    }
-}
 int
 main (int argc, char **argv)
 {
@@ -1240,105 +1383,93 @@ main (int argc, char **argv)
     char input[4096] = {0, };
     bool permanent = false;
     int geom_v[4] = { -1, -1, 0, 0 };
+    int ch;
 
-    /* Install the parachute! */
+    // Install the parachute!
     atexit(cleanup);
     signal(SIGINT, sighandle);
     signal(SIGTERM, sighandle);
 
-    /* Connect to the Xserver and initialize scr */
+    // Connect to the Xserver and initialize scr
     xconn();
 
-    /* B/W combo */
-    dbgc = bgc = parse_color("black", NULL, scr->black_pixel);
-    dfgc = fgc = parse_color("white", NULL, scr->white_pixel);
+    // B/W combo
+    dbgc = bgc = parse_color("black", NULL, (rgba_t)scr->black_pixel);
+    dfgc = fgc = parse_color("white", NULL, (rgba_t)scr->white_pixel);
 
     ugc = fgc;
 
-    char* end_ptr = NULL;
-    char ch;
     while ((ch = getopt(argc, argv, "hg:bdf:a:pu:B:F:")) != -1) {
         switch (ch) {
-        case 'h':
-            printf ("usage: %s [-h | -g | -b | -d | -f | -a | -p | -u | -B | -F]\n"
-                    "\t-h Show this help\n"
-                    "\t-g Set the bar geometry {width}x{height}+{xoffset}+{yoffset}\n"
-                    "\t-b Put bar at the bottom of the screen\n"
-                    "\t-d Force docking (use this if your WM isn't EWMH compliant)\n"
-                    "\t-f Bar font list, comma separated\n"
-                    "\t-p Don't close after the data ends\n"
-                    "\t-u Set the underline/overline height in pixels\n"
-                    "\t-B Set background color in #AARRGGBB\n"
-                    "\t-F Set foreground color in #AARRGGBB\n", argv[0]);
-            exit (EXIT_SUCCESS);
-        case 'g':
-            (void)parse_geometry_string(optarg, geom_v);
-            break;
-        case 'p':
-            permanent = true;
-            break;
-        case 'b':
-            topbar = false;
-            break;
-        case 'd':
-            dock = true;
-            break;
-        case 'f':
-            parse_font_list(optarg);
-            break;
-        case 'u':
-            bu = strtoul(optarg, NULL, 10);
-            break;
-        case 'B':
-            dbgc = bgc = parse_color(optarg, &end_ptr, scr->black_pixel);
-            break;
-        case 'F':
-            dfgc = fgc = parse_color(optarg, &end_ptr, scr->white_pixel);
-            break;
+            case 'h':
+                printf ("usage: %s [-h | -g | -b | -d | -f | -a | -p | -u | -B | -F]\n"
+                        "\t-h Show this help\n"
+                        "\t-g Set the bar geometry {width}x{height}+{xoffset}+{yoffset}\n"
+                        "\t-b Put bar at the bottom of the screen\n"
+                        "\t-d Force docking (use this if your WM isn't EWMH compliant)\n"
+                        "\t-f Bar font list, comma separated\n"
+                        "\t-p Don't close after the data ends\n"
+                        "\t-u Set the underline/overline height in pixels\n"
+                        "\t-B Set background color in #AARRGGBB\n"
+                        "\t-F Set foreground color in #AARRGGBB\n", argv[0]);
+                exit (EXIT_SUCCESS);
+            case 'g': (void)parse_geometry_string(optarg, geom_v); break;
+            case 'p': permanent = true; break;
+            case 'b': topbar = false; break;
+            case 'd': dock = true; break;
+            case 'f': parse_font_list(optarg); break;
+            case 'u': bu = strtoul(optarg, NULL, 10); break;
+            case 'B': dbgc = bgc = parse_color(optarg, NULL, (rgba_t)scr->black_pixel); break;
+            case 'F': dfgc = fgc = parse_color(optarg, NULL, (rgba_t)scr->white_pixel); break;
         }
     }
-    /* Copy the geometry values in place */
+
+    // Copy the geometry values in place
     bw = geom_v[0];
     bh = geom_v[1];
     bx = geom_v[2];
     by = geom_v[3];
 
-    /* Do the heavy lifting */
+    // Do the heavy lifting
     init();
-    /* Get the fd to Xserver */
+    // Get the fd to Xserver
     pollin[1].fd = xcb_get_file_descriptor(c);
     for (;;) {
         bool redraw = false;
 
+        // If connection is in error state, then it has been shut down.
+        if (xcb_connection_has_error(c))
+            break;
+
         if (poll(pollin, 2, -1) > 0) {
-            if (pollin[0].revents & POLLHUP) {      /* No more data... */
-                if (permanent) pollin[0].fd = -1;   /* ...null the fd and continue polling :D */
-                else break;                         /* ...bail out */
+            if (pollin[0].revents & POLLHUP) {      // No more data...
+                if (permanent) pollin[0].fd = -1;   // ...null the fd and continue polling :D
+                else break;                         // ...bail out
             }
-            if (pollin[0].revents & POLLIN) { /* New input, process it */
+            if (pollin[0].revents & POLLIN) { // New input, process it
                 if (fgets(input, sizeof(input), stdin) == NULL)
-                    break; /* EOF received */
+                    break; // EOF received
 
                 parse(input);
                 redraw = true;
             }
-            if (pollin[1].revents & POLLIN) { /* Xserver broadcasted an event */
+            if (pollin[1].revents & POLLIN) { // Xserver broadcasted an event
                 while ((ev = xcb_poll_for_event(c))) {
                     expose_ev = (xcb_expose_event_t *)ev;
 
                     switch (ev->response_type & 0x7F) {
                         case XCB_EXPOSE:
-                            if (expose_ev->count == 0) 
+                            if (expose_ev->count == 0)
                                 redraw = true;
                             break;
                         case XCB_BUTTON_PRESS:
                             press_ev = (xcb_button_press_event_t *)ev;
                             {
-                                area_t *area = area_get(press_ev->event, press_ev->event_x);
-                                /* Respond to the click */
-                                if (area && area->button == press_ev->detail) {
-                                    write(STDOUT_FILENO, area->cmd, strlen(area->cmd)); 
-                                    write(STDOUT_FILENO, "\n", 1); 
+                                area_t *area = area_get(press_ev->event, press_ev->detail, press_ev->event_x);
+                                // Respond to the click
+                                if (area) {
+                                    write(STDOUT_FILENO, area->cmd, strlen(area->cmd));
+                                    write(STDOUT_FILENO, "\n", 1);
                                 }
                             }
                         break;
@@ -1349,7 +1480,7 @@ main (int argc, char **argv)
             }
         }
 
-        if (redraw) { /* Copy our temporary pixmap onto the window */
+        if (redraw) { // Copy our temporary pixmap onto the window
             for (monitor_t *mon = monhead; mon; mon = mon->next) {
                 xcb_copy_area(c, mon->pixmap, mon->window, gc[GC_DRAW], 0, 0, 0, 0, mon->width, bh);
             }