From 9f4638f42c7946364722ea975b766ec2d1b30198 Mon Sep 17 00:00:00 2001
From: Michael Carlberg <c@rlberg.se>
Date: Sat, 26 Nov 2016 06:13:20 +0100
Subject: [PATCH] refactor: Cleanup

---
 include/components/bar.hpp     |   2 +
 include/components/types.hpp   |  14 +++++
 include/modules/xbacklight.hpp |   2 +-
 include/modules/xwindow.hpp    |   4 +-
 include/utils/bspwm.hpp        |   3 +-
 include/utils/i3.hpp           |   3 +-
 include/x11/connection.hpp     |  10 +--
 include/x11/draw.hpp           |   5 +-
 include/x11/graphics.hpp       |   3 +-
 include/x11/types.hpp          |  14 ++++-
 include/x11/window.hpp         |   2 +
 include/x11/winspec.hpp        |   4 +-
 include/x11/wm.hpp             |  18 +++---
 include/x11/xutils.hpp         |   5 ++
 src/components/bar.cpp         |  16 +++--
 src/main.cpp                   |   2 +
 src/modules/xbacklight.cpp     |  16 ++---
 src/modules/xwindow.cpp        |  10 +--
 src/utils/bspwm.cpp            |   1 +
 src/utils/i3.cpp               |   1 +
 src/x11/connection.cpp         |   8 ++-
 src/x11/draw.cpp               |   1 +
 src/x11/fonts.cpp              |   1 +
 src/x11/graphics.cpp           |   1 +
 src/x11/randr.cpp              |   1 +
 src/x11/tray.cpp               | 112 ++++++++++++++-------------------
 src/x11/winspec.cpp            |   4 ++
 src/x11/wm.cpp                 |  35 ++++++-----
 src/x11/xembed.cpp             |   1 +
 src/x11/xutils.cpp             |  27 +++++---
 30 files changed, 185 insertions(+), 141 deletions(-)

diff --git a/include/components/bar.hpp b/include/components/bar.hpp
index 0bd49cc2..3b70f1ca 100644
--- a/include/components/bar.hpp
+++ b/include/components/bar.hpp
@@ -59,6 +59,8 @@ class bar : public xpp::event::sink<evt::button_press, evt::expose, evt::propert
   string m_lastinput;
 
   std::mutex m_mutex;
+
+  event_timer m_buttonpress{};
 };
 
 di::injector<unique_ptr<bar>> configure_bar();
diff --git a/include/components/types.hpp b/include/components/types.hpp
index 8b87bbc0..e9e94008 100644
--- a/include/components/types.hpp
+++ b/include/components/types.hpp
@@ -134,4 +134,18 @@ struct action_block {
   }
 };
 
+struct event_timer {
+  xcb_timestamp_t event{0};
+  uint32_t delay_ms{0U};
+
+  bool throttle(xcb_timestamp_t evt) {
+    if (evt > event + delay_ms) {
+      event = evt;
+      return false;
+    } else {
+      return true;
+    }
+  };
+};
+
 POLYBAR_NS_END
