Merge branch 'font-fallback'

.gitlab-ci.yml

@@ -10,7 +10,8 @@ before_script:
   - echo "http://dl-cdn.alpinelinux.org/alpine/edge/testing" >> /etc/apk/repositories
   - apk update
   - apk add musl-dev eudev-libs eudev-dev linux-headers meson ninja gcc scdoc
-  - apk add libxcb-dev xcb-util-wm-dev xcb-util-cursor-dev cairo-dev yaml-dev
+  - apk add pixman-dev freetype-dev fontconfig-dev
+  - apk add libxcb-dev xcb-util-wm-dev xcb-util-cursor-dev yaml-dev
   - apk add wayland-dev wayland-protocols wlroots-dev
   - apk add json-c-dev libmpdclient-dev alsa-lib-dev
   - apk add ttf-dejavu

PKGBUILD

@@ -9,7 +9,7 @@ makedepends=('meson' 'ninja' 'scdoc')
 depends=(
   'libxcb' 'xcb-util' 'xcb-util-cursor' 'xcb-util-wm'
   'wayland' 'wlroots'
-  'freetype2' 'fontconfig' 'cairo'
+  'freetype2' 'fontconfig' 'pixman'
   'libyaml'
   'alsa-lib'
   'libudev.so'

PKGBUILD.wayland-only

@@ -10,7 +10,7 @@ provides=('f00bar')
 makedepends=('meson' 'ninja' 'scdoc')
 depends=(
   'wayland' 'wlroots'
-  'freetype2' 'fontconfig' 'cairo'
+  'freetype2' 'fontconfig' 'pixman'
   'libyaml'
   'alsa-lib'
   'libudev.so'

bar/backend.h

@@ -11,7 +11,7 @@ struct backend {
                  void (*expose)(const struct bar *bar),
                  void (*on_mouse)(struct bar *bar, enum mouse_event event,
                                   int x, int y));
-    void (*commit_surface)(const struct bar *bar);
+    void (*commit)(const struct bar *bar);
     void (*refresh)(const struct bar *bar);
     void (*set_cursor)(struct bar *bar, const char *cursor);
 };

bar/bar.c

@@ -7,6 +7,7 @@
 #include <stdbool.h>
 #include <threads.h>
 #include <assert.h>
+#include <unistd.h>
 
 #include <sys/eventfd.h>
 
@@ -61,33 +62,21 @@ static void
 expose(const struct bar *_bar)
 {
     const struct private *bar = _bar->private;
+    pixman_image_t *pix = bar->pix;
 
-    double r, g, b, a;
+    pixman_image_fill_rectangles(
-    r = bar->background.red;
+        PIXMAN_OP_SRC, pix, &bar->background, 1,
-    g = bar->background.green;
+        &(pixman_rectangle16_t){0, 0, bar->width, bar->height_with_border});
-    b = bar->background.blue;
-    a = bar->background.alpha;
-
-    cairo_set_source_rgba(bar->cairo, r, g, b, a);
-    cairo_set_operator(bar->cairo, CAIRO_OPERATOR_SOURCE);
-    cairo_paint(bar->cairo);
 
     if (bar->border.width > 0) {
-        r = bar->border.color.red;
+        pixman_image_fill_rectangles(
-        g = bar->border.color.green;
+            PIXMAN_OP_OVER, pix, &bar->border.color, 4,
-        b = bar->border.color.blue;
+            (pixman_rectangle16_t[]){
-        a = bar->border.color.alpha;
+                {0, 0, bar->width, bar->border.width},
-
+                {0, 0, bar->border.width, bar->height},
-        cairo_set_line_width(bar->cairo, bar->border.width);
+                {bar->width - bar->border.width, 0, bar->border.width, bar->height},
-        cairo_set_source_rgba(bar->cairo, r, g, b, a);
+                {0, bar->height - bar->border.width, bar->width, bar->border.width},
-        cairo_set_operator(bar->cairo, CAIRO_OPERATOR_OVER);
+            });
-        cairo_rectangle(
-            bar->cairo,
-            bar->border.width / 2.0,
-            bar->border.width / 2.0,
-            bar->width - bar->border.width,
-            bar->height_with_border - bar->border.width);
-        cairo_stroke(bar->cairo);
     }
 
     for (size_t i = 0; i < bar->left.count; i++) {
@@ -97,7 +86,7 @@ expose(const struct bar *_bar)
         if (e != NULL)
             e->destroy(e);
 
-        bar->left.exps[i] = module_begin_expose(m, bar->cairo);
+        bar->left.exps[i] = module_begin_expose(m);
     }
 
     for (size_t i = 0; i < bar->center.count; i++) {
@@ -107,7 +96,7 @@ expose(const struct bar *_bar)
         if (e != NULL)
             e->destroy(e);
 
-        bar->center.exps[i] = module_begin_expose(m, bar->cairo);
+        bar->center.exps[i] = module_begin_expose(m);
     }
 
     for (size_t i = 0; i < bar->right.count; i++) {
@@ -117,7 +106,7 @@ expose(const struct bar *_bar)
         if (e != NULL)
             e->destroy(e);
 
-        bar->right.exps[i] = module_begin_expose(m, bar->cairo);
+        bar->right.exps[i] = module_begin_expose(m);
     }
 
     int left_width, center_width, right_width;
@@ -127,14 +116,14 @@ expose(const struct bar *_bar)
     int x = bar->border.width + bar->left_margin - bar->left_spacing;
     for (size_t i = 0; i < bar->left.count; i++) {
         const struct exposable *e = bar->left.exps[i];
-        e->expose(e, bar->cairo, x + bar->left_spacing, y, bar->height);
+        e->expose(e, pix, x + bar->left_spacing, y, bar->height);
         x += bar->left_spacing + e->width + bar->right_spacing;
     }
 
     x = bar->width / 2 - center_width / 2 - bar->left_spacing;
     for (size_t i = 0; i < bar->center.count; i++) {
         const struct exposable *e = bar->center.exps[i];
-        e->expose(e, bar->cairo, x + bar->left_spacing, y, bar->height);
+        e->expose(e, pix, x + bar->left_spacing, y, bar->height);
         x += bar->left_spacing + e->width + bar->right_spacing;
     }
 
@@ -146,12 +135,11 @@ expose(const struct bar *_bar)
 
     for (size_t i = 0; i < bar->right.count; i++) {
         const struct exposable *e = bar->right.exps[i];
-        e->expose(e, bar->cairo, x + bar->left_spacing, y, bar->height);
+        e->expose(e, pix, x + bar->left_spacing, y, bar->height);
         x += bar->left_spacing + e->width + bar->right_spacing;
     }
 
-    cairo_surface_flush(bar->cairo_surface);
+    bar->backend.iface->commit(_bar);
-    bar->backend.iface->commit_surface(_bar);
 }
 
 
@@ -251,6 +239,7 @@ run(struct bar *_bar)
 
     if (!bar->backend.iface->setup(_bar)) {
         bar->backend.iface->cleanup(_bar);
+        write(_bar->abort_fd, &(uint64_t){1}, sizeof(uint64_t));
         return 1;
     }
 
@@ -312,14 +301,6 @@ run(struct bar *_bar)
 
     bar->backend.iface->cleanup(_bar);
 
-    if (bar->cairo)
-        cairo_destroy(bar->cairo);
-    if (bar->cairo_surface) {
-        cairo_device_finish(cairo_surface_get_device(bar->cairo_surface));
-        cairo_surface_finish(bar->cairo_surface);
-        cairo_surface_destroy(bar->cairo_surface);
-    }
-
     LOG_DBG("bar exiting");
     return ret;
 }
@@ -354,8 +335,6 @@ destroy(struct bar *bar)
         m->destroy(m);
     }
 
-    cairo_debug_reset_static_data();
-
     free(b->left.mods);
     free(b->left.exps);
     free(b->center.mods);

bar/bar.h

@@ -26,11 +26,11 @@ struct bar_config {
     int left_spacing, right_spacing;
     int left_margin, right_margin;
 
-    struct rgba background;
+    pixman_color_t background;
 
     struct {
         int width;
-        struct rgba color;
+        pixman_color_t color;
         int left_margin, right_margin;
         int top_margin, bottom_margin;
     } border;

bar/meson.build

@@ -1,8 +1,7 @@
 bar_backends = []
 
 if backend_x11
-  bar_x11 = declare_dependency(
+  bar_x11 = declare_dependency(sources: ['xcb.c', 'xcb.h'], dependencies: [xcb_stuff])
-    sources: ['xcb.c', 'xcb.h'], dependencies: [xcb_stuff, cairo, cairo_ft])
   bar_backends += [bar_x11]
 endif
 
@@ -37,7 +36,7 @@ if backend_wayland
 
   bar_wayland = declare_dependency(
     sources: ['wayland.c', 'wayland.h'] + wl_proto_src + wl_proto_headers,
-    dependencies: [wayland_client, wayland_cursor, cairo, cairo_ft])
+    dependencies: [wayland_client, wayland_cursor])
 
   bar_backends += [bar_wayland]
 endif

bar/private.h

@@ -1,8 +1,5 @@
 #pragma once
 
-#include <cairo.h>
-#include <cairo-xcb.h>
-
 #include "../bar/bar.h"
 #include "backend.h"
 
