diff --git a/Makefile b/Makefile
index ff620a8..50fb285 100644
--- a/Makefile
+++ b/Makefile
@@ -1,6 +1,5 @@
 CC	?= gcc
-STRIP ?= strip
-CFLAGS = -std=c99 -Os
+CFLAGS = -Wall -std=c99 -Os
 LDFLAGS = -lxcb -lxcb-xinerama -lxcb-randr
 CFDEBUG = -g3 -pedantic -Wall -Wunused-parameter -Wlong-long\
 		  -Wsign-conversion -Wconversion -Wimplicit-function-declaration
@@ -22,7 +21,6 @@ doc: README.pod
 
 ${EXEC}: ${OBJS}
 	${CC} -o ${EXEC} ${OBJS} ${LDFLAGS}
-	${STRIP} -s ${EXEC}
 
 debug: ${EXEC}
 debug: CC += ${CFDEBUG}
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 f911913..8a86c94 100644
--- a/bar.c
+++ b/bar.c
@@ -1,3 +1,4 @@
+// vim:sw=4:ts=4:et:
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -9,6 +10,7 @@
 #include <unistd.h>
 #include <errno.h>
 #include <xcb/xcb.h>
+#include <xcb/xcbext.h>
 #include <xcb/xinerama.h>
 #include <xcb/randr.h>
 
@@ -27,18 +29,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 {
@@ -65,8 +78,6 @@ enum {
 };
 
 #define MAX_FONT_COUNT 5
-/* 0 <= FONT_CACHE_SIZE <= 65536 */
-#define FONT_CACHE_SIZE 256
 
 static xcb_connection_t *c;
 static xcb_screen_t *scr;
@@ -75,29 +86,101 @@ static xcb_visualid_t visual;
 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;
 
 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 });
 }
 
 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;
 }
 
 int
@@ -107,27 +190,33 @@ draw_char (monitor_t *mon, font_t *cur_font, int x, int align, uint16_t ch)
 
     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);
+            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);
+            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, by, ch_width, bh);
 
-    /* xcb accepts string in UCS-2 BE, so swap */
+    // xcb accepts string in UCS-2 BE, so swap
     ch = (ch >> 8) | (ch << 8);
 
-    /* String baseline coordinates */
-    xcb_image_text_16(c, 1, mon->pixmap, gc[GC_DRAW], x, bh / 2 + cur_font->height / 2 - cur_font->descent, (xcb_char2b_t *)&ch);
+    // 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)
@@ -136,67 +225,76 @@ draw_char (monitor_t *mon, font_t *cur_font, int x, int align, uint16_t ch)
     return ch_width;
 }
 
-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;
-    int str_len;
-    uint32_t ret;
+    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);
+        // Some error checking is definitely good
+        if (errno) {
+            fprintf(stderr, "Invalid color specified\n");
+            return def;
+        }
 
-        if (a) {
-            r = (r * 255) / a;
-            g = (g * 255) / a;
-            b = (b * 255) / a;
+        string_len = ep - (str + 1);
 
-            /* Clamp on overflow */
-            if (r > 255) r = 255;
-            if (g > 255) g = 255;
-            if (b > 255) b = 255;
-        } else
-            r = g = b = 0;
+        // If the code is in #rrggbb form then assume it's opaque
+        if (string_len <= 6)
+            tmp.a = 255;
 
-        return a << 24 | r << 16 | g << 8 | b;
+        // 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;
 }
@@ -221,11 +319,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;
 }
 
@@ -248,19 +350,20 @@ 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;
 
@@ -275,29 +378,46 @@ area_add (char *str, const char *optend, char **end, monitor_t *mon, const int x
                 a->end = a->begin + size;
                 break;
             case ALIGN_R:
-                /* The newest is the rightmost one */
+                // 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;
@@ -308,40 +428,40 @@ area_add (char *str, const char *optend, char **end, monitor_t *mon, const int x
     return true;
 }
 
-/* returns NULL if character cannot be printed */
+bool
+font_has_glyph (font_t *font, const uint16_t c)
+{
+    return (c >= font->char_min &&
+            c <= font->char_max &&
+            font->width_lut &&
+            font->width_lut[c - font->char_min].character_width);
+}
+
+// returns NULL if character cannot be printed
 font_t *
 select_drawable_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 (c >= font->char_min && c <= font->char_max &&
-                font->width_lut[c - font->char_min].character_width != 0)
-            return font;
+    // 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 (uint16_t c)
-{
-    if (c < FONT_CACHE_SIZE)
-        return font_cache[c];
-    else
-        return select_drawable_font(c);
-}
-
 void
 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;
@@ -356,8 +476,8 @@ parse (char *text)
         if (*p == '\0' || *p == '\n')
             return;
 
-        if (*p == '%' && p++ && *p == '{' && (end = strchr(p++, '}'))) {
-            while (p < end) {
+        if (*p == '%' && p++ && *p == '{' && (block_end = strchr(p++, '}'))) {
+            while (p < block_end) {
                 while (isspace(*p))
                     p++;
 
@@ -379,10 +499,10 @@ parse (char *text)
 
                     case 'A':
                               button = XCB_BUTTON_INDEX_1;
-                              /* The range is 1-5 */
+                              // 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);
+                              area_add(p, block_end, &p, cur_mon, pos_x, align, button);
                               break;
 
                     case 'B': bgc = parse_color(p, &p, dbgc); update_gc(); break;
@@ -410,30 +530,58 @@ parse (char *text)
                               pos_x = 0;
                               break;
 
-                    /* In case of error keep parsing after the closing } */
+                    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 = end;
+                        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;
             }
-            else { /* Handle ascii > 0x80 */
+            // 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;
             }
@@ -464,7 +612,7 @@ font_load (const char *str)
 
     cookie = xcb_open_font_checked(c, font, strlen(str), str);
     if (xcb_request_check (c, cookie)) {
-        fprintf(stderr, "Could not load font %s\n", str);
+        fprintf(stderr, "Could not load font \"%s\"\n", str);
         return NULL;
     }
 
@@ -481,7 +629,15 @@ 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);
 
     return ret;
 }
@@ -507,7 +663,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",
     };
@@ -516,8 +672,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]);
 