diff --git a/include/modules/xbacklight.hpp b/include/modules/xbacklight.hpp
index 42b929cf..07769a36 100644
--- a/include/modules/xbacklight.hpp
+++ b/include/modules/xbacklight.hpp
@@ -49,7 +49,7 @@ namespace modules {
     connection& m_connection;
     monitor_t m_output;
     xcb_window_t m_proxy;
-    xcb_timestamp_t m_timestamp;
+    event_timer m_randrnotify{};
 
     ramp_t m_ramp;
     label_t m_label;
diff --git a/include/modules/xwindow.hpp b/include/modules/xwindow.hpp
index 804b4c91..7c3777f5 100644
--- a/include/modules/xwindow.hpp
+++ b/include/modules/xwindow.hpp
@@ -80,9 +80,9 @@ namespace modules {
     bool build(builder* builder, const string& tag) const;
 
    private:
-    static constexpr auto TAG_LABEL = "<label>";
+    static constexpr const char* TAG_LABEL{"<label>"};
 
-    xcb_ewmh_connection_t m_ewmh;
+    ewmh_connection_t m_ewmh;
     unique_ptr<active_window> m_active;
     label_t m_label;
   };
diff --git a/include/utils/bspwm.hpp b/include/utils/bspwm.hpp
index 3b9f0686..69376420 100644
--- a/include/utils/bspwm.hpp
+++ b/include/utils/bspwm.hpp
@@ -7,12 +7,13 @@
 #include "config.hpp"
 #include "utils/socket.hpp"
 #include "utils/string.hpp"
-#include "x11/connection.hpp"
 #include "x11/randr.hpp"
 #include "x11/window.hpp"
 
 POLYBAR_NS
 
+class connection;
+
 namespace bspwm_util {
   struct payload;
   using connection_t = unique_ptr<socket_util::unix_connection>;
diff --git a/include/utils/i3.hpp b/include/utils/i3.hpp
index b57fb5ef..bd9289ca 100644
--- a/include/utils/i3.hpp
+++ b/include/utils/i3.hpp
@@ -3,11 +3,12 @@
 #include <i3ipc++/ipc.hpp>
 
 #include "common.hpp"
-#include "x11/connection.hpp"
 #include "x11/randr.hpp"
 
 POLYBAR_NS
 
+class connection;
+
 namespace i3_util {
   using connection_t = i3ipc::connection;
 
diff --git a/include/x11/connection.hpp b/include/x11/connection.hpp
index 8bf1c520..1a55167a 100644
--- a/include/x11/connection.hpp
+++ b/include/x11/connection.hpp
@@ -8,21 +8,17 @@
 #include <xpp/xpp.hpp>
 
 #include "common.hpp"
-#include "utils/memory.hpp"
-#include "utils/string.hpp"
-#include "x11/atoms.hpp"
 #include "x11/types.hpp"
-#include "x11/xutils.hpp"
 
 #ifdef ENABLE_DAMAGE_EXT
 #include "x11/damage.hpp"
 #endif
-#ifdef ENABLE_RANDR_EXT
-#include "x11/randr.hpp"
-#endif
 #ifdef ENABLE_RENDER_EXT
 #include "x11/render.hpp"
 #endif
+#ifdef ENABLE_RANDR_EXT
+#include "x11/randr.hpp"
+#endif
 
 POLYBAR_NS
 
diff --git a/include/x11/draw.hpp b/include/x11/draw.hpp
index 9fc97f25..b2bb1311 100644
--- a/include/x11/draw.hpp
+++ b/include/x11/draw.hpp
@@ -1,10 +1,13 @@
 #pragma once
 
+#include <xcb/xcb.h>
+
 #include "common.hpp"
-#include "x11/connection.hpp"
 
 POLYBAR_NS
 
+class connection;
+
 namespace draw_util {
   void fill(connection& conn, xcb_drawable_t d, xcb_gcontext_t g, const xcb_rectangle_t rect);
   void fill(connection& conn, xcb_drawable_t d, xcb_gcontext_t g, int16_t x, int16_t y, uint16_t w, uint16_t h);
diff --git a/include/x11/graphics.hpp b/include/x11/graphics.hpp
index 134b8e84..0899f3fc 100644
--- a/include/x11/graphics.hpp
+++ b/include/x11/graphics.hpp
@@ -3,11 +3,10 @@
 #include <xcb/xcb.h>
 
 #include "common.hpp"
+#include "x11/connection.hpp"
 
 POLYBAR_NS
 
-class connection;
-
 namespace graphics_util {
   struct root_pixmap {
     uint8_t depth{0};
diff --git a/include/x11/types.hpp b/include/x11/types.hpp
index 47945bc8..e427acb1 100644
--- a/include/x11/types.hpp
+++ b/include/x11/types.hpp
@@ -3,13 +3,23 @@
 #include "config.hpp"
 
 // fwd
-#ifdef ENABLE_RANDR_EXT
 namespace xpp {
+#ifdef ENABLE_DAMAGE_EXT
+  namespace damage {
+    class extension;
+  }
+#endif
+#ifdef ENABLE_RANDR_EXT
   namespace randr {
     class extension;
   }
-}
 #endif
+#ifdef ENABLE_RENDER_EXT
+  namespace render {
+    class extension;
+  }
+#endif
+}
 
 #include <xpp/xpp.hpp>
 
diff --git a/include/x11/window.hpp b/include/x11/window.hpp
index b07acc75..71a9aa54 100644
--- a/include/x11/window.hpp
+++ b/include/x11/window.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <xcb/xcb_aux.h>
+
 #include "common.hpp"
 #include "x11/connection.hpp"
 #include "x11/randr.hpp"
diff --git a/include/x11/winspec.hpp b/include/x11/winspec.hpp
index a62829d9..235a8969 100644
--- a/include/x11/winspec.hpp
+++ b/include/x11/winspec.hpp
@@ -1,13 +1,13 @@
 #pragma once
 
+#include <xcb/xcb_aux.h>
+
 #include "common.hpp"
 #include "components/types.hpp"
 #include "x11/connection.hpp"
 
 POLYBAR_NS
 
-using connection_t = connection;
-
 struct cw_size {
   explicit cw_size(uint16_t w, uint16_t h) : w(w), h(h) {}
   explicit cw_size(struct size size) : w(size.w), h(size.h) {}
diff --git a/include/x11/wm.hpp b/include/x11/wm.hpp
index cbaf825a..ed1991b4 100644
--- a/include/x11/wm.hpp
+++ b/include/x11/wm.hpp
@@ -6,18 +6,16 @@
 
 POLYBAR_NS
 
-class connection;
-
 namespace wm_util {
-  void set_wmname(connection& conn, xcb_window_t win, const string& wm_name, const string& wm_class);
-  void set_wmprotocols(connection& conn, xcb_window_t win, vector<xcb_atom_t> flags);
-  void set_windowtype(connection& conn, xcb_window_t win, vector<xcb_atom_t> types);
-  void set_wmstate(connection& conn, xcb_window_t win, vector<xcb_atom_t> states);
-  void set_wmpid(connection& conn, xcb_window_t win, pid_t pid);
-  void set_wmdesktop(connection& conn, xcb_window_t win, uint32_t desktop = -1u);
+  void set_wmname(xcb_connection_t* conn, xcb_window_t win, const string& wm_name, const string& wm_class);
+  void set_wmprotocols(xcb_connection_t* conn, xcb_window_t win, vector<xcb_atom_t> flags);
+  void set_windowtype(xcb_connection_t* conn, xcb_window_t win, vector<xcb_atom_t> types);
+  void set_wmstate(xcb_connection_t* conn, xcb_window_t win, vector<xcb_atom_t> states);
+  void set_wmpid(xcb_connection_t* conn, xcb_window_t win, pid_t pid);
+  void set_wmdesktop(xcb_connection_t* conn, xcb_window_t win, uint32_t desktop = -1u);
 
-  void set_trayorientation(connection& conn, xcb_window_t win, uint32_t orientation);
-  void set_trayvisual(connection& conn, xcb_window_t win, xcb_visualid_t visual);
+  void set_trayorientation(xcb_connection_t* conn, xcb_window_t win, uint32_t orientation);
+  void set_trayvisual(xcb_connection_t* conn, xcb_window_t win, xcb_visualid_t visual);
 }
 
 POLYBAR_NS_END
diff --git a/include/x11/xutils.hpp b/include/x11/xutils.hpp
index 49b7ab86..a3d991ca 100644
--- a/include/x11/xutils.hpp
+++ b/include/x11/xutils.hpp
@@ -4,14 +4,19 @@
 #include <xcb/xcb_util.h>
 
 #include "common.hpp"
+#include "x11/randr.hpp"
 
 POLYBAR_NS
 
 class connection;
+class config;
 
 namespace xutils {
   xcb_connection_t* get_connection();
 
+  uint32_t event_timer_ms(const config& conf, const xcb_button_press_event_t&);
+  uint32_t event_timer_ms(const config& conf, const xcb_randr_notify_event_t&);
+
   void pack_values(uint32_t mask, const uint32_t* src, uint32_t* dest);
   void pack_values(uint32_t mask, const xcb_params_cw_t* src, uint32_t* dest);
   void pack_values(uint32_t mask, const xcb_params_gc_t* src, uint32_t* dest);
diff --git a/src/components/bar.cpp b/src/components/bar.cpp
index 68e05946..e93f4583 100644
--- a/src/components/bar.cpp
+++ b/src/components/bar.cpp
@@ -8,10 +8,14 @@
 #include "utils/color.hpp"
 #include "utils/math.hpp"
 #include "utils/string.hpp"
+#include "x11/atoms.hpp"
+#include "x11/connection.hpp"
+#include "x11/ewmh.hpp"
 #include "x11/fonts.hpp"
 #include "x11/graphics.hpp"
 #include "x11/tray.hpp"
 #include "x11/wm.hpp"
+#include "x11/xutils.hpp"
 
 #if ENABLE_I3
 #include "utils/i3.hpp"
@@ -84,6 +88,8 @@ void bar::bootstrap(bool nodraw) {
 
     m_opts.strut.top = m_conf.get<int>("global/wm", "margin-top", 0);
     m_opts.strut.bottom = m_conf.get<int>("global/wm", "margin-bottom", 0);
+
+    m_buttonpress.delay_ms = xutils::event_timer_ms(m_conf, xcb_button_press_event_t{});
   }
 
   m_log.trace("bar: Load color values");
@@ -554,12 +560,6 @@ void bar::reconfigure_window() {
   xcb_icccm_set_wm_name(m_connection, m_window, XCB_ATOM_STRING, 8, m_opts.wmname.size(), m_opts.wmname.c_str());
   xcb_icccm_set_wm_class(m_connection, m_window, 15, "polybar\0Polybar");
 
-  m_log.trace("bar: Set window WM_NORMAL_HINTS");
-  xcb_size_hints_t hints;
-  xcb_icccm_size_hints_set_position(&hints, true, m_opts.pos.x, m_opts.pos.y);
-  xcb_icccm_size_hints_set_size(&hints, true, m_opts.size.w, m_opts.size.h);
-  xcb_icccm_set_wm_normal_hints(m_connection, m_window, &hints);
-
   m_log.trace("bar: Set window _NET_WM_WINDOW_TYPE");
   wm_util::set_windowtype(m_connection, m_window, {_NET_WM_WINDOW_TYPE_DOCK});
 
@@ -585,6 +585,10 @@ void bar::handle(const evt::button_press& evt) {
 
   std::lock_guard<std::mutex> guard(m_mutex, std::adopt_lock);
 
+  if (m_buttonpress.throttle(evt->time)) {
+    return m_log.trace_x("bar: Ignoring button press (throttled)...");
+  }
+
   m_log.trace_x("bar: Received button press: %i at pos(%i, %i)", evt->detail, evt->event_x, evt->event_y);
 
   const mousebtn button{static_cast<mousebtn>(evt->detail)};
diff --git a/src/main.cpp b/src/main.cpp
index 80fe2acf..3b679730 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -10,6 +10,7 @@
 #include "config.hpp"
 #include "utils/env.hpp"
 #include "utils/inotify.hpp"
+#include "x11/ewmh.hpp"
 #include "x11/xutils.hpp"
 
 using namespace polybar;
@@ -145,6 +146,7 @@ int main(int argc, char** argv) {
   }
 
   logger.trace("Close connection to X server");
+  ewmh_util::dealloc();
   xcb_disconnect(connection);
   close(xfd);
 
diff --git a/src/modules/xbacklight.cpp b/src/modules/xbacklight.cpp
index d0983f63..25efd222 100644
--- a/src/modules/xbacklight.cpp
+++ b/src/modules/xbacklight.cpp
@@ -5,6 +5,7 @@
 #include "utils/math.hpp"
 #include "x11/connection.hpp"
 #include "x11/graphics.hpp"
+#include "x11/xutils.hpp"
 
 #include "modules/meta/base.inl"
 #include "modules/meta/static_module.inl"
@@ -59,6 +60,9 @@ namespace modules {
       throw module_error("Failed to create event proxy");
     }
 
+    // Get the throttle time
+    m_randrnotify.delay_ms = xutils::event_timer_ms(m_conf, xcb_randr_notify_event_t{});
+
     // Connect with the event registry and make sure we get
     // notified when a RandR output property gets modified
     m_connection.attach_sink(this, 1);
@@ -102,15 +106,11 @@ namespace modules {
       return;
     } else if (evt->u.op.atom != m_output->backlight.atom) {
       return;
-    } else if (evt->u.op.timestamp <= m_timestamp) {
-      return;
+    } else if (m_randrnotify.throttle(evt->u.op.timestamp)) {
+      return m_log.trace_x("%s: Ignoring randr notify (throttled)...", name());
+    } else {
+      update();
     }
-
-    // Store the timestamp with a throttle offset (ms)
-    m_timestamp = evt->u.op.timestamp + 50;
-
-    // Fetch the new values
-    update();
   }
 
   /**
diff --git a/src/modules/xwindow.cpp b/src/modules/xwindow.cpp
index 468cacf0..7ebf1bf1 100644
--- a/src/modules/xwindow.cpp
+++ b/src/modules/xwindow.cpp
@@ -20,12 +20,12 @@ namespace modules {
     connection& conn{configure_connection().create<decltype(conn)>()};
 
     // Initialize ewmh atoms
-    if (!ewmh_util::setup(conn, &m_ewmh)) {
+    if ((m_ewmh = ewmh_util::initialize()) == nullptr) {
       throw module_error("Failed to initialize ewmh atoms");
     }
 
     // Check if the WM supports _NET_ACTIVE_WINDOW
-    if (!ewmh_util::supports(&m_ewmh, _NET_ACTIVE_WINDOW)) {
+    if (!ewmh_util::supports(m_ewmh.get(), _NET_ACTIVE_WINDOW)) {
       throw module_error("The WM does not list _NET_ACTIVE_WINDOW as a supported hint");
     }
 
@@ -81,14 +81,14 @@ namespace modules {
    * Update the currently active window and query its title
    */
   void xwindow_module::update() {
-    xcb_window_t win{ewmh_util::get_active_window(&m_ewmh)};
+    xcb_window_t win{ewmh_util::get_active_window(m_ewmh.get())};
     string title;
 
     if (m_active && m_active->match(win)) {
-      title = m_active->title(&m_ewmh);
+      title = m_active->title(m_ewmh.get());
     } else if (win != XCB_NONE) {
       m_active = make_unique<active_window>(win);
-      title = m_active->title(&m_ewmh);
+      title = m_active->title(m_ewmh.get());
     } else {
       m_active.reset();
     }
diff --git a/src/utils/bspwm.cpp b/src/utils/bspwm.cpp
index e731028d..cc20e9a2 100644
--- a/src/utils/bspwm.cpp
+++ b/src/utils/bspwm.cpp
@@ -3,6 +3,7 @@
 #include "errors.hpp"
 #include "utils/bspwm.hpp"
 #include "utils/env.hpp"
+#include "x11/connection.hpp"
 
 POLYBAR_NS
 
diff --git a/src/utils/i3.cpp b/src/utils/i3.cpp
index ee0baa42..f676c4de 100644
--- a/src/utils/i3.cpp
+++ b/src/utils/i3.cpp
@@ -7,6 +7,7 @@
 #include "utils/i3.hpp"
 #include "utils/socket.hpp"
 #include "utils/string.hpp"
+#include "x11/connection.hpp"
 
 POLYBAR_NS
 
diff --git a/src/x11/connection.cpp b/src/x11/connection.cpp
index 6cc7ed88..2c8475bd 100644
--- a/src/x11/connection.cpp
+++ b/src/x11/connection.cpp
@@ -1,8 +1,10 @@
-#include "config.hpp"
-
+#include "x11/connection.hpp"
 #include "errors.hpp"
 #include "utils/factory.hpp"
-#include "x11/connection.hpp"
+#include "utils/memory.hpp"
+#include "utils/string.hpp"
+#include "x11/atoms.hpp"
+#include "x11/xutils.hpp"
 
 POLYBAR_NS
 
diff --git a/src/x11/draw.cpp b/src/x11/draw.cpp
index 45b88a63..1f20f50e 100644
--- a/src/x11/draw.cpp
+++ b/src/x11/draw.cpp
@@ -2,6 +2,7 @@
 
 #include "utils/string.hpp"
 #include "x11/color.hpp"
+#include "x11/connection.hpp"
 #include "x11/draw.hpp"
 
 POLYBAR_NS
diff --git a/src/x11/fonts.cpp b/src/x11/fonts.cpp
index 1626d63a..a65ad0f9 100644
--- a/src/x11/fonts.cpp
+++ b/src/x11/fonts.cpp
@@ -5,6 +5,7 @@
 #include "x11/connection.hpp"
 #include "x11/fonts.hpp"
 #include "x11/xlib.hpp"
+#include "x11/xutils.hpp"
 
 POLYBAR_NS
 
diff --git a/src/x11/graphics.cpp b/src/x11/graphics.cpp
index fae4209c..50b1752d 100644
--- a/src/x11/graphics.cpp
+++ b/src/x11/graphics.cpp
@@ -6,6 +6,7 @@
 #include "x11/atoms.hpp"
 #include "x11/connection.hpp"
 #include "x11/graphics.hpp"
+#include "x11/xutils.hpp"
 
 POLYBAR_NS
 
diff --git a/src/x11/randr.cpp b/src/x11/randr.cpp
index eeb25210..90c3e7b7 100644
--- a/src/x11/randr.cpp
+++ b/src/x11/randr.cpp
@@ -1,6 +1,7 @@
 #include <utility>
 
 #include "utils/string.hpp"
+#include "x11/atoms.hpp"
 #include "x11/connection.hpp"
 #include "x11/randr.hpp"
 
diff --git a/src/x11/tray.cpp b/src/x11/tray.cpp
index f3d8bac7..f9758e09 100644
--- a/src/x11/tray.cpp
+++ b/src/x11/tray.cpp
@@ -9,15 +9,18 @@
 #include "utils/factory.hpp"
 #include "utils/memory.hpp"
 #include "utils/process.hpp"
+#include "x11/atoms.hpp"
 #include "x11/color.hpp"
 #include "x11/connection.hpp"
 #include "x11/draw.hpp"
+#include "x11/ewmh.hpp"
 #include "x11/graphics.hpp"
 #include "x11/tray.hpp"
 #include "x11/window.hpp"
 #include "x11/winspec.hpp"
 #include "x11/wm.hpp"
 #include "x11/xembed.hpp"
+#include "x11/xutils.hpp"
 
 POLYBAR_NS
 
@@ -550,12 +553,7 @@ void tray_manager::create_bg(bool realloc) {  // {{{
   }
 
   try {
-    uint32_t mask = 0;
-    uint32_t values[16];
-    xcb_params_cw_t params;
-    XCB_AUX_ADD_PARAM(&mask, &params, back_pixmap, m_pixmap);
-    xutils::pack_values(mask, &params, values);
-    m_connection.change_window_attributes_checked(m_tray, mask, values);
+    m_connection.change_window_attributes_checked(m_tray, XCB_CW_BACK_PIXMAP, &m_pixmap);
   } catch (const exception& err) {
     m_log.err("Failed to set tray window back pixmap (%s)", err.what());
   }
@@ -596,23 +594,13 @@ void tray_manager::set_wmhints() {  // {{{
   xcb_icccm_set_wm_class(m_connection, m_tray, 12, TRAY_WM_CLASS);
 
   m_log.trace("tray: Set window WM_PROTOCOLS");
-  vector<xcb_atom_t> wm_flags;
-  wm_flags.emplace_back(WM_DELETE_WINDOW);
-  wm_flags.emplace_back(WM_TAKE_FOCUS);
-  wm_util::set_wmprotocols(m_connection, m_tray, wm_flags);
+  wm_util::set_wmprotocols(m_connection, m_tray, {WM_DELETE_WINDOW, WM_TAKE_FOCUS});
 
   m_log.trace("tray: Set window _NET_WM_WINDOW_TYPE");
-  vector<xcb_atom_t> types;
-  types.emplace_back(_NET_WM_WINDOW_TYPE_DOCK);
-  types.emplace_back(_NET_WM_WINDOW_TYPE_NORMAL);
-  wm_util::set_wmprotocols(m_connection, m_tray, types);
-  wm_util::set_windowtype(m_connection, m_tray, types);
+  wm_util::set_windowtype(m_connection, m_tray, {_NET_WM_WINDOW_TYPE_DOCK, _NET_WM_WINDOW_TYPE_NORMAL});
 
   m_log.trace("tray: Set window _NET_WM_STATE");
-  vector<xcb_atom_t> states;
-  states.emplace_back(_NET_WM_STATE_SKIP_TASKBAR);
-  m_connection.change_property(
-      XCB_PROP_MODE_REPLACE, m_tray, _NET_WM_STATE, XCB_ATOM_ATOM, 32, states.size(), states.data());
+  wm_util::set_wmstate(m_connection, m_tray, {_NET_WM_STATE_SKIP_TASKBAR});
 
   m_log.trace("tray: Set window _NET_WM_PID");
   wm_util::set_wmpid(m_connection, m_tray, getpid());
@@ -691,7 +679,7 @@ void tray_manager::notify_clients_delayed(chrono::duration<double, std::milli> d
   }
 
   m_delaythread = thread([&] {
-    std::this_thread::sleep_for(delay);
+    this_thread::sleep_for(delay);
     notify_clients();
   });
 
@@ -702,12 +690,12 @@ void tray_manager::notify_clients_delayed(chrono::duration<double, std::milli> d
  * If it gets destroyed or goes away we can reactivate the tray_manager
  */
 void tray_manager::track_selection_owner(xcb_window_t owner) {  // {{{
-  if (!owner) {
-    return;
+  if (owner) {
+    m_log.trace("tray: Listen for events on the new selection window");
+    const uint32_t mask{XCB_CW_EVENT_MASK};
+    const uint32_t values[]{XCB_EVENT_MASK_STRUCTURE_NOTIFY};
+    m_connection.change_window_attributes(owner, mask, values);
   }
-  m_log.trace("tray: Listen for events on the new selection window");
-  const uint32_t value_list[1]{XCB_EVENT_MASK_STRUCTURE_NOTIFY};
-  m_connection.change_window_attributes(owner, XCB_CW_EVENT_MASK, value_list);
 }  // }}}
 
 /**
@@ -740,13 +728,11 @@ void tray_manager::process_docking_request(xcb_window_t win) {  // {{{
   try {
     m_log.trace("tray: Update client window");
     {
-      uint32_t mask = 0;
-      uint32_t values[16];
-      xcb_params_cw_t params;
-      XCB_AUX_ADD_PARAM(&mask, &params, event_mask, XCB_EVENT_MASK_PROPERTY_CHANGE | XCB_EVENT_MASK_STRUCTURE_NOTIFY);
-      XCB_AUX_ADD_PARAM(&mask, &params, back_pixmap, XCB_BACK_PIXMAP_PARENT_RELATIVE);
-      xutils::pack_values(mask, &params, values);
+      // clang-format off
+      const uint32_t mask{XCB_CW_BACK_PIXMAP | XCB_CW_EVENT_MASK};
+      const uint32_t values[]{XCB_BACK_PIXMAP_PARENT_RELATIVE, XCB_EVENT_MASK_PROPERTY_CHANGE | XCB_EVENT_MASK_STRUCTURE_NOTIFY};
       m_connection.change_window_attributes_checked(client->window(), mask, values);
+      // clang-format on
     }
 
     m_log.trace("tray: Configure client size");
@@ -802,11 +788,13 @@ void tray_manager::bar_visibility_change(bool state) {  // {{{
  */
 int16_t tray_manager::calculate_x(uint16_t width) const {  // {{{
   auto x = m_opts.orig_x;
+
   if (m_opts.align == alignment::RIGHT) {
     x -= ((m_opts.width + m_opts.spacing) * m_clients.size() + m_opts.spacing);
   } else if (m_opts.align == alignment::CENTER) {
     x -= (width / 2) - (m_opts.width / 2);
   }
+
   return x;
 }  // }}}
 
@@ -924,34 +912,21 @@ void tray_manager::handle(const evt::client_message& evt) {  // {{{
     return;
   }
 
-  if (evt->type == _NET_SYSTEM_TRAY_OPCODE && evt->format == 32) {
-    m_log.trace("tray: Received client_message");
-
-    switch (evt->data.data32[1]) {
-      case SYSTEM_TRAY_REQUEST_DOCK:
-        try {
-          process_docking_request(evt->data.data32[2]);
-        } catch (const exception& err) {
-          auto id = m_connection.id(evt->data.data32[2]);
-          m_log.err("Error while processing docking request for %s (%s)", id, err.what());
-        }
-        return;
-
-      case SYSTEM_TRAY_BEGIN_MESSAGE:
-        // process_messages(...);
-        return;
-
-      case SYSTEM_TRAY_CANCEL_MESSAGE:
-        // process_messages(...);
-        return;
-    }
-  } else if (evt->type == WM_PROTOCOLS && evt->data.data32[0] == WM_DELETE_WINDOW) {
+  if (evt->type == WM_PROTOCOLS && evt->data.data32[0] == WM_DELETE_WINDOW) {
     if (evt->window == m_tray) {
       m_log.warn("Received WM_DELETE");
       m_tray = 0;
       deactivate();
     }
   }
+
+  if (evt->type == _NET_SYSTEM_TRAY_OPCODE && evt->format == 32) {
+    m_log.trace("tray: Received client_message");
+
+    if (SYSTEM_TRAY_REQUEST_DOCK == evt->data.data32[1]) {
+      process_docking_request(evt->data.data32[2]);
+    }
+  }
 }  // }}}
 
 /**
@@ -967,6 +942,7 @@ void tray_manager::handle(const evt::configure_request& evt) {  // {{{
   }
 
   auto client = find_client(evt->window);
+
   if (!client) {
     return;
   }
@@ -989,6 +965,7 @@ void tray_manager::handle(const evt::resize_request& evt) {  // {{{
   }
 
   auto client = find_client(evt->window);
+
   if (!client) {
     return;
   }
@@ -1041,8 +1018,9 @@ void tray_manager::handle(const evt::property_notify& evt) {  // {{{
   } else if (evt->atom == ESETROOT_PMAP_ID) {
     reconfigure_bg(true);
     refresh_window();
-  } else if (evt->atom != _XEMBED_INFO) {
+  } else if (evt->atom == _XEMBED_INFO) {
     auto client = find_client(evt->window);
+
     if (!client) {
       return;
     }
@@ -1075,6 +1053,7 @@ void tray_manager::handle(const evt::reparent_notify& evt) {  // {{{
   }
 
   auto client = find_client(evt->window);
+
   if (client && evt->parent != m_tray) {
     m_log.trace("tray: Received reparent_notify for client, remove...");
     remove_client(client);
@@ -1093,6 +1072,7 @@ void tray_manager::handle(const evt::destroy_notify& evt) {  // {{{
     // activate();
   } else if (m_activated) {
     auto client = find_client(evt->window);
+
     if (client) {
       m_log.trace("tray: Received destroy_notify for client, remove...");
       remove_client(client);
@@ -1108,15 +1088,15 @@ void tray_manager::handle(const evt::map_notify& evt) {  // {{{
     return;
   }
 
-  if (evt->window == m_tray && !m_mapped) {
-    if (m_mapped) {
-      return;
+  if (evt->window == m_tray) {
+    if (!m_mapped) {
+      m_log.trace("tray: Received map_notify");
+      m_log.trace("tray: Update container mapped flag");
+      m_mapped = true;
     }
-    m_log.trace("tray: Received map_notify");
-    m_log.trace("tray: Update container mapped flag");
-    m_mapped = true;
   } else {
     auto client = find_client(evt->window);
+
     if (client) {
       m_log.trace("tray: Received map_notify");
       m_log.trace("tray: Set client mapped");
@@ -1139,17 +1119,19 @@ void tray_manager::handle(const evt::unmap_notify& evt) {  // {{{
 
   if (evt->window == m_tray) {
     m_log.trace("tray: Received unmap_notify");
-    if (!m_mapped) {
-      return;
+
+    if (m_mapped) {
+      m_log.trace("tray: Update container mapped flag");
+      m_mapped = false;
     }
-    m_log.trace("tray: Update container mapped flag");
-    m_mapped = false;
-    if (!m_hidden) {
+
+    if (m_mapped && !m_hidden) {
       m_opts.configured_w = 0;
       m_opts.configured_x = 0;
     }
   } else {
     auto client = find_client(evt->window);
+
     if (client) {
       m_log.trace("tray: Received unmap_notify");
       m_log.trace("tray: Set client unmapped");
diff --git a/src/x11/winspec.cpp b/src/x11/winspec.cpp
index 55cb5a69..ba4c3145 100644
--- a/src/x11/winspec.cpp
+++ b/src/x11/winspec.cpp
@@ -1,4 +1,8 @@
+#include <xcb/xcb.h>
+
+#include "x11/connection.hpp"
 #include "x11/winspec.hpp"
+#include "x11/xutils.hpp"
 
 POLYBAR_NS
 
diff --git a/src/x11/wm.cpp b/src/x11/wm.cpp
index 436bca56..98dd57c8 100644
--- a/src/x11/wm.cpp
+++ b/src/x11/wm.cpp
@@ -1,47 +1,48 @@
+#include <unistd.h>
 #include <xcb/xcb_icccm.h>
 
 #include "x11/atoms.hpp"
-#include "x11/connection.hpp"
 #include "x11/wm.hpp"
 
 POLYBAR_NS
 
 namespace wm_util {
-  void set_wmname(connection& conn, xcb_window_t win, const string& wm_name, const string& wm_class) {
+  void set_wmname(xcb_connection_t* conn, xcb_window_t win, const string& wm_name, const string& wm_class) {
     xcb_icccm_set_wm_name(conn, win, XCB_ATOM_STRING, 8, wm_name.length(), wm_name.c_str());
     xcb_icccm_set_wm_class(conn, win, wm_class.length(), wm_class.c_str());
   }
 
-  void set_wmprotocols(connection& conn, xcb_window_t win, vector<xcb_atom_t> flags) {
+  void set_wmprotocols(xcb_connection_t* conn, xcb_window_t win, vector<xcb_atom_t> flags) {
     xcb_icccm_set_wm_protocols(conn, win, WM_PROTOCOLS, flags.size(), flags.data());
   }
 
-  void set_windowtype(connection& conn, xcb_window_t win, vector<xcb_atom_t> types) {
-    conn.change_property(
-        XCB_PROP_MODE_REPLACE, win, _NET_WM_WINDOW_TYPE, XCB_ATOM_ATOM, 32, types.size(), types.data());
+  void set_windowtype(xcb_connection_t* conn, xcb_window_t win, vector<xcb_atom_t> types) {
+    xcb_change_property(
+        conn, XCB_PROP_MODE_REPLACE, win, _NET_WM_WINDOW_TYPE, XCB_ATOM_ATOM, 32, types.size(), types.data());
   }
 
-  void set_wmstate(connection& conn, xcb_window_t win, vector<xcb_atom_t> states) {
-    conn.change_property(XCB_PROP_MODE_REPLACE, win, _NET_WM_STATE, XCB_ATOM_ATOM, 32, states.size(), states.data());
+  void set_wmstate(xcb_connection_t* conn, xcb_window_t win, vector<xcb_atom_t> states) {
+    xcb_change_property(
+        conn, XCB_PROP_MODE_REPLACE, win, _NET_WM_STATE, XCB_ATOM_ATOM, 32, states.size(), states.data());
   }
 
-  void set_wmpid(connection& conn, xcb_window_t win, pid_t pid) {
+  void set_wmpid(xcb_connection_t* conn, xcb_window_t win, pid_t pid) {
     pid = getpid();
-    conn.change_property(XCB_PROP_MODE_REPLACE, win, _NET_WM_PID, XCB_ATOM_CARDINAL, 32, 1, &pid);
+    xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win, _NET_WM_PID, XCB_ATOM_CARDINAL, 32, 1, &pid);
   }
 
-  void set_wmdesktop(connection& conn, xcb_window_t win, uint32_t desktop) {
+  void set_wmdesktop(xcb_connection_t* conn, xcb_window_t win, uint32_t desktop) {
     const uint32_t value_list[1]{desktop};
-    conn.change_property(XCB_PROP_MODE_REPLACE, win, _NET_WM_DESKTOP, XCB_ATOM_CARDINAL, 32, 1, value_list);
+    xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win, _NET_WM_DESKTOP, XCB_ATOM_CARDINAL, 32, 1, value_list);
   }
 
-  void set_trayorientation(connection& conn, xcb_window_t win, uint32_t orientation) {
-    conn.change_property(
-        XCB_PROP_MODE_REPLACE, win, _NET_SYSTEM_TRAY_ORIENTATION, _NET_SYSTEM_TRAY_ORIENTATION, 32, 1, &orientation);
+  void set_trayorientation(xcb_connection_t* conn, xcb_window_t win, uint32_t orientation) {
+    xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win, _NET_SYSTEM_TRAY_ORIENTATION, _NET_SYSTEM_TRAY_ORIENTATION,
+        32, 1, &orientation);
   }
 
-  void set_trayvisual(connection& conn, xcb_window_t win, xcb_visualid_t visual) {
-    conn.change_property(XCB_PROP_MODE_REPLACE, win, _NET_SYSTEM_TRAY_VISUAL, XCB_ATOM_VISUALID, 32, 1, &visual);
+  void set_trayvisual(xcb_connection_t* conn, xcb_window_t win, xcb_visualid_t visual) {
+    xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win, _NET_SYSTEM_TRAY_VISUAL, XCB_ATOM_VISUALID, 32, 1, &visual);
   }
 }
 
diff --git a/src/x11/xembed.cpp b/src/x11/xembed.cpp
index aee68347..6728efdd 100644
--- a/src/x11/xembed.cpp
+++ b/src/x11/xembed.cpp
@@ -1,5 +1,6 @@
 #include "x11/xembed.hpp"
 #include "errors.hpp"
+#include "x11/atoms.hpp"
 
 POLYBAR_NS
 
diff --git a/src/x11/xutils.cpp b/src/x11/xutils.cpp
index 05fe7f75..292c7e3a 100644
--- a/src/x11/xutils.cpp
+++ b/src/x11/xutils.cpp
@@ -1,24 +1,35 @@
-#include "x11/xutils.hpp"
+#include <xcb/xcb.h>
+
+#include "components/config.hpp"
+#include "utils/memory.hpp"
 #include "x11/atoms.hpp"
 #include "x11/connection.hpp"
 #include "x11/xlib.hpp"
+#include "x11/xutils.hpp"
 
 POLYBAR_NS
 
 namespace xutils {
-  xcb_connection_t* g_connection_ptr = nullptr;
+  xcb_connection_t* g_connection_ptr{nullptr};
   xcb_connection_t* get_connection() {
     if (g_connection_ptr == nullptr) {
-      Display* dsp;
-      if ((dsp = xlib::get_display()) == nullptr) {
-        return nullptr;
+      Display* dsp{xlib::get_display()};
+      if (dsp != nullptr) {
+        XSetEventQueueOwner(dsp, XCBOwnsEventQueue);
+        g_connection_ptr = XGetXCBConnection(dsp);
       }
-      XSetEventQueueOwner(dsp, XCBOwnsEventQueue);
-      g_connection_ptr = XGetXCBConnection(dsp);
     }
     return g_connection_ptr;
   }
 
+  uint32_t event_timer_ms(const config& conf, const xcb_button_press_event_t&) {
+    return conf.get<uint32_t>("settings", "x-delay-buttonpress", 25);
+  }
+
+  uint32_t event_timer_ms(const config& conf, const xcb_randr_notify_event_t&) {
+    return conf.get<uint32_t>("settings", "x-delay-randrnotify", 50);
+  }
+
   void pack_values(uint32_t mask, const uint32_t* src, uint32_t* dest) {
     for (; mask; mask >>= 1, src++) {
       if (mask & 1) {
@@ -49,7 +60,7 @@ namespace xutils {
   }
 
   void compton_shadow_exclude(connection& conn, const xcb_window_t& win) {
-    const uint32_t shadow = 0;
+    const uint32_t shadow{0};
     conn.change_property(XCB_PROP_MODE_REPLACE, win, _COMPTON_SHADOW, XCB_ATOM_CARDINAL, 32, 1, &shadow);
   }
 }