wip(refactor): Improve signal and event handling

include/common.hpp

@@ -4,12 +4,8 @@
 #define BOOST_DI_CFG_DIAGNOSTICS_LEVEL 2
 #endif
 
-#include <boost/di.hpp>
-#include <cstring>
-#include <map>
 #include <memory>
 #include <string>
-#include <vector>
 
 #include "config.hpp"
 
@@ -41,7 +37,6 @@
 
 POLYBAR_NS
 
-namespace di = boost::di;
 namespace placeholders = std::placeholders;
 
 using std::string;
@@ -58,7 +53,6 @@ using std::make_unique;
 using std::make_shared;
 using std::make_pair;
 using std::array;
-using std::map;
 using std::vector;
 using std::to_string;
 

include/components/bar.hpp

@@ -2,12 +2,16 @@
 
 #include "common.hpp"
 #include "components/config.hpp"
+#include "components/screen.hpp"
 #include "components/types.hpp"
 #include "errors.hpp"
+#include "events/signal_emitter.hpp"
+#include "events/signal_fwd.hpp"
 #include "utils/concurrency.hpp"
 #include "utils/throttle.hpp"
 #include "x11/connection.hpp"
 #include "x11/events.hpp"
+#include "x11/tray_manager.hpp"
 #include "x11/types.hpp"
 #include "x11/window.hpp"
 
@@ -21,20 +25,16 @@ class renderer;
 
 class bar : public xpp::event::sink<evt::button_press, evt::expose, evt::property_notify> {
  public:
-  explicit bar(connection& conn, const config& config, const logger& logger, unique_ptr<screen> screen, unique_ptr<tray_manager> tray_manager);
-  ~bar();
+  explicit bar(connection& conn, signal_emitter& emitter, const config& config, const logger& logger,
+      unique_ptr<screen> screen, unique_ptr<tray_manager> tray_manager);
 
-  void bootstrap(bool nodraw = false);
-  void bootstrap_tray();
-  void activate_tray();
+  ~bar();
 
   const bar_settings settings() const;
 
   void parse(const string& data, bool force = false);
 
  protected:
-  void setup_monitor();
-  void configure_geom();
   void restack_window();
   void reconfigure_pos();
   void reconfigure_struts();
@@ -47,22 +47,37 @@ class bar : public xpp::event::sink<evt::button_press, evt::expose, evt::propert
 
  private:
   connection& m_connection;
+  signal_emitter& m_sig;
   const config& m_conf;
   const logger& m_log;
   unique_ptr<screen> m_screen;
   unique_ptr<tray_manager> m_tray;
   unique_ptr<renderer> m_renderer;
 
-  xcb_window_t m_window;
   bar_settings m_opts;
 
   string m_lastinput;
 
   std::mutex m_mutex;
 
-  event_timer m_buttonpress{};
+  event_timer m_buttonpress{0L, 5L};
 };
 
-di::injector<unique_ptr<bar>> configure_bar();
+namespace {
+  /**
+   * Configure bar controller
+   */
+  inline unique_ptr<bar> make_bar() {
+    // clang-format off
+    return factory_util::unique<bar>(
+          make_connection(),
+          make_signal_emitter(),
+          make_confreader(),
+          make_logger(),
+          make_screen(),
+          make_tray_manager());
+    // clang-format on
+  }
+}
 
 POLYBAR_NS_END

include/components/builder.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <map>
+
 #include "common.hpp"
 #include "components/config.hpp"
 #include "components/types.hpp"
@@ -7,6 +9,8 @@
 
 POLYBAR_NS
 
+using std::map;
+
 #define DEFAULT_SPACING -1
 
 #ifndef BUILDER_SPACE_TOKEN