@@ -14,11 +11,11 @@ struct private {
     int left_spacing, right_spacing;
     int left_margin, right_margin;
 
-    struct rgba background;
+    pixman_color_t background;
 
     struct {
         int width;
-        struct rgba color;
+        pixman_color_t color;
         int left_margin, right_margin;
         int top_margin, bottom_margin;
     } border;
@@ -46,22 +43,10 @@ struct private {
     /* Name of currently active cursor */
     char *cursor_name;
 
-    cairo_t *cairo;
+    pixman_image_t *pix;
-    cairo_surface_t *cairo_surface;
 
     struct {
         void *data;
         const struct backend *iface;
     } backend;
-#if 0
-    /* Backend specifics */
-    xcb_connection_t *conn;
-
-    xcb_window_t win;
-    xcb_colormap_t colormap;
-    xcb_pixmap_t pixmap;
-    xcb_gc_t gc;
-    xcb_cursor_context_t *cursor_ctx;
-    xcb_cursor_t cursor;
-#endif
 };

bar/wayland.c

@@ -10,7 +10,7 @@
 #include <sys/mman.h>
 #include <linux/memfd.h>
 
-#include <cairo.h>
+#include <pixman.h>
 #include <wayland-client.h>
 #include <wayland-cursor.h>
 
@@ -21,6 +21,7 @@
 #define LOG_ENABLE_DBG 0
 #include "../log.h"
 #include "../tllist.h"
+#include "../stride.h"
 
 #include "private.h"
 
@@ -31,8 +32,7 @@ struct buffer {
 
     struct wl_buffer *wl_buf;
 
-    cairo_surface_t *cairo_surface;
+    pixman_image_t *pix;
-    cairo_t *cairo;
 };
 
 struct monitor {
@@ -51,6 +51,7 @@ struct monitor {
     int width_px;
     int height_px;
 
+    bool preferred;
     int scale;
 };
 
@@ -269,6 +270,8 @@ static void
 output_mode(void *data, struct wl_output *wl_output, uint32_t flags,
             int32_t width, int32_t height, int32_t refresh)
 {
+    struct monitor *mon = data;
+    mon->preferred = flags & WL_OUTPUT_MODE_PREFERRED;
 }
 
 static void
@@ -448,11 +451,10 @@ get_buffer(struct wayland_backend *backend)
      * No existing buffer available. Create a new one by:
      *
      * 1. open a memory backed "file" with memfd_create()
-     * 2. mmap() the memory file, to be used by the cairo surface
+     * 2. mmap() the memory file, to be used by the pixman image
      * 3. create a wayland shm buffer for the same memory file
      *
-     * The cairo surface and the wayland buffer are now sharing
+     * The pixman image and the wayland buffer are now sharing memory.
-     * memory.
      */
 
     int pool_fd = -1;
@@ -462,8 +464,7 @@ get_buffer(struct wayland_backend *backend)
     struct wl_shm_pool *pool = NULL;
     struct wl_buffer *buf = NULL;
 
-    cairo_surface_t *cairo_surface = NULL;
+    pixman_image_t *pix = NULL;
-    cairo_t *cairo = NULL;
 
     /* Backing memory for SHM */
     pool_fd = memfd_create("f00bar-wayland-shm-buffer-pool", MFD_CLOEXEC);
@@ -473,8 +474,9 @@ get_buffer(struct wayland_backend *backend)
     }
 
     /* Total size */
-    const uint32_t stride = cairo_format_stride_for_width(
+    const uint32_t stride = stride_for_format_and_width(
-        CAIRO_FORMAT_ARGB32, backend->width);
+        PIXMAN_a8r8g8b8, backend->width);
+
     size = stride * backend->height;
     if (ftruncate(pool_fd, size) == -1) {
         LOG_ERR("failed to truncate SHM pool");
@@ -504,19 +506,10 @@ get_buffer(struct wayland_backend *backend)
     wl_shm_pool_destroy(pool); pool = NULL;
     close(pool_fd); pool_fd = -1;
 
-    /* Create a cairo surface around the mmapped memory */
+    pix = pixman_image_create_bits_no_clear(
-    cairo_surface = cairo_image_surface_create_for_data(
+        PIXMAN_a8r8g8b8, backend->width, backend->height, (uint32_t *)mmapped, stride);
-        mmapped, CAIRO_FORMAT_ARGB32, backend->width, backend->height, stride);
+    if (pix == NULL) {
-    if (cairo_surface_status(cairo_surface) != CAIRO_STATUS_SUCCESS) {
+        LOG_ERR("failed to create pixman image");
-        LOG_ERR("failed to create cairo surface: %s",
-                cairo_status_to_string(cairo_surface_status(cairo_surface)));
-        goto err;
-    }
-
-    cairo = cairo_create(cairo_surface);
-    if (cairo_status(cairo) != CAIRO_STATUS_SUCCESS) {
-        LOG_ERR("failed to create cairo context: %s",
-                cairo_status_to_string(cairo_status(cairo)));
         goto err;
     }
 
@@ -528,9 +521,8 @@ get_buffer(struct wayland_backend *backend)
             .size = size,
             .mmapped = mmapped,
             .wl_buf = buf,
-            .cairo_surface = cairo_surface,
+            .pix = pix,
-            .cairo = cairo}
+            })
-            )
         );
 
     struct buffer *ret = &tll_back(backend->buffers);
@@ -538,10 +530,8 @@ get_buffer(struct wayland_backend *backend)
     return ret;
 
 err:
-    if (cairo != NULL)
+    if (pix != NULL)
-        cairo_destroy(cairo);
+        pixman_image_unref(pix);
-    if (cairo_surface != NULL)
-        cairo_surface_destroy(cairo_surface);
     if (buf != NULL)
         wl_buffer_destroy(buf);
     if (pool != NULL)
@@ -601,11 +591,21 @@ setup(struct bar *_bar)
                  mon->name, mon->width_px, mon->height_px,
                  mon->x, mon->y, mon->width_mm, mon->height_mm);
 
-        /* TODO: detect primary output when user hasn't specified a monitor */
+        if (bar->monitor == NULL && mon->preferred) {
-        if (bar->monitor == NULL)
+            /* User didn't specify a monitor, and this is the default one */
             backend->monitor = mon;
-        else if (strcmp(bar->monitor, mon->name) == 0)
+        }
+
+        else if (bar->monitor != NULL && strcmp(bar->monitor, mon->name) == 0) {
+            /* User specified a monitor, and this is one */
             backend->monitor = mon;
+        }
+    }
+
+    if (backend->monitor == NULL) {
+        LOG_ERR("failed to find the specified monitor: %s",
+                bar->monitor != NULL ? bar->monitor : "default");
+        return false;
     }
 
     backend->surface = wl_compositor_create_surface(backend->compositor);
@@ -709,12 +709,10 @@ setup(struct bar *_bar)
     //wl_surface_commit(backend->surface);
     //wl_display_roundtrip(backend->display);
 
-    /* Prepare a buffer + cairo context for bar to draw to */
+    /* Prepare a buffer + pixman image for bar to draw to */
     backend->next_buffer = get_buffer(backend);
     assert(backend->next_buffer != NULL && backend->next_buffer->busy);
-
+    bar->pix = backend->next_buffer->pix;
-    bar->cairo_surface = backend->next_buffer->cairo_surface;
-    bar->cairo = backend->next_buffer->cairo;
 
     return true;
 }
@@ -728,10 +726,8 @@ cleanup(struct bar *_bar)
     tll_foreach(backend->buffers, it) {
         if (it->item.wl_buf != NULL)
             wl_buffer_destroy(it->item.wl_buf);
-        if (it->item.cairo != NULL)
+        if (it->item.pix != NULL)
-            cairo_destroy(it->item.cairo);
+            pixman_image_unref(it->item.pix);
-        if (it->item.cairo_surface != NULL)
-            cairo_surface_destroy(it->item.cairo_surface);
 
         munmap(it->item.mmapped, it->item.size);
         tll_remove(backend->buffers, it);
@@ -778,8 +774,7 @@ cleanup(struct bar *_bar)
         wl_display_disconnect(backend->display);
 
     /* Destroyed when freeing buffer list */
-    bar->cairo_surface = NULL;
+    bar->pix = NULL;
-    bar->cairo = NULL;
 
 }
 
@@ -902,7 +897,7 @@ frame_callback(void *data, struct wl_callback *wl_callback, uint32_t callback_da
 }
 
 static void
-commit_surface(const struct bar *_bar)
+commit(const struct bar *_bar)
 {
     struct private *bar = _bar->private;
     struct wayland_backend *backend = bar->backend.data;
@@ -939,9 +934,7 @@ commit_surface(const struct bar *_bar)
 
     backend->next_buffer = get_buffer(backend);
     assert(backend->next_buffer != NULL && backend->next_buffer->busy);
-
+    bar->pix = backend->next_buffer->pix;
-    bar->cairo_surface = backend->next_buffer->cairo_surface;
-    bar->cairo = backend->next_buffer->cairo;
 }
 
 static void
@@ -973,7 +966,7 @@ const struct backend wayland_backend_iface = {
     .setup = &setup,
     .cleanup = &cleanup,
     .loop = &loop,
-    .commit_surface = &commit_surface,
+    .commit = &commit,
     .refresh = &refresh,
     .set_cursor = &set_cursor,
 };

bar/xcb.c

@@ -6,6 +6,7 @@
 #include <unistd.h>
 #include <poll.h>
 
+#include <pixman.h>
 #include <xcb/xcb.h>
 #include <xcb/randr.h>
 #include <xcb/render.h>
@@ -18,6 +19,7 @@
 
 #define LOG_MODULE "bar:xcb"
 #include "../log.h"
+#include "../stride.h"
 #include "../xcb.h"
 
 struct xcb_backend {
@@ -27,10 +29,15 @@ struct xcb_backend {
 
     xcb_window_t win;
     xcb_colormap_t colormap;
-    xcb_pixmap_t pixmap;
     xcb_gc_t gc;
     xcb_cursor_context_t *cursor_ctx;
     xcb_cursor_t cursor;
+
+    uint8_t depth;
+    void *client_pixmap;
+    size_t client_pixmap_size;
+    pixman_image_t *pix;
+
 };
 
 void *
@@ -131,6 +138,7 @@ setup(struct bar *_bar)
 
     assert(depth == 32 || depth == 24);
     assert(vis != NULL);
+    backend->depth = depth;
     LOG_DBG("using a %hhu-bit visual", depth);
 
     backend->colormap = xcb_generate_id(backend->conn);
@@ -234,19 +242,20 @@ setup(struct bar *_bar)
         _NET_WM_STRUT_PARTIAL, XCB_ATOM_CARDINAL, 32,
         12, strut);
 
