Initial commit

1 files changed, 872 insertions, 0 deletions

diff --git a/src/main.cc b/src/main.cc
new file mode 100644
index 0000000..3cdb618
--- /dev/null
+++ b/src/main.cc
@@ -0,0 +1,872 @@
+#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>
+#include <xcb/xcb_icccm.h>
+#include <xcb/xcb_keysyms.h>
+
+#include "args.hh"
+#include "fake_monitor.hh"
+#include "io.hh"
+#include "monitor.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 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 {
+public:
+  explicit MonMon(std::shared_ptr<PollLooper> const& looper)
+    : looper_(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),
+      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));
+  }
+
+  ~MonMon() {
+    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);
+
+    uint32_t values[2];
+    values[0] = screen->black_pixel;
+    values[1] = XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_EXPOSURE
+      | XCB_EVENT_MASK_STRUCTURE_NOTIFY;
+    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,
+                      XCB_CW_BACK_PIXEL | XCB_CW_EVENT_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;
+      }
+    }
+    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 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());
+  }
+
+  void connect(Args const* args) {
+#if FAKE_MONITOR
+    monitor_.reset(FakeMonitor::create(looper_));
+#else
+    monitor_.reset(Monitor::create(looper_));
+#endif
+    monitor_->add_observer(this);
+    monitor_->connect(args->arg("network", ""),
+                      args->arg("scheduler", ""));
+  }
+
+  void quit_from_xcb() {
+    io::write(pipe_, "q", 1);
+  }
+
+  /*
+  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:
+  struct Machine {
+    uint32_t id;
+    Monitor::Machine data;
+    unsigned jobs;
+    unsigned requests;
+
+    explicit Machine(uint32_t id)
+      : id(id), jobs(0), requests(0) {
+    }
+
+    bool operator<(Machine const& machine) const {
+      if (data.name < machine.data.name) return true;
+      if (data.name > machine.data.name) return false;
+      return id < machine.id;
+    }
+  };
+
+  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;
+    }
+
+    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') {
+          draw();
+          return;
+        }
+      }
+    }
+
+    monitor_->disconnect();
+    looper_->exit_when_empty();
+    close_pipe();
+  }
+
+  void state(Monitor*, Monitor::State state) override {
+    switch (state) {
+    case Monitor::SEARCHING:
+      connected_ = false;
+      machines_.clear();
+      max_jobs_ = 0;
+      jobs_ = 0;
+      requests_ = 0;
+      if (!wnd_) return;
+      draw();
+      break;
+    case Monitor::CONNECTED:
+      connected_ = true;
+      draw();
+      break;
+    }
+  }
+
+  void update(Machine& machine) {
+    auto old = machine.data.max_jobs;
+    machine.data = monitor_->machine(machine.id);
+    if (old < machine.data.max_jobs) {
+      max_jobs_ += machine.data.max_jobs - old;
+    } else if (old > machine.data.max_jobs) {
+      max_jobs_ -= old - machine.data.max_jobs;
+    }
+  }
+
+  void draw() {
+    internal_draw();
+    xcb_flush(wnd_.conn());
+  }
+
+  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 pad_x = std::min(9.0, w_ / 20.0), pad_y = pad_x;
+    auto margin_x = std::min(7.5, w_ / 20.0), margin_y = margin_x;
+    auto y = pad_y;
+    auto box_width = w_ - pad_x * 2;
+    auto 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));
+      cairo_pattern_add_color_stop_rgb(job_pattern_.get(), 0.000000,
+                                       0.000000, 0.000000, 0.000000);
+      cairo_pattern_add_color_stop_rgb(job_pattern_.get(), 0.594324,
+                                       0.729412, 0.000000, 0.000000);
+      cairo_pattern_add_color_stop_rgb(job_pattern_.get(), 0.809683,
+                                       1.000000, 0.545098, 0.196078);
+      cairo_pattern_add_color_stop_rgb(job_pattern_.get(), 0.899833,
+                                       0.972549, 0.937255, 0.074510);
+      cairo_pattern_add_color_stop_rgb(job_pattern_.get(), 1.000000,
+                                       0.976471, 0.968627, 0.831373);
+    }
+    pango_layout_set_width(layout_.get(),
+                           (box_width - margin_x * 2) * PANGO_SCALE);
+    for (auto const& machine : machines_) {
+      pango_layout_set_text(layout_.get(), machine.data.name.data(),
+                            machine.data.name.size());
+      rounded_path(cairo_.get(), pad_x, y, box_width, box_height);
+      cairo_set_source_rgba(cairo_.get(), 0.1, 0.1, 0.1, 0.7);
+
+      if (machine.jobs > 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(), pad_x, y,
+                        (machine.jobs * box_width) / machine.data.max_jobs,
+                        box_height);
+        cairo_clip(cairo_.get());
+        cairo_append_path(cairo_.get(), old.get());
+        cairo_set_source(cairo_.get(), job_pattern_.get());
+        cairo_fill(cairo_.get());
+        cairo_reset_clip(cairo_.get());
+      } else {
+        cairo_fill(cairo_.get());
+      }
+      if (machine.requests > 0) {
+        cairo_set_line_width(cairo_.get(), 1.5);
+        cairo_new_path(cairo_.get());
+        cairo_move_to(cairo_.get(), pad_x + box_width, y);
+        cairo_rel_line_to(cairo_.get(),
+                          -(machine.requests * box_width) / requests_, 0);
+        cairo_set_source_rgb(cairo_.get(), 0, 0.6, 0);
+        cairo_stroke(cairo_.get());
+      }
+
+      cairo_move_to(cairo_.get(), pad_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(), pad_x + margin_x, y + margin_y);
+      pango_cairo_show_layout(cairo_.get(), layout_.get());
+      y += box_height + pad_y * 2;
+      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 {
+    Machine machine(id);
+    update(machine);
+    machines_.insert(
+        std::lower_bound(machines_.begin(), machines_.end(), machine),
+        machine);
+    draw();
+  }
+
+  void updated_machine(Monitor*, uint32_t id) override {
+    for (auto& machine : machines_) {
+      if (machine.id == id) {
+        auto old = machine.data.name;
+        update(machine);
+        if (machine.data.name != old) {
+          // TODO: Perhaps remove and insert instead?
+          std::sort(machines_.begin(), machines_.end());
+        }
+        draw();
+        return;
+      }
+    }
+    assert(false);
+  }
+
+  void removed_machine(Monitor*, uint32_t id) override {
+    for (auto it = machines_.begin(); it != machines_.end(); ++it) {
+      if (it->id == id) {
+        max_jobs_ -= it->data.max_jobs;
+        requests_ -= it->requests;
+        jobs_ -= it->jobs;
+        machines_.erase(it);
+        draw();
+        return;
+      }
+    }
+    assert(false);
+  }
+
+  void added_job(Monitor*, uint32_t source, uint32_t target) override {
+    if (source == target) {
+      for (auto& machine : machines_) {
+        if (machine.id == source) {
+          ++machine.jobs;
+        }
+      }
+    } else {
+      for (auto& machine : machines_) {
+        if (machine.id == source) {
+          ++machine.requests;
+        }
+        if (machine.id == target) {
+          ++machine.jobs;
+        }
+      }
+      ++requests_;
+    }
+    ++jobs_;
+    draw();
+  }
+
+  void removed_job(Monitor*, uint32_t source, uint32_t target) override {
+    if (source == target) {
+      for (auto& machine : machines_) {
+        if (machine.id == source) {
+          --machine.jobs;
+        }
+      }
+    } else {
+      for (auto& machine : machines_) {
+        if (machine.id == source) {
+          --machine.requests;
+        }
+        if (machine.id == target) {
+          --machine.jobs;
+        }
+      }
+      --requests_;
+    }
+    --jobs_;
+    draw();
+  }
+
+  std::shared_ptr<PollLooper> looper_;
+  std::unique_ptr<Monitor> monitor_;
+  bool connected_;
+  io::pipe pipe_;
+  std::shared_ptr<x::Atoms> atoms_;
+  x::unique_window wnd_;
+  x::unique_gcontext gcontext_;
+  uint8_t depth_;
+  uint32_t black_pixel_;
+  xcb_screen_t const* screen_;
+  double box_height_;
+  std::vector<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_;
+  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 {
+  void operator()(xcb_key_symbols_t* ptr) const {
+    if (ptr) xcb_key_symbols_free(ptr);
+  }
+};
+
+struct XcbGenericEventDelete {
+  void operator()(xcb_generic_event_t* ptr) const {
+    free(ptr);
+  }
+};
+
+void xcb_event_loop(x::shared_connection const& conn,
+                    std::shared_ptr<x::Atoms> const& atoms,
+                    std::shared_ptr<MonMon> const& monmon) {
+  std::unique_ptr<xcb_key_symbols_t, XcbKeySymbolsDelete> syms;
+  syms.reset(xcb_key_symbols_alloc(conn.get()));
+  std::unique_ptr<xcb_generic_event_t, XcbGenericEventDelete> event;
+  auto const quit = atoms->get("__MONMON_QUIT");
+  auto const wm_protocols = atoms->get("WM_PROTOCOLS");
+  auto const wm_delete_window = atoms->get("WM_DELETE_WINDOW");
+  while (true) {
+    event.reset(xcb_wait_for_event(conn.get()));
+    if (!event) {
+      std::cerr << "fatal error: "
+                << xcb_connection_has_error(conn.get()) << std::endl;
+      monmon->quit_from_xcb();
+      return;
+    }
+    if (event->response_type == 0) {
+      auto e = reinterpret_cast<xcb_generic_error_t*>(event.get());
+#ifndef NDEBUG
+      std::cerr << "error: " << xcb_event_get_error_label(e->error_code)
+                << std::endl;
+#endif
+      continue;
+    }
+    switch (XCB_EVENT_RESPONSE_TYPE(event)) {
+    case XCB_EXPOSE: {
+      auto e = reinterpret_cast<xcb_expose_event_t*>(event.get());
+      if (monmon->match(e->window)) {
+        monmon->expose(e->x, e->y, e->width, e->height);
+      }
+      if (e->count != 0) continue;  // Only flush for e->count == 0
+      break;
+    }
+    case XCB_KEY_PRESS: {
+      auto e = reinterpret_cast<xcb_key_press_event_t*>(event.get());
+      auto sym = xcb_key_press_lookup_keysym(syms.get(), e, 0);
+      switch (sym) {
+      case 'Q':
+      case 'q':
+      case 0xff1b: {  // escape
+        if (monmon->match(e->event)) {
+          monmon->quit_from_xcb();
+          return;
+        }
+        break;
+      }
+      }
+      break;
+    }
+    case XCB_DESTROY_NOTIFY: {
+      auto e = reinterpret_cast<xcb_destroy_notify_event_t*>(event.get());
+      if (monmon->match(e->window)) {
+        monmon->quit_from_xcb();
+        return;
+      }
+      break;
+    }
+    case XCB_CONFIGURE_NOTIFY: {
+      auto e = reinterpret_cast<xcb_configure_notify_event_t*>(event.get());
+      if (monmon->match(e->window)) {
+        monmon->configure(e->x, e->y, e->width, e->height);
+      }
+      break;
+    }
+    case XCB_CLIENT_MESSAGE: {
+      auto e = reinterpret_cast<xcb_client_message_event_t*>(event.get());
+      if (e->format == 32
+          && e->type == wm_protocols
+          && e->data.data32[0] == wm_delete_window) {
+        if (monmon->match(e->window)) {
+          monmon->quit_from_xcb();
+          return;
+        }
+      } else if (e->format == 32 && e->type == quit) {
+        // Do not call quit_from_xcb() here, only reason to end up
+        // here is if main already called quit_from_main()
+        return;
+      }
+      break;
+    }
+    case XCB_MAPPING_NOTIFY: {
+      auto e = reinterpret_cast<xcb_mapping_notify_event_t*>(event.get());
+      xcb_refresh_keyboard_mapping(syms.get(), e);
+      break;
+    }
+    case XCB_REPARENT_NOTIFY: {
+      auto e = reinterpret_cast<xcb_reparent_notify_event_t*>(event.get());
+      if (monmon->match(e->window)) {
+        monmon->update_desktop_window();
+      }
+      break;
+    }
+    case XCB_PROPERTY_NOTIFY: {
+      auto e = reinterpret_cast<xcb_property_notify_event_t*>(event.get());
+      monmon->update_desktop_window(e->window, e->atom);
+      break;
+    }
+    }
+    xcb_flush(conn.get());
+  }
+}
+
+}  // namespace
+
+int main(int argc, char** argv) {
+  std::unique_ptr<Args> args(Args::create());
+  args->add("network", "NETNAME",
+            "monitor NETNAME instead of default ICECREAM");
+  args->add("scheduler", "HOST",
+            "connect to scheduler at HOST instead of broadcasting");
+  args->add("display", "HOST:VS", "connect to X server at [HOST]:[VS]");
+  args->add("no-render", "do not use render extension even if available");
+  args->add("titlebar", "create a normal window instead of the default without"
+            " titlebar (or other WM addons)");
+  args->add("black", "use black background instead of background pixmap");
+  args->add("help", "display this text and exit.");
+  if (!args->run(argc, argv)) {
+    std::cout << "Try `monmon --help` for usage." << std::endl;
+    return EXIT_FAILURE;
+  }
+  if (args->is_set("help")) {
+    std::cout << "Usage: `monmon [OPTIONS...]`\n"
+              << "icecream (icecc) monitor\n"
+              << "\n";
+    args->print_help(std::cout);
+    return EXIT_FAILURE;
+  }
+  int screen_index;
+  x::shared_connection conn(
+      xcb_connect(args->arg("display", nullptr), &screen_index));
+  if (xcb_connection_has_error(conn.get())) {
+    std::cerr << "Unable to connect to X server." << std::endl;
+    return EXIT_FAILURE;
+  }
+  x::prefetch_extensions(conn.get());
+  auto screen = x::get_screen(conn.get(), screen_index);
+  auto format = x::get_best_format(conn.get(), screen,
+                                   !args->is_set("no-render"));
+  if (!format.good()) {
+    std::cerr << "Unable to find a good X visual." << std::endl;
+    return EXIT_FAILURE;
+  }
+  std::shared_ptr<PollLooper> looper(PollLooper::create());
+  std::shared_ptr<x::Atoms> atoms(x::Atoms::create(conn));
+  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);
+  std::shared_ptr<x::Ewmh> ewmh(x::Ewmh::create(conn, screen_index));
+  auto monmon = std::make_shared<MonMon>(looper);
+  monmon->init(conn, screen, format, atoms, ewmh, 400, 400,
+               args->is_set("titlebar"), args->is_set("black"));
+  monmon->connect(args.get());
+  std::thread xcb_thread(xcb_event_loop, conn, atoms, monmon);
+  conn.reset();
+  looper->run();
+  xcb_thread.join();
+  return EXIT_SUCCESS;
+}