@@ -28,7 +32,7 @@ class builder {
   explicit builder(const bar_settings bar) : m_bar(bar) {}
 
   string flush();
-  void append(string text);
+  void append(const string& text);
   void node(string str, bool add_space = false);
   void node(string str, int font_index, bool add_space = false);
   void node(const label_t& label, bool add_space = false);

include/components/command_line.hpp

@@ -1,7 +1,10 @@
 #pragma once
 
+#include <map>
+
 #include "common.hpp"
 #include "errors.hpp"
+#include "utils/factory.hpp"
 
 POLYBAR_NS
 
@@ -12,7 +15,7 @@ namespace command_line {
   class option;
   using choices = vector<string>;
   using options = vector<option>;
-  using values = map<string, string>;
+  using values = std::map<string, string>;
 
   // class definition : option {{{
 
@@ -69,13 +72,8 @@ namespace {
   /**
    * Configure injection module
    */
-  template <class T = cliparser>
-  di::injector<T> configure_cliparser(string scriptname, const clioptions& opts) {
-    // clang-format off
-    return di::make_injector(
-        di::bind<>().to("Usage: " + scriptname + " bar_name [OPTION...]"),
-        di::bind<>().to(opts));
-    // clang-format on
+  inline unique_ptr<cliparser> make_command_line(string scriptname, const clioptions& opts) {
+    return factory_util::unique<cliparser>("Usage: " + scriptname + " bar_name [OPTION...]", opts);
   }
 }
 

include/components/config.hpp

@@ -268,9 +268,9 @@ namespace {
   /**
    * Configure injection module
    */
-  template <typename T = const config&>
-  di::injector<T> configure_config() {
-    return di::make_injector(configure_logger(), configure_xresource_manager());
+  inline const config& make_confreader() {
+    shared_ptr<config> instance = factory_util::singleton<config>(make_logger(), make_xresource_manager());
+    return static_cast<config&>(*instance);
   }
 }
 

include/components/controller.hpp

@@ -3,11 +3,16 @@
 #include <csignal>
 
 #include "common.hpp"
+#include "components/bar.hpp"
 #include "components/config.hpp"
 #include "components/eventloop.hpp"
 #include "components/ipc.hpp"
 #include "components/logger.hpp"
+#include "components/types.hpp"
 #include "config.hpp"
+#include "events/signal_emitter.hpp"
+#include "events/signal_fwd.hpp"
+#include "events/signal_receiver.hpp"
 #include "utils/command.hpp"
 #include "utils/inotify.hpp"
 #include "x11/connection.hpp"
@@ -18,65 +23,46 @@ POLYBAR_NS
 // fwd decl {{{
 
 class bar;
+struct bar_settings;
 
 // }}}
 
 using watch_t = inotify_util::watch_t;
 
-class controller {
- public:
-  explicit controller(connection& conn, const logger& logger, const config& config, unique_ptr<eventloop> eventloop,
-      unique_ptr<bar> bar, inotify_util::watch_t& confwatch)
-      : m_connection(conn)
-      , m_log(logger)
-      , m_conf(config)
-      , m_eventloop(forward<decltype(eventloop)>(eventloop))
-      , m_bar(forward<decltype(bar)>(bar))
-      , m_confwatch(confwatch) {}
+namespace sig_ev = signals::eventloop;
+namespace sig_ui = signals::ui;
+namespace sig_ipc = signals::ipc;
 
+class controller : public signal_receiver<SIGN_PRIORITY_CONTROLLER, sig_ev::process_update, sig_ev::process_input,
+                       sig_ev::process_quit, sig_ui::button_press, sig_ipc::process_action, sig_ipc::process_command,
+                       sig_ipc::process_hook> {
+ public:
+  explicit controller(connection& conn, signal_emitter& emitter, const logger& logger, const config& config,
+      unique_ptr<eventloop> eventloop, unique_ptr<bar> bar, unique_ptr<ipc> ipc, watch_t confwatch, bool writeback);
   ~controller();
 
-  void bootstrap(bool writeback = false, bool dump_wmname = false);
+  void setup();
   bool run();
 
+  const bar_settings opts() const;
+
  protected:
-  void install_sigmask();
-  void uninstall_sigmask();
-
-  void install_confwatch();
-  void uninstall_confwatch();
-
   void wait_for_signal();
   void wait_for_xevent();
   void wait_for_eventloop();
   void wait_for_configwatch();
 
-  void bootstrap_modules();
-
-  void on_ipc_action(const ipc_action& message);
-  void on_mouse_event(const string& input);
-  void on_unrecognized_action(string input);
-  void on_update(bool force);
-
- private:
-  enum class thread_role {
-    EVENT_QUEUE,
-    EVENT_QUEUE_X,
-    IPC_LISTENER,
-    CONF_LISTENER,
-  };
-
-  bool is_thread_joinable(thread_role&& role) {
-    if (m_threads.find(role) == m_threads.end()) {
-      return false;
-    } else {
-      return m_threads[role].joinable();
-    }
-  }
+  bool on(const sig_ev::process_update& evt);
+  bool on(const sig_ev::process_input& evt);
+  bool on(const sig_ev::process_quit& evt);
+  bool on(const sig_ui::button_press& evt);
+  bool on(const sig_ipc::process_action& evt);
+  bool on(const sig_ipc::process_command& evt);
+  bool on(const sig_ipc::process_hook& evt);
 
  private:
   connection& m_connection;
-  registry m_registry{m_connection};
+  signal_emitter& m_sig;
   const logger& m_log;
   const config& m_conf;
   unique_ptr<eventloop> m_eventloop;
@@ -86,18 +72,37 @@ class controller {
   stateflag m_running{false};
   stateflag m_reload{false};
   stateflag m_waiting{false};
-  stateflag m_trayactivated{false};
 
-  sigset_t m_blockmask;
   sigset_t m_waitmask;
-  map<thread_role, thread> m_threads;
+  vector<thread> m_threads;
 
-  inotify_util::watch_t& m_confwatch;
-  command_util::command_t m_command;
+  watch_t m_confwatch;
+  command_t m_command;
 
   bool m_writeback{false};
 };
 
-di::injector<unique_ptr<controller>> configure_controller(watch_t& confwatch);
+namespace {
+  inline unique_ptr<controller> make_controller(watch_t&& confwatch, bool enableipc = false, bool writeback = false) {
+    unique_ptr<ipc> ipc;
+
+    if (enableipc) {
+      ipc = make_ipc();
+    }
+
+    // clang-format off
+    return factory_util::unique<controller>(
+        make_connection(),
+        make_signal_emitter(),
+        make_logger(),
+        make_confreader(),
+        make_eventloop(),
+        make_bar(),
+        move(ipc),
+        move(confwatch),
+        writeback);
+    // clang-format on
+  }
+}
 
 POLYBAR_NS_END

include/components/eventloop.hpp

@@ -5,104 +5,107 @@
 
 #include "common.hpp"
 #include "components/logger.hpp"
+#include "events/signal_emitter.hpp"
+#include "events/signal_fwd.hpp"
+#include "events/signal_receiver.hpp"
 #include "modules/meta/base.hpp"
 
 POLYBAR_NS
 
+using namespace signals::eventloop;
+
 using module_t = unique_ptr<modules::module_interface>;
 using modulemap_t = map<alignment, vector<module_t>>;
 
-enum class event_type : uint8_t {
-  NONE = 0,
-  UPDATE,
-  CHECK,
-  INPUT,
-  QUIT,
-};
-
-struct event {
-  uint8_t type{0};
-  char data[256]{'\0'};
-};
-
-struct quit_event {
-  const uint8_t type{static_cast<uint8_t>(event_type::QUIT)};
-  bool reload{false};
-};
-
-struct update_event {
-  const uint8_t type{static_cast<uint8_t>(event_type::UPDATE)};
-  bool force{false};
-};
-
-struct input_event {
-  const uint8_t type{static_cast<uint8_t>(event_type::INPUT)};
-  char data[256]{'\0'};
-};
-
-class eventloop {
+class eventloop : public signal_receiver<SIGN_PRIORITY_EVENTLOOP, process_quit, process_input, process_check,
+                      enqueue_event, enqueue_quit, enqueue_update, enqueue_input, enqueue_check> {
  public:
-  /**
-   * Queue type
-   */
-  using entry_t = event;
-  using queue_t = moodycamel::BlockingConcurrentQueue<entry_t>;
+  enum class event_type : uint8_t {
+    NONE = 0,
+    UPDATE,
+    CHECK,
+    INPUT,
+    QUIT,
+  };
+
+  struct event {
+    uint8_t type{static_cast<uint8_t>(event_type::NONE)};
+    bool flag{false};
+  };
+
+  struct input_data {
+    char data[EVENT_SIZE];
+  };
+
+  template <typename EventType>
+  using queue_t = moodycamel::BlockingConcurrentQueue<EventType>;
   using duration_t = chrono::duration<double, std::milli>;
 
-  explicit eventloop(const logger& logger, const config& config);
+ public:
+  explicit eventloop(signal_emitter& emitter, const logger& logger, const config& config);
   ~eventloop();
 
   void start();
-  void wait();
   void stop();
 
-  bool enqueue(const entry_t& entry);
-  bool enqueue_delayed(const entry_t& entry);
-
-  void set_update_cb(callback<bool>&& cb);
-  void set_input_db(callback<string>&& cb);
+  bool enqueue(event&& evt);
+  bool enqueue(input_data&& evt);
 
   void add_module(const alignment pos, module_t&& module);
   const modulemap_t& modules() const;
   size_t module_count() const;
 
-  static const eventloop::entry_t& make(update_event&& event, bool force = false) {
-    event.force = force;
-    return reinterpret_cast<const eventloop::entry_t&>(event);
+  static auto make_quit_evt(bool reload = false) {
+    return event{static_cast<uint8_t>(event_type::QUIT), reload};
   }
-
-  static const eventloop::entry_t& make(quit_event&& event, bool reload = false) {
-    event.reload = reload;
-    return reinterpret_cast<const eventloop::entry_t&>(event);
+  static auto make_update_evt(bool force = false) {
+    return event{static_cast<uint8_t>(event_type::UPDATE), force};
   }
-
-  static const eventloop::entry_t& make(input_event&& event, const string& data) {
-    snprintf(event.data, sizeof(event.data), "%s", data.c_str());
-    return reinterpret_cast<const eventloop::entry_t&>(event);
+  static auto make_input_evt() {
+    return event{static_cast<uint8_t>(event_type::INPUT)};
+  }
+  static auto make_input_data(string&& data) {
+    input_data d{};
+    memcpy(d.data, &data[0], sizeof(d.data));
+    return d;
+  }
+  static auto make_check_evt() {
+    return event{static_cast<uint8_t>(event_type::CHECK)};
   }
 
  protected:
+  void process_inputqueue();
   void dispatch_modules();
-  void dispatch_queue_worker();
-  void dispatch_delayed_worker();
 
-  inline bool match_event(entry_t evt, event_type type);
-  inline bool compare_events(entry_t evt, entry_t evt2);
-  void forward_event(entry_t evt);
+  inline bool compare_events(event evt, event evt2);
+  inline bool compare_events(input_data data, input_data data1);
 
-  void on_update(const update_event& evt);
-  void on_input(const input_event& evt);
-  void on_check();
-  void on_quit(const quit_event& evt);
+  void forward_event(event evt);
+
+  bool on(const process_input& evt);
+  bool on(const process_check& evt);
+  bool on(const process_quit& evt);
+
+  bool on(const enqueue_event& evt);
+  bool on(const enqueue_quit& evt);
+  bool on(const enqueue_update& evt);
+  bool on(const enqueue_input& evt);
+  bool on(const enqueue_check& evt);
 
  private:
+  signal_emitter& m_sig;
   const logger& m_log;
   const config& m_conf;
 
   /**
    * @brief Event queue
    */
-  queue_t m_queue;
+  queue_t<event> m_queue;
+
+  /**
+   * @brief Event queue
+   */
+  queue_t<input_data> m_inputqueue;
 
   /**
    * @brief Loaded modules
@@ -114,16 +117,6 @@ class eventloop {
    */
   stateflag m_running;
 
-  /**
-   * @brief Callback fired when receiving UPDATE events
-   */
-  callback<bool> m_update_cb;
-
-  /**
-   * @brief Callback fired for unprocessed INPUT events
-   */
-  callback<string> m_unrecognized_input_cb;
-
   /**
    * @brief Time to wait for subsequent events
    */
@@ -133,45 +126,11 @@ class eventloop {
    * @brief Maximum amount of subsequent events to swallow within timeframe
    */
   size_t m_swallow_limit{0};
-
-  /**
-   * @brief Time until releasing the lock on the delayed enqueue channel
-   */
-  duration_t m_delayed_time;
-
-  /**
-   * @brief Lock used to control the condition variable
-   */
-  std::mutex m_delayed_lock;
-
-  /**
-   * @brief Condition variable used to manage notifications for delayed enqueues
-   */
-  std::condition_variable m_delayed_cond;
-
-  /**
-   * @brief Pending event on the delayed channel
-   */
-  entry_t m_delayed_entry{0};
-
-  /**
-   * @brief Queue worker thread
-   */
-  thread m_queue_thread;
-
-  /**
-   * @brief Delayed notifier thread
-   */
-  thread m_delayed_thread;
 };
 
 namespace {
-  /**
-   * Configure injection module
-   */
-  template <typename T = unique_ptr<eventloop>>
-  di::injector<T> configure_eventloop() {
-    return di::make_injector(configure_logger(), configure_config());
+  inline unique_ptr<eventloop> make_eventloop() {
+    return make_unique<eventloop>(make_signal_emitter(), make_logger(), make_confreader());
   }
 }
 

include/components/eventloop_fwd.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "common.hpp"
+
+POLYBAR_NS
+
+enum class event_type;
+struct event;
+struct quit_event;
+struct update_event;
+struct input_event;
+
+class eventloop {
+ public:
+  using entry_t = event;
+};
+
+POLYBAR_NS_END

include/components/ipc.hpp

@@ -2,8 +2,10 @@
 
 #include "common.hpp"
 #include "components/logger.hpp"
+#include "events/signal_emitter.hpp"
 #include "utils/concurrency.hpp"
 #include "utils/functional.hpp"
+#include "utils/factory.hpp"
 
 POLYBAR_NS
 
@@ -12,15 +14,15 @@ POLYBAR_NS
  */
 struct ipc_command {
   static constexpr const char* prefix{"cmd:"};
-  string payload;
+  char payload[EVENT_SIZE]{'\0'};
 };
 struct ipc_hook {
   static constexpr const char* prefix{"hook:"};
-  string payload;
+  char payload[EVENT_SIZE]{'\0'};
 };
 struct ipc_action {
   static constexpr const char* prefix{"action:"};
-  string payload;
+  char payload[EVENT_SIZE]{'\0'};
 };
 
 /**
@@ -32,40 +34,28 @@ struct ipc_action {
  */
 class ipc {
  public:
-  explicit ipc(const logger& logger) : m_log(logger) {}
+  explicit ipc(signal_emitter& emitter, const logger& logger) : m_sig(emitter), m_log(logger) {}
   ~ipc();
 
-  void attach_callback(callback<const ipc_command&>&& cb);
-  void attach_callback(callback<const ipc_hook&>&& cb);
-  void attach_callback(callback<const ipc_action&>&& cb);
   void receive_messages();
 
  protected:
   void parse(const string& payload) const;
-  void delegate(const ipc_command& message) const;
-  void delegate(const ipc_hook& message) const;
-  void delegate(const ipc_action& message) const;
 
  private:
+  signal_emitter& m_sig;
   const logger& m_log;
-
-  vector<callback<const ipc_command&>> m_command_callbacks;
-  vector<callback<const ipc_hook&>> m_hook_callbacks;
-  vector<callback<const ipc_action&>> m_action_callbacks;
-
-  stateflag m_running{false};
-
   string m_fifo;
   int m_fd;
+  stateflag m_running{false};
 };
 
 namespace {
   /**
    * Configure injection module
    */
-  template <typename T = unique_ptr<ipc>>
-  di::injector<T> configure_ipc() {
-    return di::make_injector(configure_logger());
+  inline unique_ptr<ipc> make_ipc() {
+    return factory_util::unique<ipc>(make_signal_emitter(), make_logger());
   }
 }
 

include/components/logger.hpp

@@ -1,13 +1,15 @@
 #pragma once
 
 #include <cstdio>
+#include <map>
+#include <string>
 
 #include "common.hpp"
 #include "utils/factory.hpp"
 
 POLYBAR_NS
 
-enum class loglevel {
+enum class loglevel : uint8_t {
   NONE = 0,
   ERROR,
   WARNING,
@@ -25,34 +27,26 @@ class logger {
   void verbosity(loglevel level);
   void verbosity(string level);
 
-  /**
-   * Output a trace message
-   */
+#ifdef DEBUG_LOGGER  // {{{
   template <typename... Args>
-#ifdef DEBUG_LOGGER
   void trace(string message, Args... args) const {
     output(loglevel::TRACE, message, args...);
   }
-#else
 #ifdef VERBOSE_TRACELOG
-#undef VERBOSE_TRACELOG
-#endif
-  void trace(string, Args...) const {
-  }
-#endif
-
-  /**
-   * Output extra verbose trace message
-   */
   template <typename... Args>
-#ifdef VERBOSE_TRACELOG
   void trace_x(string message, Args... args) const {
     output(loglevel::TRACE, message, args...);
   }
 #else
-  void trace_x(string, Args...) const {
-  }
+  template <typename... Args>
+  void trace_x(Args...) const {}
 #endif
+#else
+  template <typename... Args>
+  void trace(Args...) const {}
+  template <typename... Args>
+  void trace_x(Args...) const {}
+#endif  // }}}
 
   /**
    * Output an info message
@@ -97,70 +91,56 @@ class logger {
    */
   template <typename... Args>
   void output(loglevel level, string format, Args... values) const {
-    if (level > m_level)
+    if (level > m_level) {
       return;
+    }
 
-    auto prefix = m_prefixes.find(level)->second;
-    auto suffix = m_suffixes.find(level)->second;
-
-// silence the compiler
-#if defined(__clang__)
+#if defined(__clang__)  // {{{
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wformat-security"
 #elif defined(__GNUC__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wformat-security"
-#endif
-    dprintf(m_fd, (prefix + format + suffix + "\n").c_str(), convert(values)...);
-#if defined(__clang__)
+#endif  // }}}
+
+    dprintf(m_fd, (m_prefixes.at(level) + format + m_suffixes.at(level) + "\n").c_str(), convert(values)...);
+
+#if defined(__clang__)  // {{{
 #pragma clang diagnostic pop
 #elif defined(__GNUC__)
 #pragma GCC diagnostic pop
-#endif
+#endif  // }}}
   }
 
  private:
   /**
    * Logger verbosity level
    */
-  loglevel m_level = loglevel::TRACE;
+  loglevel m_level{loglevel::TRACE};
 
   /**
    * File descriptor used when writing the log messages
    */
-  int m_fd = STDERR_FILENO;
+  int m_fd{STDERR_FILENO};
 
   /**
    * Loglevel specific prefixes
    */
-  // clang-format off
-  map<loglevel, string> m_prefixes {
-    {loglevel::TRACE,   "polybar|trace  "},
-    {loglevel::INFO,    "polybar|info   "},
-    {loglevel::WARNING, "polybar|warn   "},
-    {loglevel::ERROR,   "polybar|error  "},
-  };
+  std::map<loglevel, string> m_prefixes;
 
   /**
    * Loglevel specific suffixes
    */
-  map<loglevel, string> m_suffixes {
-    {loglevel::TRACE,   ""},
-    {loglevel::INFO,    ""},
-    {loglevel::WARNING, ""},
-    {loglevel::ERROR,   ""},
-  };
-  // clang-format on
+  std::map<loglevel, string> m_suffixes;
 };
 
+/**
+ * Configure injection module
+ */
 namespace {
-  /**
-   * Configure injection module
-   */
-  template <typename T = const logger&>
-  di::injector<T> configure_logger(loglevel level = loglevel::NONE) {
-    auto instance = factory_util::generic_singleton<logger>(level);
-    return di::make_injector(di::bind<>().to(instance));
+  inline const logger& make_logger(loglevel level = loglevel::NONE) {
+    auto instance = factory_util::singleton<const logger>(level);
+    return static_cast<const logger&>(*instance);
   }
 }
 

include/components/parser.hpp

@@ -5,6 +5,7 @@
 
 POLYBAR_NS
 
+class signal_emitter;
 class logger;
 struct bar_settings;
 enum class attribute : uint8_t;
@@ -17,7 +18,7 @@ DEFINE_CHILD_ERROR(unclosed_actionblocks, parser_error);
 
 class parser {
  public:
-  explicit parser(const logger& logger, const bar_settings& bar);
+  explicit parser(signal_emitter& emitter, const logger& logger, const bar_settings& bar);
   void operator()(string data);
   void codeblock(string data);
   size_t text(string data);
@@ -30,6 +31,7 @@ class parser {
   string parse_action_cmd(const string& data);
 
  private:
+  signal_emitter& m_sig;
   const logger& m_log;
   const bar_settings& m_bar;
   vector<int> m_actions;

include/components/renderer.hpp

@@ -1,7 +1,13 @@
 #pragma once
 
 #include "common.hpp"
+#include "components/logger.hpp"
 #include "components/types.hpp"
+#include "events/signal_emitter.hpp"
+#include "events/signal_fwd.hpp"
+#include "events/signal_receiver.hpp"
+#include "x11/connection.hpp"
+#include "x11/fonts.hpp"
 #include "x11/types.hpp"
 
 POLYBAR_NS
@@ -10,12 +16,17 @@ class connection;
 class font_manager;
 class logger;
 
-class renderer {
+using namespace signals::parser;
+
+class renderer
+    : public signal_receiver<SIGN_PRIORITY_RENDERER, change_background, change_foreground, change_underline,
+          change_overline, change_font, change_alignment, offset_pixel, attribute_set, attribute_unset,
+          attribute_toggle, action_begin, action_end, write_text_ascii, write_text_unicode, write_text_string> {
  public:
   enum class gc : uint8_t { BG, FG, OL, UL, BT, BB, BL, BR };
 
-  explicit renderer(connection& conn, const logger& logger, unique_ptr<font_manager> font_manager,
-      const bar_settings& bar, const vector<string>& fonts);
+  explicit renderer(connection& conn, signal_emitter& emitter, const logger& logger,
+      unique_ptr<font_manager> font_manager, const bar_settings& bar, const vector<string>& fonts);
   ~renderer();
 
   xcb_window_t window() const;
@@ -52,6 +63,22 @@ class renderer {
   int16_t shift_content(int16_t x, const int16_t shift_x);
   int16_t shift_content(const int16_t shift_x);
 
+  bool on(const change_background& evt);
+  bool on(const change_foreground& evt);
+  bool on(const change_underline& evt);
+  bool on(const change_overline& evt);
+  bool on(const change_font& evt);
+  bool on(const change_alignment& evt);
+  bool on(const offset_pixel& evt);
+  bool on(const attribute_set& evt);
+  bool on(const attribute_unset& evt);
+  bool on(const attribute_toggle& evt);
+  bool on(const action_begin& evt);
+  bool on(const action_end& evt);
+  bool on(const write_text_ascii& evt);
+  bool on(const write_text_unicode& evt);
+  bool on(const write_text_string& evt);
+
 #ifdef DEBUG_HINTS
   vector<xcb_window_t> m_debughints;
   void debug_hints();
@@ -65,13 +92,13 @@ class renderer {
 
  private:
   connection& m_connection;
+  signal_emitter& m_sig;
   const logger& m_log;
   unique_ptr<font_manager> m_fontmanager;
 
   const bar_settings& m_bar;
 
   xcb_rectangle_t m_rect{0, 0, 0U, 0U};
-
   xcb_rectangle_t m_cleared{0, 0, 0U, 0U};
   reserve_area m_cleararea{};
 
@@ -95,6 +122,21 @@ class renderer {
   xcb_font_t m_gcfont{XCB_NONE};
 };
 
-di::injector<unique_ptr<renderer>> configure_renderer(const bar_settings& bar, const vector<string>& fonts);
+namespace {
+  /**
+   * Configure injection module
+   */
+  inline unique_ptr<renderer> make_renderer(const bar_settings& bar, const vector<string>& fonts) {
+    // clang-format off
+    return factory_util::unique<renderer>(
+          make_connection(),
+          make_signal_emitter(),
+          make_logger(),
+          make_font_manager(),
+          bar,
+          fonts);
+    // clang-format on
+  }
+}
 
 POLYBAR_NS_END

include/components/screen.hpp

@@ -1,7 +1,10 @@
 #pragma once
 
 #include "common.hpp"
+#include "components/config.hpp"
+#include "components/logger.hpp"
 #include "components/types.hpp"
+#include "events/signal_emitter.hpp"
 #include "x11/events.hpp"
 #include "x11/window.hpp"
 
@@ -11,10 +14,11 @@ POLYBAR_NS
 class config;
 class logger;
 class connection;
+class signal_emitter;
 
 class screen : public xpp::event::sink<evt::randr_screen_change_notify> {
  public:
-  explicit screen(connection& conn, const logger& logger, const config& conf);
+  explicit screen(connection& conn, signal_emitter& emitter, const logger& logger, const config& conf);
   ~screen();
 
   struct size size() const {
@@ -30,6 +34,7 @@ class screen : public xpp::event::sink<evt::randr_screen_change_notify> {
 
  private:
   connection& m_connection;
+  signal_emitter& m_sig;
   const logger& m_log;
   const config& m_conf;
 
@@ -37,10 +42,20 @@ class screen : public xpp::event::sink<evt::randr_screen_change_notify> {
   xcb_window_t m_proxy{XCB_NONE};
 
   vector<monitor_t> m_monitors;
-  struct size m_size{0U, 0U};
+  struct size m_size {
+    0U, 0U
+  };
   bool m_sigraised{false};
 };
 
-di::injector<unique_ptr<screen>> configure_screen();
+namespace {
+  /**
+   * Configure injection module
+   */
+  inline unique_ptr<screen> make_screen() {
+    return factory_util::unique<screen>(
+        make_connection(), make_signal_emitter(), make_logger(), make_confreader());
+  }
+}
 
 POLYBAR_NS_END

include/components/signals.hpp

@@ -1,68 +0,0 @@
-#pragma once
-
-#include "common.hpp"
-
-#include "components/eventloop.hpp"
-#include "utils/functional.hpp"
-
-POLYBAR_NS
-
-// fwd decl {{{
-
-enum class mousebtn : uint8_t;
-enum class syntaxtag : uint8_t;
-enum class alignment : uint8_t;
-enum class attribute : uint8_t;
-
-// }}}
-
-/**
- * @TODO: Allow multiple signal handlers
- * @TODO: Encapsulate signals
- */
-namespace g_signals {
-  /**
-   * Helper used to create no-op "callbacks"
-   */
-  template <typename... T>
-  static callback<T...> noop = [](T...) {};
-
-  /**
-   * Signals used to communicate with the event loop
-   */
-  namespace event {
-    extern callback<const eventloop::entry_t&> enqueue;
-    extern callback<const eventloop::entry_t&> enqueue_delayed;
-  }
-
-  /**
-   * Signals used to communicate with the bar window
-   */
-  namespace bar {
-    extern callback<string> action_click;
-    extern callback<const bool> visibility_change;
-  }
-
-  /**
-   * Signals used to communicate with the input parser
-   */
-  namespace parser {
-    extern callback<const uint32_t> background_change;
-    extern callback<const uint32_t> foreground_change;
-    extern callback<const uint32_t> underline_change;
-    extern callback<const uint32_t> overline_change;
-    extern callback<const alignment> alignment_change;
-    extern callback<const attribute> attribute_set;
-    extern callback<const attribute> attribute_unset;
-    extern callback<const attribute> attribute_toggle;
-    extern callback<const int8_t> font_change;
-    extern callback<const int16_t> pixel_offset;
-    extern callback<const mousebtn, const string> action_block_open;
-    extern callback<const mousebtn> action_block_close;
-    extern callback<const uint16_t> ascii_text_write;
-    extern callback<const uint16_t> unicode_text_write;
-    extern callback<const char*, const size_t> string_write;
-  }
-}
-
-POLYBAR_NS_END

include/components/types.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <string>
+
 #include "common.hpp"
 #include "x11/color.hpp"
 #include "x11/randr.hpp"
@@ -80,8 +82,8 @@ struct action {
 
 struct action_block : public action {
   alignment align{alignment::NONE};
-  double start_x{0.0};
-  double end_x{0.0};
+  volatile double start_x{0.0};
+  volatile double end_x{0.0};
   bool active{true};
 
   uint16_t width() const {
@@ -90,6 +92,11 @@ struct action_block : public action {
 };
 
 struct bar_settings {
+  explicit bar_settings() = default;
+  bar_settings(const bar_settings& other) = default;
+
+  xcb_window_t window;
+
   monitor_t monitor;
   edge origin{edge::TOP};
   struct size size {
@@ -109,7 +116,7 @@ struct bar_settings {
   line_settings underline;
   line_settings overline;
 
-  map<edge, border_settings> borders;
+  std::unordered_map<edge, border_settings> borders;
 
   uint8_t spacing{1U};
   string separator;
@@ -128,13 +135,20 @@ struct bar_settings {
       rect.x = pos.x;
       rect.y = pos.y;
     }
-
-    rect.y += borders.at(edge::TOP).size;
-    rect.height -= borders.at(edge::TOP).size;
-    rect.height -= borders.at(edge::BOTTOM).size;
-    rect.x += borders.at(edge::LEFT).size;
-    rect.width -= borders.at(edge::LEFT).size;
-    rect.width -= borders.at(edge::RIGHT).size;
+    if (borders.find(edge::TOP) != borders.end()) {
+      rect.y += borders.at(edge::TOP).size;
+      rect.height -= borders.at(edge::TOP).size;
+    }
+    if (borders.find(edge::BOTTOM) != borders.end()) {
+      rect.height -= borders.at(edge::BOTTOM).size;
+    }
+    if (borders.find(edge::LEFT) != borders.end()) {
+      rect.x += borders.at(edge::LEFT).size;
+      rect.width -= borders.at(edge::LEFT).size;
+    }
+    if (borders.find(edge::RIGHT) != borders.end()) {
+      rect.width -= borders.at(edge::RIGHT).size;
+    }
     return rect;
   }
 };

include/config.hpp.cmake

@@ -29,6 +29,15 @@
 #cmakedefine VERBOSE_TRACELOG
 #cmakedefine DEBUG_HINTS
 
+static const size_t EVENT_SIZE{64U};
+
+static const int SIGN_PRIORITY_EVENTLOOP{1};
+static const int SIGN_PRIORITY_CONTROLLER{2};
+static const int SIGN_PRIORITY_SCREEN{3};
+static const int SIGN_PRIORITY_BAR{4};
+static const int SIGN_PRIORITY_RENDERER{5};
+static const int SIGN_PRIORITY_TRAY{6};
+
 static const int SINK_PRIORITY_BAR{1};
 static const int SINK_PRIORITY_SCREEN{2};
 static const int SINK_PRIORITY_TRAY{3};

include/drawtypes/iconset.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <map>
+
 #include "common.hpp"
 #include "drawtypes/label.hpp"
 #include "utils/mixins.hpp"
@@ -15,7 +17,7 @@ namespace drawtypes {
     operator bool();
 
    protected:
-    map<string, icon_t> m_icons;
+    std::map<string, icon_t> m_icons;
   };
 
   using iconset_t = shared_ptr<iconset>;

include/errors.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <cerrno>
+#include <cstring>
 
 #include "common.hpp"
 

include/events/signal.hpp

@@ -0,0 +1,135 @@
+#pragma once
+
+#include "common.hpp"
+
+#include "components/eventloop.hpp"
+#include "components/ipc.hpp"
+#include "components/types.hpp"
+#include "utils/functional.hpp"
+
+POLYBAR_NS
+
+// fwd decl {{{
+
+enum class mousebtn : uint8_t;
+enum class syntaxtag : uint8_t;
+enum class alignment : uint8_t;
+enum class attribute : uint8_t;
+
+// }}}
+
+#define DEFINE_SIGNAL(id, name)                        \
+  struct name : public detail::base_signal<name, id> { \
+    using base_type::base_type;                        \
+  }
+
+#define DEFINE_VALUE_SIGNAL(id, name, type)                   \
+  struct name : public detail::value_signal<name, id, type> { \
+    using base_type::base_type;                               \
+  }
+
+namespace signals {
+  namespace detail {
+    // definition : signal {{{
+
+    class signal {
+     public:
+      explicit signal() = default;
+      virtual ~signal() {}
+      virtual size_t size() const = 0;
+    };
+
+    // }}}
+    // definition : base_signal {{{
+
+    template <typename Derived, uint8_t Id>
+    class base_signal : public signal {
+     public:
+      using base_type = base_signal<Derived, Id>;
+
+      explicit base_signal() = default;
+
+      virtual ~base_signal() {}
+
+      static uint8_t id() {
+        return Id;
+      }
+
+      virtual size_t size() const override {
+        return sizeof(Derived);
+      };
+    };
+
+    // }}}
+    // definition : value_signal {{{
+
+    template <typename Derived, uint8_t Id, typename ValueType>
+    class value_signal : public base_signal<Derived, Id> {
+     public:
+      using base_type = value_signal<Derived, Id, ValueType>;
+      using value_type = ValueType;
+
+      explicit value_signal() {}
+      explicit value_signal(ValueType&& data) {
+        memcpy(m_data, &data, sizeof(data));
+      }
+
+      virtual ~value_signal() {}
+
+      const ValueType* operator()() const {
+        return reinterpret_cast<const ValueType*>(&m_data);
+      }
+
+     private:
+      char m_data[sizeof(ValueType)];
+    };
+
+    // }}}
+  }
+
+  namespace eventloop {
+    using eventloop_t = polybar::eventloop;
+
+    DEFINE_VALUE_SIGNAL(1, process_quit, eventloop_t::event);
+    DEFINE_VALUE_SIGNAL(2, process_update, eventloop_t::event);
+    DEFINE_VALUE_SIGNAL(3, process_input, eventloop_t::input_data);
+    DEFINE_VALUE_SIGNAL(4, process_check, eventloop_t::event);
+
+    DEFINE_VALUE_SIGNAL(5, enqueue_event, eventloop_t::event);
+    DEFINE_VALUE_SIGNAL(6, enqueue_quit, eventloop_t::event);
+    DEFINE_VALUE_SIGNAL(7, enqueue_update, eventloop_t::event);
+    DEFINE_VALUE_SIGNAL(8, enqueue_input, eventloop_t::input_data);
+    DEFINE_VALUE_SIGNAL(9, enqueue_check, eventloop_t::event);
+  }
+
+  namespace ipc {
+    DEFINE_VALUE_SIGNAL(20, process_command, ipc_command);
+    DEFINE_VALUE_SIGNAL(21, process_hook, ipc_hook);
+    DEFINE_VALUE_SIGNAL(22, process_action, ipc_action);
+  }
+
+  namespace ui {
+    DEFINE_VALUE_SIGNAL(50, button_press, string);
+    DEFINE_VALUE_SIGNAL(51, visibility_change, bool);
+  }
+
+  namespace parser {
+    DEFINE_VALUE_SIGNAL(70, change_background, uint32_t);
+    DEFINE_VALUE_SIGNAL(71, change_foreground, uint32_t);
+    DEFINE_VALUE_SIGNAL(72, change_underline, uint32_t);
+    DEFINE_VALUE_SIGNAL(73, change_overline, uint32_t);
+    DEFINE_VALUE_SIGNAL(74, change_font, int8_t);
+    DEFINE_VALUE_SIGNAL(75, change_alignment, alignment);
+    DEFINE_VALUE_SIGNAL(76, offset_pixel, int16_t);
+    DEFINE_VALUE_SIGNAL(77, attribute_set, attribute);
+    DEFINE_VALUE_SIGNAL(78, attribute_unset, attribute);
+    DEFINE_VALUE_SIGNAL(79, attribute_toggle, attribute);
+    DEFINE_VALUE_SIGNAL(80, action_begin, action);
+    DEFINE_VALUE_SIGNAL(81, action_end, mousebtn);
+    DEFINE_VALUE_SIGNAL(82, write_text_ascii, uint16_t);
+    DEFINE_VALUE_SIGNAL(83, write_text_unicode, uint16_t);
+    DEFINE_VALUE_SIGNAL(84, write_text_string, string);
+  }
+}
+
+POLYBAR_NS_END

include/events/signal_emitter.hpp

@@ -0,0 +1,112 @@
+#pragma once
+
+#include "common.hpp"
+#include "events/signal_receiver.hpp"
+#include "utils/factory.hpp"
+#include "utils/mixins.hpp"
+
+POLYBAR_NS
+
+/**
+ * @brief Holds all signal receivers attached to the emitter
+ */
+extern signal_receivers_t g_signal_receivers;
+
+/**
+ * Wrapper used to delegate emitted signals
+ * to attached signal receivers
+ */
+class signal_emitter {
+ public:
+  explicit signal_emitter() = default;
+  virtual ~signal_emitter() {}
+
+  template <typename Signal>
+  bool emit(const Signal& sig) {
+    try {
+      for (auto&& item : g_signal_receivers.at(id<Signal>())) {
+        if (item.second->on(sig)) {
+          return true;
+        }
+      }
+    } catch (...) {
+    }
+
+    return false;
+  }
+
+  template <typename Signal, typename Next, typename... Signals>
+  bool emit(const Signal& sig) const {
+    return emit<Signal>(sig) || emit<Next, Signals...>(sig);
+  }
+
+  template <uint8_t Priority, typename Signal, typename... Signals>
+  void attach(signal_receiver<Priority, Signal, Signals...>* s) {
+    attach<signal_receiver<Priority, Signal, Signals...>, Signal, Signals...>(s);
+  }
+
+  template <uint8_t Priority, typename Signal, typename... Signals>
+  void detach(signal_receiver<Priority, Signal, Signals...>* s) {
+    detach<signal_receiver<Priority, Signal, Signals...>, Signal, Signals...>(s);
+  }
+
+ protected:
+  template <typename Signal>
+  uint8_t id() const {
+    return Signal::id();
+  }
+
+  template <typename Receiver, typename Signal>
+  void attach(Receiver* s) {
+    attach(s, id<Signal>());
+  }
+
+  template <typename Receiver, typename Signal, typename Next, typename... Signals>
+  void attach(Receiver* s) {
+    attach(s, id<Signal>());
+    attach<Receiver, Next, Signals...>(s);
+  }
+
+  void attach(signal_receiver_interface* s, uint8_t id) {
+    g_signal_receivers[id].emplace(s->priority(), s);
+  }
+
+  template <typename Receiver, typename Signal>
+  void detach(Receiver* s) {
+    detach(s, id<Signal>());
+  }
+
+  template <typename Receiver, typename Signal, typename Next, typename... Signals>
+  void detach(Receiver* s) {
+    detach(s, id<Signal>());
+    detach<Receiver, Next, Signals...>(s);
+  }
+
+  void detach(signal_receiver_interface* d, uint8_t id) {
+    try {
+      auto& prio_map = g_signal_receivers.at(id);
+      const auto& prio_sink_pair = prio_map.equal_range(d->priority());
+
+      for (auto it = prio_sink_pair.first; it != prio_sink_pair.second;) {
+        if (d == it->second) {
+          it = prio_map.erase(it);
+        } else {
+          ++it;
+        }
+      }
+    } catch (...) {
+    }
+  }
+};
+
+namespace {
+  /**
+   * Configure injection module
+   */
+  inline signal_emitter& make_signal_emitter() {
+    auto instance = factory_util::singleton<signal_emitter>();
+    return static_cast<signal_emitter&>(*instance);
+  }
+}
+
+POLYBAR_NS_END

include/events/signal_fwd.hpp

@@ -0,0 +1,48 @@
+#pragma once
+
+#include "common.hpp"
+
+POLYBAR_NS
+
+namespace signals {
+  namespace eventloop {
+    struct process_quit;
+    struct process_update;
+    struct process_input;
+    struct process_check;
+
+    struct enqueue_event;
+    struct enqueue_quit;
+    struct enqueue_update;
+    struct enqueue_input;
+    struct enqueue_check;
+  }
+  namespace ipc {
+    struct process_command;
+    struct process_hook;
+    struct process_action;
+  }
+  namespace ui {
+    struct button_press;
+    struct visibility_change;
+  }
+  namespace parser {
+    struct change_background;
+    struct change_foreground;
+    struct change_underline;
+    struct change_overline;
+    struct change_font;
+    struct change_alignment;
+    struct offset_pixel;
+    struct attribute_set;
+    struct attribute_unset;
+    struct attribute_toggle;
+    struct action_begin;
+    struct action_end;
+    struct write_text_ascii;
+    struct write_text_unicode;
+    struct write_text_string;
+  }
+}
+
+POLYBAR_NS_END

include/events/signal_receiver.hpp

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <map>
+#include <unordered_map>
+
+#include "common.hpp"
+
+POLYBAR_NS
+
+class signal_receiver_interface {
+ public:
+  using prio = unsigned int;
+  using prio_map = std::multimap<prio, signal_receiver_interface*>;
+  virtual ~signal_receiver_interface() {}
+  virtual prio priority() const = 0;
+  template <typename Signal>
+  bool on(const Signal& signal);
+};
+
+template <typename Signal>
+class signal_receiver_impl {
+ public:
+  virtual ~signal_receiver_impl() {}
+  virtual bool on(const Signal&) = 0;
+};
+
+template <typename Signal>
+bool signal_receiver_interface::on(const Signal& s) {
+  auto event_sink = dynamic_cast<signal_receiver_impl<Signal>*>(this);
+
+  if (event_sink != nullptr && event_sink->on(s)) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+template <uint8_t Priority, typename Signal, typename... Signals>
+class signal_receiver : public signal_receiver_interface,
+                        public signal_receiver_impl<Signal>,
+                        public signal_receiver_impl<Signals>... {
+ public:
+  prio priority() const {
+    return Priority;
+  }
+};
+
+using signal_receivers_t = std::unordered_map<uint8_t, signal_receiver_interface::prio_map>;
+
+POLYBAR_NS_END

include/modules/meta/base.hpp

@@ -4,6 +4,7 @@
 #include <chrono>
 #include <condition_variable>
 #include <mutex>
+#include <map>
 
 #include "common.hpp"
 #include "components/config.hpp"
@@ -19,6 +20,7 @@ POLYBAR_NS
 
 namespace chrono = std::chrono;
 using namespace std::chrono_literals;
+using std::map;
 
 #define DEFAULT_FORMAT "format"
 

include/modules/meta/factory.hpp

@@ -0,0 +1,96 @@
+#pragma once
+
+#include "common.hpp"
+
+#include "modules/backlight.hpp"
+#include "modules/battery.hpp"
+#include "modules/bspwm.hpp"
+#include "modules/counter.hpp"
+#include "modules/cpu.hpp"
+#include "modules/date.hpp"
+#include "modules/fs.hpp"
+#include "modules/ipc.hpp"
+#include "modules/memory.hpp"
+#include "modules/menu.hpp"
+#include "modules/meta/base.hpp"
+#include "modules/script.hpp"
+#include "modules/temperature.hpp"
+#include "modules/text.hpp"
+#include "modules/xbacklight.hpp"
+#include "modules/xwindow.hpp"
+#include "modules/xworkspaces.hpp"
+#if ENABLE_I3
+#include "modules/i3.hpp"
+#endif
+#if ENABLE_MPD
+#include "modules/mpd.hpp"
+#endif
+#if ENABLE_NETWORK
+#include "modules/network.hpp"
+#endif
+#if ENABLE_ALSA
+#include "modules/volume.hpp"
+#endif
+#if WITH_XKB
+#include "modules/xkeyboard.hpp"
+#endif
+#if not(ENABLE_I3 && ENABLE_MPD && ENABLE_NETWORK && ENABLE_ALSA && WITH_XKB)
+#include "modules/unsupported.hpp"
+#endif
+
+POLYBAR_NS
+
+using namespace modules;
+
+namespace {
+  template <typename... Args>
+  module_interface* make_module(string&& name, Args&&... args) {
+    if (name == "internal/counter") {
+      return new counter_module(forward<Args>(args)...);
+    } else if (name == "internal/backlight") {
+      return new backlight_module(forward<Args>(args)...);
+    } else if (name == "internal/battery") {
+      return new battery_module(forward<Args>(args)...);
+    } else if (name == "internal/bspwm") {
+      return new bspwm_module(forward<Args>(args)...);
+    } else if (name == "internal/cpu") {
+      return new cpu_module(forward<Args>(args)...);
+    } else if (name == "internal/date") {
+      return new date_module(forward<Args>(args)...);
+    } else if (name == "internal/fs") {
+      return new fs_module(forward<Args>(args)...);
+    } else if (name == "internal/memory") {
+      return new memory_module(forward<Args>(args)...);
+    } else if (name == "internal/i3") {
+      return new i3_module(forward<Args>(args)...);
+    } else if (name == "internal/mpd") {
+      return new mpd_module(forward<Args>(args)...);
+    } else if (name == "internal/volume") {
+      return new volume_module(forward<Args>(args)...);
+    } else if (name == "internal/network") {
+      return new network_module(forward<Args>(args)...);
+    } else if (name == "internal/temperature") {
+      return new temperature_module(forward<Args>(args)...);
+    } else if (name == "internal/xbacklight") {
+      return new xbacklight_module(forward<Args>(args)...);
+    } else if (name == "internal/xkeyboard") {
+      return new xkeyboard_module(forward<Args>(args)...);
+    } else if (name == "internal/xwindow") {
+      return new xwindow_module(forward<Args>(args)...);
+    } else if (name == "internal/xworkspaces") {
+      return new xworkspaces_module(forward<Args>(args)...);
+    } else if (name == "custom/text") {
+      return new text_module(forward<Args>(args)...);
+    } else if (name == "custom/script") {
+      return new script_module(forward<Args>(args)...);
+    } else if (name == "custom/menu") {
+      return new menu_module(forward<Args>(args)...);
+    } else if (name == "custom/ipc") {
+      return new ipc_module(forward<Args>(args)...);
+    } else {
+      throw application_error("Unknown module: " + name);
+    }
+  }
+}
+
+POLYBAR_NS_END

include/modules/script.hpp

@@ -30,7 +30,7 @@ namespace modules {
     static constexpr const char* TAG_OUTPUT{"<output>"};
     static constexpr const char* TAG_LABEL{"<label>"};
 
-    command_util::command_t m_command;
+    unique_ptr<command> m_command;
 
     string m_exec;
     bool m_tail{false};

include/modules/xbacklight.hpp

@@ -25,7 +25,7 @@ namespace modules {
    */
   class xbacklight_module : public static_module<xbacklight_module>, public xpp::event::sink<evt::randr_notify> {
    public:
-    xbacklight_module(const bar_settings& bar, const logger& logger, const config& config, string name);
+    explicit xbacklight_module(const bar_settings& bar, const logger& logger, const config& config, string name);
 
     void setup();
     void teardown();
@@ -39,24 +39,23 @@ namespace modules {
     }
 
    private:
-    static constexpr auto TAG_LABEL = "<label>";
-    static constexpr auto TAG_BAR = "<bar>";
-    static constexpr auto TAG_RAMP = "<ramp>";
+    static constexpr const char* TAG_LABEL{"<label>"};
+    static constexpr const char* TAG_BAR{"<bar>"};
+    static constexpr const char* TAG_RAMP{"<ramp>"};
 
-    static constexpr auto EVENT_SCROLLUP = "xbacklight+";
-    static constexpr auto EVENT_SCROLLDOWN = "xbacklight-";
+    static constexpr const char* EVENT_SCROLLUP{"xbacklight+"};
+    static constexpr const char* EVENT_SCROLLDOWN{"xbacklight-"};
 
     connection& m_connection;
     monitor_t m_output;
     xcb_window_t m_proxy;
-    event_timer m_randrnotify{};
 
     ramp_t m_ramp;
     label_t m_label;
     progressbar_t m_progressbar;
 
-    bool m_scroll = true;
-    int m_percentage = 0;
+    bool m_scroll{true};
+    int m_percentage{0};
   };
 }
 

include/modules/xkeyboard.hpp

@@ -19,7 +19,7 @@ namespace modules {
   class xkeyboard_module : public static_module<xkeyboard_module>,
                            public xpp::event::sink<evt::xkb_new_keyboard_notify, evt::xkb_state_notify, evt::xkb_indicator_state_notify> {
    public:
-    xkeyboard_module(const bar_settings& bar, const logger& logger, const config& config, string name);
+    explicit xkeyboard_module(const bar_settings& bar, const logger& logger, const config& config, string name);
 
     void setup();
     void teardown();

include/modules/xwindow.hpp

@@ -32,7 +32,7 @@ namespace modules {
    */
   class xwindow_module : public static_module<xwindow_module>, public xpp::event::sink<evt::property_notify> {
    public:
-    xwindow_module(const bar_settings&, const logger&, const config&, string);
+    explicit xwindow_module(const bar_settings&, const logger&, const config&, string);
 
     void setup();
     void teardown();

include/modules/xworkspaces.hpp

@@ -49,7 +49,7 @@ namespace modules {
    */
   class xworkspaces_module : public static_module<xworkspaces_module>, public xpp::event::sink<evt::property_notify> {
    public:
-    xworkspaces_module(const bar_settings& bar, const logger& logger, const config& config, string name);
+    explicit xworkspaces_module(const bar_settings& bar, const logger& logger, const config& config, string name);
 
     void setup();
     void teardown();

include/utils/command.hpp

@@ -2,6 +2,7 @@
 
 #include "common.hpp"
 #include "components/logger.hpp"
+#include "errors.hpp"
 #include "utils/concurrency.hpp"
 #include "utils/functional.hpp"
 
@@ -73,15 +74,13 @@ namespace command_util {
     concurrency_util::spin_lock m_pipelock;
   };
 
-  using command_t = unique_ptr<command>;
-
   template <typename... Args>
-  command_t make_command(Args&&... args) {
-    return make_unique<command>(configure_logger().create<const logger&>(), forward<Args>(args)...);
+  unique_ptr<command> make_command(Args&&... args) {
+    return make_unique<command>(make_logger(), forward<Args>(args)...);
   }
 }
 
 using command = command_util::command;
-using command_t = command_util::command_t;
+using command_t = unique_ptr<command>;
 
 POLYBAR_NS_END

include/utils/factory.hpp

@@ -20,14 +20,19 @@ namespace factory_util {
     }
   };
 
-  template <class InstanceType, class... Deps>
-  unique_ptr<InstanceType> generic_instance(Deps... deps) {
-    return make_unique<InstanceType>(deps...);
+  template <typename T, typename... Deps>
+  unique_ptr<T> unique(Deps&&... deps) {
+    return make_unique<T>(forward<Deps>(deps)...);
   }
 
-  template <class InstanceType, class... Deps>
-  shared_ptr<InstanceType> generic_singleton(Deps... deps) {
-    static auto instance = make_shared<InstanceType>(deps...);
+  template <typename T, typename... Deps>
+  shared_ptr<T> shared(Deps&&... deps) {
+    return make_shared<T>(forward<Deps>(deps)...);
+  }
+
+  template <class T, class... Deps>
+  shared_ptr<T> singleton(Deps&&... deps) {
+    static auto instance = make_shared<T>(forward<Deps>(deps)...);
     return instance;
   }
 }

include/x11/color.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <map>
+
 #include <X11/Xft/Xft.h>
 
 #include "common.hpp"
@@ -26,7 +28,7 @@ class color {
   string m_source;
 };
 
-extern map<string, class color> g_colorstore;
+extern std::map<string, class color> g_colorstore;
 extern color g_colorempty;
 extern color g_colorblack;
 extern color g_colorwhite;

include/x11/connection.hpp

@@ -8,9 +8,11 @@
 #include <xpp/xpp.hpp>
 
 #include "common.hpp"
+#include "utils/factory.hpp"
 #include "x11/extensions.hpp"
 #include "x11/registry.hpp"
 #include "x11/types.hpp"
+#include "x11/xutils.hpp"
 
 POLYBAR_NS
 
@@ -18,8 +20,7 @@ using xpp_connection = xpp::connection<XPP_EXTENSION_LIST>;
 
 class connection : public xpp_connection {
  public:
-  explicit connection() {}
-  explicit connection(xcb_connection_t* conn) : xpp_connection(conn) {}
+  explicit connection(xcb_connection_t* conn) : connection(conn, 0) {}
   explicit connection(xcb_connection_t* conn, int connection_fd)
       : xpp_connection(conn), m_connection_fd(connection_fd) {}
 
@@ -54,7 +55,6 @@ class connection : public xpp_connection {
   }
 
   void preload_atoms();
-
   void query_extensions();
 
   string id(xcb_window_t w) const;
@@ -98,6 +98,14 @@ class connection : public xpp_connection {
   int m_connection_fd{0};
 };
 
-di::injector<connection&> configure_connection();
+namespace {
+  /**
+   * Configure injection module
+   */
+  inline connection& make_connection() {
+    auto instance = factory_util::singleton<connection>(xutils::get_connection(), xutils::get_connection_fd());
+    return static_cast<connection&>(*instance);
+  }
+}
 
 POLYBAR_NS_END

include/x11/fonts.hpp

@@ -78,6 +78,6 @@ class font_manager {
   XftDraw* m_xftdraw{nullptr};
 };
 
-di::injector<unique_ptr<font_manager>> configure_font_manager();
+unique_ptr<font_manager> make_font_manager();
 
 POLYBAR_NS_END

include/x11/tray_client.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <xcb/xcb.h>
+
+#include "common.hpp"
+#include "utils/concurrency.hpp"
+
+POLYBAR_NS
+
+// fwd declarations
+class connection;
+struct xembed_data;
+
+class tray_client {
+ public:
+  explicit tray_client(connection& conn, xcb_window_t win, uint16_t w, uint16_t h);
+  tray_client(const tray_client& c) = default;
+  tray_client& operator=(tray_client& c) = default;
+
+~tray_client();
+
+uint16_t width() const;
+uint16_t height() const;
+void clear_window() const;
+
+bool match(const xcb_window_t& win) const;
+bool mapped() const;
+void mapped(bool state);
+
+xcb_window_t window() const;
+xembed_data* xembed() const;
+
+void ensure_state() const;
+void reconfigure(int16_t x, int16_t y) const;
+void configure_notify(int16_t x, int16_t y) const;
+
+protected:
+connection& m_connection;
+xcb_window_t m_window{0};
+
+shared_ptr<xembed_data> m_xembed;
+bool m_mapped{false};
+
+uint16_t m_width;
+uint16_t m_height;
+}
+;
+
+POLYBAR_NS_END

include/x11/tray_manager.hpp

@@ -6,8 +6,14 @@
 #include "common.hpp"
 #include "components/logger.hpp"
 #include "components/types.hpp"
+#include "events/signal_emitter.hpp"
+#include "events/signal_fwd.hpp"
 #include "utils/concurrency.hpp"
+#include "x11/atoms.hpp"
+#include "x11/connection.hpp"
 #include "x11/events.hpp"
+#include "x11/graphics.hpp"
+#include "x11/tray_client.hpp"
 
 #define _NET_SYSTEM_TRAY_ORIENTATION_HORZ 0
 #define _NET_SYSTEM_TRAY_ORIENTATION_VERT 1
@@ -23,24 +29,19 @@ POLYBAR_NS
 
 namespace chrono = std::chrono;
 using namespace std::chrono_literals;
+using namespace signals::eventloop;
+using namespace signals::ui;
 
 // fwd declarations
 class connection;
 struct xembed_data;
 
-namespace graphics_util {
-  struct root_pixmap;
-}
-
-using root_pixmap = graphics_util::root_pixmap;
-
-// class definition : settings {{{
-
 struct tray_settings {
   tray_settings() = default;
   tray_settings& operator=(const tray_settings& o) = default;
 
   alignment align{alignment::NONE};
+  int16_t running{false};
   int16_t orig_x{0};
   int16_t orig_y{0};
   int16_t configured_x{0};
@@ -59,55 +60,18 @@ struct tray_settings {
   bool detached{false};
 };
 
-// }}}
-// class definition : tray_client {{{
-
-class tray_client {
- public:
-  explicit tray_client(connection& conn, xcb_window_t win, uint16_t w, uint16_t h);
-
-  ~tray_client();
-
-  uint16_t width() const;
-  uint16_t height() const;
-  void clear_window() const;
-
-  bool match(const xcb_window_t& win) const;
-  bool mapped() const;
-  void mapped(bool state);
-
-  xcb_window_t window() const;
-  xembed_data* xembed() const;
-
-  void ensure_state() const;
-  void reconfigure(int16_t x, int16_t y) const;
-  void configure_notify(int16_t x, int16_t y) const;
-
- protected:
-  connection& m_connection;
-  xcb_window_t m_window{0};
-
-  shared_ptr<xembed_data> m_xembed;
-  stateflag m_mapped{false};
-
-  uint16_t m_width;
-  uint16_t m_height;
-};
-
-// }}}
-// class definition : tray_manager {{{
-
 class tray_manager : public xpp::event::sink<evt::expose, evt::visibility_notify, evt::client_message,
                          evt::configure_request, evt::resize_request, evt::selection_clear, evt::property_notify,
-                         evt::reparent_notify, evt::destroy_notify, evt::map_notify, evt::unmap_notify> {
+                         evt::reparent_notify, evt::destroy_notify, evt::map_notify, evt::unmap_notify>,
+                     public signal_receiver<SIGN_PRIORITY_TRAY, visibility_change> {
  public:
-  explicit tray_manager(connection& conn, const logger& logger);
+  explicit tray_manager(connection& conn, signal_emitter& emitter, const logger& logger);
 
   ~tray_manager();
 
   const tray_settings settings() const;
 
-  void bootstrap(tray_settings settings);
+  void setup(const bar_settings& bar_opts);
   void activate();
   void activate_delayed(chrono::duration<double, std::milli> delay = 1s);
   void deactivate(bool clear_selection = true);
@@ -124,8 +88,8 @@ class tray_manager : public xpp::event::sink<evt::expose, evt::visibility_notify
   void create_window();
   void create_bg(bool realloc = false);
   void restack_window();
-  void set_wmhints();
-  void set_traycolors();
+  void set_wm_hints();
+  void set_tray_colors();
 
   void acquire_selection();
   void notify_clients();
@@ -134,8 +98,6 @@ class tray_manager : public xpp::event::sink<evt::expose, evt::visibility_notify
   void track_selection_owner(xcb_window_t owner);
   void process_docking_request(xcb_window_t win);
 
-  void bar_visibility_change(bool visible);
-
   int16_t calculate_x(uint16_t width) const;
   int16_t calculate_y() const;
   uint16_t calculate_w() const;
@@ -144,9 +106,11 @@ class tray_manager : public xpp::event::sink<evt::expose, evt::visibility_notify
   int16_t calculate_client_x(const xcb_window_t& win);
   int16_t calculate_client_y();
 
+  bool is_embedded(const xcb_window_t& win) const;
   shared_ptr<tray_client> find_client(const xcb_window_t& win) const;
   void remove_client(shared_ptr<tray_client>& client, bool reconfigure = true);
-  int mapped_clients() const;
+  void remove_client(xcb_window_t window, bool reconfigure = true);
+  size_t mapped_clients() const;
 
   void handle(const evt::expose& evt);
   void handle(const evt::visibility_notify& evt);
@@ -160,8 +124,11 @@ class tray_manager : public xpp::event::sink<evt::expose, evt::visibility_notify
   void handle(const evt::map_notify& evt);
   void handle(const evt::unmap_notify& evt);
 
+  bool on(const visibility_change& evt);
+
  private:
   connection& m_connection;
+  signal_emitter& m_sig;
   const logger& m_log;
   vector<shared_ptr<tray_client>> m_clients;
 
@@ -169,7 +136,7 @@ class tray_manager : public xpp::event::sink<evt::expose, evt::visibility_notify
 
   xcb_gcontext_t m_gc{0};
   xcb_pixmap_t m_pixmap{0};
-  root_pixmap m_rootpixmap;
+  graphics_util::root_pixmap m_rootpixmap;
   uint16_t m_prevwidth{0};
   uint16_t m_prevheight{0};
 
@@ -189,15 +156,12 @@ class tray_manager : public xpp::event::sink<evt::expose, evt::visibility_notify
   std::mutex m_mtx;
 };
 
-// }}}
-
 namespace {
   /**
    * Configure injection module
    */
-  template <class T = unique_ptr<tray_manager>>
-  di::injector<T> configure_tray_manager() {
-    return di::make_injector(configure_logger(), configure_connection());
+  inline unique_ptr<tray_manager> make_tray_manager() {
+    return factory_util::unique<tray_manager>(make_connection(), make_signal_emitter(), make_logger());
   }
 }
 

include/x11/wm.hpp

@@ -7,15 +7,12 @@
 POLYBAR_NS
 
 namespace wm_util {
-  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(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);
+  void set_wm_name(xcb_connection_t* conn, xcb_window_t win, const string& wm_name, const string& wm_class);
+  void set_wm_protocols(xcb_connection_t* conn, xcb_window_t win, vector<xcb_atom_t> flags);
+  void set_wm_window_type(xcb_connection_t* conn, xcb_window_t win, vector<xcb_atom_t> types);
+  void set_wm_state(xcb_connection_t* conn, xcb_window_t win, vector<xcb_atom_t> states);
+  void set_wm_pid(xcb_connection_t* conn, xcb_window_t win, pid_t pid);
+  void set_wm_desktop(xcb_connection_t* conn, xcb_window_t win, uint32_t desktop = -1u);
 }
 
 POLYBAR_NS_END

include/x11/xkb.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <map>
+
 #include "config.hpp"
 
 #if not WITH_XKB
@@ -24,6 +26,8 @@
 
 POLYBAR_NS
 
+using std::map;
+
 // fwd
 class connection;
 

include/x11/xresources.hpp

@@ -22,6 +22,6 @@ class xresource_manager {
   XrmDatabase m_db;
 };
 
-di::injector<const xresource_manager&> configure_xresource_manager();
+const xresource_manager& make_xresource_manager();
 
 POLYBAR_NS_END

include/x11/xutils.hpp

@@ -16,9 +16,6 @@ namespace xutils {
   xcb_connection_t* get_connection();
   int get_connection_fd();
 
-  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);

src/components/bar.cpp

@@ -1,20 +1,24 @@
 #include <xcb/xcb_icccm.h>
+#include <algorithm>
+#include <string>
 
 #include "components/bar.hpp"
+#include "components/command_line.hpp"
+#include "components/config.hpp"
+#include "components/eventloop.hpp"
 #include "components/parser.hpp"
 #include "components/renderer.hpp"
 #include "components/screen.hpp"
-#include "components/signals.hpp"
+#include "events/signal.hpp"
+#include "events/signal_emitter.hpp"
 #include "utils/bspwm.hpp"
 #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/tray_manager.hpp"
 #include "x11/wm.hpp"
 #include "x11/xutils.hpp"
 
@@ -24,167 +28,183 @@
 
 POLYBAR_NS
 
-namespace ph = std::placeholders;
-
-/**
- * Configure injection module
- */
-di::injector<unique_ptr<bar>> configure_bar() {
-  // clang-format off
-  return di::make_injector(
-      configure_connection(),
-      configure_config(),
-      configure_logger(),
-      configure_screen(),
-      configure_tray_manager());
-  // clang-format on
-}
+using namespace signals::ui;
+using namespace wm_util;
 
 /**
  * Construct bar instance
- */
-bar::bar(connection& conn, const config& config, const logger& logger, unique_ptr<screen> screen,
-    unique_ptr<tray_manager> tray_manager)
-    : m_connection(conn), m_conf(config), m_log(logger), m_screen(move(screen)), m_tray(move(tray_manager)) {}
-
-/**
- * Cleanup signal handlers and destroy the bar window
- */
-bar::~bar() {
-  std::lock_guard<std::mutex> guard(m_mutex);
-  m_connection.detach_sink(this, SINK_PRIORITY_BAR);
-  m_tray.reset();
-}
-
-/**
- * Create required components
  *
- * This is done outside the constructor due to boost::di noexcept
+ * TODO: Break out all tray handling
  */
-void bar::bootstrap(bool nodraw) {
-  auto bs = m_conf.bar_section();
+bar::bar(connection& conn, signal_emitter& emitter, const config& config, const logger& logger,
+    unique_ptr<screen> screen, unique_ptr<tray_manager> tray_manager)
+    : m_connection(conn)
+    , m_sig(emitter)
+    , m_conf(config)
+    , m_log(logger)
+    , m_screen(move(screen))
+    , m_tray(move(tray_manager)) {
+  string bs{m_conf.bar_section()};
 
-  setup_monitor();
+  // Get available RandR outputs
+  auto monitor_name = m_conf.get<string>(bs, "monitor", "");
+  auto monitor_strictmode = m_conf.get<bool>(bs, "monitor-strict", false);
+  auto monitors = randr_util::get_monitors(m_connection, m_connection.screen()->root, monitor_strictmode);
 
-  m_log.trace("bar: Load config values");
-  {
-    m_opts.locale = m_conf.get<string>(bs, "locale", "");
-    m_opts.separator = string_util::trim(m_conf.get<string>(bs, "separator", ""), '"');
-    m_opts.wmname = m_conf.get<string>(bs, "wm-name", "polybar-" + bs.substr(4) + "_" + m_opts.monitor->name);
-    m_opts.wmname = string_util::replace(m_opts.wmname, " ", "-");
+  if (monitors.empty()) {
+    throw application_error("No monitors found");
+  } else if (monitor_name.empty()) {
+    monitor_name = monitors[0]->name;
+    m_log.warn("No monitor specified, using \"%s\"", monitor_name);
+  }
 
-    if (m_conf.get<bool>(bs, "bottom", false)) {
-      m_opts.origin = edge::BOTTOM;
-    }
-
-    try {
-      m_opts.override_redirect = m_conf.get<bool>(bs, "dock");
-      m_conf.warn_deprecated(bs, "dock", "override-redirect");
-    } catch (const key_error& err) {
-      m_opts.override_redirect = m_conf.get<bool>(bs, "override-redirect", m_opts.override_redirect);
-    }
-
-    GET_CONFIG_VALUE(bs, m_opts.spacing, "spacing");
-    GET_CONFIG_VALUE(bs, m_opts.padding.left, "padding-left");
-    GET_CONFIG_VALUE(bs, m_opts.padding.right, "padding-right");
-    GET_CONFIG_VALUE(bs, m_opts.module_margin.left, "module-margin-left");
-    GET_CONFIG_VALUE(bs, m_opts.module_margin.right, "module-margin-right");
-
-    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.offset = xutils::event_timer_ms(m_conf, xcb_button_press_event_t{});
-
-    // Get fallback click handlers
-    auto click_left = m_conf.get<string>(bs, "click-left", "");
-    auto click_middle = m_conf.get<string>(bs, "click-middle", "");
-    auto click_right = m_conf.get<string>(bs, "click-right", "");
-    auto scroll_up = m_conf.get<string>(bs, "scroll-up", "");
-    auto scroll_down = m_conf.get<string>(bs, "scroll-down", "");
-
-    if (!click_left.empty()) {
-      m_opts.actions.emplace_back(action{mousebtn::LEFT, move(click_left)});
-    }
-    if (!click_middle.empty()) {
-      m_opts.actions.emplace_back(action{mousebtn::MIDDLE, move(click_middle)});
-    }
-    if (!click_right.empty()) {
-      m_opts.actions.emplace_back(action{mousebtn::RIGHT, move(click_right)});
-    }
-    if (!scroll_up.empty()) {
-      m_opts.actions.emplace_back(action{mousebtn::SCROLL_UP, move(scroll_up)});
-    }
-    if (!scroll_down.empty()) {
-      m_opts.actions.emplace_back(action{mousebtn::SCROLL_DOWN, move(scroll_down)});
+  // Match against the defined monitor name
+  for (auto&& monitor : monitors) {
+    if (monitor->match(monitor_name, monitor_strictmode)) {
+      m_opts.monitor = move(monitor);
+      break;
     }
   }
 
-  m_log.trace("bar: Load color values");
-  {
-    m_opts.background =
-        color::parse(m_conf.get<string>(bs, "background", color_util::hex<uint16_t>(m_opts.background)));
-    m_opts.foreground =
-        color::parse(m_conf.get<string>(bs, "foreground", color_util::hex<uint16_t>(m_opts.foreground)));
+  if (!m_opts.monitor) {
+    throw application_error("Monitor \"" + monitor_name + "\" not found or disconnected");
+  }
 
-    auto linecolor = color::parse(m_conf.get<string>(bs, "linecolor", "#f00"));
-    auto lineheight = m_conf.get<int>(bs, "lineheight", 0);
+  m_log.trace("bar: Loaded monitor %s (%ix%i+%i+%i)", m_opts.monitor->name, m_opts.monitor->w, m_opts.monitor->h,
+      m_opts.monitor->x, m_opts.monitor->y);
 
-    m_conf.warn_deprecated(bs, "linecolor", "{underline,overline}-color");
-    m_conf.warn_deprecated(bs, "lineheight", "{underline,overline}-size");
+  try {
+    m_opts.override_redirect = m_conf.get<bool>(bs, "dock");
+    m_conf.warn_deprecated(bs, "dock", "override-redirect");
+  } catch (const key_error& err) {
+    m_opts.override_redirect = m_conf.get<bool>(bs, "override-redirect", m_opts.override_redirect);
+  }
 
-    try {
-      m_opts.overline.size = m_conf.get<int16_t>(bs, "overline-size", lineheight);
-      m_opts.overline.color = color::parse(m_conf.get<string>(bs, "overline-color"));
-    } catch (const key_error& err) {
-      m_opts.overline.color = linecolor;
-    }
+  // Build WM_NAME
+  m_opts.wmname = m_conf.get<string>(bs, "wm-name", "polybar-" + bs.substr(4) + "_" + m_opts.monitor->name);
+  m_opts.wmname = string_util::replace(m_opts.wmname, " ", "-");
 
-    try {
-      m_opts.underline.size = m_conf.get<uint16_t>(bs, "underline-size", lineheight);
-      m_opts.underline.color = color::parse(m_conf.get<string>(bs, "underline-color"));
-    } catch (const key_error& err) {
-      m_opts.underline.color = linecolor;
+  // Load configuration values
+  m_opts.origin = m_conf.get<bool>(bs, "bottom", false) ? edge::BOTTOM : edge::TOP;
+  m_opts.spacing = m_conf.get<decltype(m_opts.spacing)>(bs, "spacing", m_opts.spacing);
+  m_opts.padding.left = m_conf.get<decltype(m_opts.padding.left)>(bs, "padding-left", m_opts.padding.left);
+  m_opts.padding.right = m_conf.get<decltype(m_opts.padding.right)>(bs, "padding-right", m_opts.padding.right);
+  m_opts.module_margin.left =
+      m_conf.get<decltype(m_opts.module_margin.left)>(bs, "module-margin-left", m_opts.module_margin.left);
+  m_opts.module_margin.right =
+      m_conf.get<decltype(m_opts.module_margin.right)>(bs, "module-margin-right", m_opts.module_margin.right);
+  m_opts.separator = string_util::trim(m_conf.get<string>(bs, "separator", ""), '"');
+  m_opts.locale = m_conf.get<string>(bs, "locale", "");
+
+  // Load values used to adjust the struts atom
+  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);
+
+  // Load commands used for fallback click handlers
+  vector<action> actions;
+  actions.emplace_back(action{mousebtn::LEFT, m_conf.get<string>(bs, "click-left", "")});
+  actions.emplace_back(action{mousebtn::MIDDLE, m_conf.get<string>(bs, "click-middle", "")});
+  actions.emplace_back(action{mousebtn::RIGHT, m_conf.get<string>(bs, "click-right", "")});
+  actions.emplace_back(action{mousebtn::SCROLL_UP, m_conf.get<string>(bs, "scroll-up", "")});
+  actions.emplace_back(action{mousebtn::SCROLL_DOWN, m_conf.get<string>(bs, "scroll-down", "")});
+
+  for (auto&& act : actions) {
+    if (!act.command.empty()) {
+      m_opts.actions.emplace_back(action{act.button, act.command});
     }
   }
 
-  m_log.trace("bar: Load border values");
-  {
-    auto bsize = m_conf.get<int>(bs, "border-size", 0);
-    auto bcolor = m_conf.get<string>(bs, "border-color", "#00000000");
+  // Load foreground/background
+  m_opts.background = color::parse(m_conf.get<string>(bs, "background", color_util::hex<uint16_t>(m_opts.background)));
+  m_opts.foreground = color::parse(m_conf.get<string>(bs, "foreground", color_util::hex<uint16_t>(m_opts.foreground)));
 
-    m_opts.borders.emplace(edge::TOP, border_settings{});
-    m_opts.borders[edge::TOP].size = m_conf.get<int>(bs, "border-top", bsize);
-    m_opts.borders[edge::TOP].color = color::parse(m_conf.get<string>(bs, "border-top-color", bcolor));
+  // Load over-/underline color and size (warn about deprecated params if used)
+  m_conf.warn_deprecated(bs, "linecolor", "{underline,overline}-color");
+  m_conf.warn_deprecated(bs, "lineheight", "{underline,overline}-size");
 
-    m_opts.borders.emplace(edge::BOTTOM, border_settings{});
-    m_opts.borders[edge::BOTTOM].size = m_conf.get<int>(bs, "border-bottom", bsize);
-    m_opts.borders[edge::BOTTOM].color = color::parse(m_conf.get<string>(bs, "border-bottom-color", bcolor));
+  auto linecolor = color::parse(m_conf.get<string>(bs, "linecolor", "#f00"));
+  auto lineheight = m_conf.get<int>(bs, "lineheight", 0);
+  m_opts.overline.size = m_conf.get<int16_t>(bs, "overline-size", lineheight);
+  m_opts.overline.color = color::parse(m_conf.get<string>(bs, "overline-color", linecolor));
+  m_opts.underline.size = m_conf.get<uint16_t>(bs, "underline-size", lineheight);
+  m_opts.underline.color = color::parse(m_conf.get<string>(bs, "underline-color", linecolor));
 
-    m_opts.borders.emplace(edge::LEFT, border_settings{});
-    m_opts.borders[edge::LEFT].size = m_conf.get<int>(bs, "border-left", bsize);
-    m_opts.borders[edge::LEFT].color = color::parse(m_conf.get<string>(bs, "border-left-color", bcolor));
+  // Load border settings
+  auto bsize = m_conf.get<int>(bs, "border-size", 0);
+  auto bcolor = m_conf.get<string>(bs, "border-color", "#00000000");
 
-    m_opts.borders.emplace(edge::RIGHT, border_settings{});
-    m_opts.borders[edge::RIGHT].size = m_conf.get<int>(bs, "border-right", bsize);
-    m_opts.borders[edge::RIGHT].color = color::parse(m_conf.get<string>(bs, "border-right-color", bcolor));
+  m_opts.borders.emplace(edge::TOP, border_settings{});
+  m_opts.borders[edge::TOP].size = m_conf.get<int>(bs, "border-top", bsize);
+  m_opts.borders[edge::TOP].color = color::parse(m_conf.get<string>(bs, "border-top-color", bcolor));
+  m_opts.borders.emplace(edge::BOTTOM, border_settings{});
+  m_opts.borders[edge::BOTTOM].size = m_conf.get<int>(bs, "border-bottom", bsize);
+  m_opts.borders[edge::BOTTOM].color = color::parse(m_conf.get<string>(bs, "border-bottom-color", bcolor));
+  m_opts.borders.emplace(edge::LEFT, border_settings{});
+  m_opts.borders[edge::LEFT].size = m_conf.get<int>(bs, "border-left", bsize);
+  m_opts.borders[edge::LEFT].color = color::parse(m_conf.get<string>(bs, "border-left-color", bcolor));
+  m_opts.borders.emplace(edge::RIGHT, border_settings{});
+  m_opts.borders[edge::RIGHT].size = m_conf.get<int>(bs, "border-right", bsize);
+  m_opts.borders[edge::RIGHT].color = color::parse(m_conf.get<string>(bs, "border-right-color", bcolor));
+
+  // Load geometry values
+  auto w = m_conf.get<string>(m_conf.bar_section(), "width", "100%");
+  auto h = m_conf.get<string>(m_conf.bar_section(), "height", "24");
+  auto offsetx = m_conf.get<string>(m_conf.bar_section(), "offset-x", "");
+  auto offsety = m_conf.get<string>(m_conf.bar_section(), "offset-y", "");
+
+  if ((m_opts.size.w = atoi(w.c_str())) && w.find('%') != string::npos) {
+    m_opts.size.w = math_util::percentage_to_value<int>(m_opts.size.w, m_opts.monitor->w);
+  }
+  if ((m_opts.size.h = atoi(h.c_str())) && h.find('%') != string::npos) {
+    m_opts.size.h = math_util::percentage_to_value<int>(m_opts.size.h, m_opts.monitor->h);
+  }
+  if ((m_opts.offset.x = atoi(offsetx.c_str())) != 0 && offsetx.find('%') != string::npos) {
+    m_opts.offset.x = math_util::percentage_to_value<int>(m_opts.offset.x, m_opts.monitor->w);
+  }
+  if ((m_opts.offset.y = atoi(offsety.c_str())) != 0 && offsety.find('%') != string::npos) {
+    m_opts.offset.y = math_util::percentage_to_value<int>(m_opts.offset.y, m_opts.monitor->h);
   }
 
-  if (nodraw) {
-    m_log.trace("bar: Abort bootstrap routine (reason: nodraw)");
-    m_tray.reset();
-    return;
+  // Apply offsets
+  m_opts.pos.x = m_opts.offset.x + m_opts.monitor->x;
+  m_opts.pos.y = m_opts.offset.y + m_opts.monitor->y;
+  m_opts.size.h += m_opts.borders[edge::TOP].size;
+  m_opts.size.h += m_opts.borders[edge::BOTTOM].size;
+
+  if (m_opts.origin == edge::BOTTOM) {
+    m_opts.pos.y = m_opts.monitor->y + m_opts.monitor->h - m_opts.size.h - m_opts.offset.y;
   }
 
+  if (m_opts.size.w <= 0 || m_opts.size.w > m_opts.monitor->w) {
+    throw application_error("Resulting bar width is out of bounds");
+  } else if (m_opts.size.h <= 0 || m_opts.size.h > m_opts.monitor->h) {
+    throw application_error("Resulting bar height is out of bounds");
+  }
+
+  m_opts.size.w = math_util::cap<int>(m_opts.size.w, 0, m_opts.monitor->w);
+  m_opts.size.h = math_util::cap<int>(m_opts.size.h, 0, m_opts.monitor->h);
+
+  m_opts.center.y = m_opts.size.h;
+  m_opts.center.y -= m_opts.borders[edge::BOTTOM].size;
+  m_opts.center.y /= 2;
+  m_opts.center.y += m_opts.borders[edge::TOP].size;
+
+  m_opts.center.x = m_opts.size.w;
+  m_opts.center.x -= m_opts.borders[edge::RIGHT].size;
+  m_opts.center.x /= 2;
+  m_opts.center.x += m_opts.borders[edge::LEFT].size;
+
+  m_log.trace("bar: Create renderer");
+  auto fonts = m_conf.get_list<string>(m_conf.bar_section(), "font", {});
+  m_renderer = make_renderer(m_opts, move(fonts));
+
   m_log.trace("bar: Attaching sink to registry");
   m_connection.attach_sink(this, SINK_PRIORITY_BAR);
 
-  configure_geom();
-
-  m_renderer = configure_renderer(m_opts, m_conf.get_list<string>(bs, "font", {})).create<unique_ptr<renderer>>();
-  m_window = m_renderer->window();
-
-  m_log.info("Bar window: %s", m_connection.id(m_window));
+  m_log.info("Bar geometry: %ix%i+%i+%i", m_opts.size.w, m_opts.size.h, m_opts.pos.x, m_opts.pos.y);
+  m_opts.window = m_renderer->window();
 
+  m_log.info("Bar window: %s", m_connection.id(m_opts.window));
   restack_window();
 
   m_log.trace("bar: Reconfigure window");
@@ -192,190 +212,29 @@ void bar::bootstrap(bool nodraw) {
   reconfigure_wm_hints();
 
   m_log.trace("bar: Map window");
-  m_connection.map_window_checked(m_window);
+  m_connection.map_window_checked(m_opts.window);
 
   // Reconfigure window position after mapping (required by Openbox)
   // Required by Openbox
   reconfigure_pos();
 
-  m_log.trace("bar: Attach parser signal handlers");
-  g_signals::parser::background_change = bind(&renderer::set_background, m_renderer.get(), ph::_1);
-  g_signals::parser::foreground_change = bind(&renderer::set_foreground, m_renderer.get(), ph::_1);
-  g_signals::parser::underline_change = bind(&renderer::set_underline, m_renderer.get(), ph::_1);
-  g_signals::parser::overline_change = bind(&renderer::set_overline, m_renderer.get(), ph::_1);
-  g_signals::parser::pixel_offset = bind(&renderer::fill_shift, m_renderer.get(), ph::_1);
-  g_signals::parser::alignment_change = bind(&renderer::set_alignment, m_renderer.get(), ph::_1);
-  g_signals::parser::attribute_set = bind(&renderer::set_attribute, m_renderer.get(), ph::_1, true);
-  g_signals::parser::attribute_unset = bind(&renderer::set_attribute, m_renderer.get(), ph::_1, false);
-  g_signals::parser::attribute_toggle = bind(&renderer::toggle_attribute, m_renderer.get(), ph::_1);
-  g_signals::parser::action_block_open = bind(&renderer::begin_action, m_renderer.get(), ph::_1, ph::_2);
-  g_signals::parser::action_block_close = bind(&renderer::end_action, m_renderer.get(), ph::_1);
-  g_signals::parser::font_change = bind(&renderer::set_fontindex, m_renderer.get(), ph::_1);
-  g_signals::parser::ascii_text_write = bind(&renderer::draw_character, m_renderer.get(), ph::_1);
-  g_signals::parser::unicode_text_write = bind(&renderer::draw_character, m_renderer.get(), ph::_1);
-  g_signals::parser::string_write = bind(&renderer::draw_textstring, m_renderer.get(), ph::_1, ph::_2);
+  m_log.trace("bar: Drawing empty bar");
+  m_renderer->begin();
+  m_renderer->fill_background();
+  m_renderer->end();
 
-  try {
-    m_log.trace("bar: Drawing empty bar");
-    m_renderer->begin();
-    m_renderer->fill_background();
-    m_renderer->end();
-  } catch (const exception& err) {
-    throw application_error("Failed to output empty bar window (reason: " + string{err.what()} + ")");
-  }
+  m_log.trace("bar: Setup tray manager");
+  m_tray->setup(static_cast<const bar_settings&>(m_opts));
+
+  broadcast_visibility();
 }
 
 /**
- * Setup tray manager
+ * Cleanup signal handlers and destroy the bar window
  */
-void bar::bootstrap_tray() {
-  if (!m_tray) {
-    return;
-  }
-
-  tray_settings settings;
-
-  auto bs = m_conf.bar_section();
-  auto tray_position = m_conf.get<string>(bs, "tray-position", "");
-
-  if (tray_position == "left") {
-    settings.align = alignment::LEFT;
-  } else if (tray_position == "right") {
-    settings.align = alignment::RIGHT;
-  } else if (tray_position == "center") {
-    settings.align = alignment::CENTER;
-  } else {
-    settings.align = alignment::NONE;
-  }
-
-  if (settings.align == alignment::NONE) {
-    m_log.warn("Disabling tray manager (reason: disabled in config)");
-    m_tray.reset();
-    return;
-  }
-
-  settings.detached = m_conf.get<bool>(bs, "tray-detached", false);
-
-  settings.height = m_opts.size.h;
-  settings.height -= m_opts.borders.at(edge::BOTTOM).size;
-  settings.height -= m_opts.borders.at(edge::TOP).size;
-  settings.height_fill = settings.height;
-
-  if (settings.height % 2 != 0) {
-    settings.height--;
-  }
-
-  auto maxsize = m_conf.get<int>(bs, "tray-maxsize", 16);
-  if (settings.height > maxsize) {
-    settings.spacing += (settings.height - maxsize) / 2;
-    settings.height = maxsize;
-  }
-
-  settings.width_max = m_opts.size.w;
-  settings.width = settings.height;
-  settings.orig_y = m_opts.pos.y + m_opts.borders.at(edge::TOP).size;
-
-  // Apply user-defined scaling
-  auto scale = m_conf.get<float>(bs, "tray-scale", 1.0f);
-  settings.width *= scale;
-  settings.height_fill *= scale;
-
-  auto inner_area = m_opts.inner_area(true);
-
-  switch (settings.align) {
-    case alignment::NONE:
-      break;
-    case alignment::LEFT:
-      settings.orig_x = inner_area.x;
-      break;
-    case alignment::CENTER:
-      settings.orig_x = inner_area.x + inner_area.width / 2 - settings.width / 2;
-      break;
-    case alignment::RIGHT:
-      settings.orig_x = inner_area.x + inner_area.width;
-      break;
-  }
-
-  // Set user-defined background color
-  if (!(settings.transparent = m_conf.get<bool>(bs, "tray-transparent", settings.transparent))) {
-    auto bg = m_conf.get<string>(bs, "tray-background", "");
-
-    if (bg.length() > 7) {
-      m_log.warn("Alpha support for the systray is limited. See the wiki for more details.");
-    }
-
-    if (!bg.empty()) {
-      settings.background = color::parse(bg, g_colorempty);
-    } else {
-      settings.background = m_opts.background;
-    }
-
-    if (color_util::alpha_channel(settings.background) == 0) {
-      settings.transparent = true;
-      settings.background = 0;
-    }
-  }
-
-  // Add user-defined padding
-  settings.spacing += m_conf.get<int>(bs, "tray-padding", 0);
-
-  // Add user-defiend offset
-  auto offset_x_def = m_conf.get<string>(bs, "tray-offset-x", "");
-  auto offset_y_def = m_conf.get<string>(bs, "tray-offset-y", "");
-
-  auto offset_x = atoi(offset_x_def.c_str());
-  auto offset_y = atoi(offset_y_def.c_str());
-
-  if (offset_x != 0 && offset_x_def.find('%') != string::npos) {
-    if (settings.detached) {
-      offset_x = math_util::percentage_to_value<int>(offset_x, m_opts.monitor->w);
-    } else {
-      offset_x = math_util::percentage_to_value<int>(offset_x, inner_area.width);
-    }
-  }
-
-  if (offset_y != 0 && offset_y_def.find('%') != string::npos) {
-    if (settings.detached) {
-      offset_y = math_util::percentage_to_value<int>(offset_y, m_opts.monitor->h);
-    } else {
-      offset_y = math_util::percentage_to_value<int>(offset_y, inner_area.height);
-    }
-  }
-
-  settings.orig_x += offset_x;
-  settings.orig_y += offset_y;
-
-  // Put the tray next to the bar in the window stack
-  settings.sibling = m_window;
-
-  try {
-    m_log.trace("bar: Setup tray manager");
-    m_tray->bootstrap(settings);
-  } catch (const exception& err) {
-    m_log.err(err.what());
-    m_log.warn("Failed to setup tray, disabling...");
-    m_tray.reset();
-  }
-}
-
-/**
- * Activate tray manager
- */
-void bar::activate_tray() {
-  if (!m_tray) {
-    return;
-  }
-
-  m_log.trace("bar: Activate tray manager");
-
-  try {
-    broadcast_visibility();
-    m_tray->activate();
-  } catch (const exception& err) {
-    m_log.err(err.what());
-    m_log.err("Failed to activate tray manager, disabling...");
-    m_tray.reset();
-  }
+bar::~bar() {
+  std::lock_guard<std::mutex> guard(m_mutex);
+  m_connection.detach_sink(this, SINK_PRIORITY_BAR);
 }
 
 /**
@@ -404,6 +263,7 @@ void bar::parse(const string& data, bool force) {
 
   m_lastinput = data;
 
+  m_log.info("Redrawing bar window");
   m_renderer->begin();
 
   if (m_tray && !m_tray->settings().detached && m_tray->settings().configured_slots) {
@@ -417,8 +277,10 @@ void bar::parse(const string& data, bool force) {
   m_renderer->fill_background();
 
   try {
-    parser parser{m_log, m_opts};
-    parser(data);
+    if (!data.empty()) {
+      parser parser{m_sig, m_log, m_opts};
+      parser(data);
+    }
   } catch (const parser_error& err) {
     m_log.err("Failed to parse contents (reason: %s)", err.what());
   }
@@ -426,108 +288,6 @@ void bar::parse(const string& data, bool force) {
   m_renderer->end();
 }
 
-/**
- * Configure geometry values
- */
-void bar::configure_geom() {
-  m_log.trace("bar: Configure window geometry");
-
-  auto w = m_conf.get<string>(m_conf.bar_section(), "width", "100%");
-  auto h = m_conf.get<string>(m_conf.bar_section(), "height", "24");
-
-  auto offsetx = m_conf.get<string>(m_conf.bar_section(), "offset-x", "");
-  auto offsety = m_conf.get<string>(m_conf.bar_section(), "offset-y", "");
-
-  // look for user-defined width
-  if ((m_opts.size.w = atoi(w.c_str())) && w.find('%') != string::npos) {
-    m_opts.size.w = math_util::percentage_to_value<int>(m_opts.size.w, m_opts.monitor->w);
-  }
-
-  // look for user-defined  height
-  if ((m_opts.size.h = atoi(h.c_str())) && h.find('%') != string::npos) {
-    m_opts.size.h = math_util::percentage_to_value<int>(m_opts.size.h, m_opts.monitor->h);
-  }
-
-  // look for user-defined offset-x
-  if ((m_opts.offset.x = atoi(offsetx.c_str())) != 0 && offsetx.find('%') != string::npos) {
-    m_opts.offset.x = math_util::percentage_to_value<int>(m_opts.offset.x, m_opts.monitor->w);
-  }
-
-  // look for user-defined offset-y
-  if ((m_opts.offset.y = atoi(offsety.c_str())) != 0 && offsety.find('%') != string::npos) {
-    m_opts.offset.y = math_util::percentage_to_value<int>(m_opts.offset.y, m_opts.monitor->h);
-  }
-
-  // apply offsets
-  m_opts.pos.x = m_opts.offset.x + m_opts.monitor->x;
-  m_opts.pos.y = m_opts.offset.y + m_opts.monitor->y;
-
-  // apply borders
-  m_opts.size.h += m_opts.borders[edge::TOP].size;
-  m_opts.size.h += m_opts.borders[edge::BOTTOM].size;
-
-  if (m_opts.origin == edge::BOTTOM) {
-    m_opts.pos.y = m_opts.monitor->y + m_opts.monitor->h - m_opts.size.h - m_opts.offset.y;
-  }
-
-  if (m_opts.size.w <= 0 || m_opts.size.w > m_opts.monitor->w) {
-    throw application_error("Resulting bar width is out of bounds");
-  }
-  if (m_opts.size.h <= 0 || m_opts.size.h > m_opts.monitor->h) {
-    throw application_error("Resulting bar height is out of bounds");
-  }
-
-  m_opts.size.w = math_util::cap<int>(m_opts.size.w, 0, m_opts.monitor->w);
-  m_opts.size.h = math_util::cap<int>(m_opts.size.h, 0, m_opts.monitor->h);
-
-  m_opts.center.y = m_opts.size.h;
-  m_opts.center.y -= m_opts.borders[edge::BOTTOM].size;
-  m_opts.center.y /= 2;
-  m_opts.center.y += m_opts.borders[edge::TOP].size;
-
-  m_opts.center.x = m_opts.size.w;
-  m_opts.center.x -= m_opts.borders[edge::RIGHT].size;
-  m_opts.center.x /= 2;
-  m_opts.center.x += m_opts.borders[edge::LEFT].size;
-
-  m_log.info("Bar geometry: %ix%i+%i+%i", m_opts.size.w, m_opts.size.h, m_opts.pos.x, m_opts.pos.y);
-}
-
-/**
- * Create monitor object
- */
-void bar::setup_monitor() {
-  m_log.trace("bar: Create monitor from matching X RandR output");
-
-  auto strict = m_conf.get<bool>(m_conf.bar_section(), "monitor-strict", false);
-  auto monitors = randr_util::get_monitors(m_connection, m_screen->root(), strict);
-
-  if (monitors.empty()) {
-    throw application_error("No monitors found");
-  }
-
-  auto name = m_conf.get<string>(m_conf.bar_section(), "monitor", "");
-
-  if (name.empty()) {
-    name = monitors[0]->name;
-    m_log.warn("No monitor specified, using \"%s\"", name);
-  }
-
-  for (auto&& monitor : monitors) {
-    if (monitor->match(name, strict)) {
-      m_opts.monitor = move(monitor);
-      break;
-    }
-  }
-
-  if (!m_opts.monitor) {
-    throw application_error("Monitor \"" + name + "\" not found or disconnected");
-  }
-
-  const auto& m = m_opts.monitor;
-  m_log.trace("bar: Loaded monitor %s (%ix%i+%i+%i)", m->name, m->w, m->h, m->x, m->y);
-}
-
 /**
  * Move the bar window above defined sibling
  * in the X window stack
@@ -544,10 +304,10 @@ void bar::restack_window() {
   auto restacked = false;
 
   if (wm_restack == "bspwm") {
-    restacked = bspwm_util::restack_above_root(m_connection, m_opts.monitor, m_window);
+    restacked = bspwm_util::restack_above_root(m_connection, m_opts.monitor, m_opts.window);
 #if ENABLE_I3
   } else if (wm_restack == "i3" && m_opts.override_redirect) {
-    restacked = i3_util::restack_above_root(m_connection, m_opts.monitor, m_window);
+    restacked = i3_util::restack_above_root(m_connection, m_opts.monitor, m_opts.window);
   } else if (wm_restack == "i3" && !m_opts.override_redirect) {
     m_log.warn("Ignoring restack of i3 window (not needed when `override-redirect = false`)");
     wm_restack.clear();
@@ -568,7 +328,7 @@ void bar::restack_window() {
  * Reconfigure window position
  */
 void bar::reconfigure_pos() {
-  window win{m_connection, m_window};
+  window win{m_connection, m_opts.window};
   win.reconfigure_pos(m_opts.pos.x, m_opts.pos.y);
 }
 
@@ -592,7 +352,7 @@ void bar::reconfigure_struts() {
     h += m_opts.monitor->y;
   }
 
-  window win{m_connection, m_window};
+  window win{m_connection, m_opts.window};
   win.reconfigure_struts(w, h, m_opts.pos.x, m_opts.origin == edge::BOTTOM);
 }
 
@@ -601,42 +361,34 @@ void bar::reconfigure_struts() {
  */
 void bar::reconfigure_wm_hints() {
   m_log.trace("bar: Set window WM_NAME");
-  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");
+  xcb_icccm_set_wm_name(m_connection, m_opts.window, XCB_ATOM_STRING, 8, m_opts.wmname.size(), m_opts.wmname.c_str());
+  xcb_icccm_set_wm_class(m_connection, m_opts.window, 15, "polybar\0Polybar");
 
-  m_log.trace("bar: Set window _NET_WM_WINDOW_TYPE");
-  wm_util::set_windowtype(m_connection, m_window, {_NET_WM_WINDOW_TYPE_DOCK});
+  m_log.trace("bar: Set window _NET_Wm_opts.window_TYPE");
+  set_wm_window_type(m_connection, m_opts.window, {_NET_WM_WINDOW_TYPE_DOCK});
 
   m_log.trace("bar: Set window _NET_WM_STATE");
-  wm_util::set_wmstate(m_connection, m_window, {_NET_WM_STATE_STICKY, _NET_WM_STATE_ABOVE});
+  set_wm_state(m_connection, m_opts.window, {_NET_WM_STATE_STICKY, _NET_WM_STATE_ABOVE});
 
   m_log.trace("bar: Set window _NET_WM_DESKTOP");
-  wm_util::set_wmdesktop(m_connection, m_window, 0xFFFFFFFF);
+  set_wm_desktop(m_connection, m_opts.window, 0xFFFFFFFF);
 
   m_log.trace("bar: Set window _NET_WM_PID");
-  wm_util::set_wmpid(m_connection, m_window, getpid());
+  set_wm_pid(m_connection, m_opts.window, getpid());
 }
 
 /**
  * Broadcast current map state
  */
 void bar::broadcast_visibility() {
-  if (!g_signals::bar::visibility_change) {
-    return m_log.trace("bar: no callback handler set for bar visibility change");
-  }
+  auto attr = m_connection.get_window_attributes(m_opts.window);
 
-  try {
-    auto attr = m_connection.get_window_attributes(m_window);
-
-    if (attr->map_state == XCB_MAP_STATE_UNVIEWABLE) {
-      g_signals::bar::visibility_change(false);
-    } else if (attr->map_state == XCB_MAP_STATE_UNMAPPED) {
-      g_signals::bar::visibility_change(false);
-    } else {
-      g_signals::bar::visibility_change(true);
-    }
-  } catch (const exception& err) {
-    return;
+  if (attr->map_state == XCB_MAP_STATE_UNVIEWABLE) {
+    m_sig.emit(visibility_change{move(false)});
+  } else if (attr->map_state == XCB_MAP_STATE_UNMAPPED) {
+    m_sig.emit(visibility_change{move(false)});
+  } else {
+    m_sig.emit(visibility_change{move(true)});
   }
 }
 
@@ -669,29 +421,17 @@ void bar::handle(const evt::button_press& evt) {
       continue;
     } else if (action.end_x < evt->event_x) {
       continue;
+    } else {
+      m_log.trace("Found matching input area");
+      m_sig.emit(button_press{string{action.command}});
+      return;
     }
-
-    m_log.trace("Found matching input area");
-    m_log.trace_x("action.command = %s", action.command);
-    m_log.trace_x("action.button = %i", evt->detail);
-    m_log.trace_x("action.start_x = %i", action.start_x);
-    m_log.trace_x("action.end_x = %i", action.end_x);
-
-    if (g_signals::bar::action_click) {
-      g_signals::bar::action_click(action.command);
-    }
-
-    return;
   }
 
   for (auto&& action : m_opts.actions) {
     if (action.button == button && !action.command.empty()) {
       m_log.trace("Triggering fallback click handler: %s", action.command);
-
-      if (g_signals::bar::action_click) {
-        g_signals::bar::action_click(action.command);
-      }
-
+      m_sig.emit(button_press{string{action.command}});
       return;
     }
   }
@@ -705,7 +445,11 @@ void bar::handle(const evt::button_press& evt) {
  * Used to redraw the bar
  */
 void bar::handle(const evt::expose& evt) {
-  if (evt->window == m_window && evt->count == 0) {
+  if (evt->window == m_opts.window && evt->count == 0) {
+    if (m_tray->settings().running) {
+      broadcast_visibility();
+    }
+
     m_log.trace("bar: Received expose event");
     m_renderer->flush(false);
   }
@@ -729,7 +473,7 @@ void bar::handle(const evt::property_notify& evt) {
   m_log.trace_x("bar: property_notify(%s)", atom_name);
 #endif
 
-  if (evt->window == m_window && evt->atom == WM_STATE) {
+  if (evt->window == m_opts.window && evt->atom == WM_STATE) {
     broadcast_visibility();
   }
 }

src/components/builder.cpp

@@ -54,7 +54,7 @@ string builder::flush() {
 /**
  * Insert raw text string
  */
-void builder::append(string text) {
+void builder::append(const string& text) {
   m_output += text;
 }
 

src/components/config.cpp

@@ -4,6 +4,7 @@
 #include <utility>
 
 #include "components/config.hpp"
+#include "components/logger.hpp"
 #include "utils/env.hpp"
 #include "utils/file.hpp"
 

src/components/controller.cpp

@@ -1,114 +1,59 @@
-#include <chrono>
-#include <mutex>
-
+#include "components/controller.hpp"
+#include "common.hpp"
 #include "components/bar.hpp"
 #include "components/config.hpp"
-#include "components/controller.hpp"
 #include "components/eventloop.hpp"
 #include "components/ipc.hpp"
 #include "components/logger.hpp"
-#include "components/signals.hpp"
-#include "modules/backlight.hpp"
-#include "modules/battery.hpp"
-#include "modules/bspwm.hpp"
-#include "modules/counter.hpp"
-#include "modules/cpu.hpp"
-#include "modules/date.hpp"
-#include "modules/fs.hpp"
-#include "modules/ipc.hpp"
-#include "modules/memory.hpp"
-#include "modules/menu.hpp"
-#include "modules/script.hpp"
-#include "modules/temperature.hpp"
-#include "modules/text.hpp"
-#include "modules/xbacklight.hpp"
-#include "modules/xwindow.hpp"
-#include "modules/xworkspaces.hpp"
+#include "events/signal.hpp"
+#include "modules/meta/factory.hpp"
+#include "utils/factory.hpp"
 #include "utils/process.hpp"
 #include "utils/string.hpp"
-
-#if ENABLE_I3
-#include "modules/i3.hpp"
-#endif
-#if ENABLE_MPD
-#include "modules/mpd.hpp"
-#endif
-#if ENABLE_NETWORK
-#include "modules/network.hpp"
-#endif
-#if ENABLE_ALSA
-#include "modules/volume.hpp"
-#endif
-#if WITH_XKB
-#include "modules/xkeyboard.hpp"
-#endif
-
-#if not(ENABLE_I3 && ENABLE_MPD && ENABLE_NETWORK && ENABLE_ALSA && WITH_XKB)
-#include "modules/unsupported.hpp"
-#endif
+#include "x11/xutils.hpp"
 
 POLYBAR_NS
 
 using namespace modules;
 
-namespace chrono = std::chrono;
+controller::controller(connection& conn, signal_emitter& emitter, const logger& logger, const config& config,
+    unique_ptr<eventloop> eventloop, unique_ptr<bar> bar, unique_ptr<ipc> ipc, watch_t confwatch, bool writeback)
+    : m_connection(conn)
+    , m_sig(emitter)
+    , m_log(logger)
+    , m_conf(config)
+    , m_eventloop(move(eventloop))
+    , m_bar(move(bar))
+    , m_ipc(move(ipc))
+    , m_confwatch(move(confwatch))
+    , m_writeback(writeback) {}
 
-/**
- * Configure injection module
- */
-di::injector<unique_ptr<controller>> configure_controller(watch_t& confwatch) {
-  // clang-format off
-  return di::make_injector(
-      di::bind<>().to(confwatch),
-      configure_connection(),
-      configure_logger(),
-      configure_config(),
-      configure_eventloop(),
-      configure_bar());
-  // clang-format on
-}
-
-/**
- * Stop modules and cleanup X components,
- * threads and spawned processes
- */
 controller::~controller() {
-  pthread_sigmask(SIG_UNBLOCK, &m_blockmask, nullptr);
-
-  sigset_t sig;
-  sigemptyset(&sig);
-  sigaddset(&sig, SIGALRM);
-  pthread_sigmask(SIG_BLOCK, &sig, nullptr);
-
-  if (m_command) {
-    m_log.info("Terminating running shell command");
-    m_command.reset();
-  }
-
-  if (m_bar) {
-    m_log.info("Deconstructing bar");
-    m_bar.reset();
-  }
-
-  if (m_ipc) {
-    m_log.info("Deconstructing ipc");
-    m_ipc.reset();
-  }
-
   if (m_eventloop) {
     m_log.info("Deconstructing eventloop");
     m_eventloop.reset();
   }
-
+  if (m_command) {
+    m_log.info("Terminating running shell command");
+    m_command.reset();
+  }
+  if (m_bar) {
+    m_log.info("Deconstructing bar");
+    m_bar.reset();
+  }
+  if (m_ipc) {
+    m_log.info("Deconstructing ipc");
+    m_ipc.reset();
+  }
   if (!m_writeback) {
     m_log.info("Interrupting X event loop");
     m_connection.send_dummy_event(m_connection.root());
   }
 
   m_log.info("Joining active threads");
-  for (auto&& th : m_threads) {
-    if (th.second.joinable()) {
-      th.second.join();
+  for (auto&& thread_ : m_threads) {
+    if (thread_.joinable()) {
+      thread_.join();
     }
   }
 
@@ -117,90 +62,82 @@ controller::~controller() {
     ;
   }
 
+  m_sig.detach(this);
   m_connection.flush();
 }
 
-/**
- * Initialize components and setup X environment
- */
-void controller::bootstrap(bool writeback, bool dump_wmname) {
-  // Add all signals to the block mask
-  sigfillset(&m_blockmask);
-
-  if (pthread_sigmask(SIG_BLOCK, &m_blockmask, nullptr) == -1) {
-    throw system_error("Failed to block signals");
-  }
-
-  m_writeback = writeback;
-
-  m_log.trace("controller: Initialize X atom cache");
-  m_connection.preload_atoms();
-
-  m_log.trace("controller: Query X extension data");
-  m_connection.query_extensions();
-
-  if (m_conf.get<bool>(m_conf.bar_section(), "enable-ipc", false)) {
-    m_log.trace("controller: Create IPC handler");
-    m_ipc = configure_ipc().create<decltype(m_ipc)>();
-    m_ipc->attach_callback(bind(&controller::on_ipc_action, this, placeholders::_1));
-  } else {
-    m_log.info("Inter-process messaging disabled");
-  }
-
-  // Listen for events on the root window to be able to
-  // break the blocking wait call when cleaning up
-  m_log.trace("controller: Listen for events on the root window");
-  const uint32_t value_list[2]{XCB_EVENT_MASK_PROPERTY_CHANGE | XCB_EVENT_MASK_STRUCTURE_NOTIFY};
-  m_connection.change_window_attributes_checked(m_connection.root(), XCB_CW_EVENT_MASK, value_list);
-
-  m_log.trace("controller: Setup bar");
-  m_bar->bootstrap(m_writeback || dump_wmname);
-  m_bar->bootstrap_tray();
-
-  if (dump_wmname) {
-    std::cout << m_bar->settings().wmname << std::endl;
-    return;
-  }
-
-  m_log.trace("controller: Attach eventloop update callback");
-  m_eventloop->set_update_cb(bind(&controller::on_update, this, placeholders::_1));
-
-  if (!m_writeback) {
-    m_log.trace("controller: Attach eventloop input callback");
-    g_signals::bar::action_click = bind(&controller::on_mouse_event, this, placeholders::_1);
-    m_eventloop->set_input_db(bind(&controller::on_unrecognized_action, this, placeholders::_1));
-  }
+void controller::setup() {
+  string bs{m_conf.bar_section()};
 
   m_log.trace("controller: Setup user-defined modules");
-  bootstrap_modules();
+
+  for (int i = 0; i < 3; i++) {
+    alignment align = static_cast<alignment>(i + 1);
+    string confkey;
+
+    if (align == alignment::LEFT) {
+      confkey = "modules-left";
+    } else if (align == alignment::CENTER) {
+      confkey = "modules-center";
+    } else if (align == alignment::RIGHT) {
+      confkey = "modules-right";
+    }
+
+    for (auto& module_name : string_util::split(m_conf.get<string>(bs, confkey, ""), ' ')) {
+      if (module_name.empty()) {
+        continue;
+      }
+
+      try {
+        auto type = m_conf.get<string>("module/" + module_name, "type");
+        if (type == "custom/ipc" && !m_ipc) {
+          throw application_error("Inter-process messaging needs to be enabled");
+        }
+
+        unique_ptr<module_interface> module{make_module(move(type), m_bar->settings(), m_log, m_conf, module_name)};
+
+        module->set_update_cb([&] {
+          if (m_eventloop && m_running) {
+            m_sig.emit(enqueue_update{eventloop_t::make_update_evt(false)});
+          }
+        });
+        module->set_stop_cb([&] {
+          if (m_eventloop && m_running) {
+            m_sig.emit(enqueue_check{eventloop::make_check_evt()});
+          }
+        });
+        module->setup();
+
+        m_eventloop->add_module(align, move(module));
+      } catch (const std::runtime_error& err) {
+        m_log.err("Disabling module \"%s\" (reason: %s)", module_name, err.what());
+      }
+    }
+  }
+
+  if (!m_eventloop->module_count()) {
+    throw application_error("No modules created");
+  }
 }
 
-/**
- * Launch the controller
- */
 bool controller::run() {
   assert(!m_connection.connection_has_error());
+  m_sig.attach(this);
 
   m_log.info("Starting application");
   m_running = true;
 
   if (m_confwatch && !m_writeback) {
-    m_threads[thread_role::CONF_LISTENER] = thread(&controller::wait_for_configwatch, this);
+    m_threads.emplace_back(thread(&controller::wait_for_configwatch, this));
   }
-
-  // Start ipc receiver if its enabled
-  if (m_conf.get<bool>(m_conf.bar_section(), "enable-ipc", false)) {
-    m_threads[thread_role::IPC_LISTENER] = thread(&ipc::receive_messages, m_ipc.get());
+  if (m_ipc) {
+    m_threads.emplace_back(thread(&ipc::receive_messages, m_ipc.get()));
   }
-
-  // Listen for X events in separate thread
   if (!m_writeback) {
-    m_threads[thread_role::EVENT_QUEUE_X] = thread(&controller::wait_for_xevent, this);
+    m_threads.emplace_back(thread(&controller::wait_for_xevent, this));
   }
-
-  // Start event loop
   if (m_eventloop) {
-    m_threads[thread_role::EVENT_QUEUE] = thread(&controller::wait_for_eventloop, this);
+    m_threads.emplace_back(thread(&controller::wait_for_eventloop, this));
   }
 
   m_log.trace("controller: Wait for signal");
@@ -226,11 +163,13 @@ bool controller::run() {
   m_log.warn("Termination signal received, shutting down...");
   m_log.trace("controller: Caught signal %d", caught_signal);
 
+  // Signal the eventloop, in case it's still running
+  m_eventloop->enqueue(eventloop::make_quit_evt(false));
+
   if (m_eventloop) {
     m_log.trace("controller: Stopping event loop");
     m_eventloop->stop();
   }
-
   if (!m_writeback && m_confwatch) {
     m_log.trace("controller: Removing config watch");
     m_confwatch->remove(true);
@@ -239,9 +178,10 @@ bool controller::run() {
   return !m_running && !m_reload;
 }
 
-/**
- * Listen for changes to the config file
- */
+const bar_settings controller::opts() const {
+  return m_bar->settings();
+}
+
 void controller::wait_for_configwatch() {
   try {
     m_log.trace("controller: Attach config watch");
@@ -259,19 +199,14 @@ void controller::wait_for_configwatch() {
   }
 }
 
-/**
- * Wait for X events and forward them to
- * the event registry
- */
 void controller::wait_for_xevent() {
   m_log.trace("controller: Listen for X events");
-
   m_connection.flush();
 
-  shared_ptr<xcb_generic_event_t> evt;
   while (m_running) {
     try {
-      if ((evt = m_connection.wait_for_event()) != nullptr && m_running) {
+      auto evt = m_connection.wait_for_event();
+      if (evt && m_running) {
         m_connection.dispatch_event(evt);
       }
     } catch (xpp::connection_error& err) {
@@ -279,7 +214,6 @@ void controller::wait_for_xevent() {
     } catch (const exception& err) {
       m_log.err("Error in X event loop: %s", err.what());
     }
-
     if (m_connection.connection_has_error()) {
       break;
     }
@@ -290,14 +224,10 @@ void controller::wait_for_xevent() {
   }
 }
 
-/**
- * Start event loop and wait for it to finish
- */
 void controller::wait_for_eventloop() {
   m_eventloop->start();
-  m_eventloop->wait();
 
-  this_thread::sleep_for(250ms);
+  this_thread::sleep_for(std::chrono::milliseconds{250});
 
   if (m_running) {
     m_log.trace("controller: eventloop ended, raising SIGALRM");
@@ -305,178 +235,16 @@ void controller::wait_for_eventloop() {
   }
 }
 
-/**
- * Create and initialize bar modules
- */
-void controller::bootstrap_modules() {
-  const bar_settings bar{m_bar->settings()};
-  string bs{m_conf.bar_section()};
-
-  for (int i = 0; i < 3; i++) {
-    alignment align = static_cast<alignment>(i + 1);
-    string confkey;
-
-    switch (align) {
-      case alignment::LEFT:
-        confkey = "modules-left";
-        break;
-      case alignment::CENTER:
-        confkey = "modules-center";
-        break;
-      case alignment::RIGHT:
-        confkey = "modules-right";
-        break;
-      default:
-        break;
-    }
-
-    for (auto& module_name : string_util::split(m_conf.get<string>(bs, confkey, ""), ' ')) {
-      if (module_name.empty()) {
-        continue;
-      }
-
-      try {
-        auto type = m_conf.get<string>("module/" + module_name, "type");
-        module_t module;
-
-        if (type == "internal/counter") {
-          module.reset(new counter_module(bar, m_log, m_conf, module_name));
-        } else if (type == "internal/backlight") {
-          module.reset(new backlight_module(bar, m_log, m_conf, module_name));
-        } else if (type == "internal/battery") {
-          module.reset(new battery_module(bar, m_log, m_conf, module_name));
-        } else if (type == "internal/bspwm") {
-          module.reset(new bspwm_module(bar, m_log, m_conf, module_name));
-        } else if (type == "internal/cpu") {
-          module.reset(new cpu_module(bar, m_log, m_conf, module_name));
-        } else if (type == "internal/date") {
-          module.reset(new date_module(bar, m_log, m_conf, module_name));
-        } else if (type == "internal/fs") {
-          module.reset(new fs_module(bar, m_log, m_conf, module_name));
-        } else if (type == "internal/memory") {
-          module.reset(new memory_module(bar, m_log, m_conf, module_name));
-        } else if (type == "internal/i3") {
-          module.reset(new i3_module(bar, m_log, m_conf, module_name));
-        } else if (type == "internal/mpd") {
-          module.reset(new mpd_module(bar, m_log, m_conf, module_name));
-        } else if (type == "internal/volume") {
-          module.reset(new volume_module(bar, m_log, m_conf, module_name));
-        } else if (type == "internal/network") {
-          module.reset(new network_module(bar, m_log, m_conf, module_name));
-        } else if (type == "internal/temperature") {
-          module.reset(new temperature_module(bar, m_log, m_conf, module_name));
-        } else if (type == "internal/xbacklight") {
-          module.reset(new xbacklight_module(bar, m_log, m_conf, module_name));
-        } else if (type == "internal/xkeyboard") {
-          module.reset(new xkeyboard_module(bar, m_log, m_conf, module_name));
-        } else if (type == "internal/xwindow") {
-          module.reset(new xwindow_module(bar, m_log, m_conf, module_name));
-        } else if (type == "internal/xworkspaces") {
-          module.reset(new xworkspaces_module(bar, m_log, m_conf, module_name));
-        } else if (type == "custom/text") {
-          module.reset(new text_module(bar, m_log, m_conf, module_name));
-        } else if (type == "custom/script") {
-          module.reset(new script_module(bar, m_log, m_conf, module_name));
-        } else if (type == "custom/menu") {
-          module.reset(new menu_module(bar, m_log, m_conf, module_name));
-        } else if (type == "custom/ipc") {
-          if (!m_ipc) {
-            throw application_error("Inter-process messaging needs to be enabled");
-          }
-          module.reset(new ipc_module(bar, m_log, m_conf, module_name));
-          m_ipc->attach_callback(
-              bind(&ipc_module::on_message, static_cast<ipc_module*>(module.get()), placeholders::_1));
-        } else {
-          throw application_error("Unknown module: " + module_name);
-        }
-
-        module->set_update_cb(
-            bind(&eventloop::enqueue, m_eventloop.get(), eventloop::entry_t{static_cast<uint8_t>(event_type::UPDATE)}));
-        module->set_stop_cb(
-            bind(&eventloop::enqueue, m_eventloop.get(), eventloop::entry_t{static_cast<uint8_t>(event_type::CHECK)}));
-        module->setup();
-
-        m_eventloop->add_module(align, move(module));
-      } catch (const std::runtime_error& err) {
-        m_log.err("Disabling module \"%s\" (reason: %s)", module_name, err.what());
-      }
-    }
-  }
-
-  if (!m_eventloop->module_count()) {
-    throw application_error("No modules created");
-  }
-}
-
-/**
- * Callback for received ipc actions
- */
-void controller::on_ipc_action(const ipc_action& message) {
-  if (!m_eventloop) {
-    return;
-  }
-
-  string action = message.payload.substr(strlen(ipc_action::prefix));
-
-  if (action.size() >= sizeof(input_event::data)) {
-    m_log.warn("Ignoring input event (size)");
-  } else if (action.empty()) {
-    m_log.err("Cannot enqueue empty IPC action");
-  } else {
-    m_log.info("Enqueuing IPC action: %s", action);
-    m_eventloop->enqueue(eventloop::make(input_event{}, action));
-  }
-}
-
-/**
- * Callback for clicked bar actions
- */
-void controller::on_mouse_event(const string& input) {
-  if (!m_eventloop) {
-    return;
-  } else if (input.length() >= sizeof(input_event::data)) {
-    m_log.warn("Ignoring input event (size)");
-  } else if (!m_eventloop->enqueue_delayed(eventloop::make(input_event{}, input))) {
-    m_log.trace_x("controller: Dispatcher busy");
-  }
-}
-
-/**
- * Callback for actions not handled internally by a module
- */
-void controller::on_unrecognized_action(string input) {
-  try {
-    if (m_command) {
-      m_log.warn("Terminating previous shell command");
-      m_command->terminate();
-    }
-
-    m_log.info("Executing shell command: %s", input);
-
-    m_command = command_util::make_command(input);
-    m_command->exec();
-    m_command.reset();
-  } catch (const application_error& err) {
-    m_log.err("controller: Error while forwarding input to shell -> %s", err.what());
-  }
-}
-
-/**
- * Callback for module content update
- */
-void controller::on_update(bool force) {
+bool controller::on(const sig_ev::process_update& evt) {
   if (!m_bar) {
-    return;
+    return false;
   }
 
   const bar_settings& bar{m_bar->settings()};
-
   string contents;
   string separator{bar.separator};
-
   string padding_left(bar.padding.left, ' ');
   string padding_right(bar.padding.right, ' ');
-
   auto margin_left = bar.module_margin.left;
   auto margin_right = bar.module_margin.right;
 
@@ -518,9 +286,7 @@ void controller::on_update(bool force) {
 
     if (block_contents.empty()) {
       continue;
-    }
-
-    if (is_left) {
+    } else if (is_left) {
       contents += "%{l}";
       contents += padding_left;
     } else if (is_center) {
@@ -542,25 +308,110 @@ void controller::on_update(bool force) {
     contents += string_util::replace_all(block_contents, "}%{", " ");
   }
 
-  if (m_writeback) {
-    std::cout << contents << std::endl;
-    return;
-  }
-
   try {
-    if (!m_trayactivated) {
-      m_trayactivated = true;
-      m_bar->activate_tray();
+    if (!m_writeback) {
+      m_bar->parse(contents, evt());
+    } else {
+      std::cout << contents << std::endl;
     }
-  } catch (const exception& err) {
-    m_log.err("Failed to active tray manager (reason: %s)", err.what());
-  }
-
-  try {
-    m_bar->parse(contents, force);
   } catch (const exception& err) {
     m_log.err("Failed to update bar contents (reason: %s)", err.what());
   }
+
+  return true;
+}
+
+bool controller::on(const sig_ev::process_input& evt) {
+  try {
+    string input{(*evt()).data};
+
+    if (m_command) {
+      m_log.warn("Terminating previous shell command");
+      m_command->terminate();
+    }
+
+    m_log.info("Executing shell command: %s", input);
+
+    m_command = command_util::make_command(input);
+    m_command->exec();
+    m_command.reset();
+  } catch (const application_error& err) {
+    m_log.err("controller: Error while forwarding input to shell -> %s", err.what());
+  }
+
+  return true;
+}
+
+bool controller::on(const sig_ev::process_quit&) {
+  kill(getpid(), SIGUSR1);
+  return false;
+}
+
+bool controller::on(const sig_ui::button_press& evt) {
+  if (!m_eventloop) {
+    return false;
+  }
+
+  string input{*evt()};
+
+  if (input.length() >= sizeof(eventloop::input_data)) {
+    m_log.warn("Ignoring input event (size)");
+  } else if (!m_sig.emit(enqueue_input{eventloop::make_input_data(move(input))})) {
+    m_log.trace_x("controller: Dispatcher busy");
+  }
+
+  return true;
+}
+
+bool controller::on(const sig_ipc::process_action& evt) {
+  ipc_action a{*evt()};
+  string action{a.payload};
+  action.erase(0, strlen(ipc_action::prefix));
+
+  if (action.size() >= sizeof(eventloop::input_data)) {
+    m_log.warn("Ignoring input event (size)");
+  } else if (action.empty()) {
+    m_log.err("Cannot enqueue empty ipc action");
+  } else {
+    m_log.info("Enqueuing ipc action: %s", action);
+    m_eventloop->enqueue(eventloop::make_input_evt());
+  }
+  return true;
+}
+
+bool controller::on(const sig_ipc::process_command& evt) {
+  ipc_command c{*evt()};
+  string command{c.payload};
+  command.erase(0, strlen(ipc_command::prefix));
+
+  if (command.empty()) {
+    return false;
+  }
+
+  if (command == "quit") {
+    m_eventloop->enqueue(eventloop::make_quit_evt(false));
+  } else if (command == "restart") {
+    m_eventloop->enqueue(eventloop::make_quit_evt(true));
+  } else {
+    m_log.warn("\"%s\" is not a valid ipc command", command);
+  }
+
+  return true;
+}
+
+bool controller::on(const sig_ipc::process_hook& evt) {
+  const ipc_hook hook{*evt()};
+
+  for (const auto& block : m_eventloop->modules()) {
+    for (const auto& module : block.second) {
+      auto ipc = dynamic_cast<ipc_module*>(module.get());
+      if (ipc != nullptr) {
+        ipc->on_message(hook);
+      }
+    }
+  }
+
+  return true;
 }
 
 POLYBAR_NS_END

src/components/eventloop.cpp

@@ -1,8 +1,8 @@
 #include <csignal>
 
 #include "components/eventloop.hpp"
-#include "components/signals.hpp"
 #include "components/types.hpp"
+#include "events/signal.hpp"
 #include "utils/string.hpp"
 #include "utils/time.hpp"
 #include "x11/color.hpp"
@@ -12,31 +12,18 @@ POLYBAR_NS
 /**
  * Construct eventloop instance
  */
-eventloop::eventloop(const logger& logger, const config& config) : m_log(logger), m_conf(config) {
-  m_delayed_time = duration_t{m_conf.get<double>("settings", "eventloop-delayed-time", 25)};
+eventloop::eventloop(signal_emitter& emitter, const logger& logger, const config& config)
+    : m_sig(emitter), m_log(logger), m_conf(config) {
   m_swallow_time = duration_t{m_conf.get<double>("settings", "eventloop-swallow-time", 10)};
   m_swallow_limit = m_conf.get<size_t>("settings", "eventloop-swallow", 5U);
-
-  g_signals::event::enqueue = bind(&eventloop::enqueue, this, placeholders::_1);
-  g_signals::event::enqueue_delayed = bind(&eventloop::enqueue_delayed, this, placeholders::_1);
+  m_sig.attach(this);
 }
 
 /**
  * Deconstruct eventloop
  */
 eventloop::~eventloop() {
-  g_signals::event::enqueue = g_signals::noop<const eventloop::entry_t&>;
-  g_signals::event::enqueue_delayed = g_signals::noop<const eventloop::entry_t&>;
-
-  m_update_cb = nullptr;
-  m_unrecognized_input_cb = nullptr;
-
-  if (m_delayed_thread.joinable()) {
-    m_delayed_thread.join();
-  }
-  if (m_queue_thread.joinable()) {
-    m_queue_thread.join();
-  }
+  m_sig.detach(this);
 
   for (auto&& block : m_modules) {
     for (auto&& module : block.second) {
@@ -45,7 +32,7 @@ eventloop::~eventloop() {
         module->stop();
         module.reset();
       });
-      m_log.trace("eventloop: Deconstruction of %s took %lu microsec.", module_name, cleanup_ms);
+      m_log.info("eventloop: Deconstruction of %s took %lu microsec.", module_name, cleanup_ms);
     }
   }
 }
@@ -56,19 +43,61 @@ eventloop::~eventloop() {
 void eventloop::start() {
   m_log.info("Starting event loop");
   m_running = true;
-
   dispatch_modules();
 
-  m_queue_thread = thread(&eventloop::dispatch_queue_worker, this);
-  m_delayed_thread = thread(&eventloop::dispatch_delayed_worker, this);
+  while (m_running) {
+    event evt, next;
+    input_data data;
+
+    m_queue.wait_dequeue(evt);
+
+    if (!m_running) {
+      break;
+    }
+
+    if (evt.type == static_cast<uint8_t>(event_type::INPUT)) {
+      while (m_running && m_inputqueue.try_dequeue(data)) {
+        m_sig.emit(process_input{move(data)});
+      }
+    } else {
+      size_t swallowed{0};
+      while (swallowed++ < m_swallow_limit && m_queue.wait_dequeue_timed(next, m_swallow_time)) {
+        if (next.type == static_cast<uint8_t>(event_type::QUIT)) {
+          evt = next;
+          break;
+
+        } else if (next.type == static_cast<uint8_t>(event_type::INPUT)) {
+          evt = next;
+          break;
+
+        } else if (!compare_events(evt, next)) {
+          enqueue(move(next));
+          break;
+
+        } else {
+          m_log.trace_x("eventloop: Swallowing event within timeframe");
+          evt = next;
+        }
+      }
+
+      if (evt.type == static_cast<uint8_t>(event_type::INPUT)) {
+        while (m_inputqueue.try_dequeue(data)) {
+          m_sig.emit(process_input{move(data)});
+        }
+      } else {
+        forward_event(evt);
+      }
+    }
+  }
+
+  m_log.info("Queue worker done");
 }
 
-/**
- * Wait for worker threads to end
- */
-void eventloop::wait() {
-  if (m_queue_thread.joinable()) {
-    m_queue_thread.join();
+void eventloop::process_inputqueue() {
+  input_data data{};
+
+  while (m_inputqueue.try_dequeue(data)) {
+    m_sig.emit(process_input{move(data)});
   }
 }
 
@@ -78,61 +107,33 @@ void eventloop::wait() {
 void eventloop::stop() {
   m_log.info("Stopping event loop");
   m_running = false;
-
-  if (m_delayed_thread.joinable()) {
-    m_delayed_cond.notify_one();
-  }
-
-  enqueue({static_cast<uint8_t>(event_type::QUIT)});
+  m_sig.emit(enqueue_quit{make_quit_evt(false)});
 }
 
 /**
  * Enqueue event
  */
-bool eventloop::enqueue(const entry_t& entry) {
-  if (m_queue.enqueue(entry)) {
-    return true;
-  }
-  m_log.warn("Failed to enqueue event (%d)", entry.type);
-  return false;
-}
+bool eventloop::enqueue(event&& evt) {
+  uint8_t type{static_cast<uint8_t>(evt.type)};
 
-/**
- * Delay enqueue by given time
- */
-bool eventloop::enqueue_delayed(const entry_t& entry) {
-  if (!m_delayed_lock.try_lock()) {
+  if (!m_queue.enqueue(move(evt))) {
+    m_log.warn("Failed to enqueue event (%d)", static_cast<uint8_t>(type));
     return false;
   }
 
-  std::unique_lock<std::mutex> guard(m_delayed_lock, std::adopt_lock);
+  return true;
+}
 
-  if (m_delayed_entry.type != 0) {
+/**
+ * Enqueue input event
+ */
+bool eventloop::enqueue(input_data&& evt) {
+  if (!m_inputqueue.enqueue(move(evt))) {
+    m_log.warn("Failed to enqueue input_data");
     return false;
   }
 
-  m_delayed_entry = entry;
-
-  if (m_queue.enqueue(entry)) {
-    return true;
-  }
-
-  m_delayed_entry.type = 0;
-  return false;
-}
-
-/**
- * Set callback handler for UPDATE events
- */
-void eventloop::set_update_cb(callback<bool>&& cb) {
-  m_update_cb = forward<decltype(cb)>(cb);
-}
-
-/**
- * Set callback handler for raw INPUT events
- */
-void eventloop::set_input_db(callback<string>&& cb) {
-  m_unrecognized_input_cb = forward<decltype(cb)>(cb);
+  return true;
 }
 
 /**
@@ -184,165 +185,101 @@ void eventloop::dispatch_modules() {
   }
 }
 
-/**
- * Dispatch queue worker thread
- */
-void eventloop::dispatch_queue_worker() {
-  while (m_running) {
-    entry_t evt, next{static_cast<uint8_t>(event_type::NONE)};
-    m_queue.wait_dequeue(evt);
-
-    if (!m_running) {
-      break;
-    }
-
-    if (m_delayed_entry.type != 0 && compare_events(evt, m_delayed_entry)) {
-      m_delayed_cond.notify_one();
-    }
-
-    size_t swallowed{0};
-    while (swallowed++ < m_swallow_limit && m_queue.wait_dequeue_timed(next, m_swallow_time)) {
-      if (match_event(next, event_type::QUIT)) {
-        evt = next;
-        break;
-      } else if (!compare_events(evt, next)) {
-        enqueue(move(next));
-        break;
-      }
-
-      m_log.trace_x("eventloop: Swallowing event within timeframe");
-      evt = next;
-    }
-
-    forward_event(evt);
-  }
-
-  m_log.info("Queue worker done");
-}
-
-/**
- * Dispatch delayed worker thread
- */
-void eventloop::dispatch_delayed_worker() {
-  while (true) {
-    // wait for notification
-    while (m_running && m_delayed_entry.type != 0) {
-      std::unique_lock<std::mutex> guard(m_delayed_lock);
-      m_delayed_cond.wait(guard, [&] { return m_delayed_entry.type != 0 || !m_running; });
-    }
-
-    if (!m_running) {
-      break;
-    }
-
-    this_thread::sleep_for(m_delayed_time);
-    m_delayed_entry.type = 0;
-  }
-
-  m_log.info("Delayed worker done");
-}
-
-/**
- * Test if event matches given type
- */
-inline bool eventloop::match_event(entry_t evt, event_type type) {
-  return static_cast<uint8_t>(type) == evt.type;
-}
-
 /**
  * Compare given events
  */
-inline bool eventloop::compare_events(entry_t evt, entry_t evt2) {
-  if (evt.type != evt2.type) {
-    return false;
-  } else if (match_event(evt, event_type::INPUT)) {
-    return evt.data[0] == evt2.data[0] && strncmp(evt.data, evt2.data, strlen(evt.data)) == 0;
-  }
+inline bool eventloop::compare_events(event evt, event evt2) {
+  return evt.type != evt2.type;
+}
 
-  return true;
+inline bool eventloop::compare_events(input_data data, input_data data2) {
+  return data.data[0] == data2.data[0] && strncmp(data.data, data2.data, strlen(data.data)) == 0;
 }
 
 /**
  * Forward event to handler based on type
  */
-void eventloop::forward_event(entry_t evt) {
-  if (evt.type == static_cast<uint8_t>(event_type::UPDATE)) {
-    on_update(reinterpret_cast<const update_event&>(evt));
-  } else if (evt.type == static_cast<uint8_t>(event_type::INPUT)) {
-    on_input(reinterpret_cast<const input_event&>(evt));
+void eventloop::forward_event(event evt) {
+  if (evt.type == static_cast<uint8_t>(event_type::QUIT)) {
+    m_sig.emit(process_quit{reinterpret_cast<event&&>(evt)});
+  } else if (evt.type == static_cast<uint8_t>(event_type::UPDATE)) {
+    m_sig.emit(process_update{reinterpret_cast<event&&>(evt)});
   } else if (evt.type == static_cast<uint8_t>(event_type::CHECK)) {
-    on_check();
-  } else if (evt.type == static_cast<uint8_t>(event_type::QUIT)) {
-    on_quit(reinterpret_cast<const quit_event&>(evt));
+    m_sig.emit(process_check{reinterpret_cast<event&&>(evt)});
   } else {
     m_log.warn("Unknown event type for enqueued event (%d)", evt.type);
   }
 }
 
-/**
- * Handler for enqueued UPDATE events
- */
-void eventloop::on_update(const update_event& evt) {
-  m_log.trace("eventloop: Received UPDATE event");
-
-  if (m_update_cb) {
-    m_update_cb(evt.force);
-  } else {
-    m_log.warn("No callback to handle update");
-  }
-}
-
-/**
- * Handler for enqueued INPUT events
- */
-void eventloop::on_input(const input_event& evt) {
-  m_log.trace("eventloop: Received INPUT event");
+bool eventloop::on(const process_input& evt) {
+  string input{(*evt()).data};
 
   for (auto&& block : m_modules) {
     for (auto&& module : block.second) {
-      if (!module->receive_events()) {
-        continue;
-      }
-      if (module->handle_event(evt.data)) {
-        return;
+      if (module->receive_events() && module->handle_event(input)) {
+        return true;
       }
     }
   }
 
-  if (m_unrecognized_input_cb) {
-    m_unrecognized_input_cb(evt.data);
-  } else {
-    m_log.warn("No callback to handle unrecognized input");
-  }
+  m_log.warn("Input event \"%s\" was rejected by all modules, passing to shell...", input);
+
+  return false;
 }
 
-/**
- * Handler for enqueued CHECK events
- */
-void eventloop::on_check() {
+bool eventloop::on(const process_check&) {
   for (const auto& block : m_modules) {
     for (const auto& module : block.second) {
       if (m_running && module->running()) {
-        return;
+        return true;
       }
     }
   }
-
   m_log.warn("No running modules...");
-
-  stop();
+  enqueue(make_quit_evt(false));
+  return true;
 }
 
-/**
- * Handler for enqueued QUIT events
- */
-void eventloop::on_quit(const quit_event& evt) {
-  m_log.trace("eventloop: Received QUIT event");
+bool eventloop::on(const process_quit& evt) {
+  assert((*evt()).type == static_cast<uint8_t>(event_type::QUIT));
+  const event quit{static_cast<const event>(*evt())};
+  m_log.info("Processing QUIT event (reload=%i)", quit.flag);
   m_running = false;
+  return !quit.flag;  // break emit chain if reload flag isn't set
+}
 
-  if (evt.reload) {
-    kill(getpid(), SIGUSR1);
+bool eventloop::on(const enqueue_event& evt) {
+  m_log.trace("eventloop: enqueuing event (type=%i)", (*evt()).type);
+  return enqueue(static_cast<event>(*evt()));
+}
+
+bool eventloop::on(const enqueue_quit& evt) {
+  assert((*evt()).type == static_cast<uint8_t>(event_type::QUIT));
+  if (m_running) {
+    const event quit{reinterpret_cast<const event&>(*evt())};
+    m_log.info("Enqueuing QUIT event (reload=%i)", quit.flag);
+    return enqueue(static_cast<event>(*evt()));
   }
+  return true;
+}
+
+bool eventloop::on(const enqueue_update& evt) {
+  event update{reinterpret_cast<const event&>(*evt())};
+  assert(update.type == static_cast<uint8_t>(event_type::UPDATE));
+  m_log.trace("eventloop: enqueuing UPDATE event (force=%i)", update.flag);
+  return enqueue(move(update));
+}
+
+bool eventloop::on(const enqueue_input& evt) {
+  m_log.trace("eventloop: enqueuing INPUT event");
+  return enqueue(input_data{(*evt())}) && enqueue(make_input_evt());
+}
+
+bool eventloop::on(const enqueue_check& evt) {
+  event check{reinterpret_cast<const event&>(*evt())};
+  assert(check.type == static_cast<uint8_t>(event_type::CHECK));
+  m_log.trace("eventloop: enqueuing CHECK event");
+  return enqueue(move(check));
 }
 
 POLYBAR_NS_END

src/components/ipc.cpp

@@ -4,12 +4,16 @@
 
 #include "components/ipc.hpp"
 #include "config.hpp"
+#include "events/signal.hpp"
+#include "events/signal_emitter.hpp"
 #include "utils/file.hpp"
 #include "utils/io.hpp"
 #include "utils/string.hpp"
 
 POLYBAR_NS
 
+using namespace signals::ipc;
+
 /**
  * Interrupt the blocked listener and
  * remove the file handler
@@ -28,27 +32,6 @@ ipc::~ipc() {
   }
 }
 
-/**
- * Register listener callback for ipc_command messages
- */
-void ipc::attach_callback(callback<const ipc_command&>&& cb) {
-  m_command_callbacks.emplace_back(cb);
-}
-
-/**
- * Register listener callback for ipc_hook messages
- */
-void ipc::attach_callback(callback<const ipc_hook&>&& cb) {
-  m_hook_callbacks.emplace_back(cb);
-}
-
-/**
- * Register listener callback for ipc_action messages
- */
-void ipc::attach_callback(callback<const ipc_action&>&& cb) {
-  m_action_callbacks.emplace_back(cb);
-}
-
 /**
  * Start listening for event messages
  */
@@ -76,53 +59,20 @@ void ipc::parse(const string& payload) const {
   if (payload.empty()) {
     return;
   } else if (payload.find(ipc_command::prefix) == 0) {
-    delegate(ipc_command{payload});
+    ipc_command msg{};
+    memcpy(msg.payload, &payload[0], payload.size());
+    m_sig.emit(process_command{move(msg)});
   } else if (payload.find(ipc_hook::prefix) == 0) {
-    delegate(ipc_hook{payload});
+    ipc_hook msg{};
+    memcpy(msg.payload, &payload[0], payload.size());
+    m_sig.emit(process_hook{move(msg)});
   } else if (payload.find(ipc_action::prefix) == 0) {
-    delegate(ipc_action{payload});
+    ipc_action msg{};
+    memcpy(msg.payload, &payload[0], payload.size());
+    m_sig.emit(process_action{move(msg)});
   } else {
     m_log.warn("Received unknown ipc message: (payload=%s)", payload);
   }
 }
 
-/**
- * Send ipc message to attached listeners
- */
-void ipc::delegate(const ipc_command& message) const {
-  if (!m_command_callbacks.empty()) {
-    for (auto&& callback : m_command_callbacks) {
-      callback(message);
-    }
-  } else {
-    m_log.warn("Unhandled message (payload=%s)", message.payload);
-  }
-}
-
-/**
- * Send ipc message to attached listeners
- */
-void ipc::delegate(const ipc_hook& message) const {
-  if (!m_hook_callbacks.empty()) {
-    for (auto&& callback : m_hook_callbacks) {
-      callback(message);
-    }
-  } else {
-    m_log.warn("Unhandled message (payload=%s)", message.payload);
-  }
-}
-
-/**
- * Send ipc message to attached listeners
- */
-void ipc::delegate(const ipc_action& message) const {
-  if (!m_action_callbacks.empty()) {
-    for (auto&& callback : m_action_callbacks) {
-      callback(message);
-    }
-  } else {
-    m_log.warn("Unhandled message (payload=%s)", message.payload);
-  }
-}
-
 POLYBAR_NS_END

src/components/logger.cpp

@@ -1,7 +1,5 @@
 #include <unistd.h>
 
-#include <utility>
-
 #include "components/logger.hpp"
 #include "errors.hpp"
 #include "utils/string.hpp"
@@ -12,8 +10,8 @@ POLYBAR_NS
  * Construct logger
  */
 logger::logger(loglevel level) : m_level(level) {
+  // clang-format off
   if (isatty(m_fd)) {
-    // clang-format off
     m_prefixes[loglevel::TRACE]   = "\r\033[0;90m- ";
     m_prefixes[loglevel::INFO]    = "\r\033[1;32m* \033[0m";
     m_prefixes[loglevel::WARNING] = "\r\033[1;33mwarn: \033[0m";
@@ -22,8 +20,17 @@ logger::logger(loglevel level) : m_level(level) {
     m_suffixes[loglevel::INFO]    = "\033[0m";
     m_suffixes[loglevel::WARNING] = "\033[0m";
     m_suffixes[loglevel::ERROR]   = "\033[0m";
-    // clang-format on
+  } else {
+    m_prefixes.emplace(make_pair(loglevel::TRACE,   "polybar|trace  "));
+    m_prefixes.emplace(make_pair(loglevel::INFO,    "polybar|infoe  "));
+    m_prefixes.emplace(make_pair(loglevel::WARNING, "polybar|warne  "));
+    m_prefixes.emplace(make_pair(loglevel::ERROR,   "polybar|error  "));
+    m_suffixes.emplace(make_pair(loglevel::TRACE,   ""));
+    m_suffixes.emplace(make_pair(loglevel::INFO,    ""));
+    m_suffixes.emplace(make_pair(loglevel::WARNING, ""));
+    m_suffixes.emplace(make_pair(loglevel::ERROR,   ""));
   }
+  // clang-format on
 }
 
 /**

src/components/parser.cpp

@@ -2,33 +2,21 @@
 
 #include "components/logger.hpp"
 #include "components/parser.hpp"
-#include "components/signals.hpp"
 #include "components/types.hpp"
+#include "events/signal.hpp"
+#include "events/signal_emitter.hpp"
 #include "utils/math.hpp"
 #include "utils/string.hpp"
 
 POLYBAR_NS
 
+using namespace signals::parser;
+
 /**
  * Construct parser instance
  */
-parser::parser(const logger& logger, const bar_settings& bar) : m_log(logger), m_bar(bar) {
-  assert(g_signals::parser::background_change != nullptr);
-  assert(g_signals::parser::foreground_change != nullptr);
-  assert(g_signals::parser::underline_change != nullptr);
-  assert(g_signals::parser::overline_change != nullptr);
-  assert(g_signals::parser::alignment_change != nullptr);
-  assert(g_signals::parser::attribute_set != nullptr);
-  assert(g_signals::parser::attribute_unset != nullptr);
-  assert(g_signals::parser::attribute_toggle != nullptr);
-  assert(g_signals::parser::font_change != nullptr);
-  assert(g_signals::parser::pixel_offset != nullptr);
-  assert(g_signals::parser::action_block_open != nullptr);
-  assert(g_signals::parser::action_block_close != nullptr);
-  assert(g_signals::parser::ascii_text_write != nullptr);
-  assert(g_signals::parser::unicode_text_write != nullptr);
-  assert(g_signals::parser::string_write != nullptr);
-}
+parser::parser(signal_emitter& emitter, const logger& logger, const bar_settings& bar)
+    : m_sig(emitter), m_log(logger), m_bar(bar) {}
 
 /**
  * Process input string
@@ -82,61 +70,61 @@ void parser::codeblock(string data) {
 
     switch (tag) {
       case 'B':
-        g_signals::parser::background_change(parse_color(value, m_bar.background));
+        m_sig.emit(change_background{parse_color(value, m_bar.background)});
         break;
 
       case 'F':
-        g_signals::parser::foreground_change(parse_color(value, m_bar.foreground));
+        m_sig.emit(change_foreground{parse_color(value, m_bar.foreground)});
         break;
 
       case 'T':
-        g_signals::parser::font_change(parse_fontindex(value));
+        m_sig.emit(change_font{parse_fontindex(value)});
         break;
 
       case 'U':
-        g_signals::parser::underline_change(parse_color(value, m_bar.underline.color));
-        g_signals::parser::overline_change(parse_color(value, m_bar.overline.color));
+        m_sig.emit(change_underline{parse_color(value, m_bar.underline.color)});
+        m_sig.emit(change_overline{parse_color(value, m_bar.overline.color)});
         break;
 
       case 'u':
-        g_signals::parser::underline_change(parse_color(value, m_bar.underline.color));
+        m_sig.emit(change_underline{parse_color(value, m_bar.underline.color)});
         break;
 
       case 'o':
-        g_signals::parser::overline_change(parse_color(value, m_bar.overline.color));
+        m_sig.emit(change_overline{parse_color(value, m_bar.overline.color)});
         break;
 
       case 'R':
-        g_signals::parser::background_change(m_bar.foreground);
-        g_signals::parser::foreground_change(m_bar.background);
+        m_sig.emit(change_background{parse_color(value, m_bar.foreground)});
+        m_sig.emit(change_foreground{parse_color(value, m_bar.background)});
         break;
 
       case 'O':
-        g_signals::parser::pixel_offset(atoi(value.c_str()));
+        m_sig.emit(offset_pixel{static_cast<int16_t>(std::atoi(value.c_str()))});
         break;
 
       case 'l':
-        g_signals::parser::alignment_change(alignment::LEFT);
+        m_sig.emit(change_alignment{alignment::LEFT});
         break;
 
       case 'c':
-        g_signals::parser::alignment_change(alignment::CENTER);
+        m_sig.emit(change_alignment{alignment::CENTER});
         break;
 
       case 'r':
-        g_signals::parser::alignment_change(alignment::RIGHT);
+        m_sig.emit(change_alignment{alignment::RIGHT});
         break;
 
       case '+':
-        g_signals::parser::attribute_set(parse_attr(value[0]));
+        m_sig.emit(attribute_set{parse_attr(value[0])});
         break;
 
       case '-':
-        g_signals::parser::attribute_unset(parse_attr(value[0]));
+        m_sig.emit(attribute_unset{parse_attr(value[0])});
         break;
 
       case '!':
-        g_signals::parser::attribute_toggle(parse_attr(value[0]));
+        m_sig.emit(attribute_toggle{parse_attr(value[0])});
         break;
 
       case 'A':
@@ -145,7 +133,7 @@ void parser::codeblock(string data) {
           mousebtn btn = parse_action_btn(data);
           m_actions.push_back(static_cast<int>(btn));
 
-          g_signals::parser::action_block_open(btn, value);
+          m_sig.emit(action_begin{action{btn, value}});
 
           // make sure we strip the correct length (btn+wrapping colons)
           if (value[0] != ':') {
@@ -153,7 +141,7 @@ void parser::codeblock(string data) {
           }
           value += "::";
         } else if (!m_actions.empty()) {
-          g_signals::parser::action_block_close(parse_action_btn(value));
+          m_sig.emit(action_end{parse_action_btn(value)});
           m_actions.pop_back();
         }
         break;
@@ -172,7 +160,7 @@ void parser::codeblock(string data) {
  * Process text contents
  */
 size_t parser::text(string data) {
-  uint8_t* utf = (uint8_t*)data.c_str();
+  uint8_t* utf = reinterpret_cast<uint8_t*>(const_cast<char*>(data.c_str()));
 
   if (utf[0] < 0x80) {
     // grab all consecutive ascii chars
@@ -184,25 +172,26 @@ size_t parser::text(string data) {
     while (utf[n] != '\0' && utf[++n] < 0x80) {
       ;
     }
-    g_signals::parser::string_write(data.substr(0, n).c_str(), n);
+    m_sig.emit(write_text_string{data.substr(0, n)});
     return n;
   } else if ((utf[0] & 0xe0) == 0xc0) {  // 2 byte utf-8 sequence
-    g_signals::parser::unicode_text_write((utf[0] & 0x1f) << 6 | (utf[1] & 0x3f));
+    m_sig.emit(write_text_unicode{static_cast<uint16_t>((utf[0] & 0x1f) << 6 | (utf[1] & 0x3f))});
     return 2;
   } else if ((utf[0] & 0xf0) == 0xe0) {  // 3 byte utf-8 sequence
-    g_signals::parser::unicode_text_write((utf[0] & 0xf) << 12 | (utf[1] & 0x3f) << 6 | (utf[2] & 0x3f));
+    m_sig.emit(
+        write_text_unicode{static_cast<uint16_t>((utf[0] & 0xf) << 12 | (utf[1] & 0x3f) << 6 | (utf[2] & 0x3f))});
     return 3;
   } else if ((utf[0] & 0xf8) == 0xf0) {  // 4 byte utf-8 sequence
-    g_signals::parser::unicode_text_write(0xfffd);
+    m_sig.emit(write_text_unicode{static_cast<uint16_t>(0xfffd)});
     return 4;
   } else if ((utf[0] & 0xfc) == 0xf8) {  // 5 byte utf-8 sequence
-    g_signals::parser::unicode_text_write(0xfffd);
+    m_sig.emit(write_text_unicode{static_cast<uint16_t>(0xfffd)});
     return 5;
   } else if ((utf[0] & 0xfe) == 0xfc) {  // 6 byte utf-8 sequence
-    g_signals::parser::unicode_text_write(0xfffd);
+    m_sig.emit(write_text_unicode{static_cast<uint16_t>(0xfffd)});
     return 6;
   } else {  // invalid utf-8 sequence
-    g_signals::parser::ascii_text_write(utf[0]);
+    m_sig.emit(write_text_ascii{utf[0]});
     return 1;
   }
 }

src/components/renderer.cpp

@@ -2,6 +2,9 @@
 #include "components/logger.hpp"
 #include "components/types.hpp"
 #include "errors.hpp"
+#include "events/signal.hpp"
+#include "events/signal_emitter.hpp"
+#include "events/signal.hpp"
 #include "x11/connection.hpp"
 #include "x11/draw.hpp"
 #include "x11/fonts.hpp"
@@ -12,30 +15,19 @@
 
 POLYBAR_NS
 
-/**
- * Configure injection module
- */
-di::injector<unique_ptr<renderer>> configure_renderer(const bar_settings& bar, const vector<string>& fonts) {
-  // clang-format off
-  return di::make_injector(
-      di::bind<>().to(bar),
-      di::bind<>().to(fonts),
-      configure_connection(),
-      configure_logger(),
-      configure_font_manager());
-  // clang-format on
-}
-
 /**
  * Construct renderer instance
  */
-renderer::renderer(connection& conn, const logger& logger, unique_ptr<font_manager> font_manager,
-    const bar_settings& bar, const vector<string>& fonts)
+renderer::renderer(connection& conn, signal_emitter& emitter, const logger& logger,
+    unique_ptr<font_manager> font_manager, const bar_settings& bar, const vector<string>& fonts)
     : m_connection(conn)
+    , m_sig(emitter)
     , m_log(logger)
     , m_fontmanager(forward<decltype(font_manager)>(font_manager))
-    , m_bar(bar)
-    , m_rect(bar.inner_area()) {
+    , m_bar(forward<const bar_settings&>(bar))
+    , m_rect(m_bar.inner_area()) {
+  m_sig.attach(this);
+
   m_log.trace("renderer: Get TrueColor visual");
   m_visual = m_connection.visual_type(m_connection.screen(), 32).get();
 
@@ -127,11 +119,9 @@ renderer::renderer(connection& conn, const logger& logger, unique_ptr<font_manag
     if (!fonts_loaded && !fonts.empty()) {
       m_log.warn("Unable to load fonts, using fallback font \"fixed\"");
     }
-
     if (!fonts_loaded && !m_fontmanager->load("fixed")) {
       throw application_error("Unable to load fonts");
     }
-
     m_fontmanager->allocate_color(m_bar.foreground, true);
   }
 }
@@ -140,6 +130,8 @@ renderer::renderer(connection& conn, const logger& logger, unique_ptr<font_manag
  * Deconstruct instance
  */
 renderer::~renderer() {
+  m_sig.detach(this);
+
   if (m_window != XCB_NONE) {
     m_connection.destroy_window(m_window);
   }
@@ -183,7 +175,7 @@ void renderer::end() {
 }
 
 /**
- * Redraw window contents
+ * Flush pixmap contents onto the target window
  */
 void renderer::flush(bool clear) {
   const xcb_rectangle_t& r = m_rect;
@@ -291,110 +283,14 @@ void renderer::reserve_space(edge side, uint16_t w) {
 }
 
 /**
- * Change value of background gc
- */
-void renderer::set_background(const uint32_t color) {
-  if (m_colors[gc::BG] == color) {
-    return m_log.trace_x("renderer: ignoring unchanged background color(#%08x)", color);
-  }
-  m_log.trace_x("renderer: set_background(#%08x)", color);
-  m_connection.change_gc(m_gcontexts.at(gc::BG), XCB_GC_FOREGROUND, &color);
-  m_colors[gc::BG] = color;
-  shift_content(0);
-}
-
-/**
- * Change value of foreground gc
- */
-void renderer::set_foreground(const uint32_t color) {
-  if (m_colors[gc::FG] == color) {
-    return m_log.trace_x("renderer: ignoring unchanged foreground color(#%08x)", color);
-  }
-  m_log.trace_x("renderer: set_foreground(#%08x)", color);
-  m_connection.change_gc(m_gcontexts.at(gc::FG), XCB_GC_FOREGROUND, &color);
-  m_fontmanager->allocate_color(color);
-  m_colors[gc::FG] = color;
-}
-
-/**
- * Change value of underline gc
- */
-void renderer::set_underline(const uint32_t color) {
-  if (m_colors[gc::UL] == color) {
-    return m_log.trace_x("renderer: ignoring unchanged underline color(#%08x)", color);
-  }
-  m_log.trace_x("renderer: set_underline(#%08x)", color);
-  m_connection.change_gc(m_gcontexts.at(gc::UL), XCB_GC_FOREGROUND, &color);
-  m_colors[gc::UL] = color;
-}
-
-/**
- * Change value of overline gc
- */
-void renderer::set_overline(const uint32_t color) {
-  if (m_colors[gc::OL] == color) {
-    return m_log.trace_x("renderer: ignoring unchanged overline color(#%08x)", color);
-  }
-  m_log.trace_x("renderer: set_overline(#%08x)", color);
-  m_connection.change_gc(m_gcontexts.at(gc::OL), XCB_GC_FOREGROUND, &color);
-  m_colors[gc::OL] = color;
-}
-
-/**
- * Change preferred font index used when matching glyphs
- */
-void renderer::set_fontindex(const int8_t font) {
-  if (m_fontindex == font) {
-    return m_log.trace_x("renderer: ignoring unchanged font index(%i)", static_cast<int8_t>(font));
-  }
-  m_log.trace_x("renderer: set_fontindex(%i)", static_cast<int8_t>(font));
-  m_fontmanager->set_preferred_font(font);
-  m_fontindex = font;
-}
-
-/**
- * Change current alignment
- */
-void renderer::set_alignment(const alignment align) {
-  if (align == m_alignment) {
-    return m_log.trace_x("renderer: ignoring unchanged alignment(%i)", static_cast<uint8_t>(align));
-  }
-
-  m_log.trace_x("renderer: set_alignment(%i)", static_cast<uint8_t>(align));
-  m_alignment = align;
-  m_currentx = 0;
-}
-
-/**
- * Enable/remove attribute
- */
-void renderer::set_attribute(const attribute attr, bool state) {
-  m_log.trace_x("renderer: set_attribute(%i, %i)", static_cast<uint8_t>(attr), state);
-
-  if (state) {
-    m_attributes |= 1U << static_cast<uint8_t>(attr);
-  } else {
-    m_attributes &= ~(1U << static_cast<uint8_t>(attr));
-  }
-}
-
-/**
- * Toggle attribute
- */
-void renderer::toggle_attribute(const attribute attr) {
-  m_log.trace_x("renderer: toggle_attribute(%i)", static_cast<uint8_t>(attr));
-  m_attributes ^= 1U << static_cast<uint8_t>(attr);
-}
-
-/**
- * Check if the given attribute is set
+ * Check if given attribute is enabled
  */
 bool renderer::check_attribute(const attribute attr) {
   return (m_attributes >> static_cast<uint8_t>(attr)) & 1U;
 }
 
 /**
- * Fill background area
+ * Fill background color
  */
 void renderer::fill_background() {
   m_log.trace_x("renderer: fill_background");
@@ -402,7 +298,7 @@ void renderer::fill_background() {
 }
 
 /**
- * Fill overline area
+ * Fill overline color
  */
 void renderer::fill_overline(int16_t x, uint16_t w) {
   if (!check_attribute(attribute::OVERLINE)) {
@@ -415,7 +311,7 @@ void renderer::fill_overline(int16_t x, uint16_t w) {
 }
 
 /**
- * Fill underline area
+ * Fill underline color
  */
 void renderer::fill_underline(int16_t x, uint16_t w) {
   if (!check_attribute(attribute::UNDERLINE)) {
@@ -429,7 +325,7 @@ void renderer::fill_underline(int16_t x, uint16_t w) {
 }
 
 /**
- * Shift filled area by given pixels
+ * @see shift_content
  */
 void renderer::fill_shift(const int16_t px) {
   shift_content(px);
@@ -469,7 +365,7 @@ void renderer::draw_character(uint16_t character) {
 }
 
 /**
- * Draw character glyphs
+ * Draw consecutive character glyphs
  */
 void renderer::draw_textstring(const char* text, size_t len) {
   m_log.trace_x("renderer: draw_textstring(\"%s\")", text);
@@ -493,7 +389,6 @@ void renderer::draw_textstring(const char* text, size_t len) {
       chars.emplace_back(text[++n]);
     }
 
-    // TODO: cache
     auto width = m_fontmanager->char_width(font, chars[0]) * chars.size();
     auto x = shift_content(width);
     auto y = m_rect.height / 2 + font->height / 2 - font->descent + font->offset_y;
@@ -517,70 +412,14 @@ void renderer::draw_textstring(const char* text, size_t len) {
 }
 
 /**
- * Create new action block at the current position
- */
-void renderer::begin_action(const mousebtn btn, const string& cmd) {
-  action_block action{};
-  action.button = btn;
-  action.align = m_alignment;
-  action.start_x = m_currentx;
-  action.command = string_util::replace_all(cmd, ":", "\\:");
-  action.active = true;
-  if (action.button == mousebtn::NONE) {
-    action.button = mousebtn::LEFT;
-  }
-  m_log.trace_x("renderer: begin_action(%i, %s)", static_cast<uint8_t>(action.button), cmd.c_str());
-  m_actions.emplace_back(action);
-}
-
-/**
- * End action block at the current position
- */
-void renderer::end_action(const mousebtn btn) {
-  int16_t clickable_width{0};
-
-  for (auto action = m_actions.rbegin(); action != m_actions.rend(); action++) {
-    if (!action->active || action->align != m_alignment || action->button != btn) {
-      continue;
-    }
-
-    action->active = false;
-
-    switch (action->align) {
-      case alignment::NONE:
-        break;
-      case alignment::LEFT:
-        action->end_x = m_currentx;
-        break;
-      case alignment::CENTER:
-        clickable_width = m_currentx - action->start_x;
-        action->start_x = m_rect.width / 2 - clickable_width / 2 + action->start_x / 2;
-        action->end_x = action->start_x + clickable_width;
-        break;
-      case alignment::RIGHT:
-        action->start_x = m_rect.width - m_currentx + action->start_x;
-        action->end_x = m_rect.width;
-        break;
-    }
-
-    action->start_x += m_bar.pos.x + m_rect.x;
-    action->end_x += m_bar.pos.x + m_rect.x;
-
-    m_log.trace_x("renderer: end_action(%i, %s, %i)", static_cast<uint8_t>(btn), action->command, action->width());
-
-    return;
-  }
-}
-
-/**
- * Get all action blocks
+ * Get completed action blocks
  */
 const vector<action_block> renderer::get_actions() {
   return m_actions;
 }
 
 /**
- * Shift contents by given pixel value
+ * Shift pixmap content by given value
  */
 int16_t renderer::shift_content(int16_t x, const int16_t shift_x) {
   m_log.trace_x("renderer: shift_content(%i)", shift_x);
@@ -628,7 +467,7 @@ int16_t renderer::shift_content(int16_t x, const int16_t shift_x) {
 }
 
 /**
- * Shift contents by given pixel value
+ * @see shift_content
  */
 int16_t renderer::shift_content(const int16_t shift_x) {
   return shift_content(m_currentx, shift_x);
@@ -636,7 +475,7 @@ int16_t renderer::shift_content(const int16_t shift_x) {
 
 #ifdef DEBUG_HINTS
 /**
- * Draw debugging hints onto the output window
+ * Draw boxes at the location of each created action block
  */
 void renderer::debug_hints() {
   uint16_t border_width{1};
@@ -685,4 +524,185 @@ void renderer::debug_hints() {
 }
 #endif
 
+bool renderer::on(const change_background& evt) {
+  uint32_t color{*evt()};
+
+  if (m_colors[gc::BG] == color) {
+    m_log.trace_x("renderer: ignoring unchanged background color(#%08x)", color);
+  } else {
+    m_log.trace_x("renderer: set_background(#%08x)", color);
+    m_connection.change_gc(m_gcontexts.at(gc::BG), XCB_GC_FOREGROUND, &color);
+    m_colors[gc::BG] = color;
+    shift_content(0);
+  }
+
+  return true;
+}
+
+bool renderer::on(const change_foreground& evt) {
+  uint32_t color{*evt()};
+
+  if (m_colors[gc::FG] == color) {
+    m_log.trace_x("renderer: ignoring unchanged foreground color(#%08x)", color);
+  } else {
+    m_log.trace_x("renderer: set_foreground(#%08x)", color);
+    m_connection.change_gc(m_gcontexts.at(gc::FG), XCB_GC_FOREGROUND, &color);
+    m_fontmanager->allocate_color(color);
+    m_colors[gc::FG] = color;
+  }
+
+  return true;
+}
+
+bool renderer::on(const change_underline& evt) {
+  uint32_t color{*evt()};
+
+  if (m_colors[gc::UL] == color) {
+    m_log.trace_x("renderer: ignoring unchanged underline color(#%08x)", color);
+  } else {
+    m_log.trace_x("renderer: set_underline(#%08x)", color);
+    m_connection.change_gc(m_gcontexts.at(gc::UL), XCB_GC_FOREGROUND, &color);
+    m_colors[gc::UL] = color;
+  }
+
+  return true;
+}
+
+bool renderer::on(const change_overline& evt) {
+  uint32_t color{*evt()};
+
+  if (m_colors[gc::OL] == color) {
+    m_log.trace_x("renderer: ignoring unchanged overline color(#%08x)", color);
+  } else {
+    m_log.trace_x("renderer: set_overline(#%08x)", color);
+    m_connection.change_gc(m_gcontexts.at(gc::OL), XCB_GC_FOREGROUND, &color);
+    m_colors[gc::OL] = color;
+  }
+
+  return true;
+}
+
+bool renderer::on(const change_font& evt) {
+  int8_t font{*evt()};
+
+  if (m_fontindex == font) {
+    m_log.trace_x("renderer: ignoring unchanged font index(%i)", static_cast<int8_t>(font));
+  } else {
+    m_log.trace_x("renderer: set_fontindex(%i)", static_cast<int8_t>(font));
+    m_fontmanager->set_preferred_font(font);
+    m_fontindex = font;
+  }
+
+  return true;
+}
+
+bool renderer::on(const change_alignment& evt) {
+  alignment align{*evt()};
+
+  if (align == m_alignment) {
+    m_log.trace_x("renderer: ignoring unchanged alignment(%i)", static_cast<uint8_t>(align));
+  } else {
+    m_log.trace_x("renderer: set_alignment(%i)", static_cast<uint8_t>(align));
+    m_alignment = align;
+    m_currentx = 0;
+  }
+
+  return true;
+}
+
+bool renderer::on(const offset_pixel& evt) {
+  shift_content(*evt());
+  return true;
+}
+
+bool renderer::on(const attribute_set& evt) {
+  m_log.trace_x("renderer: attribute_set(%i, %i)", static_cast<uint8_t>(*evt()), true);
+  m_attributes |= 1U << static_cast<uint8_t>(*evt());
+  return true;
+}
+
+bool renderer::on(const attribute_unset& evt) {
+  m_log.trace_x("renderer: attribute_unset(%i, %i)", static_cast<uint8_t>(*evt()), true);
+  m_attributes &= ~(1U << static_cast<uint8_t>(*evt()));
+  return true;
+}
+
+bool renderer::on(const attribute_toggle& evt) {
+  m_log.trace_x("renderer: attribute_toggle(%i)", static_cast<uint8_t>(*evt()));
+  m_attributes ^= 1U << static_cast<uint8_t>(*evt());
+  return true;
+}
+
+bool renderer::on(const action_begin& evt) {
+  action a{*evt()};
+  action_block action{};
+  action.button = a.button;
+  action.align = m_alignment;
+  action.start_x = m_currentx;
+  action.command = string_util::replace_all(a.command, ":", "\\:");
+  action.active = true;
+
+  if (action.button == mousebtn::NONE) {
+    action.button = mousebtn::LEFT;
+  }
+
+  m_log.trace_x("renderer: action_begin(%i, %s)", static_cast<uint8_t>(a.button), a.command.c_str());
+  m_actions.emplace_back(action);
+
+  return true;
+}
+
+bool renderer::on(const action_end& evt) {
+  mousebtn btn{*evt()};
+  int16_t clickable_width{0};
+
+  for (auto action = m_actions.rbegin(); action != m_actions.rend(); action++) {
+    if (!action->active || action->align != m_alignment || action->button != btn) {
+      continue;
+    }
+
+    action->active = false;
+
+    switch (action->align) {
+      case alignment::NONE:
+        break;
+      case alignment::LEFT:
+        action->end_x = m_currentx;
+        break;
+      case alignment::CENTER:
+        clickable_width = m_currentx - action->start_x;
+        action->start_x = m_rect.width / 2 - clickable_width / 2 + action->start_x / 2;
+        action->end_x = action->start_x + clickable_width;
+        break;
+      case alignment::RIGHT:
+        action->start_x = m_rect.width - m_currentx + action->start_x;
+        action->end_x = m_rect.width;
+        break;
+    }
+
+    action->start_x += m_bar.pos.x + m_rect.x;
+    action->end_x += m_bar.pos.x + m_rect.x;
+
+    m_log.trace_x("renderer: action_end(%i, %s, %i)", static_cast<uint8_t>(btn), action->command, action->width());
+  }
+
+  return true;
+}
+
+bool renderer::on(const write_text_ascii& evt) {
+  draw_character(*evt());
+  return true;
+}
+
+bool renderer::on(const write_text_unicode& evt) {
+  draw_character(*evt());
+  return true;
+}
+
+bool renderer::on(const write_text_string& evt) {
+  string text{*evt()};
+  draw_textstring(text.c_str(), text.size());
+  return true;
+}
+
 POLYBAR_NS_END

src/components/screen.cpp

@@ -5,33 +5,28 @@
 #include "components/eventloop.hpp"
 #include "components/logger.hpp"
 #include "components/screen.hpp"
-#include "components/signals.hpp"
 #include "components/types.hpp"
+#include "events/signal.hpp"
+#include "events/signal_emitter.hpp"
 #include "x11/connection.hpp"
 #include "x11/randr.hpp"
 #include "x11/winspec.hpp"
 
 POLYBAR_NS
 
-/**
- * Configure injection module
- */
-di::injector<unique_ptr<screen>> configure_screen() {
-  return di::make_injector(configure_connection(), configure_logger(), configure_config());
-}
+using namespace signals::eventloop;
 
 /**
  * Construct screen instance
  */
-screen::screen(connection& conn, const logger& logger, const config& conf)
+screen::screen(connection& conn, signal_emitter& emitter, const logger& logger, const config& conf)
     : m_connection(conn)
+    , m_sig(emitter)
     , m_log(logger)
     , m_conf(conf)
     , m_root(conn.root())
     , m_monitors(randr_util::get_monitors(m_connection, m_root, true))
     , m_size({conn.screen()->width_in_pixels, conn.screen()->height_in_pixels}) {
-  assert(g_signals::event::enqueue != nullptr);
-
   // Check if the reloading has been disabled by the user
   if (!m_conf.get<bool>("settings", "screenchange-reload", false)) {
     return;
@@ -105,8 +100,8 @@ void screen::handle(const evt::randr_screen_change_notify& evt) {
   }
 
   m_log.warn("randr_screen_change_notify (%ux%u)... reloading", evt->width, evt->height);
+  m_sig.emit(process_quit{eventloop::make_quit_evt(true)});
   m_sigraised = true;
-  g_signals::event::enqueue(eventloop::make(quit_event{}, true));
 }
 
 POLYBAR_NS_END

src/components/signals.cpp

@@ -1,45 +0,0 @@
-#include "components/signals.hpp"
-#include "components/types.hpp"
-
-POLYBAR_NS
-
-namespace g_signals {
-  /**
-   * Signals used to communicate with the event loop
-   */
-  namespace event {
-    callback<const eventloop::entry_t&> enqueue{noop<const eventloop::entry_t&>};
-    callback<const eventloop::entry_t&> enqueue_delayed{noop<const eventloop::entry_t&>};
-  }
-
-  /**
-   * Signals used to communicate with the bar window
-   */
-  namespace bar {
-    callback<const string> action_click{noop<const string>};
-    callback<const bool> visibility_change{noop<const bool>};
-  }
-
-  /**
-   * Signals used to communicate with the input parser
-   */
-  namespace parser {
-    callback<const uint32_t> background_change{noop<const uint32_t>};
-    callback<const uint32_t> foreground_change{noop<const uint32_t>};
-    callback<const uint32_t> underline_change{noop<const uint32_t>};
-    callback<const uint32_t> overline_change{noop<const uint32_t>};
-    callback<const alignment> alignment_change{noop<const alignment>};
-    callback<const attribute> attribute_set{noop<const attribute>};
-    callback<const attribute> attribute_unset{noop<const attribute>};
-    callback<const attribute> attribute_toggle{noop<const attribute>};
-    callback<const int8_t> font_change{noop<const int8_t>};
-    callback<const int16_t> pixel_offset{noop<const int16_t>};
-    callback<const mousebtn, const string> action_block_open{noop<const mousebtn, const string>};
-    callback<const mousebtn> action_block_close{noop<const mousebtn>};
-    callback<const uint16_t> ascii_text_write{noop<const uint16_t>};
-    callback<const uint16_t> unicode_text_write{noop<const uint16_t>};
-    callback<const char*, const size_t> string_write{noop<const char*, const size_t>};
-  }
-}
-
-POLYBAR_NS_END

src/drawtypes/animation.cpp

@@ -61,7 +61,7 @@ namespace drawtypes {
 
     auto framerate = conf.get<int>(section, name + "-framerate", 1000);
 
-    return make_shared<animation>(move(vec), framerate);
+    return factory_util::shared<animation>(move(vec), framerate);
   }
 }
 

src/drawtypes/label.cpp

@@ -19,7 +19,7 @@ namespace drawtypes {
       std::back_insert_iterator<decltype(tokens)> back_it(tokens);
       std::copy(m_tokens.begin(), m_tokens.end(), back_it);
     }
-    return make_shared<label>(m_text, m_foreground, m_background, m_underline, m_overline, m_font, m_padding, m_margin,
+    return factory_util::shared<label>(m_text, m_foreground, m_background, m_underline, m_overline, m_font, m_padding, m_margin,
         m_maxlen, m_ellipsis, move(tokens));
   }
 
@@ -145,7 +145,7 @@ namespace drawtypes {
       auto value = conf.get<int>(section, key, 0);
       auto left = conf.get<int>(section, key + "-left", value);
       auto right = conf.get<int>(section, key + "-right", value);
-      return side_values {static_cast<uint16_t>(left), static_cast<uint16_t>(right)};
+      return side_values{static_cast<uint16_t>(left), static_cast<uint16_t>(right)};
     };
 
     padding = get_left_right(name + "-padding");

src/drawtypes/ramp.cpp

@@ -45,7 +45,7 @@ namespace drawtypes {
       vec.emplace_back(move(icon));
     }
 
-    return make_shared<ramp>(move(vec));
+    return factory_util::shared<ramp>(move(vec));
   }
 }
 

src/events/signal_emitter.cpp

@@ -0,0 +1,8 @@
+#include "events/signal_emitter.hpp"
+#include "events/signal_receiver.hpp"
+
+POLYBAR_NS
+
+signal_receivers_t g_signal_receivers;
+
+POLYBAR_NS_END

src/events/signal_receiver.cpp

@@ -0,0 +1 @@
+#include "events/signal_receiver.hpp"

src/main.cpp

@@ -2,7 +2,6 @@
 
 #include "common.hpp"
 
-#include "components/bar.hpp"
 #include "components/command_line.hpp"
 #include "components/config.hpp"
 #include "components/controller.hpp"
@@ -11,7 +10,6 @@
 #include "utils/env.hpp"
 #include "utils/inotify.hpp"
 #include "utils/process.hpp"
-#include "x11/ewmh.hpp"
 #include "x11/xutils.hpp"
 
 using namespace polybar;
@@ -34,55 +32,69 @@ int main(int argc, char** argv) {
   };
   // clang-format on
 
-  logger& logger{configure_logger<decltype(logger)>(loglevel::WARNING).create<decltype(logger)>()};
-
   uint8_t exit_code{EXIT_SUCCESS};
   bool reload{false};
 
+  logger& logger{const_cast<class logger&>(make_logger(loglevel::WARNING))};
+
   try {
     //==================================================
     // Connect to X server
     //==================================================
     XInitThreads();
+    xcb_connection_t* xcbconn{nullptr};
 
-    if (!xutils::get_connection()) {
+    if ((xcbconn = xutils::get_connection()) == nullptr) {
       logger.err("A connection to X could not be established... ");
       throw exit_failure{};
     }
 
+    connection{xcbconn}.preload_atoms();
+    connection{xcbconn}.query_extensions();
+
+    //==================================================
+    // Block all signals by default
+    //==================================================
+    sigset_t blockmask;
+    sigfillset(&blockmask);
+
+    if (pthread_sigmask(SIG_BLOCK, &blockmask, nullptr) == -1) {
+      throw system_error("Failed to block signals");
+    }
+
     //==================================================
     // Parse command line arguments
     //==================================================
     string scriptname{argv[0]};
     vector<string> args(argv + 1, argv + argc);
 
-    cliparser cli{configure_cliparser<decltype(cli)>(scriptname, opts).create<decltype(cli)>()};
-    cli.process_input(args);
+    unique_ptr<cliparser> cli{make_command_line(scriptname, opts)};
+    cli->process_input(args);
 
-    if (cli.has("quiet")) {
+    if (cli->has("quiet")) {
       logger.verbosity(loglevel::ERROR);
-    } else if (cli.has("log")) {
-      logger.verbosity(cli.get("log"));
+    } else if (cli->has("log")) {
+      logger.verbosity(cli->get("log"));
     }
 
-    if (cli.has("help")) {
-      cli.usage();
+    if (cli->has("help")) {
+      cli->usage();
       throw exit_success{};
-    } else if (cli.has("version")) {
+    } else if (cli->has("version")) {
       print_build_info(version_details(args));
       throw exit_success{};
     } else if (args.empty() || args[0][0] == '-') {
-      cli.usage();
+      cli->usage();
       throw exit_failure{};
     }
 
     //==================================================
     // Load user configuration
     //==================================================
-    config& conf{configure_config<decltype(conf)>().create<decltype(conf)>()};
+    config& conf{const_cast<config&>(make_confreader())};
 
-    if (cli.has("config")) {
-      conf.load(cli.get("config"), args[0]);
+    if (cli->has("config")) {
+      conf.load(cli->get("config"), args[0]);
     } else if (env_util::has("XDG_CONFIG_HOME")) {
       conf.load(env_util::get("XDG_CONFIG_HOME") + "/polybar/config", args[0]);
     } else if (env_util::has("HOME")) {
@@ -94,37 +106,43 @@ int main(int argc, char** argv) {
     //==================================================
     // Dump requested data
     //==================================================
-    if (cli.has("dump")) {
-      std::cout << conf.get<string>(conf.bar_section(), cli.get("dump")) << std::endl;
+    if (cli->has("dump")) {
+      std::cout << conf.get<string>(conf.bar_section(), cli->get("dump")) << std::endl;
       throw exit_success{};
     }
 
     //==================================================
-    // Create config watch if we should track changes
+    // Create controller and run application
     //==================================================
-    inotify_util::watch_t watch;
+    unique_ptr<controller> ctrl;
+    bool enable_ipc{conf.get<bool>(conf.bar_section(), "enable-ipc", false)};
+    watch_t confwatch;
 
-    if (cli.has("reload")) {
-      watch = inotify_util::make_watch(conf.filepath());
+    if (cli->has("print-wmname")) {
+      enable_ipc = false;
+    } else if (cli->has("reload")) {
+      inotify_util::make_watch(conf.filepath());
     }
 
-    //==================================================
-    // Create controller
-    //==================================================
-    auto ctrl = configure_controller(watch).create<unique_ptr<controller>>();
+    ctrl = make_controller(move(confwatch), enable_ipc, cli->has("stdout"));
 
-    ctrl->bootstrap(cli.has("stdout"), cli.has("print-wmname"));
-
-    if (cli.has("print-wmname")) {
+    if (cli->has("print-wmname")) {
+      std::cout << ctrl->opts().wmname << std::endl;
       throw exit_success{};
     }
 
-    //==================================================
-    // Run application
-    //==================================================
+    ctrl->setup();
+
     if (!ctrl->run()) {
       reload = true;
     }
+
+    //==================================================
+    // Unblock signals
+    //==================================================
+    if (pthread_sigmask(SIG_UNBLOCK, &blockmask, nullptr) == -1) {
+      throw system_error("Failed to unblock signals");
+    }
   } catch (const exit_success& term) {
     exit_code = EXIT_SUCCESS;
   } catch (const exit_failure& term) {

src/modules/bspwm.cpp

@@ -118,13 +118,13 @@ namespace modules {
       m_modelabels.emplace(mode::NODE_PRIVATE, load_optional_label(m_conf, name(), "label-private"));
     }
 
-    m_icons = make_shared<iconset>();
-    m_icons->add(DEFAULT_ICON, make_shared<label>(m_conf.get<string>(name(), DEFAULT_ICON, "")));
+    m_icons = factory_util::shared<iconset>();
+    m_icons->add(DEFAULT_ICON, factory_util::shared<label>(m_conf.get<string>(name(), DEFAULT_ICON, "")));
 
     for (const auto& workspace : m_conf.get_list<string>(name(), "ws-icon", {})) {
       auto vec = string_util::split(workspace, ';');
       if (vec.size() == 2) {
-        m_icons->add(vec[0], make_shared<label>(vec[1]));
+        m_icons->add(vec[0], factory_util::shared<label>(vec[1]));
       }
     }
   }

src/modules/i3.cpp

@@ -55,13 +55,13 @@ namespace modules {
       m_modelabel = load_optional_label(m_conf, name(), "label-mode", "%mode%");
     }
 
-    m_icons = make_shared<iconset>();
-    m_icons->add(DEFAULT_WS_ICON, make_shared<label>(m_conf.get<string>(name(), DEFAULT_WS_ICON, "")));
+    m_icons = factory_util::shared<iconset>();
+    m_icons->add(DEFAULT_WS_ICON, factory_util::shared<label>(m_conf.get<string>(name(), DEFAULT_WS_ICON, "")));
 
     for (const auto& workspace : m_conf.get_list<string>(name(), "ws-icon", {})) {
       auto vec = string_util::split(workspace, ';');
       if (vec.size() == 2) {
-        m_icons->add(vec[0], make_shared<label>(vec[1]));
+        m_icons->add(vec[0], factory_util::shared<label>(vec[1]));
       }
     }
 

src/modules/mpd.cpp

@@ -30,7 +30,7 @@ namespace modules {
 
     m_formatter->add(FORMAT_OFFLINE, "", {TAG_LABEL_OFFLINE});
 
-    m_icons = make_shared<iconset>();
+    m_icons = factory_util::shared<iconset>();
 
     if (m_formatter->has(TAG_ICON_PLAY) || m_formatter->has(TAG_TOGGLE) || m_formatter->has(TAG_TOGGLE_STOP)) {
       m_icons->add("play", load_icon(m_conf, name(), TAG_ICON_PLAY));

src/modules/xbacklight.cpp

@@ -21,7 +21,7 @@ namespace modules {
    */
   xbacklight_module::xbacklight_module(const bar_settings& bar, const logger& logger, const config& config, string name)
       : static_module<xbacklight_module>(bar, logger, config, name)
-      , m_connection(configure_connection().create<connection&>()) {}
+      , m_connection(make_connection()) {}
 
   /**
    * Bootstrap the module by grabbing all required components
@@ -60,9 +60,6 @@ namespace modules {
       throw module_error("Failed to create event proxy");
     }
 
-    // Get the throttle time
-    m_randrnotify.offset = 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, SINK_PRIORITY_MODULE);
@@ -106,8 +103,6 @@ namespace modules {
       return;
     } else if (evt->u.op.atom != m_output->backlight.atom) {
       return;
-    } else if (m_randrnotify.deny(evt->u.op.timestamp)) {
-      return m_log.trace_x("%s: Ignoring randr notify (throttled)...", name());
     } else {
       update();
     }
@@ -142,8 +137,8 @@ namespace modules {
     // with the cmd handlers
     string output{module::get_output()};
 
-    m_builder->cmd(mousebtn::SCROLL_UP, EVENT_SCROLLUP, m_scroll && m_percentage < 100);
-    m_builder->cmd(mousebtn::SCROLL_DOWN, EVENT_SCROLLDOWN, m_scroll && m_percentage > 0);
+    m_builder->cmd(mousebtn::SCROLL_UP, string{EVENT_SCROLLUP}, m_scroll && m_percentage < 100);
+    m_builder->cmd(mousebtn::SCROLL_DOWN, string{EVENT_SCROLLDOWN}, m_scroll && m_percentage > 0);
 
     m_builder->append(output);
 

src/modules/xkeyboard.cpp

@@ -18,7 +18,7 @@ namespace modules {
    */
   xkeyboard_module::xkeyboard_module(const bar_settings& bar, const logger& logger, const config& config, string name)
       : static_module<xkeyboard_module>(bar, logger, config, name)
-      , m_connection(configure_connection().create<connection&>()) {}
+      , m_connection(make_connection()) {}
 
   /**
    * Bootstrap the module

src/modules/xwindow.cpp

@@ -18,7 +18,7 @@ namespace modules {
    * currently active to enable title tracking
    */
   active_window::active_window(xcb_window_t win)
-      : m_connection(configure_connection().create<decltype(m_connection)>()), m_window(m_connection, win) {
+      : m_connection(make_connection()), m_window(m_connection, win) {
     try {
       m_window.change_event_mask(XCB_EVENT_MASK_PROPERTY_CHANGE);
     } catch (const xpp::x::error::window& err) {
@@ -66,7 +66,7 @@ namespace modules {
    */
   xwindow_module::xwindow_module(const bar_settings& bar, const logger& logger, const config& config, string name)
       : static_module<xwindow_module>(bar, logger, config, name)
-      , m_connection(configure_connection().create<connection&>()) {}
+      , m_connection(make_connection()) {}
 
   /**
    * Bootstrap the module

src/modules/xworkspaces.cpp

@@ -22,7 +22,7 @@ namespace modules {
   xworkspaces_module::xworkspaces_module(
       const bar_settings& bar, const logger& logger, const config& config, string name)
       : static_module<xworkspaces_module>(bar, logger, config, name)
-      , m_connection(configure_connection().create<connection&>()) {}
+      , m_connection(make_connection()) {}
 
   /**
    * Bootstrap the module
@@ -73,13 +73,13 @@ namespace modules {
       // clang-format on
     }
 
-    m_icons = make_shared<iconset>();
-    m_icons->add(DEFAULT_ICON, make_shared<label>(m_conf.get<string>(name(), DEFAULT_ICON, "")));
+    m_icons = factory_util::shared<iconset>();
+    m_icons->add(DEFAULT_ICON, factory_util::shared<label>(m_conf.get<string>(name(), DEFAULT_ICON, "")));
 
     for (const auto& workspace : m_conf.get_list<string>(name(), "icon", {})) {
       auto vec = string_util::split(workspace, ';');
       if (vec.size() == 2) {
-        m_icons->add(vec[0], make_shared<label>(vec[1]));
+        m_icons->add(vec[0], factory_util::shared<label>(vec[1]));
       }
     }
 

src/utils/inotify.cpp

@@ -105,14 +105,13 @@ namespace inotify_util {
     return m_path;
   }
 
-  watch_t make_watch(string path) {
-    di::injector<watch_t> injector = di::make_injector(di::bind<>().to(path));
-    return injector.create<watch_t>();
-  }
-
   bool match(const event_t* evt, int mask) {
     return (evt->mask & mask) == mask;
   }
+
+  watch_t make_watch(string path) {
+    return watch_t{new watch_t::element_type{path}};
+  }
 }
 
 POLYBAR_NS_END

src/x11/color.cpp

@@ -1,5 +1,6 @@
 #include <iomanip>
 #include <utility>
+#include <map>
 
 #include "errors.hpp"
 #include "utils/color.hpp"
@@ -8,7 +9,7 @@
 
 POLYBAR_NS
 
-map<string, color> g_colorstore;
+std::map<string, color> g_colorstore;
 color g_colorempty{"#00000000"};
 color g_colorblack{"#ff000000"};
 color g_colorwhite{"#ffffffff"};

src/x11/connection.cpp

@@ -8,14 +8,6 @@
 
 POLYBAR_NS
 
-/**
- * Configure injection module
- */
-di::injector<connection&> configure_connection() {
-  return di::make_injector(di::bind<>().to(
-      factory_util::generic_singleton<connection>(xutils::get_connection(), xutils::get_connection_fd())));
-}
-
 /**
  * Preload required xcb atoms
  */

src/x11/fonts.cpp

@@ -1,6 +1,7 @@
 #include <X11/Xlib-xcb.h>
 
 #include "utils/color.hpp"
+#include "utils/factory.hpp"
 #include "utils/memory.hpp"
 #include "x11/connection.hpp"
 #include "x11/fonts.hpp"
@@ -12,8 +13,8 @@ POLYBAR_NS
 /**
  * Configure injection module
  */
-di::injector<unique_ptr<font_manager>> configure_font_manager() {
-  return di::make_injector(configure_connection(), configure_logger());
+unique_ptr<font_manager> make_font_manager() {
+  return factory_util::unique<font_manager>(make_connection(), make_logger());
 }
 
 array<char, XFT_MAXCHARS> xft_widths;

src/x11/tray_client.cpp

@@ -0,0 +1,122 @@
+#include <xcb/xcb.h>
+#include <xcb/xcb_aux.h>
+
+#include "utils/memory.hpp"
+#include "x11/connection.hpp"
+#include "x11/tray_client.hpp"
+#include "x11/xembed.hpp"
+#include "x11/xutils.hpp"
+
+POLYBAR_NS
+
+tray_client::tray_client(connection& conn, xcb_window_t win, uint16_t w, uint16_t h)
+    : m_connection(conn), m_window(win), m_width(w), m_height(h) {
+  m_xembed = memory_util::make_malloc_ptr<xembed_data>();
+  m_xembed->version = XEMBED_VERSION;
+  m_xembed->flags = XEMBED_MAPPED;
+}
+
+tray_client::~tray_client() {
+  xembed::unembed(m_connection, window(), m_connection.root());
+}
+
+uint16_t tray_client::width() const {
+  return m_width;
+}
+
+uint16_t tray_client::height() const {
+  return m_height;
+}
+
+void tray_client::clear_window() const {
+  try {
+    m_connection.clear_area_checked(1, window(), 0, 0, width(), height());
+  } catch (const xpp::x::error::window& err) {
+    // ignore
+  }
+}
+
+/**
+ * Match given window against client window
+ */
+bool tray_client::match(const xcb_window_t& win) const {
+  return win == m_window;
+}
+
+/**
+ * Get client window mapped state
+ */
+bool tray_client::mapped() const {
+  return m_mapped;
+}
+
+/**
+ * Set client window mapped state
+ */
+void tray_client::mapped(bool state) {
+  m_mapped = state;
+}
+
+/**
+ * Get client window
+ */
+xcb_window_t tray_client::window() const {
+  return m_window;
+}
+
+/**
+ * Get xembed data pointer
+ */
+xembed_data* tray_client::xembed() const {
+  return m_xembed.get();
+}
+
+/**
+ * Make sure that the window mapping state is correct
+ */
+void tray_client::ensure_state() const {
+  if (!mapped() && ((xembed()->flags & XEMBED_MAPPED) == XEMBED_MAPPED)) {
+    m_connection.map_window_checked(window());
+  } else if (mapped() && ((xembed()->flags & XEMBED_MAPPED) != XEMBED_MAPPED)) {
+    m_connection.unmap_window_checked(window());
+  }
+}
+
+/**
+ * Configure window size
+ */
+void tray_client::reconfigure(int16_t x, int16_t y) const {
+  uint32_t configure_mask = 0;
+  uint32_t configure_values[7];
+  xcb_params_configure_window_t configure_params;
+
+  XCB_AUX_ADD_PARAM(&configure_mask, &configure_params, width, m_width);
+  XCB_AUX_ADD_PARAM(&configure_mask, &configure_params, height, m_height);
+  XCB_AUX_ADD_PARAM(&configure_mask, &configure_params, x, x);
+  XCB_AUX_ADD_PARAM(&configure_mask, &configure_params, y, y);
+
+  xutils::pack_values(configure_mask, &configure_params, configure_values);
+  m_connection.configure_window_checked(window(), configure_mask, configure_values);
+}
+
+/**
+ * Respond to client resize requests
+ */
+void tray_client::configure_notify(int16_t x, int16_t y) const {
+  auto notify = memory_util::make_malloc_ptr<xcb_configure_notify_event_t>(32);
+  notify->response_type = XCB_CONFIGURE_NOTIFY;
+  notify->event = m_window;
+  notify->window = m_window;
+  notify->override_redirect = false;
+  notify->above_sibling = 0;
+  notify->x = x;
+  notify->y = y;
+  notify->width = m_width;
+  notify->height = m_height;
+  notify->border_width = 0;
+
+  const char* data = reinterpret_cast<const char*>(notify.get());
+  m_connection.send_event_checked(false, m_window, XCB_EVENT_MASK_STRUCTURE_NOTIFY, data);
+}
+
+POLYBAR_NS_END

src/x11/wm.cpp

@@ -7,43 +7,34 @@
 POLYBAR_NS
 
 namespace wm_util {
-  void set_wmname(xcb_connection_t* conn, xcb_window_t win, const string& wm_name, const string& wm_class) {
+  void set_wm_name(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(xcb_connection_t* conn, xcb_window_t win, vector<xcb_atom_t> flags) {
+  void set_wm_protocols(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(xcb_connection_t* conn, xcb_window_t win, vector<xcb_atom_t> types) {
+  void set_wm_window_type(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(xcb_connection_t* conn, xcb_window_t win, vector<xcb_atom_t> states) {
+  void set_wm_state(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(xcb_connection_t* conn, xcb_window_t win, pid_t pid) {
+  void set_wm_pid(xcb_connection_t* conn, xcb_window_t win, pid_t pid) {
     pid = getpid();
     xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win, _NET_WM_PID, XCB_ATOM_CARDINAL, 32, 1, &pid);
   }
 
-  void set_wmdesktop(xcb_connection_t* conn, xcb_window_t win, uint32_t desktop) {
+  void set_wm_desktop(xcb_connection_t* conn, xcb_window_t win, uint32_t desktop) {
     const uint32_t value_list[1]{desktop};
     xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win, _NET_WM_DESKTOP, XCB_ATOM_CARDINAL, 32, 1, value_list);
   }
-
-  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(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);
-  }
 }
 
 POLYBAR_NS_END

src/x11/xresources.cpp

@@ -1,5 +1,5 @@
 #include <X11/Xlib.h>
-
+#include <cstring>
 #include <utility>
 
 #include "utils/factory.hpp"
@@ -11,9 +11,9 @@ POLYBAR_NS
 /**
  * Configure injection module
  */
-di::injector<const xresource_manager&> configure_xresource_manager() {
-  auto instance = factory_util::generic_singleton<xresource_manager>();
-  return di::make_injector(di::bind<>().to(instance));
+const xresource_manager& make_xresource_manager() {
+  auto instance = factory_util::singleton<xresource_manager>();
+  return static_cast<const xresource_manager&>(*instance);
 }
 
 /**

src/x11/xutils.cpp

@@ -35,14 +35,6 @@ namespace xutils {
     return *g_connection_fd.get();
   }
 
-  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) {