-    backend->pixmap = xcb_generate_id(backend->conn);
-    xcb_create_pixmap(backend->conn, depth, backend->pixmap, backend->win,
-                      bar->width, bar->height_with_border);
-
     backend->gc = xcb_generate_id(backend->conn);
-    xcb_create_gc(backend->conn, backend->gc, backend->pixmap,
+    xcb_create_gc(backend->conn, backend->gc, backend->win,
                   XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES,
                   (const uint32_t []){screen->white_pixel, 0});
 
-    LOG_DBG("cairo: %s", cairo_version_string());
+    const uint32_t stride = stride_for_format_and_width(
-    bar->cairo_surface = cairo_xcb_surface_create(
+        PIXMAN_a8r8g8b8, bar->width);
-        backend->conn, backend->pixmap, vis, bar->width, bar->height_with_border);
+
-    bar->cairo = cairo_create(bar->cairo_surface);
+    backend->client_pixmap_size = stride * bar->height_with_border;
+    backend->client_pixmap = malloc(backend->client_pixmap_size);
+    backend->pix = pixman_image_create_bits_no_clear(
+        PIXMAN_a8r8g8b8, bar->width, bar->height_with_border,
+        (uint32_t *)backend->client_pixmap, stride);
+    bar->pix = backend->pix;
 
     xcb_map_window(backend->conn, backend->win);
 
@@ -274,10 +283,12 @@ cleanup(struct bar *_bar)
     /* TODO: move to bar.c */
     free(bar->cursor_name);
 
+    if (backend->pix != NULL)
+        pixman_image_unref(backend->pix);
+    free(backend->client_pixmap);
+
     if (backend->gc != 0)
         xcb_free_gc(backend->conn, backend->gc);
-    if (backend->pixmap != 0)
-        xcb_free_pixmap(backend->conn, backend->pixmap);
     if (backend->win != 0)
         xcb_destroy_window(backend->conn, backend->win);
     if (backend->colormap != 0)
@@ -370,12 +381,15 @@ loop(struct bar *_bar,
 }
 
 static void
-commit_surface(const struct bar *_bar)
+commit(const struct bar *_bar)
 {
     const struct private *bar = _bar->private;
     const struct xcb_backend *backend = bar->backend.data;
-    xcb_copy_area(backend->conn, backend->pixmap, backend->win, backend->gc,
+
-                  0, 0, 0, 0, bar->width, bar->height_with_border);
+    xcb_put_image(
+        backend->conn, XCB_IMAGE_FORMAT_Z_PIXMAP, backend->win, backend->gc,
+        bar->width, bar->height_with_border, 0, 0, 0,
+        backend->depth, backend->client_pixmap_size, backend->client_pixmap);
     xcb_flush(backend->conn);
 }
 
@@ -430,7 +444,7 @@ const struct backend xcb_backend_iface = {
     .setup = &setup,
     .cleanup = &cleanup,
     .loop = &loop,
-    .commit_surface = &commit_surface,
+    .commit = &commit,
     .refresh = &refresh,
     .set_cursor = &set_cursor,
 };

config.c

@@ -13,6 +13,10 @@
 #include "module.h"
 #include "plugin.h"
 
+#define LOG_MODULE "config"
+#define LOG_ENABLE_DBG 0
+#include "log.h"
+
 static uint8_t
 hex_nibble(char hex)
 {
@@ -36,7 +40,7 @@ hex_byte(const char hex[2])
     return upper << 4 | lower;
 }
 
-struct rgba
+pixman_color_t
 conf_to_color(const struct yml_node *node)
 {
     const char *hex = yml_value_as_string(node);
@@ -44,30 +48,26 @@ conf_to_color(const struct yml_node *node)
     assert(hex != NULL);
     assert(strlen(hex) == 8);
 
-    uint8_t red = hex_byte(&hex[0]);
+    uint16_t red = hex_byte(&hex[0]);
-    uint8_t green = hex_byte(&hex[2]);
+    uint16_t green = hex_byte(&hex[2]);
-    uint8_t blue = hex_byte(&hex[4]);
+    uint16_t blue = hex_byte(&hex[4]);
-    uint8_t alpha = hex_byte(&hex[6]);
+    uint16_t alpha = hex_byte(&hex[6]);
 
-    struct rgba rgba = {
+    alpha |= alpha << 8;
-        (double)red / 255.0,
+    int alpha_div = 0xffff / alpha;
-        (double)green / 255.0,
+
-        (double)blue / 255.0,
+    return (pixman_color_t){
-        (double)alpha / 255.0
+        .red =   (red << 8 | red) / alpha_div,
+        .green = (green << 8 | green) / alpha_div,
+        .blue =  (blue << 8 | blue) / alpha_div,
+        .alpha = alpha,
     };
-
-    assert(rgba.red >= 0.0 && rgba.red <= 1.0);
-    assert(rgba.green >= 0.0 && rgba.green <= 1.0);
-    assert(rgba.blue >= 0.0 && rgba.blue <= 1.0);
-    assert(rgba.alpha >= 0.0 && rgba.alpha <= 1.0);
-
-    return rgba;
 }
 
 struct font *
 conf_to_font(const struct yml_node *node)
 {
-    return font_new(yml_value_as_string(node));
+    return font_from_name(yml_value_as_string(node));
 }
 
 struct deco *
@@ -155,7 +155,7 @@ conf_to_particle(const struct yml_node *node, struct conf_inherit inherited)
      */
     struct font *font = font_node != NULL
         ? conf_to_font(font_node) : font_clone(inherited.font);
-    struct rgba foreground = foreground_node != NULL
+    pixman_color_t foreground = foreground_node != NULL
         ? conf_to_color(foreground_node) : inherited.foreground;
 
     /* Instantiate base/common particle */
@@ -263,8 +263,8 @@ conf_to_bar(const struct yml_node *bar, enum bar_backend backend)
      * and particles. This allows us to specify a default font and
      * foreground color at top-level.
      */
-    struct font *font = font_new("sans");
+    struct font *font = font_from_name("sans");
-    struct rgba foreground = (struct rgba){1.0, 1.0, 1.0, 1.0}; /* White */
+    pixman_color_t foreground = {0xffff, 0xffff, 0xffff, 0xffff}; /* White */
 
     const struct yml_node *font_node = yml_get_value(bar, "font");
     if (font_node != NULL) {

config.h

@@ -14,12 +14,12 @@ struct bar *conf_to_bar(const struct yml_node *bar, enum bar_backend backend);
  * Utility functions, for e.g. modules
  */
 
-struct rgba conf_to_color(const struct yml_node *node);
+pixman_color_t conf_to_color(const struct yml_node *node);
 struct font *conf_to_font(const struct yml_node *node);
 
 struct conf_inherit {
     const struct font *font;
-    struct rgba foreground;
+    pixman_color_t foreground;
 };
 
 struct particle *conf_to_particle(

decoration.h

@@ -1,10 +1,10 @@
 #pragma once
 
-#include <cairo.h>
+#include <pixman.h>
 
 struct deco {
     void *private;
-    void (*expose)(const struct deco *deco, cairo_t *cr,
+    void (*expose)(const struct deco *deco, pixman_image_t *pix,
                    int x, int y, int width, int height);
     void (*destroy)(struct deco *deco);
 };

decorations/background.c

@@ -6,7 +6,8 @@
 #include "../plugin.h"
 
 struct private {
-    struct rgba color;
+    //struct rgba color;
+    pixman_color_t color;
 };
 
 static void
@@ -18,17 +19,16 @@ destroy(struct deco *deco)
 }
 
 static void
-expose(const struct deco *deco, cairo_t *cr, int x, int y, int width, int height)
+expose(const struct deco *deco, pixman_image_t *pix, int x, int y, int width, int height)
 {
     const struct private *d = deco->private;
-    cairo_set_source_rgba(
+    pixman_image_fill_rectangles(
-        cr, d->color.red, d->color.green, d->color.blue, d->color.alpha);
+        PIXMAN_OP_OVER, pix, &d->color, 1,
-    cairo_rectangle(cr, x, y, width, height);
+        &(pixman_rectangle16_t){x, y, width, height});
-    cairo_fill(cr);
 }
 
 static struct deco *
-background_new(struct rgba color)
+background_new(pixman_color_t color)
 {
     struct private *priv = calloc(1, sizeof(*priv));
     priv->color = color;

decorations/meson.build

@@ -1,4 +1,4 @@
-deco_sdk = declare_dependency(dependencies: [cairo, cairo_ft])
+deco_sdk = declare_dependency(dependencies: [freetype, pixman])
 
 decorations = []
 foreach deco : ['background', 'stack', 'underline']

decorations/stack.c

@@ -24,11 +24,11 @@ destroy(struct deco *deco)
 }
 
 static void
-expose(const struct deco *deco, cairo_t *cr, int x, int y, int width, int height)
+expose(const struct deco *deco, pixman_image_t *pix, int x, int y, int width, int height)
 {
     const struct private *d = deco->private;
     for (size_t i = 0; i < d->count; i++)
-        d->decos[i]->expose(d->decos[i], cr, x, y, width, height);
+        d->decos[i]->expose(d->decos[i], pix, x, y, width, height);
 }
 
 static struct deco *

decorations/underline.c

@@ -7,7 +7,7 @@
 
 struct private {
     int size;
-    struct rgba color;
+    pixman_color_t color;
 };
 
 static void
@@ -19,17 +19,16 @@ destroy(struct deco *deco)
 }
 
 static void
-expose(const struct deco *deco, cairo_t *cr, int x, int y, int width, int height)
+expose(const struct deco *deco, pixman_image_t *pix, int x, int y, int width, int height)
 {
     const struct private *d = deco->private;
-    cairo_set_source_rgba(
+    pixman_image_fill_rectangles(
-        cr, d->color.red, d->color.green, d->color.blue, d->color.alpha);
+        PIXMAN_OP_OVER, pix, &d->color, 1,
-    cairo_rectangle(cr, x, y + height - d->size, width, d->size);
+        &(pixman_rectangle16_t){x, y + height - d->size, width, d->size});
-    cairo_fill(cr);
 }
 
 static struct deco *
-underline_new(int size, struct rgba color)
+underline_new(int size, pixman_color_t color)
 {
     struct private *priv = calloc(1, sizeof(*priv));
     priv->size = size;

font.c

@@ -1,29 +1,32 @@
 #include "font.h"
-#include <stdlib.h>
-#include <string.h>
-#include <stdbool.h>
-#include <assert.h>
 
-#include <fontconfig/fontconfig.h>
+#include <stdlib.h>
-#include <cairo-ft.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <wchar.h>
+#include <assert.h>
+#include <threads.h>
 
 #define LOG_MODULE "font"
 #define LOG_ENABLE_DBG 0
 #include "log.h"
-#include "tllist.h"
+#include "stride.h"
 
-struct font {
+#define min(x, y) ((x) < (y) ? (x) : (y))
-    char *name;
-    cairo_scaled_font_t *scaled_font;
-    int ref_counter;
-};
 
-static tll(const struct font *) cache = tll_init();
+static FT_Library ft_lib;
+static mtx_t ft_lock;
+
+static tll(const struct font *) font_cache = tll_init();
+
+static const size_t glyph_cache_size = 512;
 
 static void __attribute__((constructor))
 init(void)
 {
     FcInit();
+    FT_Init_FreeType(&ft_lib);
+    mtx_init(&ft_lock, mtx_plain);
 
 #if defined(LOG_ENABLE_DBG) && LOG_ENABLE_DBG
     int raw_version = FcGetVersion();
@@ -40,16 +43,229 @@ init(void)
 static void __attribute__((destructor))
 fini(void)
 {
+    assert(tll_length(font_cache) == 0);
+
+    mtx_destroy(&ft_lock);
+    FT_Done_FreeType(ft_lib);
     FcFini();
-    assert(tll_length(cache) == 0);
+}
+
+static bool
+font_destroy_no_free(struct font *font)
+{
+    assert(font->ref_counter > 0);
+    if (--font->ref_counter > 0)
+        return false;
+
+    if (font->face != NULL) {
+        mtx_lock(&ft_lock);
+        FT_Done_Face(font->face);
+        mtx_unlock(&ft_lock);
+    }
+
+    if (font->fc_pattern != NULL)
+        FcPatternDestroy(font->fc_pattern);
+    if (font->fc_fonts != NULL)
+        FcFontSetDestroy(font->fc_fonts);
+
+    free(font->name);
+
+    if (font->cache == NULL)
+        return true;
+
+    for (size_t i = 0; i < glyph_cache_size; i++) {
+        if (font->cache[i] == NULL)
+            continue;
+
+        tll_foreach(*font->cache[i], it) {
+            if (!it->item.valid)
+                continue;
+
+            void *image = pixman_image_get_data(it->item.pix);
+            pixman_image_unref(it->item.pix);
+            free(image);
+        }
+
+        tll_free(*font->cache[i]);
+        free(font->cache[i]);
+    }
+    free(font->cache);
+
+    tll_foreach(font_cache, it) {
+        if (it->item == font) {
+            tll_remove(font_cache, it);
+            break;
+        }
+    }
+
+    return true;
+}
+
+static bool
+from_font_set(FcPattern *pattern, FcFontSet *fonts, int start_idx,
+              struct font *font, bool is_fallback)
+{
+    memset(font, 0, sizeof(*font));
+
+    FcChar8 *face_file = NULL;
+    FcPattern *final_pattern = NULL;
+    int font_idx = -1;
+
+    for (int i = start_idx; i < fonts->nfont; i++) {
+        FcPattern *pat = FcFontRenderPrepare(NULL, pattern, fonts->fonts[i]);
+        assert(pat != NULL);
+
+        if (FcPatternGetString(pat, FC_FT_FACE, 0, &face_file) != FcResultMatch) {
+            if (FcPatternGetString(pat, FC_FILE, 0, &face_file) != FcResultMatch) {
+                FcPatternDestroy(pat);
+                continue;
+            }
+        }
+
+        final_pattern = pat;
+        font_idx = i;
+        break;
+    }
+
+    assert(font_idx != -1);
+    assert(final_pattern != NULL);
+
+    double dpi;
+    if (FcPatternGetDouble(final_pattern, FC_DPI, 0, &dpi) != FcResultMatch)
+        dpi = 96;
+
+    double size;
+    if (FcPatternGetDouble(final_pattern, FC_PIXEL_SIZE, 0, &size)) {
+        LOG_ERR("%s: failed to get size", face_file);
+        FcPatternDestroy(final_pattern);
+        return false;
+    }
+
+    FcBool scalable;
+    if (FcPatternGetBool(final_pattern, FC_SCALABLE, 0, &scalable) != FcResultMatch)
+        scalable = FcTrue;
+
+    double pixel_fixup;
+    if (FcPatternGetDouble(final_pattern, "pixelsizefixupfactor", 0, &pixel_fixup) != FcResultMatch)
+        pixel_fixup = 1.;
+
+    LOG_DBG("loading: %s", face_file);
+
+    mtx_lock(&ft_lock);
+    FT_Face ft_face;
+    FT_Error ft_err = FT_New_Face(ft_lib, (const char *)face_file, 0, &ft_face);
+    mtx_unlock(&ft_lock);
+    if (ft_err != 0)
+        LOG_ERR("%s: failed to create FreeType face", face_file);
+
+    if ((ft_err = FT_Set_Char_Size(ft_face, size * 64, 0, 0, 0)) != 0)
+        LOG_WARN("failed to set character size");
+
+    FcBool fc_hinting;
+    if (FcPatternGetBool(final_pattern, FC_HINTING,0,  &fc_hinting) != FcResultMatch)
+        fc_hinting = FcTrue;
+
+    FcBool fc_antialias;
+    if (FcPatternGetBool(final_pattern, FC_ANTIALIAS, 0, &fc_antialias) != FcResultMatch)
+        fc_antialias = FcTrue;
+
+    int fc_hintstyle;
+    if (FcPatternGetInteger(final_pattern, FC_HINT_STYLE, 0, &fc_hintstyle) != FcResultMatch)
+        fc_hintstyle = FC_HINT_SLIGHT;
+
+    int fc_rgba;
+    if (FcPatternGetInteger(final_pattern, FC_RGBA, 0, &fc_rgba) != FcResultMatch)
+        fc_rgba = FC_RGBA_UNKNOWN;
+
+    int load_flags = 0;
+    if (!fc_antialias) {
+        if (!fc_hinting || fc_hintstyle == FC_HINT_NONE)
+            load_flags |= FT_LOAD_MONOCHROME | FT_LOAD_NO_HINTING | FT_LOAD_TARGET_NORMAL;
+        else
+            load_flags |= FT_LOAD_MONOCHROME | FT_LOAD_TARGET_MONO;
+    } else {
+        if (!fc_hinting || fc_hintstyle == FC_HINT_NONE)
+            load_flags |= FT_LOAD_DEFAULT | FT_LOAD_NO_HINTING | FT_LOAD_TARGET_NORMAL;
+        else if (fc_hinting && fc_hintstyle == FC_HINT_SLIGHT)
+            load_flags |= FT_LOAD_DEFAULT | FT_LOAD_TARGET_LIGHT;
+        else if (fc_rgba == FC_RGBA_RGB || fc_rgba == FC_RGBA_BGR)
+            load_flags |= FT_LOAD_DEFAULT | FT_LOAD_TARGET_LCD;
+        else if (fc_rgba == FC_RGBA_VRGB || fc_rgba == FC_RGBA_VBGR)
+            load_flags |= FT_LOAD_DEFAULT | FT_LOAD_TARGET_LCD_V;
+        else
+            load_flags |= FT_LOAD_DEFAULT | FT_LOAD_TARGET_NORMAL;
+    }
+
+    FcBool fc_embeddedbitmap;
+    if (FcPatternGetBool(final_pattern, FC_EMBEDDED_BITMAP, 0, &fc_embeddedbitmap) != FcResultMatch)
+        fc_embeddedbitmap = FcTrue;
+
+    if (!fc_embeddedbitmap)
+        load_flags |= FT_LOAD_NO_BITMAP;
+
+    int render_flags = 0;
+    if (!fc_antialias)
+        render_flags |= FT_RENDER_MODE_MONO;
+    else {
+        if (fc_rgba == FC_RGBA_RGB || fc_rgba == FC_RGBA_BGR)
+            render_flags |= FT_RENDER_MODE_LCD;
+        else if (fc_rgba == FC_RGBA_VRGB || fc_rgba == FC_RGBA_VBGR)
+            render_flags |= FT_RENDER_MODE_LCD_V;
+        else
+            render_flags |= FT_RENDER_MODE_NORMAL;
+    }
+
+    int fc_lcdfilter;
+    if (FcPatternGetInteger(final_pattern, FC_LCD_FILTER, 0, &fc_lcdfilter) != FcResultMatch)
+        fc_lcdfilter = FC_LCD_DEFAULT;
+
+    switch (fc_lcdfilter) {
+    case FC_LCD_NONE:    font->lcd_filter = FT_LCD_FILTER_NONE; break;
+    case FC_LCD_DEFAULT: font->lcd_filter = FT_LCD_FILTER_DEFAULT; break;
+    case FC_LCD_LIGHT:   font->lcd_filter = FT_LCD_FILTER_LIGHT; break;
+    case FC_LCD_LEGACY:  font->lcd_filter = FT_LCD_FILTER_LEGACY; break;
+    }
+
+    FcPatternDestroy(final_pattern);
+
+    int max_x_advance = ft_face->size->metrics.max_advance / 64;
+    int height = ft_face->size->metrics.height / 64;
+    int descent = ft_face->size->metrics.descender / 64;
+    int ascent = ft_face->size->metrics.ascender / 64;
+
+    font->face = ft_face;
+    font->load_flags = load_flags | FT_LOAD_COLOR;
+    font->render_flags = render_flags;
+    font->pixel_size_fixup = scalable ? pixel_fixup : 1.;
+    font->bgr = fc_rgba == FC_RGBA_BGR || fc_rgba == FC_RGBA_VBGR;
+    font->fc_idx = font_idx;
+    font->is_fallback = is_fallback;
+    font->ref_counter = 1;
+
+    font->fextents.height = height * font->pixel_size_fixup;
+    font->fextents.descent = -descent * font->pixel_size_fixup;
+    font->fextents.ascent = ascent * font->pixel_size_fixup;
+    font->fextents.max_x_advance = max_x_advance * font->pixel_size_fixup;
+
+    LOG_DBG("metrics: height: %d, descent: %d, ascent: %d, x-advance: %d",
+            height, descent, ascent, max_x_advance);
+
+    if (!is_fallback) {
+        font->fc_pattern = pattern;
+        font->fc_fonts = fonts;
+        font->cache = calloc(glyph_cache_size, sizeof(font->cache[0]));
+    }
+
+    return true;
 }
 
 struct font *
-font_new(const char *name)
+font_from_name(const char *name)
 {
-    /* Check if font have already been loaded */
+    LOG_DBG("instantiating %s", name);
-    tll_foreach(cache, it) {
+
-        if (strcmp(name, it->item->name) == 0)
+    tll_foreach(font_cache, it) {
+        if (strcmp(it->item->name, name) == 0)
             return font_clone(it->item);
     }
 
@@ -68,58 +284,267 @@ font_new(const char *name)
     FcDefaultSubstitute(pattern);
 
     FcResult result;
-    FcPattern *final_pattern = FcFontMatch(NULL, pattern, &result);
+    FcFontSet *fonts = FcFontSort(NULL, pattern, FcTrue, NULL, &result);
-    FcPatternDestroy(pattern);
+    if (result != FcResultMatch) {
-
-    if (final_pattern == NULL) {
         LOG_ERR("%s: failed to match font", name);
-        return NULL;
+        FcPatternDestroy(pattern);
-    }
-
-    double font_size;
-    if (FcPatternGetDouble(final_pattern, FC_PIXEL_SIZE, 0, &font_size)) {
-        LOG_ERR("%s: failed to get size", name);
-        FcPatternDestroy(final_pattern);
-        return NULL;
-    }
-
-    cairo_font_face_t *face = cairo_ft_font_face_create_for_pattern(
-        final_pattern);
-
-    FcPatternDestroy(final_pattern);
-
-    if (cairo_font_face_status(face) != CAIRO_STATUS_SUCCESS) {
-        LOG_ERR("%s: failed to create cairo font face", name);
-        cairo_font_face_destroy(face);
-        return NULL;
-    }
-
-    cairo_matrix_t matrix, ctm;
-    cairo_matrix_init_identity(&ctm);
-    cairo_matrix_init_scale(&matrix, font_size, font_size);
-
-    cairo_font_options_t *options = cairo_font_options_create();
-    cairo_scaled_font_t *scaled_font = cairo_scaled_font_create(
-        face, &matrix, &ctm, options);
-
-    cairo_font_options_destroy(options);
-    cairo_font_face_destroy(face);
-
-    if (cairo_scaled_font_status(scaled_font) != CAIRO_STATUS_SUCCESS) {
-        LOG_ERR("%s: failed to create scaled font", name);
-        cairo_scaled_font_destroy(scaled_font);
         return NULL;
     }
 
     struct font *font = malloc(sizeof(*font));
-    font->name = strdup(name);
+    if (!from_font_set(pattern, fonts, 0, font, false)) {
-    font->scaled_font = scaled_font;
+        free(font);
-    font->ref_counter = 1;
+        FcFontSetDestroy(fonts);
+        FcPatternDestroy(pattern);
+        return NULL;
+    }
 
-    tll_push_back(cache, font);
+    font->name = strdup(name);
+    tll_push_back(font_cache, font);
     return font;
 }
 
+static size_t
+hash_index(wchar_t wc)
+{
+    return wc % glyph_cache_size;
+}
+
+static bool
+glyph_for_wchar(const struct font *font, wchar_t wc, struct glyph *glyph)
+{
+    /*
+     * LCD filter is per library instance. Thus we need to re-set it
+     * every time...
+     *
+     * Also note that many freetype builds lack this feature
+     * (FT_CONFIG_OPTION_SUBPIXEL_RENDERING must be defined, and isn't
+     * by default) */
+    FT_Error err = FT_Library_SetLcdFilter(ft_lib, font->lcd_filter);
+    if (err != 0 && err != FT_Err_Unimplemented_Feature)
+        goto err;
+
+    FT_UInt idx = FT_Get_Char_Index(font->face, wc);
+    if (idx == 0) {
+        /* No glyph in this font, try fontconfig fallback fonts */
+
+        /* Try fontconfig fallback fonts */
+        assert(font->fc_pattern != NULL);
+        assert(font->fc_fonts != NULL);
+        assert(font->fc_idx != -1);
+
+        for (int i = font->fc_idx + 1; i < font->fc_fonts->nfont; i++) {
+            struct font fallback;
+            if (!from_font_set(font->fc_pattern, font->fc_fonts, i, &fallback, true))
+                continue;
+
+            if (glyph_for_wchar(&fallback, wc, glyph)) {
+                LOG_DBG("%C: used fontconfig fallback", wc);
+                font_destroy_no_free(&fallback);
+                return true;
+            }
+
+            font_destroy_no_free(&fallback);
+        }
+
+        LOG_WARN("%C: no glyph found (in neither the main font, "
+                 "nor any fallback fonts)", wc);
+    }
+
+    err = FT_Load_Glyph(font->face, idx, font->load_flags);
+    if (err != 0) {
+        LOG_ERR("load failed");
+        goto err;
+    }
+
+    err = FT_Render_Glyph(font->face->glyph, font->render_flags);
+    if (err != 0)
+        goto err;
+
+    assert(font->face->glyph->format == FT_GLYPH_FORMAT_BITMAP);
+
+    FT_Bitmap *bitmap = &font->face->glyph->bitmap;
+    if (bitmap->width == 0)
+        goto err;
+
+    pixman_format_code_t pix_format;
+    int width;
+    int rows;
+
+    switch (bitmap->pixel_mode) {
+    case FT_PIXEL_MODE_MONO:
+        pix_format = PIXMAN_a1;
+        width = bitmap->width;
+        rows = bitmap->rows;
+        break;
+
+    case FT_PIXEL_MODE_GRAY:
+        pix_format = PIXMAN_a8;
+        width = bitmap->width;
+        rows = bitmap->rows;
+        break;
+
+    case FT_PIXEL_MODE_LCD:
+        pix_format = PIXMAN_x8r8g8b8;
+        width = bitmap->width / 3;
+        rows = bitmap->rows;
+        break;
+
+    case FT_PIXEL_MODE_LCD_V:
+        pix_format = PIXMAN_x8r8g8b8;
+        width = bitmap->width;
+        rows = bitmap->rows / 3;
+        break;
+
+    case FT_PIXEL_MODE_BGRA:
+        pix_format = PIXMAN_a8r8g8b8;
+        width = bitmap->width;
+        rows = bitmap->rows;
+        break;
+
+    default:
+        LOG_ERR("unimplemented: FT pixel mode: %d", bitmap->pixel_mode);
+        goto err;
+        break;
+    }
+
+    int stride = stride_for_format_and_width(pix_format, width);
+    assert(stride >= bitmap->pitch);
+
+    uint8_t *data = malloc(rows * stride);
+
+    /* Convert FT bitmap to pixman image */
+    switch (bitmap->pixel_mode) {
+    case FT_PIXEL_MODE_MONO:
+        for (size_t r = 0; r < bitmap->rows; r++) {
+            for (size_t c = 0; c < (bitmap->width + 7) / 8; c++) {
+                uint8_t v = bitmap->buffer[r * bitmap->pitch + c];
+                uint8_t reversed = 0;
+                for (size_t i = 0; i < min(8, bitmap->width - c * 8); i++)
+                    reversed |= ((v >> (7 - i)) & 1) << i;
+
+                data[r * stride + c] = reversed;
+            }
+        }
+        break;
+
+    case FT_PIXEL_MODE_GRAY:
+        for (size_t r = 0; r < bitmap->rows; r++) {
+            for (size_t c = 0; c < bitmap->width; c++)
+                data[r * stride + c] = bitmap->buffer[r * bitmap->pitch + c];
+        }
+        break;
+
+    case FT_PIXEL_MODE_BGRA:
+        assert(stride == bitmap->pitch);
+        memcpy(data, bitmap->buffer, bitmap->rows * bitmap->pitch);
+        break;
+
+    case FT_PIXEL_MODE_LCD:
+        for (size_t r = 0; r < bitmap->rows; r++) {
+            for (size_t c = 0; c < bitmap->width; c += 3) {
+                unsigned char _r = bitmap->buffer[r * bitmap->pitch + c + (font->bgr ? 2 : 0)];
+                unsigned char _g = bitmap->buffer[r * bitmap->pitch + c + 1];
+                unsigned char _b = bitmap->buffer[r * bitmap->pitch + c + (font->bgr ? 0 : 2)];
+
+                uint32_t *p = (uint32_t *)&data[r * stride + 4 * (c / 3)];
+                *p =  _r << 16 | _g << 8 | _b;
+            }
+        }
+        break;
+
+    case FT_PIXEL_MODE_LCD_V:
+        /* Unverified */
+        for (size_t r = 0; r < bitmap->rows; r += 3) {
+            for (size_t c = 0; c < bitmap->width; c++) {
+                unsigned char _r = bitmap->buffer[(r + (font->bgr ? 2 : 0)) * bitmap->pitch + c];
+                unsigned char _g = bitmap->buffer[(r + 1) * bitmap->pitch + c];
+                unsigned char _b = bitmap->buffer[(r + (font->bgr ? 0 : 2)) * bitmap->pitch + c];
+
+                uint32_t *p = (uint32_t *)&data[r / 3 * stride + 4 * c];
+                *p =  _r << 16 | _g << 8 | _b;
+            }
+        }
+        break;
+
+    default:
+        abort();
+        break;
+    }
+
+    pixman_image_t *pix = pixman_image_create_bits_no_clear(
+        pix_format, width, rows, (uint32_t *)data, stride);
+
+    if (pix == NULL) {
+        free(data);
+        goto err;
+    }
+
+    pixman_image_set_component_alpha(
+        pix,
+        bitmap->pixel_mode == FT_PIXEL_MODE_LCD ||
+        bitmap->pixel_mode == FT_PIXEL_MODE_LCD_V);
+
+    if (font->pixel_size_fixup != 1.) {
+        struct pixman_transform scale;
+        pixman_transform_init_scale(
+            &scale,
+            pixman_double_to_fixed(1. / font->pixel_size_fixup),
+            pixman_double_to_fixed(1. / font->pixel_size_fixup));
+        pixman_image_set_transform(pix, &scale);
+    }
+
+    *glyph = (struct glyph){
+        .wc = wc,
+        .cols = wcwidth(wc),
+        .pix = pix,
+        .x = font->face->glyph->bitmap_left / font->pixel_size_fixup,
+        .y = font->face->glyph->bitmap_top * font->pixel_size_fixup,
+        .x_advance = font->face->glyph->advance.x / 64,
+        .width = width,
+        .height = rows,
+        .valid = true,
+    };
+
+    return true;
+
+err:
+    *glyph = (struct glyph){
+        .wc = wc,
+        .valid = false,
+    };
+    return false;
+}
+
+const struct glyph *
+font_glyph_for_wc(struct font *font, wchar_t wc)
+{
+    assert(font->cache != NULL);
+    size_t hash_idx = hash_index(wc);
+    hash_entry_t *hash_entry = font->cache[hash_idx];
+
+    if (hash_entry != NULL) {
+        tll_foreach(*hash_entry, it) {
+            if (it->item.wc == wc)
+                return it->item.valid ? &it->item : NULL;
+        }
+    }
+
+    struct glyph glyph;
+    bool got_glyph = glyph_for_wchar(font, wc, &glyph);
+
+    if (hash_entry == NULL) {
+        hash_entry = calloc(1, sizeof(*hash_entry));
+
+        assert(font->cache[hash_idx] == NULL);
+        font->cache[hash_idx] = hash_entry;
+    }
+
+    assert(hash_entry != NULL);
+    tll_push_back(*hash_entry, glyph);
+    return got_glyph ? &tll_back(*hash_entry) : NULL;
+}
+
 struct font *
 font_clone(const struct font *_font)
 {
@@ -131,33 +556,6 @@ font_clone(const struct font *_font)
 void
 font_destroy(struct font *font)
 {
-    if (font == NULL)
+    if (font_destroy_no_free(font))
-        return;
+        free(font);
-
-    assert(font->ref_counter > 0);
-    if (--font->ref_counter > 0)
-        return;
-
-    tll_foreach(cache, it) {
-        if (it->item == font) {
-            tll_remove(cache, it);
-            break;
-        }
-    }
-
-    cairo_scaled_font_destroy(font->scaled_font);
-    free(font->name);
-    free(font);
-}
-
-const char *
-font_face(const struct font *font)
-{
-    return font->name;
-}
-
-cairo_scaled_font_t *
-font_scaled_font(const struct font *font)
-{
-    return font->scaled_font;
 }

font.h

@@ -1,15 +1,70 @@
 #pragma once
 
 #include <stdbool.h>
-#include <cairo.h>
+#include <threads.h>
 
-#include "color.h"
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_LCD_FILTER_H
+#include <fontconfig/fontconfig.h>
+#include <pixman.h>
 
-struct font;
+#include "tllist.h"
 
-struct font *font_new(const char *name);
+struct glyph {
+    wchar_t wc;
+    int cols;
+
+    pixman_image_t *pix;
+    int x;
+    int y;
+    int x_advance;
+    int width;
+    int height;
+
+    bool valid;
+};
+
+typedef tll(struct glyph) hash_entry_t;
+
+struct font {
+    char *name;
+
+    FcPattern *fc_pattern;
+    FcFontSet *fc_fonts;
+    int fc_idx;
+
+    FT_Face face;
+    int load_flags;
+    int render_flags;
+    FT_LcdFilter lcd_filter;
+    double pixel_size_fixup; /* Scale factor - should only be used with ARGB32 glyphs */
+    bool bgr;  /* True for FC_RGBA_BGR and FC_RGBA_VBGR */
+
+    struct {
+        int height;
+        int descent;
+        int ascent;
+        int max_x_advance;
+    } fextents;
+
+    struct {
+        int position;
+        int thickness;
+    } underline;
+
+    struct {
+        int position;
+        int thickness;
+    } strikeout;
+
+    hash_entry_t **cache;
+
+    bool is_fallback;
+    int ref_counter;
+};
+
+struct font *font_from_name(const char *name);
 struct font *font_clone(const struct font *font);
+const struct glyph *font_glyph_for_wc(struct font *font, wchar_t wc);
 void font_destroy(struct font *font);
-
-const char *font_face(const struct font *font);
-cairo_scaled_font_t *font_scaled_font(const struct font *font);

meson.build

@@ -36,9 +36,9 @@ endif
 cc = meson.get_compiler('c')
 dl = cc.find_library('dl')
 threads = dependency('threads')
+freetype = dependency('freetype2')
 fontconfig = dependency('fontconfig')
-cairo = dependency('cairo')
+pixman = dependency('pixman-1')
-cairo_ft = dependency('cairo-ft')
 yaml = dependency('yaml-0.1')
 
 # X11/XCB dependencies
@@ -48,11 +48,9 @@ xcb_event = dependency('xcb-event', required: get_option('backend-x11'))
 xcb_ewmh = dependency('xcb-ewmh', required: get_option('backend-x11'))
 xcb_randr = dependency('xcb-randr', required: get_option('backend-x11'))
 xcb_render = dependency('xcb-render', required: get_option('backend-x11'))
-cairo_xcb = dependency('cairo-xcb', required: get_option('backend-x11'))
 xcb_errors = dependency('xcb-errors', required: false)
 backend_x11 = xcb_aux.found() and xcb_cursor.found() and xcb_event.found() and \
-              xcb_ewmh.found() and xcb_randr.found() and xcb_render.found() and \
+              xcb_ewmh.found() and xcb_randr.found() and xcb_render.found()
-              cairo_xcb.found()
 
 # Wayland dependencies
 wayland_client = dependency('wayland-client', required: get_option('backend-wayland'))
@@ -74,7 +72,7 @@ if backend_x11
   xcb_stuff_lib = static_library(
     'xcb-stuff', 'xcb.c', 'xcb.h',
     dependencies: [xcb_aux, xcb_cursor, xcb_event, xcb_ewmh, xcb_randr,
-                   xcb_render, cairo_xcb, xcb_errors],
+                   xcb_render, xcb_errors],
     c_args: xcb_errors.found() ? '-DHAVE_XCB_ERRORS' : [],
     pic: plugs_as_libs)
 
@@ -104,7 +102,7 @@ f00bar = executable(
   'tag.c', 'tag.h',
   'tllist.h',
   'yml.c', 'yml.h',
-  dependencies: [bar, cairo, cairo_ft, fontconfig, yaml, threads, dl] +
+  dependencies: [bar, freetype, fontconfig, pixman, yaml, threads, dl] +
                 decorations + particles + modules,
   build_rpath: '$ORIGIN/modules:$ORIGIN/decorations:$ORIGIN/particles',
   export_dynamic: true,
@@ -122,6 +120,7 @@ install_headers(
   'log.h',
   'module.h',
   'particle.h',
+  'stride.h',
   'tag.h',
   'tllist.h',
   'yml.h',

module.c

@@ -20,9 +20,9 @@ module_default_destroy(struct module *mod)
 }
 
 struct exposable *
-module_begin_expose(struct module *mod, cairo_t *cr)
+module_begin_expose(struct module *mod)
 {
     struct exposable *e = mod->content(mod);
-    e->begin_expose(e, cr);
+    e->begin_expose(e);
     return e;
 }

module.h

@@ -30,7 +30,7 @@ struct module {
 
 struct module *module_common_new(void);
 void module_default_destroy(struct module *mod);
-struct exposable *module_begin_expose(struct module *mod, cairo_t *cr);
+struct exposable *module_begin_expose(struct module *mod);
 
 /* List of attributes *all* modules implement */
 #define MODULE_COMMON_ATTRS                        \

modules/i3.c

@@ -395,6 +395,7 @@ handle_window_event(int type, const struct json_object *json, void *_mod)
         assert(bytes >= 0);
 
         application[bytes - 1] = '\0';
+        free(ws->window.application);
         ws->window.application = strdup(application);
         close(fd);
     }

modules/meson.build

@@ -1,4 +1,4 @@
-module_sdk = declare_dependency(dependencies: [cairo, cairo_ft, threads])
+module_sdk = declare_dependency(dependencies: [freetype, pixman, threads])
 
 modules = []
 

particle.c

@@ -29,7 +29,7 @@ particle_default_destroy(struct particle *particle)
 struct particle *
 particle_common_new(int left_margin, int right_margin,
                     const char *on_click_template,
-                    struct font *font, struct rgba foreground,
+                    struct font *font, pixman_color_t foreground,
                     struct deco *deco)
 {
     struct particle *p = calloc(1, sizeof(*p));
@@ -52,11 +52,11 @@ exposable_default_destroy(struct exposable *exposable)
 
 void
 exposable_render_deco(const struct exposable *exposable,
-                      cairo_t *cr, int x, int y, int height)
+                      pixman_image_t *pix, int x, int y, int height)
 {
     const struct deco *deco = exposable->particle->deco;
     if (deco != NULL)
-        deco->expose(deco, cr, x, y, exposable->width, height);
+        deco->expose(deco, pix, x, y, exposable->width, height);
 
 }
 

particle.h

@@ -1,5 +1,5 @@
 #pragma once
-#include <cairo.h>
+#include <pixman.h>
 
 #include "color.h"
 #include "decoration.h"
@@ -14,7 +14,7 @@ struct particle {
     int left_margin, right_margin;
     char *on_click_template;
 
-    struct rgba foreground;
+    pixman_color_t foreground;
     struct font *font;
     struct deco *deco;
 
@@ -36,8 +36,8 @@ struct exposable {
     char *on_click;
 
     void (*destroy)(struct exposable *exposable);
-    int (*begin_expose)(struct exposable *exposable, cairo_t *cr);
+    int (*begin_expose)(struct exposable *exposable);
-    void (*expose)(const struct exposable *exposable, cairo_t *cr,
+    void (*expose)(const struct exposable *exposable, pixman_image_t *pix,
                    int x, int y, int height);
 
     void (*on_mouse)(struct exposable *exposable, struct bar *bar,
@@ -46,7 +46,7 @@ struct exposable {
 
 struct particle *particle_common_new(
     int left_margin, int right_margin, const char *on_click_template,
-    struct font *font, struct rgba foreground, struct deco *deco);
+    struct font *font, pixman_color_t foreground, struct deco *deco);
 
 void particle_default_destroy(struct particle *particle);
 
@@ -54,7 +54,7 @@ struct exposable *exposable_common_new(
     const struct particle *particle, const char *on_click);
 void exposable_default_destroy(struct exposable *exposable);
 void exposable_render_deco(
-    const struct exposable *exposable, cairo_t *cr, int x, int y, int height);
+    const struct exposable *exposable, pixman_image_t *pix, int x, int y, int height);
 
 void exposable_default_on_mouse(
     struct exposable *exposable, struct bar *bar,

particles/dynlist.c

@@ -31,7 +31,7 @@ dynlist_destroy(struct exposable *exposable)
 }
 
 static int
-dynlist_begin_expose(struct exposable *exposable, cairo_t *cr)
+dynlist_begin_expose(struct exposable *exposable)
 {
     const struct private *e = exposable->private;
 
@@ -39,7 +39,7 @@ dynlist_begin_expose(struct exposable *exposable, cairo_t *cr)
 
     for (size_t i = 0; i < e->count; i++) {
         struct exposable *ee = e->exposables[i];
-        e->widths[i] = ee->begin_expose(ee, cr);
+        e->widths[i] = ee->begin_expose(ee);
 
         exposable->width += e->left_spacing + e->widths[i] + e->right_spacing;
     }
@@ -49,7 +49,7 @@ dynlist_begin_expose(struct exposable *exposable, cairo_t *cr)
 }
 
 static void
-dynlist_expose(const struct exposable *exposable, cairo_t *cr, int x, int y, int height)
+dynlist_expose(const struct exposable *exposable, pixman_image_t *pix, int x, int y, int height)
 {
     const struct private *e = exposable->private;
 
@@ -60,7 +60,7 @@ dynlist_expose(const struct exposable *exposable, cairo_t *cr, int x, int y, int
 
     for (size_t i = 0; i < e->count; i++) {
         const struct exposable *ee = e->exposables[i];
-        ee->expose(ee, cr, x + left_spacing, y, height);
+        ee->expose(ee, pix, x + left_spacing, y, height);
         x += left_spacing + e->widths[i] + right_spacing;
     }
 }

particles/empty.c

@@ -6,7 +6,7 @@
 #include "../plugin.h"
 
 static int
-begin_expose(struct exposable *exposable, cairo_t *cr)
+begin_expose(struct exposable *exposable)
 {
     exposable->width = exposable->particle->left_margin +
         exposable->particle->right_margin;
@@ -14,9 +14,9 @@ begin_expose(struct exposable *exposable, cairo_t *cr)
 }
 
 static void
-expose(const struct exposable *exposable, cairo_t *cr, int x, int y, int height)
+expose(const struct exposable *exposable, pixman_image_t *pix, int x, int y, int height)
 {
-    exposable_render_deco(exposable, cr, x, y, height);
+    exposable_render_deco(exposable, pix, x, y, height);
 }
 
 static struct exposable *

particles/list.c

@@ -36,7 +36,7 @@ exposable_destroy(struct exposable *exposable)
 }
 
 static int
-begin_expose(struct exposable *exposable, cairo_t *cr)
+begin_expose(struct exposable *exposable)
 {
     const struct eprivate *e = exposable->private;
 
@@ -44,7 +44,7 @@ begin_expose(struct exposable *exposable, cairo_t *cr)
 
     for (size_t i = 0; i < e->count; i++) {
         struct exposable *ee = e->exposables[i];
-        e->widths[i] = ee->begin_expose(ee, cr);
+        e->widths[i] = ee->begin_expose(ee);
 
         exposable->width += e->left_spacing + e->widths[i] + e->right_spacing;
     }
@@ -55,11 +55,11 @@ begin_expose(struct exposable *exposable, cairo_t *cr)
 }
 
 static void
-expose(const struct exposable *exposable, cairo_t *cr, int x, int y, int height)
+expose(const struct exposable *exposable, pixman_image_t *pix, int x, int y, int height)
 {
     const struct eprivate *e = exposable->private;
 
-    exposable_render_deco(exposable, cr, x, y, height);
+    exposable_render_deco(exposable, pix, x, y, height);
 
     int left_margin = exposable->particle->left_margin;
     int left_spacing = e->left_spacing;
@@ -68,7 +68,7 @@ expose(const struct exposable *exposable, cairo_t *cr, int x, int y, int height)
     x += left_margin - left_spacing;
     for (size_t i = 0; i < e->count; i++) {
         const struct exposable *ee = e->exposables[i];
-        ee->expose(ee, cr, x + left_spacing, y, height);
+        ee->expose(ee, pix, x + left_spacing, y, height);
         x += left_spacing + e->widths[i] + right_spacing;
     }
 }

particles/map.c

@@ -36,26 +36,26 @@ exposable_destroy(struct exposable *exposable)
 }
 
 static int
-begin_expose(struct exposable *exposable, cairo_t *cr)
+begin_expose(struct exposable *exposable)
 {
     struct eprivate *e = exposable->private;
 
     exposable->width = (
         exposable->particle->left_margin +
-        e->exposable->begin_expose(e->exposable, cr) +
+        e->exposable->begin_expose(e->exposable) +
         exposable->particle->right_margin);
 
     return exposable->width;
 }
 
 static void
-expose(const struct exposable *exposable, cairo_t *cr, int x, int y, int height)
+expose(const struct exposable *exposable, pixman_image_t *pix, int x, int y, int height)
 {
     struct eprivate *e = exposable->private;
 
-    exposable_render_deco(exposable, cr, x, y, height);
+    exposable_render_deco(exposable, pix, x, y, height);
     e->exposable->expose(
-        e->exposable, cr, x + exposable->particle->left_margin, y, height);
+        e->exposable, pix, x + exposable->particle->left_margin, y, height);
 }
 
 static void

particles/meson.build

@@ -1,4 +1,4 @@
-particle_sdk = declare_dependency(dependencies: [cairo, cairo_ft])
+particle_sdk = declare_dependency(dependencies: [freetype, fontconfig, pixman])
 
 particles = []
 foreach particle : ['empty', 'list', 'map', 'progress-bar', 'ramp', 'string']

particles/progress-bar.c

@@ -54,7 +54,7 @@ exposable_destroy(struct exposable *exposable)
 }
 
 static int
-begin_expose(struct exposable *exposable, cairo_t *cr)
+begin_expose(struct exposable *exposable)
 {
     struct eprivate *e = exposable->private;
 
@@ -64,21 +64,21 @@ begin_expose(struct exposable *exposable, cairo_t *cr)
 
     /* Sub-exposables */
     for (size_t i = 0; i < e->count; i++)
-        exposable->width += e->exposables[i]->begin_expose(e->exposables[i], cr);
+        exposable->width += e->exposables[i]->begin_expose(e->exposables[i]);
 
     return exposable->width;
 }
 
 static void
-expose(const struct exposable *exposable, cairo_t *cr, int x, int y, int height)
+expose(const struct exposable *exposable, pixman_image_t *pix, int x, int y, int height)
 {
     const struct eprivate *e = exposable->private;
 
-    exposable_render_deco(exposable, cr, x, y, height);
+    exposable_render_deco(exposable, pix, x, y, height);
 
     x += exposable->particle->left_margin;
     for (size_t i = 0; i < e->count; i++) {
-        e->exposables[i]->expose(e->exposables[i], cr, x, y, height);
+        e->exposables[i]->expose(e->exposables[i], pix, x, y, height);
         x += e->exposables[i]->width;
     }
 }

particles/ramp.c

@@ -30,26 +30,26 @@ exposable_destroy(struct exposable *exposable)
 }
 
 static int
-begin_expose(struct exposable *exposable, cairo_t *cr)
+begin_expose(struct exposable *exposable)
 {
     struct eprivate *e = exposable->private;
 
     exposable->width = (
         exposable->particle->left_margin +
-        e->exposable->begin_expose(e->exposable, cr) +
+        e->exposable->begin_expose(e->exposable) +
         exposable->particle->right_margin);
 
     return exposable->width;
 }
 
 static void
-expose(const struct exposable *exposable, cairo_t *cr, int x, int y, int height)
+expose(const struct exposable *exposable, pixman_image_t *pix, int x, int y, int height)
 {
     struct eprivate *e = exposable->private;
 
-    exposable_render_deco(exposable, cr, x, y, height);
+    exposable_render_deco(exposable, pix, x, y, height);
     e->exposable->expose(
-        e->exposable, cr, x + exposable->particle->left_margin, y, height);
+        e->exposable, pix, x + exposable->particle->left_margin, y, height);
 }
 
 static void

particles/string.c

@@ -19,13 +19,8 @@ struct eprivate {
     /* Set when instantiating */
     char *text;
 
-    /* Set in begin_expose() */
+    const struct glyph **glyphs;
-    cairo_font_extents_t fextents;
-    cairo_glyph_t *glyphs;
-    cairo_text_cluster_t *clusters;
-    cairo_text_cluster_flags_t cluster_flags;
     int num_glyphs;
-    int num_clusters;
 };
 
 static void
@@ -34,62 +29,56 @@ exposable_destroy(struct exposable *exposable)
     struct eprivate *e = exposable->private;
 
     free(e->text);
-    if (e->glyphs != NULL)
+    free(e->glyphs);
-        cairo_glyph_free(e->glyphs);
-    if (e->clusters != NULL)
-        cairo_text_cluster_free(e->clusters);
-
     free(e);
     exposable_default_destroy(exposable);
 }
 
 static int
-begin_expose(struct exposable *exposable, cairo_t *cr)
+begin_expose(struct exposable *exposable)
 {
     struct eprivate *e = exposable->private;
 
-    cairo_scaled_font_t *scaled = font_scaled_font(exposable->particle->font);
+    struct font *font = exposable->particle->font;
-
-    cairo_set_scaled_font(cr, scaled);
-    cairo_font_extents(cr, &e->fextents);
 
     LOG_DBG("%s: ascent=%f, descent=%f, height=%f",
-            font_face(exposable->particle->font),
+            font->name, font->fextents.ascent,
-            e->fextents.ascent, e->fextents.descent, e->fextents.height);
+            font->fextents.descent, font->fextents.height);
 
-    cairo_status_t status = cairo_scaled_font_text_to_glyphs(
+    size_t chars = mbstowcs(NULL, e->text, 0);
-        scaled, 0, 0, e->text, -1, &e->glyphs, &e->num_glyphs,
+    wchar_t wtext[chars + 1];
-        &e->clusters, &e->num_clusters, &e->cluster_flags);
+    mbstowcs(wtext, e->text, chars + 1);
 
-    if (status != CAIRO_STATUS_SUCCESS) {
+    e->glyphs = malloc(chars * sizeof(e->glyphs[0]));
-        LOG_WARN("failed to convert \"%s\" to glyphs: %s",
+    e->num_glyphs = 0;
-                 e->text, cairo_status_to_string(status));
 
-        e->num_glyphs = -1;
+    /* Convert text to glyph masks/images. */
-        e->num_clusters = -1;
+    for (size_t i = 0; i < chars; i++) {
-        memset(&e->fextents, 0, sizeof(e->fextents));
+        const struct glyph *glyph = font_glyph_for_wc(font, wtext[i]);
-        exposable->width = 0;
+        if (glyph == NULL)
-    } else {
+            continue;
-        cairo_text_extents_t extents;
+        e->glyphs[e->num_glyphs++] = glyph;
-        cairo_scaled_font_glyph_extents(
-            scaled, e->glyphs, e->num_glyphs, &extents);
-
-        exposable->width = (exposable->particle->left_margin +
-                            extents.x_advance +
-                            exposable->particle->right_margin);
     }
 
+    exposable->width = exposable->particle->left_margin +
+        exposable->particle->right_margin;
+
+    /* Calculate the size we need to render the glyphs */
+    for (int i = 0; i < e->num_glyphs; i++)
+        exposable->width += e->glyphs[i]->x_advance;
+
     return exposable->width;
 }
 
 static void
-expose(const struct exposable *exposable, cairo_t *cr, int x, int y, int height)
+expose(const struct exposable *exposable, pixman_image_t *pix, int x, int y, int height)
 {
-    exposable_render_deco(exposable, cr, x, y, height);
+    exposable_render_deco(exposable, pix, x, y, height);
 
     const struct eprivate *e = exposable->private;
+    const struct font *font = exposable->particle->font;
 
-    if (e->num_glyphs == -1)
+    if (e->num_glyphs == 0)
         return;
 
     /*
@@ -108,63 +97,34 @@ expose(const struct exposable *exposable, cairo_t *cr, int x, int y, int height)
      * font family.
      */
     const double baseline = (double)y +
-      (double)(height + e->fextents.ascent + e->fextents.descent) / 2.0 -
+        (double)(height + font->fextents.ascent + font->fextents.descent) / 2.0 -
-      (e->fextents.descent > 0 ? e->fextents.descent : 0);
+        (font->fextents.descent > 0 ? font->fextents.descent : 0);
 
-    /* Adjust glyph offsets */
+    x += exposable->particle->left_margin;
+
+    /* Loop glyphs and render them, one by one */
     for (int i = 0; i < e->num_glyphs; i++) {
-        e->glyphs[i].x += x + exposable->particle->left_margin;
+        const struct glyph *glyph = e->glyphs[i];
-        e->glyphs[i].y += baseline;
+        assert(glyph != NULL);
+
+        if (pixman_image_get_format(glyph->pix) == PIXMAN_a8r8g8b8) {
+            /* Glyph surface is a pre-rendered image (typically a color emoji...) */
+            pixman_image_composite32(
+                PIXMAN_OP_OVER, glyph->pix, NULL, pix, 0, 0, 0, 0,
+                x + glyph->x, baseline - glyph->y,
+                glyph->width, glyph->height);
+        } else {
+            /* Glyph surface is an alpha mask */
+            pixman_image_t *src = pixman_image_create_solid_fill(&exposable->particle->foreground);
+            pixman_image_composite32(
+                PIXMAN_OP_OVER, src, glyph->pix, pix, 0, 0, 0, 0,
+                x + glyph->x, baseline - glyph->y,
+                glyph->width, glyph->height);
+            pixman_image_unref(src);
+        }
+
+        x += glyph->x_advance;
     }
-
-    cairo_scaled_font_t *scaled = font_scaled_font(exposable->particle->font);
-    cairo_set_scaled_font(cr, scaled);
-    cairo_set_source_rgba(cr,
-                          exposable->particle->foreground.red,
-                          exposable->particle->foreground.green,
-                          exposable->particle->foreground.blue,
-                          exposable->particle->foreground.alpha);
-    cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
-
-    cairo_show_text_glyphs(
-        cr, e->text, -1, e->glyphs, e->num_glyphs,
-        e->clusters, e->num_clusters, e->cluster_flags);
-
-#if 0
-    cairo_text_extents_t extents;
-    cairo_scaled_font_glyph_extents(scaled, e->glyphs, e->num_glyphs, &extents);
-
-    /* Bar center */
-    cairo_set_line_width(cr, 1);
-    cairo_set_source_rgba(cr, 1.0, 0.0, 0.0, 1.0);
-    cairo_move_to(cr, x, (double)y + (double)height / 2 + 0.5);
-    cairo_line_to(cr, x + extents.x_advance, (double)y + (double)height / 2 + 0.5);
-    cairo_stroke(cr);
-
-    /* Ascent */
-    cairo_set_source_rgba(cr, 0.0, 1.0, 0.0, 1.0);
-    cairo_move_to(cr, x, baseline - e->fextents.ascent + 0.5);
-    cairo_line_to(cr, x + extents.x_advance, baseline - e->fextents.ascent + 0.5);
-    cairo_stroke(cr);
-
-    /* Descent */
-    cairo_set_source_rgba(cr, 0.0, 0.0, 1.0, 1.0);
-    cairo_move_to(cr, x, baseline + e->fextents.descent + 0.5);
-    cairo_line_to(cr, x + extents.x_advance, baseline + e->fextents.descent + 0.5);
-    cairo_stroke(cr);
-
-    /* Height (!= ascent + descent) */
-    cairo_set_source_rgba(cr, 1.0, 1.0, 1.0, 1.0);
-    cairo_move_to(cr, x - 3 + 0.5, (double)y + (double)(height - e->fextents.height) / 2);
-    cairo_line_to(cr, x - 3 + 0.5, (double)y + (double)(height + e->fextents.height) / 2);
-    cairo_stroke(cr);
-
-    /* Height (ascent + descent) */
-    cairo_set_source_rgba(cr, 1.0, 0.0, 0.0, 1.0);
-    cairo_move_to(cr, x - 1 + 0.5, (double)y + (double)(height - (e->fextents.ascent + e->fextents.descent)) / 2);
-    cairo_line_to(cr, x - 1 + 0.5, (double)y + (double)(height + (e->fextents.ascent + e->fextents.descent)) / 2);
-    cairo_stroke(cr);
-#endif
 }
 
 static struct exposable *
@@ -174,8 +134,8 @@ instantiate(const struct particle *particle, const struct tag_set *tags)
     struct eprivate *e = calloc(1, sizeof(*e));
 
     e->text = tags_expand_template(p->text, tags);
-    e->num_glyphs = -1;
+    e->glyphs = NULL;
-    e->num_clusters = -1;
+    e->num_glyphs = 0;
 
     if (p->max_len > 0) {
         const size_t len = strlen(e->text);

stride.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <pixman.h>
+
+static inline int
+stride_for_format_and_width(pixman_format_code_t format, int width)
+{
+    return (((PIXMAN_FORMAT_BPP(format) * width + 7) / 8 + 4 - 1) & -4);
+}