Break out MonMon parts that are unrelated to Icecc to a separate class

1 files changed, 56 insertions, 558 deletions

diff --git a/src/main.cc b/src/main.cc
index f7b3e58..c8be11c 100644
--- a/src/main.cc
+++ b/src/main.cc
@@ -1,11 +1,8 @@
 #include "common.hh"
 
 #include <algorithm>
-#include <cairo-xcb.h>
 #include <iostream>
 #include <math.h>
-#include <mutex>
-#include <pango/pangocairo.h>
 #include <string.h>
 #include <thread>
 #include <xcb/xcb_event.h>
@@ -16,210 +13,22 @@
 #include "animator.hh"
 #include "args.hh"
 #include "blissful_monitor.hh"
+#include "cairo.hh"
 #include "fake_monitor.hh"
 #include "io.hh"
 #include "monitor.hh"
+#include "monmon.hh"
+#include "pango.hh"
 #include "poll_looper.hh"
 #include "x.hh"
 
 namespace {
 
-struct CairoSurfaceDelete {
-  void operator()(cairo_surface_t* surface) const {
-    cairo_surface_destroy(surface);
-  }
-};
-
-struct CairoDelete {
-  void operator()(cairo_t* cairo) const {
-    cairo_destroy(cairo);
-  }
-};
-
-struct GObjectDelete {
-  void operator()(gpointer ptr) const {
-    g_object_unref(ptr);
-  }
-};
-
-struct PangoFontMetricsDelete {
-  void operator()(PangoFontMetrics* ptr) const {
-    pango_font_metrics_unref(ptr);
-  }
-};
-
-struct PangoFontDescriptionDelete {
-  void operator()(PangoFontDescription* ptr) const {
-    pango_font_description_free(ptr);
-  }
-};
-
-struct CairoPatternDelete {
-  void operator()(cairo_pattern_t* pattern) const {
-    cairo_pattern_destroy(pattern);
-  }
-};
-
-struct CairoPathDelete {
-  void operator()(cairo_path_t* path) const {
-    cairo_path_destroy(path);
-  }
-};
-
-struct MwmHints {
-  uint32_t flags;
-  uint32_t functions;
-  uint32_t decorations;
-  int32_t input_mode;
-  uint32_t status;
-};
-
-class MonMon : virtual Monitor::Observer, virtual Animator::Observer {
+class IceccMonMon : public MonMon, virtual Monitor::Observer {
 public:
-  MonMon(std::shared_ptr<PollLooper> const& looper, unsigned columns)
-    : looper_(looper), animator_(Animator::create(looper)),
-      connected_(false), depth_(0), black_pixel_(0),
-      screen_(nullptr), max_jobs_(0), jobs_(0), requests_(0),
-      x_(0), y_(0), w_(0), h_(0), force_columns_(columns),
-      rootpmap_(XCB_ATOM_NONE), desktop_window_(XCB_NONE),
-      desktop_pixmap_(XCB_NONE) {
-    pipe_.open();
-    looper_->add(pipe_.read(), Looper::EV_READ,
-                 std::bind(&MonMon::pipe, this, std::placeholders::_1,
-                           std::placeholders::_2, std::placeholders::_3));
-    animator_->add_observer(this);
-  }
-
-  ~MonMon() {
-    stop_all_animations();
-    unset_desktop_window();
-    close_pipe();
-    wnd_.reset();
-  }
-
-  void init(x::shared_connection const& conn, xcb_screen_t const* screen,
-            x::Format format, std::shared_ptr<x::Atoms> const& atoms,
-            std::shared_ptr<x::Ewmh> const& ewmh,
-            uint16_t width, uint16_t height, bool normal, bool black) {
-    screen_ = screen;
-    wnd_.reset(conn);
-    pixmap_.reset(conn);
-    gcontext_.reset(conn);
-    cmap_.reset();
-
-    uint32_t values[4];
-    size_t i = 0;
-    uint32_t mask = XCB_CW_BACK_PIXEL;
-    values[i++] = screen->black_pixel;
-    if (format.need_border()) {
-      mask |= XCB_CW_BORDER_PIXEL;
-      values[i++] = screen->black_pixel;
-    }
-    mask |= XCB_CW_EVENT_MASK;
-    values[i++] = XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_EXPOSURE
-      | XCB_EVENT_MASK_STRUCTURE_NOTIFY;
-    if (format.need_colormap()) {
-      mask |= XCB_CW_COLORMAP;
-      cmap_.reset(conn);
-      xcb_create_colormap(cmap_.conn(), XCB_COLORMAP_ALLOC_NONE, cmap_.get(),
-                          screen->root, format.visual->visual_id);
-      values[i++] = cmap_.get();
-    }
-    xcb_create_window(wnd_.conn(), format.depth,
-                      wnd_.get(), screen->root,
-                      0, 0, width, height, 0,
-                      XCB_WINDOW_CLASS_INPUT_OUTPUT,
-                      format.visual->visual_id,
-                      mask, values);
-    if (!normal) {
-      if (atoms->get("_MOTIF_WM_INFO", false) != XCB_ATOM_NONE) {
-        auto atom = atoms->get("_MOTIF_WM_HINTS");
-        MwmHints hints;
-        hints.flags = 1 << 1;  // MWM_HINTS_DECORATIONS
-        hints.decorations = 0;
-        xcb_change_property(wnd_.conn(), XCB_PROP_MODE_REPLACE, wnd_.get(),
-                            atom, atom, 32, sizeof(hints) / 4, &hints);
-      } else {
-#ifndef NDEBUG
-        // There is no way to know how the window manager will implement
-        // utility window type, some might show them without titlebar ...
-        std::cerr << "Warning: No motif support detected, falling back to "
-                  << "NETWM utility window type." << std::endl;
-#endif
-        auto wm = ewmh->conn();
-        if (wm && ewmh->supported(wm->_NET_WM_WINDOW_TYPE_UTILITY)) {
-          xcb_atom_t values[1];
-          values[0] = wm->_NET_WM_WINDOW_TYPE_UTILITY;
-          xcb_ewmh_set_wm_window_type(wm, wnd_.get(), 1, values);
-        } else {
-          // TODO: Fallback to override-redirect?
-        }
-      }
-    }
-    if (!black) {
-      rootpmap_ = atoms->get("_XROOTPMAP_ID", false);
-      if (rootpmap_ == XCB_ATOM_NONE) {
-        std::cerr << "Warning: No support for Eterm style background pixmap"
-                  << std::endl;
-      }
-    }
-    auto wm = ewmh->conn();
-    if (wm) {
-      xcb_ewmh_set_wm_name(wm, wnd_.get(), 6, "MonMon");
-    } else {
-      xcb_icccm_set_wm_name(wnd_.conn(), wnd_.get(), XCB_ATOM_STRING, 8, 6, "MonMon");
-    }
-    xcb_create_gc(gcontext_.conn(), gcontext_.get(), wnd_.get(), 0, nullptr);
-    auto atom = atoms->get("WM_DELETE_WINDOW");
-    xcb_icccm_set_wm_protocols(wnd_.conn(), wnd_.get(),
-                               atoms->get("WM_PROTOCOLS"),
-                               1, &atom);
-    xcb_create_pixmap(pixmap_.conn(), format.depth, pixmap_.get(), wnd_.get(),
-                      width, height);
-    if (format.render) {
-      surface_.reset(
-          cairo_xcb_surface_create_with_xrender_format(
-              pixmap_.conn(),
-              const_cast<xcb_screen_t*>(screen),
-              pixmap_.get(),
-              format.render,
-              width, height));
-      if (cairo_surface_status(surface_.get()) != CAIRO_STATUS_SUCCESS) {
-        surface_.reset();
-      }
-    }
-    if (!surface_) {
-      surface_.reset(
-          cairo_xcb_surface_create(pixmap_.conn(), pixmap_.get(),
-                                   format.visual, width, height));
-    }
-    cairo_.reset(cairo_create(surface_.get()));
-    layout_.reset(pango_cairo_create_layout(cairo_.get()));
-    pango_layout_set_ellipsize(layout_.get(), PANGO_ELLIPSIZE_MIDDLE);
-    pango_layout_set_alignment(layout_.get(), PANGO_ALIGN_CENTER);
-    pango_layout_set_height(layout_.get(), 0);
-    auto font =
-      std::unique_ptr<PangoFontDescription, PangoFontDescriptionDelete>(
-          pango_font_description_new());
-    pango_font_description_set_size(font.get(), 10 * PANGO_SCALE);
-    pango_layout_set_font_description(layout_.get(), font.get());
-    auto context = pango_layout_get_context(layout_.get());
-    auto metrics = std::unique_ptr<PangoFontMetrics, PangoFontMetricsDelete>(
-        pango_context_get_metrics(context, nullptr, nullptr));
-    box_height_ = static_cast<double>(
-        pango_font_metrics_get_ascent(metrics.get()) +
-        pango_font_metrics_get_descent(metrics.get())) / PANGO_SCALE;
-    x_ = 0;
-    y_ = 0;
-    w_ = width;
-    h_ = height;
-    depth_ = format.depth;
-    black_pixel_ = screen->black_pixel;
-    update_desktop_window();
-
-    internal_draw();
-    xcb_map_window(wnd_.conn(), wnd_.get());
-    xcb_flush(wnd_.conn());
+  IceccMonMon(std::shared_ptr<PollLooper> const& looper, unsigned columns)
+    : MonMon(looper), connected_(false), max_jobs_(0), jobs_(0), requests_(0),
+      force_columns_(columns) {
   }
 
   void connect(Args const* args) {
@@ -235,155 +44,17 @@ public:
                       args->arg("scheduler", ""));
   }
 
-  void quit_from_xcb() {
-    io::write(pipe_, "q", 1);
+protected:
+  void width_changed() override {
+    job_pattern_.reset();
   }
 
 #if FAKE_MONITOR
-  void toggle_fakes() {
-    io::write(pipe_, " ", 1);
+  void do_toggle_fakes() override {
+    monitor_->toggle_fakes();
   }
 #endif
 
-  /*
-  void quit_from_main(std::shared_ptr<x::Atoms> const& atoms) {
-    // Wake up the event thread by sending an event to our window
-    xcb_client_message_event_t event;
-    memset(&event, 0, sizeof(event));
-    event.response_type = XCB_CLIENT_MESSAGE;
-    event.format = 32;
-    event.sequence = 0;
-    event.window = wnd_.get();
-    event.type = atoms->get("__MONMON_QUIT");
-
-    xcb_send_event(wnd_.conn(), false, wnd_.get(), XCB_EVENT_MASK_NO_EVENT,
-                   reinterpret_cast<char*>(&event));
-    xcb_flush(wnd_.conn());
-  }
-  */
-
-  void expose(int16_t x, int16_t y, uint16_t w, uint16_t h) {
-    std::lock_guard<std::mutex> lock(mutex_);
-    xcb_copy_area(wnd_.conn(), pixmap_.get(), wnd_.get(), gcontext_.get(),
-                  x, y, x, y, w, h);
-  }
-
-  bool match(xcb_window_t wnd) const {
-    return wnd == wnd_.get();
-  }
-
-  void configure(int16_t x, int16_t y, uint16_t w, uint16_t h) {
-    bool draw = false;
-    if (rootpmap_ && (x != x_ || y != y_)) {
-      x_ = x;
-      y_ = y;
-      if (desktop_surface_) {
-        draw = true;
-        io::write(pipe_, "d", 1);
-      }
-    }
-    if (w == w_ && h == h_) return;
-    {
-      std::lock_guard<std::mutex> lock(mutex_);
-      x::unique_pixmap tmp(pixmap_.shared_conn());
-      x::unique_gcontext gc(tmp.shared_conn());
-      cairo_surface_flush(surface_.get());
-      xcb_create_pixmap(tmp.conn(), depth_, tmp.get(), wnd_.get(), w, h);
-      uint32_t value[1];
-      value[0] = black_pixel_;
-      xcb_create_gc(gc.conn(), gc.get(), tmp.get(), XCB_GC_FOREGROUND, value);
-      uint32_t count = 0;
-      xcb_rectangle_t rect[2];
-      uint16_t copy_width, copy_height;
-      if (w > w_) {
-        copy_width = w_;
-        rect[count].x = w_;
-        rect[count].width = w - w_;
-        rect[count].y = 0;
-        rect[count].height = h_;
-        ++count;
-      } else {
-        copy_width = w;
-      }
-      if (h > h_) {
-        copy_height = h_;
-        rect[count].x = 0;
-        rect[count].width = w;
-        rect[count].y = h_;
-        rect[count].height = h - h_;
-        ++count;
-      } else {
-        copy_height = h;
-      }
-      if (count) {
-        xcb_poly_fill_rectangle(tmp.conn(), tmp.get(), gc.get(),
-                                count, rect);
-      }
-      xcb_copy_area(tmp.conn(), pixmap_.get(), tmp.get(), gc.get(), 0, 0, 0, 0,
-                    copy_width, copy_height);
-      cairo_xcb_surface_set_drawable(surface_.get(), tmp.get(), w, h);
-      if (w_ != w) {
-        job_pattern_.reset();
-        w_ = w;
-      }
-      h_ = h;
-      pixmap_ = std::move(tmp);
-      xcb_copy_area(wnd_.conn(), pixmap_.get(), wnd_.get(), gcontext_.get(),
-                    0, 0, 0, 0, w, h);
-    }
-    if (!draw) io::write(pipe_, "d", 1);
-  }
-
-  void update_desktop_window() {
-    if (rootpmap_ == XCB_ATOM_NONE) return;
-
-    xcb_window_t desktop_window = XCB_NONE;
-
-    auto last = wnd_.get();
-    while (true) {
-      auto cookie = xcb_query_tree(wnd_.conn(), last);
-      auto reply = xcb_query_tree_reply(wnd_.conn(), cookie, nullptr);
-      if (!reply) break;
-      auto cookie2 = xcb_get_property(wnd_.conn(), 0, reply->parent, rootpmap_,
-                                      XCB_GET_PROPERTY_TYPE_ANY, 0, 1);
-      auto reply2 = xcb_get_property_reply(wnd_.conn(), cookie2, nullptr);
-      if (reply2) {
-        if (reply2->type != 0 && reply2->format != 0 && reply2->length != 0) {
-          desktop_window = reply->parent;
-          free(reply2);
-          free(reply);
-          break;
-        }
-        free(reply2);
-      }
-      if (reply->parent == reply->root) {
-        free(reply);
-        break;
-      }
-      last = reply->parent;
-      free(reply);
-    }
-
-    if (desktop_window == desktop_window_) return;
-    unset_desktop_window();
-    if (desktop_window == XCB_NONE) return;
-
-    uint32_t values[1];
-    values[0] = XCB_EVENT_MASK_PROPERTY_CHANGE;
-    xcb_change_window_attributes(wnd_.conn(), desktop_window,
-                                 XCB_CW_EVENT_MASK,
-                                 values);
-    desktop_window_ = desktop_window;
-    update_desktop_pixmap();
-  }
-
-  void update_desktop_window(xcb_window_t window, xcb_atom_t property) {
-    if (window != desktop_window_) return;
-    if (property != rootpmap_) return;
-
-    update_desktop_pixmap();
-  }
-
 private:
   class MachineAnimation;
 
@@ -455,115 +126,6 @@ private:
     double last_;
   };
 
-  void unset_desktop_window() {
-    if (desktop_window_ == XCB_NONE) return;
-    uint32_t values[1];
-    values[0] = 0;
-    xcb_change_window_attributes(wnd_.conn(), desktop_window_,
-                                 XCB_CW_EVENT_MASK,
-                                 values);
-    desktop_window_ = XCB_NONE;
-    update_desktop_pixmap();
-  }
-
-  void update_desktop_pixmap() {
-    xcb_pixmap_t pixmap = XCB_NONE;
-
-    if (desktop_window_ != XCB_NONE) {
-      auto cookie = xcb_get_property(wnd_.conn(), 0, desktop_window_, rootpmap_,
-                                     XCB_GET_PROPERTY_TYPE_ANY, 0, 1);
-      auto reply = xcb_get_property_reply(wnd_.conn(), cookie, nullptr);
-      if (reply) {
-        if (reply->type == XCB_ATOM_PIXMAP) {
-          pixmap = *reinterpret_cast<xcb_pixmap_t*>(
-              xcb_get_property_value(reply));
-        }
-        free(reply);
-      }
-    }
-
-    if (pixmap == desktop_pixmap_) return;
-
-    auto geometry_cookie = xcb_get_geometry(wnd_.conn(), pixmap);
-    auto attr_cookie = xcb_get_window_attributes(wnd_.conn(), desktop_window_);
-
-    auto geometry_reply = xcb_get_geometry_reply(wnd_.conn(), geometry_cookie,
-                                                 nullptr);
-    uint16_t w, h;
-    uint8_t depth;
-    if (geometry_reply) {
-      depth = geometry_reply->depth;
-      w = geometry_reply->width;
-      h = geometry_reply->height;
-      free(geometry_reply);
-    } else {
-      pixmap = XCB_NONE;
-      depth = 0;
-    }
-
-    auto attr_reply = xcb_get_window_attributes_reply(wnd_.conn(), attr_cookie,
-                                                      nullptr);
-    if (attr_reply) {
-      auto iter = xcb_screen_allowed_depths_iterator(screen_);
-      auto count = xcb_screen_allowed_depths_length(screen_);
-      while (count--) {
-        if (iter.data->depth == depth) {
-          auto visuals = xcb_depth_visuals(iter.data);
-          auto visual_count = xcb_depth_visuals_length(iter.data);
-          while (visual_count--) {
-            if (visuals->visual_id == attr_reply->visual) {
-              if (pixmap != XCB_NONE) {
-                desktop_surface_.reset(cairo_xcb_surface_create(
-                                           wnd_.conn(), pixmap,
-                                           visuals, w, h));
-              }
-              break;
-            }
-            ++visuals;
-          }
-        }
-        xcb_depth_next(&iter);
-      }
-      free(attr_reply);
-    } else {
-      pixmap = XCB_NONE;
-    }
-
-    desktop_pixmap_ = pixmap;
-    if (desktop_pixmap_ == XCB_NONE) desktop_surface_.reset();
-
-    io::write(pipe_, "d", 1);
-  }
-
-  void close_pipe() {
-    if (!pipe_) return;
-    looper_->remove(pipe_.read());
-    pipe_.reset();
-  }
-
-  void pipe(Looper*, int, uint8_t event) {
-    if (event & Looper::EV_READ) {
-      char tmp;
-      if (io::read(pipe_, &tmp, 1)) {
-        if (tmp == 'd') {
-          force_draw();
-          return;
-        }
-#if FAKE_MONITOR
-        if (tmp == ' ') {
-          monitor_->toggle_fakes();
-          return;
-        }
-#endif
-      }
-    }
-
-    stop_all_animations();
-    animator_.reset();
-    monitor_->disconnect();
-    looper_->exit_when_empty();
-    close_pipe();
-  }
 
   void state(Monitor*, Monitor::State state) override {
     switch (state) {
@@ -584,13 +146,17 @@ private:
     }
   }
 
-  void stop_all_animations() {
+  void stop_all_animations() override {
     if (!animator_) return;
     for (auto& machine : machines_) {
       if (machine->animation) animator_->stop(machine->animation.get());
     }
   }
 
+  void internal_quit() override {
+    monitor_->disconnect();
+  }
+
   void update(Machine* machine) {
     auto old = machine->data.max_jobs;
     machine->data = monitor_->machine(machine->id);
@@ -603,43 +169,13 @@ private:
     }
   }
 
-  void draw() {
-    // Animator will draw soon anyway, so let it
-    if (animator_ && animator_->active()) return;
-    force_draw();
-  }
-
-  static void rounded_path(cairo_t* cr, double x, double y,
-                           double width, double height) {
-    auto radius = height / 10.0;
-    auto degrees = M_PI / 180.0;
-
-    cairo_new_sub_path(cr);
-    cairo_arc(cr, x + width - radius, y + radius, radius,
-              -90 * degrees, 0 * degrees);
-    cairo_arc(cr, x + width - radius, y + height - radius, radius,
-              0 * degrees, 90 * degrees);
-    cairo_arc(cr, x + radius, y + height - radius, radius,
-              90 * degrees, 180 * degrees);
-    cairo_arc(cr, x + radius, y + radius, radius, 180 * degrees, 270 * degrees);
-    cairo_close_path(cr);
-  }
-
-  void internal_draw() {
-    std::lock_guard<std::mutex> lock(mutex_);
-    if (!desktop_surface_) {
-      cairo_set_source_rgb(cairo_.get(), 0, 0, 0);
-    } else {
-      cairo_set_source_surface(cairo_.get(), desktop_surface_.get(),
-                               -x_, -y_);
-    }
-    cairo_rectangle(cairo_.get(), 0, 0, w_, h_);
-    cairo_fill(cairo_.get());
-    auto const pad_x = std::min(9.0, w_ / 20.0), pad_y = pad_x;
-    auto const margin_x = std::min(7.5, w_ / 20.0), margin_y = margin_x;
+  void draw_content(cairo_t* cairo, PangoLayout* layout, uint16_t w, uint16_t h)
+      override {
+    auto const pad_x = std::min(9.0, w / 20.0), pad_y = pad_x;
+    auto const margin_x = std::min(7.5, w / 20.0), margin_y = margin_x;
     auto y = pad_y;
-    auto const columns = force_columns_ ? force_columns_ : std::max(1, w_ / h_);
-    auto const box_width = (w_ - pad_x) / columns - pad_x;
+    auto const columns = force_columns_ ? force_columns_ : std::max(1, w / h);
+    auto const box_width = (w - pad_x) / columns - pad_x;
     auto const box_height = box_height_ + margin_y * 2;
     if (!job_pattern_) {
       job_pattern_.reset(cairo_pattern_create_linear(0.0, 0.0, box_width, 0.0));
@@ -654,64 +190,59 @@ private:
       cairo_pattern_add_color_stop_rgb(job_pattern_.get(), 1.000000,
                                        0.976471, 0.968627, 0.831373);
     }
-    pango_layout_set_width(layout_.get(),
+    pango_layout_set_width(layout,
                            (box_width - margin_x * 2) * PANGO_SCALE);
     unsigned col = 0;
     for (auto const& machine : machines_) {
-      pango_layout_set_text(layout_.get(), machine->data.name.data(),
+      pango_layout_set_text(layout, machine->data.name.data(),
                             machine->data.name.size());
       auto x = pad_x + col * (box_width + pad_x);
-      rounded_path(cairo_.get(), x, y, box_width, box_height);
-      cairo_set_source_rgba(cairo_.get(), 0.1, 0.1, 0.1, 0.7);
+      rounded_path(cairo, x, y, box_width, box_height);
+      cairo_set_source_rgba(cairo, 0.1, 0.1, 0.1, 0.7);
 
       if (machine->x > 0.0) {
-        cairo_fill_preserve(cairo_.get());
-        auto old = std::unique_ptr<cairo_path_t, CairoPathDelete>(
-            cairo_copy_path(cairo_.get()));
-        cairo_new_path(cairo_.get());
-        cairo_rectangle(cairo_.get(), x, y,
-                        machine->x * box_width, box_height);
-        cairo_clip(cairo_.get());
-        cairo_append_path(cairo_.get(), old.get());
+        cairo_fill_preserve(cairo);
+        auto old = cairo::unique_path(cairo_copy_path(cairo));
+        cairo_new_path(cairo);
+        cairo_rectangle(cairo, x, y, machine->x * box_width, box_height);
+        cairo_clip(cairo);
+        cairo_append_path(cairo, old.get());
         cairo_matrix_t matrix;
         cairo_matrix_init_translate(&matrix, -x, 0);
         cairo_pattern_set_matrix(job_pattern_.get(), &matrix);
-        cairo_set_source(cairo_.get(), job_pattern_.get());
-        cairo_fill(cairo_.get());
-        cairo_reset_clip(cairo_.get());
+        cairo_set_source(cairo, job_pattern_.get());
+        cairo_fill(cairo);
+        cairo_reset_clip(cairo);
       } else {
-        cairo_fill(cairo_.get());
+        cairo_fill(cairo);
       }
       if (machine->requests > 0) {
         auto radius = box_height / 10.0;
-        cairo_set_line_width(cairo_.get(), 1.5);
-        cairo_new_path(cairo_.get());
-        cairo_move_to(cairo_.get(), x + box_width - radius, y);
-        cairo_rel_line_to(cairo_.get(),
+        cairo_set_line_width(cairo, 1.5);
+        cairo_new_path(cairo);
+        cairo_move_to(cairo, x + box_width - radius, y);
+        cairo_rel_line_to(cairo,
                           -(machine->requests * (box_width - radius * 2))
                           / requests_, 0);
-        cairo_set_source_rgb(cairo_.get(), 0, 0.6, 0);
-        cairo_stroke(cairo_.get());
+        cairo_set_source_rgb(cairo, 0, 0.6, 0);
+        cairo_stroke(cairo);
       }
 
-      cairo_move_to(cairo_.get(), x + margin_x, y + margin_y);
-      pango_cairo_layout_path(cairo_.get(), layout_.get());
-      cairo_set_source_rgb(cairo_.get(), 0.0, 0.0, 0.0);
-      cairo_set_line_cap(cairo_.get(), CAIRO_LINE_CAP_ROUND);
-      cairo_set_line_width(cairo_.get(), 2.0);
-      cairo_stroke(cairo_.get());
-      cairo_set_source_rgb(cairo_.get(), 1.0, 1.0, 1.0);
-      cairo_move_to(cairo_.get(), x + margin_x, y + margin_y);
-      pango_cairo_show_layout(cairo_.get(), layout_.get());
+      cairo_move_to(cairo, x + margin_x, y + margin_y);
+      pango_cairo_layout_path(cairo, layout);
+      cairo_set_source_rgb(cairo, 0.0, 0.0, 0.0);
+      cairo_set_line_cap(cairo, CAIRO_LINE_CAP_ROUND);
+      cairo_set_line_width(cairo, 2.0);
+      cairo_stroke(cairo);
+      cairo_set_source_rgb(cairo, 1.0, 1.0, 1.0);
+      cairo_move_to(cairo, x + margin_x, y + margin_y);
+      pango_cairo_show_layout(cairo, layout);
       if (++col == columns) {
         col = 0;
         y += box_height + pad_y * 2;
-        if (y >= h_) break;
+        if (y >= h) break;
       }
     }
-    cairo_surface_flush(surface_.get());
-    xcb_copy_area(wnd_.conn(), pixmap_.get(), wnd_.get(), gcontext_.get(),
-                  0, 0, 0, 0, w_, h_);
   }
 
   void added_machine(Monitor*, uint32_t id) override {
@@ -808,15 +339,6 @@ private:
     draw();
   }
 
-  void force_draw() {
-    internal_draw();
-    xcb_flush(wnd_.conn());
-  }
-
-  void tick(Animator*) override {
-    force_draw();
-  }
-
   void animate(Machine* machine) {
     if (!animator_) return;
     if (machine->animation) return;
@@ -824,36 +346,14 @@ private:
     animator_->start(machine->animation, machine);
   }
 
-  std::shared_ptr<PollLooper> looper_;
   std::unique_ptr<Monitor> monitor_;
-  std::unique_ptr<Animator> animator_;
   bool connected_;
-  io::pipe pipe_;
-  std::shared_ptr<x::Atoms> atoms_;
-  x::unique_window wnd_;
-  x::unique_gcontext gcontext_;
-  x::unique_colormap cmap_;
-  uint8_t depth_;
-  uint32_t black_pixel_;
-  xcb_screen_t const* screen_;
-  double box_height_;
   std::vector<std::unique_ptr<Machine>> machines_;
   unsigned max_jobs_;
   unsigned jobs_;
   unsigned requests_;
-  std::mutex mutex_;
-  std::unique_ptr<cairo_surface_t, CairoSurfaceDelete> surface_;
-  std::unique_ptr<cairo_t, CairoDelete> cairo_;
-  std::unique_ptr<cairo_pattern_t, CairoPatternDelete> job_pattern_;
-  std::unique_ptr<PangoLayout, GObjectDelete> layout_;
-  x::unique_pixmap pixmap_;
-  int16_t x_, y_;
-  uint16_t w_, h_;
+  cairo::unique_pattern job_pattern_;
   unsigned force_columns_;
-  xcb_atom_t rootpmap_;
-  xcb_window_t desktop_window_;
-  xcb_pixmap_t desktop_pixmap_;
-  std::unique_ptr<cairo_surface_t, CairoSurfaceDelete> desktop_surface_;
 };
 
 struct XcbKeySymbolsDelete {
@@ -1038,11 +538,9 @@ int main(int argc, char** argv) {
   atoms->preload("WM_DELETE_WINDOW");
   atoms->preload("WM_PROTOCOLS");
   atoms->preload("__MONMON_QUIT");
-  atoms->preload("_MOTIF_WM_INFO", false);
-  atoms->preload("_MOTIF_WM_HINTS");
-  atoms->preload("_XROOTPMAP_ID", false);
+  MonMon::preload(atoms.get());
   std::shared_ptr<x::Ewmh> ewmh(x::Ewmh::create(conn, screen_index));
-  auto monmon = std::make_shared<MonMon>(looper, columns);
+  auto monmon = std::make_shared<IceccMonMon>(looper, columns);
   monmon->init(conn, screen, format, atoms, ewmh, 400, 400,
                args->is_set("titlebar"), args->is_set("black"));
   monmon->connect(args.get());