@@ -529,7 +685,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) {
@@ -547,6 +703,7 @@ set_ewmh_atoms (void)
         xcb_change_property(c, XCB_PROP_MODE_REPLACE, mon->window, atom_list[NET_WM_DESKTOP], XCB_ATOM_CARDINAL, 32, 1, (const uint32_t []){ -1 } );
         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");
     }
 }
 
@@ -562,18 +719,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);
 
     int depth = (visual == scr->root_visual) ? XCB_COPY_FROM_PARENT : 32;
     xcb_create_window(c, depth, 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 });
+            (const uint32_t []){ bgc.v, bgc.v, dock, XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_BUTTON_PRESS, colormap });
 
     ret->pixmap = xcb_generate_id(c);
     xcb_create_pixmap(c, depth, ret->pixmap, ret->window, width, bh);
@@ -618,14 +774,14 @@ monitor_create_chain (xcb_rectangle_t *rects, const int num)
     int width = 0, height = 0;
     int left = bx;
 
-    /* Sort before use */
+    // 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;
     }
@@ -633,16 +789,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)
@@ -654,11 +811,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;
         }
@@ -689,7 +849,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;
@@ -697,15 +857,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;
         }
@@ -721,7 +882,7 @@ get_randr_monitors (void)
             return;
         }
 
-        /* There's no need to handle rotated screens here (see #69) */
+        // 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);
@@ -731,13 +892,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 &&
@@ -754,11 +915,11 @@ get_randr_monitors (void)
         return;
     }
 
-	xcb_rectangle_t r[valid];
+    xcb_rectangle_t r[valid];
 
-	for (i = j = 0; i < num && j < valid; i++)
-		if (rects[i].width != 0)
-			r[j++] = rects[i];
+    for (i = j = 0; i < num && j < valid; i++)
+        if (rects[i].width != 0)
+            r[j++] = rects[i];
 
     monitor_create_chain(r, valid);
 }
@@ -778,7 +939,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;
@@ -799,7 +960,7 @@ get_visual (void)
 
     iter = xcb_screen_allowed_depths_iterator(scr);
 
-    /* Try to find a RGBA visual */
+    // Try to find a RGBA visual
     while (iter.rem) {
         xcb_visualtype_t *vis = xcb_depth_visuals(iter.data);
 
@@ -809,24 +970,117 @@ get_visual (void)
         xcb_depth_next(&iter);
     }
 
-    /* Fallback to the default one */
+    // Fallback to the default one
     return 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)
 {
-    /* Connect to X */
+    // Connect to X
     c = xcb_connect (NULL, NULL);
     if (xcb_connection_has_error(c)) {
         fprintf(stderr, "Couldn't connect to X\n");
         exit(EXIT_FAILURE);
     }
 
-    /* Grab infos from the first screen */
+    // 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 */
+    // Try to get a RGBA visual and build the colormap for that
     visual = get_visual();
 
     colormap = xcb_generate_id(c);
@@ -836,38 +1090,34 @@ xconn (void)
 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) {
@@ -875,7 +1125,7 @@ init (void)
     } else {
         qe_reply = xcb_get_extension_data(c, &xcb_xinerama_id);
 
-        /* Check if Xinerama extension is present and active */
+        // 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);
@@ -888,44 +1138,48 @@ init (void)
     }
 
     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 });
     }
 
     xcb_flush(c);
@@ -934,10 +1188,10 @@ init (void)
 void
 cleanup (void)
 {
-    for (int i = 0; font_list[i]; i++) {
+    for (int i = 0; i < font_count; i++) {
         xcb_close_font(c, font_list[i]->ptr);
+        free(font_list[i]->width_lut);
         free(font_list[i]);
-        font_list[i] = NULL;
     }
 
     while (monhead) {
@@ -967,78 +1221,6 @@ 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)
 {
@@ -1052,22 +1234,22 @@ 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 ch;
     while ((ch = getopt(argc, argv, "hg:bdf:a:pu:B:F:")) != -1) {
         switch (ch) {
             case 'h':
@@ -1088,54 +1270,58 @@ main (int argc, char **argv)
             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, scr->black_pixel); break;
-            case 'F': dfgc = fgc = parse_color(optarg, NULL, scr->white_pixel); 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;
@@ -1146,7 +1332,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);
             }