Format source codes

Change-Id: I28e99487b814b23fe99aa6bc8ec4538af3940acf
Signed-off-by: Kazumasa Mitsunari <knimitz@witz-inc.co.jp>

21 files changed, 2023 insertions, 1719 deletions

diff --git a/src/app.hpp b/src/app.hpp
index 1904245..42758c9 100644
--- a/src/app.hpp
+++ b/src/app.hpp
@@ -34,15 +34,18 @@
 #include "hmi-debug.h"
 #include "request.hpp"
 
-namespace wl {
+namespace wl
+{
 struct display;
 }
 
-namespace compositor {
+namespace compositor
+{
 struct controller;
 }
 
-namespace wm {
+namespace wm
+{
 
 using std::experimental::optional;
 
@@ -66,209 +69,218 @@ extern const char kKeyHeightPixel[];
 extern const char kKeyWidthMm[];
 extern const char kKeyHeightMm[];
 
-
-struct id_allocator {
-   unsigned next = 1;
-
-   // Surfaces that where requested but not yet created
-   std::unordered_map<unsigned, std::string> id2name;
-   // std::unordered_set<unsigned> pending_surfaces;
-   std::unordered_map<std::string, unsigned> name2id;
-
-   id_allocator(id_allocator const &) = delete;
-   id_allocator(id_allocator &&) = delete;
-   id_allocator &operator=(id_allocator const &);
-   id_allocator &operator=(id_allocator &&) = delete;
-
-   // Insert and return a new ID
-   unsigned generate_id(std::string const &name) {
-      unsigned sid = this->next++;
-      this->id2name[sid] = name;
-      // this->pending_surfaces.insert({sid});
-      this->name2id[name] = sid;
-      HMI_DEBUG("wm", "allocated new id %u with name %s", sid, name.c_str());
-      return sid;
-   }
-
-   // Insert a new ID which defined outside
-   void register_name_id(std::string const &name, unsigned sid) {
-      this->id2name[sid] = name;
-      this->name2id[name] = sid;
-      HMI_DEBUG("wm", "register id %u with name %s", sid, name.c_str());
-      return;
-   }
-
-   // Lookup by ID or by name
-   optional<unsigned> lookup(std::string const &name) const {
-      auto i = this->name2id.find(name);
-      return i == this->name2id.end() ? nullopt : optional<unsigned>(i->second);
-   }
-
-   optional<std::string> lookup(unsigned id) const {
-      auto i = this->id2name.find(id);
-      return i == this->id2name.end() ? nullopt
-                                       : optional<std::string>(i->second);
-   }
-
-   // Remove a surface id and name
-   void remove_id(std::string const &name) {
-      auto i = this->name2id.find(name);
-      if (i != this->name2id.end()) {
-         this->id2name.erase(i->second);
-         this->name2id.erase(i);
-      }
-   }
-
-   void remove_id(unsigned id) {
-      auto i = this->id2name.find(id);
-      if (i != this->id2name.end()) {
-         this->name2id.erase(i->second);
-         this->id2name.erase(i);
-      }
-   }
+struct id_allocator
+{
+    unsigned next = 1;
+
+    // Surfaces that where requested but not yet created
+    std::unordered_map<unsigned, std::string> id2name;
+    // std::unordered_set<unsigned> pending_surfaces;
+    std::unordered_map<std::string, unsigned> name2id;
+
+    id_allocator(id_allocator const &) = delete;
+    id_allocator(id_allocator &&) = delete;
+    id_allocator &operator=(id_allocator const &);
+    id_allocator &operator=(id_allocator &&) = delete;
+
+    // Insert and return a new ID
+    unsigned generate_id(std::string const &name)
+    {
+        unsigned sid = this->next++;
+        this->id2name[sid] = name;
+        // this->pending_surfaces.insert({sid});
+        this->name2id[name] = sid;
+        HMI_DEBUG("wm", "allocated new id %u with name %s", sid, name.c_str());
+        return sid;
+    }
+
+    // Insert a new ID which defined outside
+    void register_name_id(std::string const &name, unsigned sid)
+    {
+        this->id2name[sid] = name;
+        this->name2id[name] = sid;
+        HMI_DEBUG("wm", "register id %u with name %s", sid, name.c_str());
+        return;
+    }
+
+    // Lookup by ID or by name
+    optional<unsigned> lookup(std::string const &name) const
+    {
+        auto i = this->name2id.find(name);
+        return i == this->name2id.end() ? nullopt : optional<unsigned>(i->second);
+    }
+
+    optional<std::string> lookup(unsigned id) const
+    {
+        auto i = this->id2name.find(id);
+        return i == this->id2name.end() ? nullopt
+                                        : optional<std::string>(i->second);
+    }
+
+    // Remove a surface id and name
+    void remove_id(std::string const &name)
+    {
+        auto i = this->name2id.find(name);
+        if (i != this->name2id.end())
+        {
+            this->id2name.erase(i->second);
+            this->name2id.erase(i);
+        }
+    }
+
+    void remove_id(unsigned id)
+    {
+        auto i = this->id2name.find(id);
+        if (i != this->id2name.end())
+        {
+            this->name2id.erase(i->second);
+            this->id2name.erase(i);
+        }
+    }
 };
 
-struct App {
+struct App
+{
 
-   typedef std::unordered_map<uint32_t, struct compositor::rect> rect_map;
-   typedef std::function<void(const char* err_msg)> reply_func;
+    typedef std::unordered_map<uint32_t, struct compositor::rect> rect_map;
+    typedef std::function<void(const char *err_msg)> reply_func;
 
-   enum EventType {
-      Event_Val_Min = 0,
+    enum EventType
+    {
+        Event_Val_Min = 0,
 
-      Event_Active = Event_Val_Min,
-      Event_Inactive,
+        Event_Active = Event_Val_Min,
+        Event_Inactive,
 
-      Event_Visible,
-      Event_Invisible,
+        Event_Visible,
+        Event_Invisible,
 
-      Event_SyncDraw,
-      Event_FlushDraw,
+        Event_SyncDraw,
+        Event_FlushDraw,
 
-      Event_Val_Max = Event_FlushDraw,
-   };
+        Event_Val_Max = Event_FlushDraw,
+    };
 
-   const std::vector<const char *> kListEventName{
-     "active",
-     "inactive",
-     "visible",
-     "invisible",
-     "syncdraw",
-     "flushdraw"
-   };
+    const std::vector<const char *> kListEventName{
+        "active",
+        "inactive",
+        "visible",
+        "invisible",
+        "syncdraw",
+        "flushdraw"};
 
-   struct controller_hooks chooks;
+    struct controller_hooks chooks;
 
-   // This is the one thing, we do not own.
-   struct wl::display *display;
+    // This is the one thing, we do not own.
+    struct wl::display *display;
 
-   std::unique_ptr<struct compositor::controller> controller;
-   std::vector<std::unique_ptr<struct wl::output>> outputs;
+    std::unique_ptr<struct compositor::controller> controller;
+    std::vector<std::unique_ptr<struct wl::output>> outputs;
 
-   struct config config;
+    struct config config;
 
-   // track current layouts separately
-   layer_map layers;
+    // track current layouts separately
+    layer_map layers;
 
-   // ID allocation and proxy methods for lookup
-   struct id_allocator id_alloc;
+    // ID allocation and proxy methods for lookup
+    struct id_allocator id_alloc;
 
-   // Set by AFB API when wayland events need to be dispatched
-   std::atomic<bool> pending_events;
+    // Set by AFB API when wayland events need to be dispatched
+    std::atomic<bool> pending_events;
 
-   std::vector<int> pending_end_draw;
+    std::vector<int> pending_end_draw;
 
-   Policy policy;
+    Policy policy;
 
-   std::map<const char *, struct afb_event> map_afb_event;
+    std::map<const char *, struct afb_event> map_afb_event;
 
-   // Surface are info (x, y, w, h)
-   rect_map area_info;
+    // Surface are info (x, y, w, h)
+    rect_map area_info;
 
-   // FOR CES DEMO
-   std::vector<int> surface_bg;
+    // FOR CES DEMO
+    std::vector<int> surface_bg;
 
-   explicit App(wl::display *d);
-   ~App() = default;
+    explicit App(wl::display *d);
+    ~App() = default;
 
-   App(App const &) = delete;
-   App &operator=(App const &) = delete;
-   App(App &&) = delete;
-   App &operator=(App &&) = delete;
+    App(App const &) = delete;
+    App &operator=(App const &) = delete;
+    App(App &&) = delete;
+    App &operator=(App &&) = delete;
 
-   int init();
+    int init();
 
-   int dispatch_pending_events();
+    int dispatch_pending_events();
 
-   void set_pending_events();
+    void set_pending_events();
 
-   result<int> api_request_surface(char const *appid, char const *drawing_name);
-   char const *api_request_surface(char const *appid, char const *drawing_name, char const *ivi_id);
-   void api_activate_surface(char const *appid, char const *drawing_name, char const *drawing_area, const reply_func &reply);
-   void api_deactivate_surface(char const *appid, char const *drawing_name, const reply_func &reply);
-   void api_enddraw(char const *appid, char const *drawing_name);
-   result<json_object *> api_get_display_info();
-   result<json_object *> api_get_area_info(char const *drawing_name);
-   void api_ping();
-   void send_event(char const *evname, char const *label);
-   void send_event(char const *evname, char const *label, char const *area, int x, int y, int w, int h);
+    result<int> api_request_surface(char const *appid, char const *drawing_name);
+    char const *api_request_surface(char const *appid, char const *drawing_name, char const *ivi_id);
+    void api_activate_surface(char const *appid, char const *drawing_name, char const *drawing_area, const reply_func &reply);
+    void api_deactivate_surface(char const *appid, char const *drawing_name, const reply_func &reply);
+    void api_enddraw(char const *appid, char const *drawing_name);
+    result<json_object *> api_get_display_info();
+    result<json_object *> api_get_area_info(char const *drawing_name);
+    void api_ping();
+    void send_event(char const *evname, char const *label);
+    void send_event(char const *evname, char const *label, char const *area, int x, int y, int w, int h);
 
-   // Events from the compositor we are interested in
-   void surface_created(uint32_t surface_id);
-   void surface_removed(uint32_t surface_id);
+    // Events from the compositor we are interested in
+    void surface_created(uint32_t surface_id);
+    void surface_removed(uint32_t surface_id);
 
-   // Do not use this function
-   //static int processTimerHandler(sd_event_source *s, uint64_t usec, void *userdata);
-   void timerHandler();
+    // Do not use this function
+    //static int processTimerHandler(sd_event_source *s, uint64_t usec, void *userdata);
+    void timerHandler();
 
- private:
-   optional<int> lookup_id(char const *name);
-   optional<std::string> lookup_name(int id);
+  private:
+    optional<int> lookup_id(char const *name);
+    optional<std::string> lookup_name(int id);
 
-   bool pop_pending_events();
+    bool pop_pending_events();
 
-   void enqueue_flushdraw(int surface_id);
-   void check_flushdraw(int surface_id);
+    void enqueue_flushdraw(int surface_id);
+    void check_flushdraw(int surface_id);
 
-   int init_layers();
+    int init_layers();
 
-   void surface_set_layout(int surface_id, optional<int> sub_surface_id = nullopt);
-   void layout_commit();
+    void surface_set_layout(int surface_id, optional<int> sub_surface_id = nullopt);
+    void layout_commit();
 
-   // TMC WM Events to clients
-   void emit_activated(char const *label);
-   void emit_deactivated(char const *label);
-   void emit_syncdraw(char const *label, char const *area, int x, int y, int w, int h);
-   void emit_flushdraw(char const *label);
-   void emit_visible(char const *label, bool is_visible);
-   void emit_invisible(char const *label);
-   void emit_visible(char const *label);
+    // TMC WM Events to clients
+    void emit_activated(char const *label);
+    void emit_deactivated(char const *label);
+    void emit_syncdraw(char const *label, char const *area, int x, int y, int w, int h);
+    void emit_flushdraw(char const *label);
+    void emit_visible(char const *label, bool is_visible);
+    void emit_invisible(char const *label);
+    void emit_visible(char const *label);
 
-   bool do_transition(unsigned sequence_number);
+    bool do_transition(unsigned sequence_number);
 
-   void do_enddraw(unsigned sequence_number);
-   void process_request();
-   void set_timer();
-   void stop_timer();
-   const char *check_surface_exist(const char *drawing_name);
+    void do_enddraw(unsigned sequence_number);
+    void process_request();
+    void set_timer();
+    void stop_timer();
+    const char *check_surface_exist(const char *drawing_name);
 
-   void activate(int id);
-   void deactivate(int id);
-   void deactivate_main_surface();
+    void activate(int id);
+    void deactivate(int id);
+    void deactivate_main_surface();
 
-   bool can_split(struct LayoutState const &state, int new_id);
-   void try_layout(struct LayoutState &state,
-                   struct LayoutState const &new_layout,
-                   std::function<void(LayoutState const &nl)> apply);
+    bool can_split(struct LayoutState const &state, int new_id);
+    void try_layout(struct LayoutState &state,
+                    struct LayoutState const &new_layout,
+                    std::function<void(LayoutState const &nl)> apply);
 
-   // The following function is temporary.
-   // Then will be removed when layermanager is finished
-   void lm_layout_change(const char* drawing_name);
-   bool lm_layout_change(const struct WMAction &action);
-   bool lm_release(const struct WMAction &action);
-   void lm_enddraw(const char* drawing_name);
+    // The following function is temporary.
+    // Then will be removed when layermanager is finished
+    void lm_layout_change(const char *drawing_name);
+    bool lm_layout_change(const struct WMAction &action);
+    bool lm_release(const struct WMAction &action);
+    void lm_enddraw(const char *drawing_name);
 };
 
-}  // namespace wm
+} // namespace wm
 
-#endif  // TMCAGLWM_APP_HPP
+#endif // TMCAGLWM_APP_HPP
diff --git a/src/applist.cpp b/src/applist.cpp
index 37a7717..7c554e9 100644
--- a/src/applist.cpp
+++ b/src/applist.cpp
@@ -23,28 +23,32 @@ using std::string;
 using std::unique_ptr;
 using std::vector;
 
-namespace wm {
-
+namespace wm
+{
 
 AppList::AppList()
     : req_list(0),
       client_list(0),
       current_seq(1)
-{}
+{
+}
 
-AppList::~AppList(){}
+AppList::~AppList() {}
 
-void AppList::addClient(const string &appid, const string &role){
+void AppList::addClient(const string &appid, const string &role)
+{
     shared_ptr<WMClient> client = std::make_shared<WMClient>(appid, role);
     client_list[appid] = client;
     client_dump();
 }
 
-void AppList::removeClient(const string &appid){
+void AppList::removeClient(const string &appid)
+{
     client_list.erase(appid);
 }
 
-bool AppList::contains(const string &appid){
+bool AppList::contains(const string &appid)
+{
     auto result = client_list.find(appid);
     return (client_list.end() != result) ? true : false;
 }
@@ -55,7 +59,7 @@ bool AppList::contains(const string &appid){
  * @param string[in] application id(key)
  * @return WMClient object
  */
-shared_ptr <WMClient> AppList::lookUpClient(const string &appid)
+shared_ptr<WMClient> AppList::lookUpClient(const string &appid)
 {
     return client_list.at(appid);
 }
@@ -65,15 +69,18 @@ int AppList::countClient()
     return client_list.size();
 }
 
-unsigned AppList::currentSequenceNumber(){
+unsigned AppList::currentSequenceNumber()
+{
     return current_seq;
 }
 
 // Is this function necessary ?
-unsigned AppList::getSequenceNumber(const string &appid){
-    for(const auto& x : req_list){
+unsigned AppList::getSequenceNumber(const string &appid)
+{
+    for (const auto &x : req_list)
+    {
         // Since app will not request twice and more, comparing appid is enough?
-        if( (x.trigger.appid == appid))
+        if ((x.trigger.appid == appid))
         {
             return x.seq_num;
         }
@@ -81,11 +88,14 @@ unsigned AppList::getSequenceNumber(const string &appid){
     return 0;
 }
 
-unsigned AppList::addAllocateRequest(WMRequest req){
-    if(req_list.size() == 0){
+unsigned AppList::addAllocateRequest(WMRequest req)
+{
+    if (req_list.size() == 0)
+    {
         req.seq_num = current_seq;
     }
-    else{
+    else
+    {
         HMI_SEQ_DEBUG(current_seq, "real: %d", req_list.back().seq_num + 1);
         req.seq_num = req_list.back().seq_num + 1;
     }
@@ -93,12 +103,15 @@ unsigned AppList::addAllocateRequest(WMRequest req){
     return req.seq_num; // return 1; if you test time_expire
 }
 
-bool AppList::requestFinished(){
+bool AppList::requestFinished()
+{
     return req_list.empty();
 }
 
-struct WMTrigger AppList::getRequest(unsigned req_num){
-    for(auto& x : req_list){
+struct WMTrigger AppList::getRequest(unsigned req_num)
+{
+    for (auto &x : req_list)
+    {
         if (req_num == x.seq_num)
         {
             return x.trigger;
@@ -106,7 +119,8 @@ struct WMTrigger AppList::getRequest(unsigned req_num){
     }
 }
 
-const vector<struct WMAction>& AppList::getActions(unsigned req_num){
+const vector<struct WMAction> &AppList::getActions(unsigned req_num)
+{
     for (auto &x : req_list)
     {
         if (req_num == x.seq_num)
@@ -116,7 +130,8 @@ const vector<struct WMAction>& AppList::getActions(unsigned req_num){
     }
 }
 
-bool AppList::setAction(unsigned req_num, const struct WMAction &action){
+bool AppList::setAction(unsigned req_num, const struct WMAction &action)
+{
     bool result = false;
     for (auto &x : req_list)
     {
@@ -132,9 +147,10 @@ bool AppList::setAction(unsigned req_num, const struct WMAction &action){
     return result;
 }
 
-bool AppList::setAction(unsigned req_num, const string &appid, const string &role, const string &area, bool visible){
+bool AppList::setAction(unsigned req_num, const string &appid, const string &role, const string &area, bool visible)
+{
     bool result = false;
-    for (auto& x : req_list)
+    for (auto &x : req_list)
     {
         if (req_num != x.seq_num)
         {
@@ -149,9 +165,10 @@ bool AppList::setAction(unsigned req_num, const string &appid, const string &rol
     return result;
 }
 
-bool AppList::setEndDrawFinished(unsigned req_num, const string &appid, const string &role){
+bool AppList::setEndDrawFinished(unsigned req_num, const string &appid, const string &role)
+{
     bool result = false;
-    for (auto& x : req_list)
+    for (auto &x : req_list)
     {
         if (req_num < x.seq_num)
         {
@@ -159,7 +176,8 @@ bool AppList::setEndDrawFinished(unsigned req_num, const string &appid, const st
         }
         if (req_num == x.seq_num)
         {
-            for(auto& y : x.sync_draw_req){
+            for (auto &y : x.sync_draw_req)
+            {
                 if (y.appid == appid && y.role == role)
                 {
                     y.end_draw_finished = true;
@@ -177,18 +195,23 @@ bool AppList::setEndDrawFinished(unsigned req_num, const string &appid, const st
  * @param  unsigned sequence_num
  * @return true if all action is set.
  */
-bool AppList::endDrawFullfilled(unsigned req_num){
+bool AppList::endDrawFullfilled(unsigned req_num)
+{
     bool result = false;
-    for (const auto& x : req_list)
+    for (const auto &x : req_list)
     {
-        if(req_num < x.seq_num){
+        if (req_num < x.seq_num)
+        {
             break;
         }
-        if(req_num == x.seq_num){
+        if (req_num == x.seq_num)
+        {
             result = true;
-            for(const auto& y : x.sync_draw_req){
+            for (const auto &y : x.sync_draw_req)
+            {
                 result &= y.end_draw_finished;
-                if(!result){
+                if (!result)
+                {
                     break;
                 }
             }
@@ -197,14 +220,16 @@ bool AppList::endDrawFullfilled(unsigned req_num){
     return result;
 }
 
-void AppList::removeRequest(unsigned req_seq){
+void AppList::removeRequest(unsigned req_seq)
+{
     req_list.erase(remove_if(req_list.begin(), req_list.end(),
-        [req_seq](WMRequest x) {
-            return x.seq_num == req_seq;
-        }));
+                             [req_seq](WMRequest x) {
+                                 return x.seq_num == req_seq;
+                             }));
 }
 
-void AppList::next(){
+void AppList::next()
+{
     ++this->current_seq;
     if (0 == this->current_seq)
     {
@@ -212,14 +237,17 @@ void AppList::next(){
     }
 }
 
-bool AppList::haveRequest(){
+bool AppList::haveRequest()
+{
     return !req_list.empty();
 }
 
-void AppList::client_dump(){
+void AppList::client_dump()
+{
     DUMP("======= client dump =====");
-    for(const auto& x : client_list){
-        const auto& y = x.second;
+    for (const auto &x : client_list)
+    {
+        const auto &y = x.second;
         DUMP("APPID : %s", y->appID().c_str());
     }
     DUMP("======= client dump end=====");
@@ -229,7 +257,8 @@ void AppList::req_dump()
 {
     DUMP("======= req dump =====");
     DUMP("current request : %d", current_seq);
-    for(const auto& x : req_list){
+    for (const auto &x : req_list)
+    {
         DUMP("requested with  : %d", x.seq_num);
         DUMP("Trigger : (APPID :%s, ROLE :%s, AREA :%s, TASK: %d)",
              x.trigger.appid.c_str(),
@@ -237,7 +266,8 @@ void AppList::req_dump()
              x.trigger.area.c_str(),
              x.trigger.task);
 
-        for (const auto& y : x.sync_draw_req){
+        for (const auto &y : x.sync_draw_req)
+        {
             DUMP(
                 "Action  : (APPID :%s, ROLE :%s, AREA :%s, END_DRAW_FINISHED: %d)",
                 y.appid.c_str(),
@@ -248,4 +278,4 @@ void AppList::req_dump()
     }
     DUMP("======= req dump end =====\n");
 }
-}
\ No newline at end of file
+} // namespace wm
\ No newline at end of file
diff --git a/src/applist.hpp b/src/applist.hpp
index 52dcfeb..cab3595 100644
--- a/src/applist.hpp
+++ b/src/applist.hpp
@@ -24,13 +24,15 @@
 #include "windowmanager-client.hpp"
 #include "request.hpp"
 
-namespace wm {
+namespace wm
+{
 
 /* using std::experimental::nullopt;
 using std::experimental::optional; */
 
-class  AppList {
-public:
+class AppList
+{
+  public:
     AppList();
     virtual ~AppList();
     AppList(const AppList &obj) = delete;
@@ -39,7 +41,7 @@ public:
     void addClient(const std::string &appid, const std::string &role);
     void removeClient(const std::string &appid);
     bool contains(const std::string &appid);
-    int  countClient();
+    int countClient();
     std::shared_ptr<WMClient> lookUpClient(const std::string &appid);
 
     // Request Interface
@@ -49,26 +51,26 @@ public:
     /* TODO: consider, which is better WMClient or std::string appid?
     if appid is key to manage resources, it is better to select std::string
     otherwise WMClient is better, IMO */
-    bool     requestFinished();
-    bool     setAction(unsigned req_num, const struct WMAction &action);
-    bool     setAction(unsigned req_num, const std::string &appid, const std::string &role, const std::string &area, bool visible = true);
-    bool     setEndDrawFinished(unsigned req_num, const std::string &appid, const std::string &role);
-    bool     endDrawFullfilled(unsigned req_num);
-    void     removeRequest(unsigned req_num);
-    void     next();
-    bool     haveRequest();
+    bool requestFinished();
+    bool setAction(unsigned req_num, const struct WMAction &action);
+    bool setAction(unsigned req_num, const std::string &appid, const std::string &role, const std::string &area, bool visible = true);
+    bool setEndDrawFinished(unsigned req_num, const std::string &appid, const std::string &role);
+    bool endDrawFullfilled(unsigned req_num);
+    void removeRequest(unsigned req_num);
+    void next();
+    bool haveRequest();
 
     struct WMTrigger getRequest(unsigned req_num);
-    const std::vector<struct WMAction>& getActions(unsigned req_num);
+    const std::vector<struct WMAction> &getActions(unsigned req_num);
 
-    void    client_dump();
-    void    req_dump();
+    void client_dump();
+    void req_dump();
 
-private:
-  std::vector<WMRequest> req_list;
-  std::unordered_map<std::string, std::shared_ptr<WMClient>> client_list;
-  unsigned current_seq;
+  private:
+    std::vector<WMRequest> req_list;
+    std::unordered_map<std::string, std::shared_ptr<WMClient>> client_list;
+    unsigned current_seq;
 };
 
-}
+} // namespace wm
 #endif // ALLOCATE_LIST_HPP
\ No newline at end of file
diff --git a/src/config.cpp b/src/config.cpp
index c7e4ddb..7b18224 100644
--- a/src/config.cpp
+++ b/src/config.cpp
@@ -17,18 +17,22 @@
 #include "config.hpp"
 #include "hmi-debug.h"
 
-namespace wm {
+namespace wm
+{
 
-config::config() : cfg() {
-   // Supply default values for these...
-   char const *path_layers_json = getenv("AFM_APP_INSTALL_DIR");
+config::config() : cfg()
+{
+    // Supply default values for these...
+    char const *path_layers_json = getenv("AFM_APP_INSTALL_DIR");
 
-   if (!path_layers_json) {
-      HMI_ERROR("wm", "AFM_APP_INSTALL_DIR is not defined");
-   }
-   else {
-      this->cfg["layers.json"] = std::string(path_layers_json) + std::string("/etc/layers.json");
-   }
+    if (!path_layers_json)
+    {
+        HMI_ERROR("wm", "AFM_APP_INSTALL_DIR is not defined");
+    }
+    else
+    {
+        this->cfg["layers.json"] = std::string(path_layers_json) + std::string("/etc/layers.json");
+    }
 }
 
-}  // namespace wm
+} // namespace wm
diff --git a/src/config.hpp b/src/config.hpp
index 8588d65..43fb67e 100644
--- a/src/config.hpp
+++ b/src/config.hpp
@@ -20,30 +20,34 @@
 #include <experimental/optional>
 #include <map>
 
-namespace wm {
+namespace wm
+{
 
-using std::experimental::optional;
 using std::experimental::nullopt;
+using std::experimental::optional;
 
-struct config {
-   typedef std::map<std::string, std::string> map;
+struct config
+{
+    typedef std::map<std::string, std::string> map;
 
-   map cfg;
+    map cfg;
 
-   config();
+    config();
 
-   optional<std::string> get_string(char const *s) {
-      auto i = this->cfg.find(s);
-      return i != this->cfg.end() ? optional<std::string>(i->second) : nullopt;
-   }
+    optional<std::string> get_string(char const *s)
+    {
+        auto i = this->cfg.find(s);
+        return i != this->cfg.end() ? optional<std::string>(i->second) : nullopt;
+    }
 
-   optional<int> get_int(char const *s) {
-      auto i = this->cfg.find(s);
-      return i != this->cfg.end() ? optional<int>(std::stoi(i->second))
-                                  : nullopt;
-   }
+    optional<int> get_int(char const *s)
+    {
+        auto i = this->cfg.find(s);
+        return i != this->cfg.end() ? optional<int>(std::stoi(i->second))
+                                    : nullopt;
+    }
 };
 
-}  // namespace wm
+} // namespace wm
 
-#endif  // TMCAGLWM_CONFIG_HPP
+#endif // TMCAGLWM_CONFIG_HPP
diff --git a/src/controller_hooks.hpp b/src/controller_hooks.hpp
index f5265ca..b8c142c 100644
--- a/src/controller_hooks.hpp
+++ b/src/controller_hooks.hpp
@@ -21,20 +21,22 @@
 
 #include <functional>
 
-namespace wm {
+namespace wm
+{
 
 struct App;
 
-struct controller_hooks {
-   struct App *app;
+struct controller_hooks
+{
+    struct App *app;
 
-   void surface_created(uint32_t surface_id);
+    void surface_created(uint32_t surface_id);
 
-   void surface_removed(uint32_t surface_id);
-   void surface_visibility(uint32_t surface_id, uint32_t v);
-   void surface_destination_rectangle(uint32_t surface_id, uint32_t x, uint32_t y, uint32_t w, uint32_t h);
+    void surface_removed(uint32_t surface_id);
+    void surface_visibility(uint32_t surface_id, uint32_t v);
+    void surface_destination_rectangle(uint32_t surface_id, uint32_t x, uint32_t y, uint32_t w, uint32_t h);
 };
 
-}  // namespace wm
+} // namespace wm
 
-#endif  // TMCAGLWM_CONTROLLER_HOOKS_HPP
+#endif // TMCAGLWM_CONTROLLER_HOOKS_HPP
diff --git a/src/json_helper.hpp b/src/json_helper.hpp
index 78e03f7..6c9cdab 100644
--- a/src/json_helper.hpp
+++ b/src/json_helper.hpp
@@ -27,4 +27,4 @@ json_object *to_json(compositor::screen const *s);
 json_object *to_json(compositor::controller::props_map const &s);
 json_object *to_json(std::vector<uint32_t> const &v);
 
-#endif  // TMCAGLWM_JSON_HELPER_HPP
+#endif // TMCAGLWM_JSON_HELPER_HPP
diff --git a/src/layers.cpp b/src/layers.cpp
index 04f944d..af8d89e 100644
--- a/src/layers.cpp
+++ b/src/layers.cpp
@@ -22,144 +22,176 @@
 #include "util.hpp"
 #include "hmi-debug.h"
 
-namespace wm {
+namespace wm
+{
 
 using json = nlohmann::json;
 
-layer::layer(nlohmann::json const &j) {
-   this->role = j["role"];
-   this->name = j["name"];
-   this->layer_id = j["layer_id"];
-   this->rect = compositor::full_rect;
-   if (j["area"]["type"] == "rect") {
-      auto jr = j["area"]["rect"];
-      this->rect = compositor::rect{
-         jr["width"], jr["height"], jr["x"], jr["y"],
-      };
-   }
-
-   // Init flag of normal layout only
-   this->is_normal_layout_only = true;
-
-   auto split_layouts = j.find("split_layouts");
-   if (split_layouts != j.end()) {
-
-      // Clear flag of normal layout only
-      this->is_normal_layout_only = false;
-
-      auto &sls = j["split_layouts"];
-      // this->layouts.reserve(sls.size());
-      std::transform(std::cbegin(sls), std::cend(sls),
-                     std::back_inserter(this->layouts), [this](json const &sl) {
-                        struct split_layout l {
-                           sl["name"], sl["main_match"], sl["sub_match"] };
-                        HMI_DEBUG("wm",
-                           "layer %d add split_layout \"%s\" (main: \"%s\") (sub: "
-                           "\"%s\")", this->layer_id,
-                           l.name.c_str(), l.main_match.c_str(),
-                           l.sub_match.c_str());
-                        return l;
-                     });
-   }
-   HMI_DEBUG("wm", "layer_id:%d is_normal_layout_only:%d\n",
-      this->layer_id, this->is_normal_layout_only);
-}
-
-struct result<struct layer_map> to_layer_map(nlohmann::json const &j) {
-   try {
-      layer_map stl{};
-      auto m = j["mappings"];
-
-      std::transform(std::cbegin(m), std::cend(m),
-                     std::inserter(stl.mapping, stl.mapping.end()),
-                     [](nlohmann::json const &j) {
-                        return std::pair<int, struct layer>(
-                           j.value("layer_id", -1), layer(j));
-                     });
-
-      // TODO: add sanity checks here?
-      // * check for double IDs
-      // * check for double names/roles
-
-      stl.layers.reserve(m.size());
-      std::transform(std::cbegin(stl.mapping), std::cend(stl.mapping),
-                     std::back_inserter(stl.layers),
-                     [&stl](std::pair<int, struct layer> const &k) {
-                        stl.roles.emplace_back(
-                           std::make_pair(k.second.role, k.second.layer_id));
-                        return unsigned(k.second.layer_id);
-                     });
-
-      std::sort(stl.layers.begin(), stl.layers.end());
-
-      for (auto i : stl.mapping) {
-         if (i.second.name.empty()) {
-            return Err<struct layer_map>("Found mapping w/o name");
-         }
-         if (i.second.layer_id == -1) {
-            return Err<struct layer_map>("Found invalid/unset IDs in mapping");
-         }
+layer::layer(nlohmann::json const &j)
+{
+      this->role = j["role"];
+      this->name = j["name"];
+      this->layer_id = j["layer_id"];
+      this->rect = compositor::full_rect;
+      if (j["area"]["type"] == "rect")
+      {
+            auto jr = j["area"]["rect"];
+            this->rect = compositor::rect{
+                jr["width"],
+                jr["height"],
+                jr["x"],
+                jr["y"],
+            };
       }
 
-      auto msi = j.find("main_surface");
-      if (msi != j.end()) {
-         stl.main_surface_name = msi->value("surface_role", "");
-         stl.main_surface = -1;
+      // Init flag of normal layout only
+      this->is_normal_layout_only = true;
+
+      auto split_layouts = j.find("split_layouts");
+      if (split_layouts != j.end())
+      {
+
+            // Clear flag of normal layout only
+            this->is_normal_layout_only = false;
+
+            auto &sls = j["split_layouts"];
+            // this->layouts.reserve(sls.size());
+            std::transform(std::cbegin(sls), std::cend(sls),
+                           std::back_inserter(this->layouts), [this](json const &sl) {
+                                 struct split_layout l
+                                 {
+                                       sl["name"], sl["main_match"], sl["sub_match"]
+                                 };
+                                 HMI_DEBUG("wm",
+                                           "layer %d add split_layout \"%s\" (main: \"%s\") (sub: "
+                                           "\"%s\")",
+                                           this->layer_id,
+                                           l.name.c_str(), l.main_match.c_str(),
+                                           l.sub_match.c_str());
+                                 return l;
+                           });
       }
+      HMI_DEBUG("wm", "layer_id:%d is_normal_layout_only:%d\n",
+                this->layer_id, this->is_normal_layout_only);
+}
 
-      return Ok(stl);
-   } catch (std::exception &e) {
-      return Err<struct layer_map>(e.what());
-   }
+struct result<struct layer_map> to_layer_map(nlohmann::json const &j)
+{
+      try
+      {
+            layer_map stl{};
+            auto m = j["mappings"];
+
+            std::transform(std::cbegin(m), std::cend(m),
+                           std::inserter(stl.mapping, stl.mapping.end()),
+                           [](nlohmann::json const &j) {
+                                 return std::pair<int, struct layer>(
+                                     j.value("layer_id", -1), layer(j));
+                           });
+
+            // TODO: add sanity checks here?
+            // * check for double IDs
+            // * check for double names/roles
+
+            stl.layers.reserve(m.size());
+            std::transform(std::cbegin(stl.mapping), std::cend(stl.mapping),
+                           std::back_inserter(stl.layers),
+                           [&stl](std::pair<int, struct layer> const &k) {
+                                 stl.roles.emplace_back(
+                                     std::make_pair(k.second.role, k.second.layer_id));
+                                 return unsigned(k.second.layer_id);
+                           });
+
+            std::sort(stl.layers.begin(), stl.layers.end());
+
+            for (auto i : stl.mapping)
+            {
+                  if (i.second.name.empty())
+                  {
+                        return Err<struct layer_map>("Found mapping w/o name");
+                  }
+                  if (i.second.layer_id == -1)
+                  {
+                        return Err<struct layer_map>("Found invalid/unset IDs in mapping");
+                  }
+            }
+
+            auto msi = j.find("main_surface");
+            if (msi != j.end())
+            {
+                  stl.main_surface_name = msi->value("surface_role", "");
+                  stl.main_surface = -1;
+            }
+
+            return Ok(stl);
+      }
+      catch (std::exception &e)
+      {
+            return Err<struct layer_map>(e.what());
+      }
 }
 
-optional<int> layer_map::get_layer_id(int surface_id) {
-   auto i = this->surfaces.find(surface_id);
-   if (i != this->surfaces.end()) {
-      return optional<int>(i->second);
-   }
-   return nullopt;
+optional<int>
+layer_map::get_layer_id(int surface_id)
+{
+      auto i = this->surfaces.find(surface_id);
+      if (i != this->surfaces.end())
+      {
+            return optional<int>(i->second);
+      }
+      return nullopt;
 }
 
-optional<int> layer_map::get_layer_id(std::string const &role) {
-   for (auto const &r : this->roles) {
-      auto re = std::regex(r.first);
-      if (std::regex_match(role, re)) {
-         HMI_DEBUG("wm", "role %s matches layer %d", role.c_str(), r.second);
-         return optional<int>(r.second);
+optional<int> layer_map::get_layer_id(std::string const &role)
+{
+      for (auto const &r : this->roles)
+      {
+            auto re = std::regex(r.first);
+            if (std::regex_match(role, re))
+            {
+                  HMI_DEBUG("wm", "role %s matches layer %d", role.c_str(), r.second);
+                  return optional<int>(r.second);
+            }
       }
-   }
-   HMI_DEBUG("wm", "role %s does NOT match any layer", role.c_str());
-   return nullopt;
+      HMI_DEBUG("wm", "role %s does NOT match any layer", role.c_str());
+      return nullopt;
 }
 
-json layer::to_json() const {
-   auto is_full = this->rect == compositor::full_rect;
-
-   json r{};
-   if (is_full) {
-      r = {{"type", "full"}};
-   } else {
-      r = {{"type", "rect"},
-           {"rect",
-            {{"x", this->rect.x},
-             {"y", this->rect.y},
-             {"width", this->rect.w},
-             {"height", this->rect.h}}}};
-   }
-
-   return {
-      {"name", this->name},         {"role", this->role},
-      {"layer_id", this->layer_id}, {"area", r},
-   };
+json layer::to_json() const
+{
+      auto is_full = this->rect == compositor::full_rect;
+
+      json r{};
+      if (is_full)
+      {
+            r = {{"type", "full"}};
+      }
+      else
+      {
+            r = {{"type", "rect"},
+                 {"rect",
+                  {{"x", this->rect.x},
+                   {"y", this->rect.y},
+                   {"width", this->rect.w},
+                   {"height", this->rect.h}}}};
+      }
+
+      return {
+          {"name", this->name},
+          {"role", this->role},
+          {"layer_id", this->layer_id},
+          {"area", r},
+      };
 }
 
-json layer_map::to_json() const {
-   json j{};
-   for (auto const &i : this->mapping) {
-      j.push_back(i.second.to_json());
-   }
-   return j;
+json layer_map::to_json() const
+{
+      json j{};
+      for (auto const &i : this->mapping)
+      {
+            j.push_back(i.second.to_json());
+      }
+      return j;
 }
 
-}  // namespace wm
+} // namespace wm
diff --git a/src/layers.hpp b/src/layers.hpp
index 43b1071..5479c3a 100644
--- a/src/layers.hpp
+++ b/src/layers.hpp
@@ -27,134 +27,103 @@
 #include "result.hpp"
 #include "wayland_ivi_wm.hpp"
 
-namespace wm {
-
-struct split_layout {
-   std::string name;
-   std::string main_match;
-   std::string sub_match;
+namespace wm
+{
+
+struct split_layout
+{
+    std::string name;
+    std::string main_match;
+    std::string sub_match;
 };
 
-struct layer {
-   using json = nlohmann::json;
-
-   // A more or less descriptive name?
-   std::string name = "";
-   // The actual layer ID
-   int layer_id = -1;
-   // The rectangular region surfaces are allowed to draw on
-   // this layer, note however, width and hieght of the rect
-   // can be negative, in which case they specify that
-   // the actual value is computed using MAX + 1 - w
-   // That is; allow us to specify dimensions dependent on
-   // e.g. screen dimension, w/o knowing the actual screen size.
-   compositor::rect rect;
-   // Specify a role prefix for surfaces that should be
-   // put on this layer.
-   std::string role;
-   // TODO: perhaps a zorder is needed here?
-   std::vector<struct split_layout> layouts;
-
-   mutable struct LayoutState state;
-
-  // Flag of normal layout only
-   bool is_normal_layout_only;
-
-   explicit layer(nlohmann::json const &j);
-
-   json to_json() const;
+struct layer
+{
+    using json = nlohmann::json;
+
+    // A more or less descriptive name?
+    std::string name = "";
+    // The actual layer ID
+    int layer_id = -1;
+    // The rectangular region surfaces are allowed to draw on
+    // this layer, note however, width and hieght of the rect
+    // can be negative, in which case they specify that
+    // the actual value is computed using MAX + 1 - w
+    // That is; allow us to specify dimensions dependent on
+    // e.g. screen dimension, w/o knowing the actual screen size.
+    compositor::rect rect;
+    // Specify a role prefix for surfaces that should be
+    // put on this layer.
+    std::string role;
+    // TODO: perhaps a zorder is needed here?
+    std::vector<struct split_layout> layouts;
+
+    mutable struct LayoutState state;
+
+    // Flag of normal layout only
+    bool is_normal_layout_only;
+
+    explicit layer(nlohmann::json const &j);
+
+    json to_json() const;
 };
 
-struct layer_map {
-   using json = nlohmann::json;
-
-   using storage_type = std::map<int, struct layer>;
-   using layers_type = std::vector<uint32_t>;
-   using role_to_layer_map = std::vector<std::pair<std::string, int>>;
-   using addsurf_layer_map = std::map<int, int>;
-
-   storage_type mapping;  // map surface_id to layer
-   layers_type layers;    // the actual layer IDs we have
-   int main_surface;
-   std::string main_surface_name;
-   role_to_layer_map roles;
-   addsurf_layer_map surfaces;  // additional surfaces on layers
-
-   optional<int> get_layer_id(int surface_id);
-   optional<int> get_layer_id(std::string const &role);
-   optional<struct LayoutState*> get_layout_state(int surface_id) {
-      int layer_id = *this->get_layer_id(surface_id);
-      auto i = this->mapping.find(layer_id);
-      return i == this->mapping.end()
-                ? nullopt
-                : optional<struct LayoutState *>(&i->second.state);
-   }
-   optional<struct layer> get_layer(int layer_id) {
-      auto i = this->mapping.find(layer_id);
-      return i == this->mapping.end() ? nullopt
-                                      : optional<struct layer>(i->second);
-   }
-
-   layers_type::size_type get_layers_count() const {
-      return this->layers.size();
-   }
-
-   void add_surface(int surface_id, int layer_id) {
-      this->surfaces[surface_id] = layer_id;
-   }
-
-   void remove_surface(int surface_id) {
-      this->surfaces.erase(surface_id);
-   }
-
-   json to_json() const;
+struct layer_map
+{
+    using json = nlohmann::json;
+
+    using storage_type = std::map<int, struct layer>;
+    using layers_type = std::vector<uint32_t>;
+    using role_to_layer_map = std::vector<std::pair<std::string, int>>;
+    using addsurf_layer_map = std::map<int, int>;
+
+    storage_type mapping; // map surface_id to layer
+    layers_type layers;   // the actual layer IDs we have
+    int main_surface;
+    std::string main_surface_name;
+    role_to_layer_map roles;
+    addsurf_layer_map surfaces; // additional surfaces on layers
+
+    optional<int> get_layer_id(int surface_id);
+    optional<int> get_layer_id(std::string const &role);
+    optional<struct LayoutState *> get_layout_state(int surface_id)
+    {
+        int layer_id = *this->get_layer_id(surface_id);
+        auto i = this->mapping.find(layer_id);
+        return i == this->mapping.end()
+                   ? nullopt
+                   : optional<struct LayoutState *>(&i->second.state);
+    }
+    optional<struct layer> get_layer(int layer_id)
+    {
+        auto i = this->mapping.find(layer_id);
+        return i == this->mapping.end() ? nullopt
+                                        : optional<struct layer>(i->second);
+    }
+
+    layers_type::size_type get_layers_count() const
+    {
+        return this->layers.size();
+    }
+
+    void add_surface(int surface_id, int layer_id)
+    {
+        this->surfaces[surface_id] = layer_id;
+    }
+
+    void remove_surface(int surface_id)
+    {
+        this->surfaces.erase(surface_id);
+    }
+
+    json to_json() const;
 };
 
 struct result<struct layer_map> to_layer_map(nlohmann::json const &j);
 
 static const nlohmann::json default_layers_json = {
-   {"main_surface", {
-      {"surface_role", "HomeScreen"}
-   }},
-   {"mappings", {
-      {
-         {"role", "^HomeScreen$"},
-         {"name", "HomeScreen"},
-         {"layer_id", 1000},
-         {"area", {
-            {"type", "full"}
-         }}
-      },
-      {
-         {"role", "MediaPlayer|Radio|Phone|Navigation|HVAC|Settings|Dashboard|POI|Mixer"},
-         {"name", "apps"},
-         {"layer_id", 1001},
-         {"area", {
-            {"type", "rect"},
-            {"rect", {
-               {"x", 0},
-               {"y", 218},
-               {"width", -1},
-               {"height", -433}
-            }}
-         }}
-      },
-      {
-         {"role", "^OnScreen.*"},
-         {"name", "popups"},
-         {"layer_id", 9999},
-         {"area", {
-            {"type", "rect"},
-            {"rect", {
-               {"x", 0},
-               {"y", 760},
-               {"width", -1},
-               {"height", 400}
-            }}
-         }}
-      }
-   }}
-};
-}  // namespace wm
+    {"main_surface", {{"surface_role", "HomeScreen"}}},
+    {"mappings", {{{"role", "^HomeScreen$"}, {"name", "HomeScreen"}, {"layer_id", 1000}, {"area", {{"type", "full"}}}}, {{"role", "MediaPlayer|Radio|Phone|Navigation|HVAC|Settings|Dashboard|POI|Mixer"}, {"name", "apps"}, {"layer_id", 1001}, {"area", {{"type", "rect"}, {"rect", {{"x", 0}, {"y", 218}, {"width", -1}, {"height", -433}}}}}}, {{"role", "^OnScreen.*"}, {"name", "popups"}, {"layer_id", 9999}, {"area", {{"type", "rect"}, {"rect", {{"x", 0}, {"y", 760}, {"width", -1}, {"height", 400}}}}}}}}};
+} // namespace wm
 
-#endif  // TMCAGLWM_LAYERS_H
+#endif // TMCAGLWM_LAYERS_H
diff --git a/src/layout.hpp b/src/layout.hpp
index d5fd00c..d8c9b88 100644
--- a/src/layout.hpp
+++ b/src/layout.hpp
@@ -22,21 +22,25 @@
 
 #include "result.hpp"
 
-namespace wm {
-
-struct LayoutState {
-   int main{-1};
-   int sub{-1};
-
-   bool operator==(const LayoutState &b) const {
-      return main == b.main && sub == b.sub;
-   }
-
-   bool operator!=(const LayoutState &b) const {
-      return !(*this == b);
-   }
+namespace wm
+{
+
+struct LayoutState
+{
+    int main{-1};
+    int sub{-1};
+
+    bool operator==(const LayoutState &b) const
+    {
+        return main == b.main && sub == b.sub;
+    }
+
+    bool operator!=(const LayoutState &b) const
+    {
+        return !(*this == b);
+    }
 };
 
-}  // namespace wm
+} // namespace wm
 
-#endif  // TMCAGLWM_LAYOUT_HPP
+#endif // TMCAGLWM_LAYOUT_HPP
diff --git a/src/main.cpp b/src/main.cpp
index 4954abf..2cfabb0 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -25,151 +25,175 @@
 #include "util.hpp"
 #include "wayland_ivi_wm.hpp"
 
-extern "C" {
+extern "C"
+{
 #include <afb/afb-binding.h>
 #include <systemd/sd-event.h>
 }
 
-typedef struct wmClientCtxt{
+typedef struct wmClientCtxt
+{
     std::string name;
-    wmClientCtxt(const char* appName){
+    wmClientCtxt(const char *appName)
+    {
         name = appName;
     }
 } wmClientCtxt;
 
-struct afb_instance {
-   std::unique_ptr<wl::display> display;
-   wm::App app;
+struct afb_instance
+{
+    std::unique_ptr<wl::display> display;
+    wm::App app;
 
-   afb_instance() : display{new wl::display}, app{this->display.get()} {}
+    afb_instance() : display{new wl::display}, app{this->display.get()} {}
 
-   int init();
+    int init();
 };
 
 struct afb_instance *g_afb_instance;
 std::mutex binding_m;
 
-int afb_instance::init() {
-   return this->app.init();
+int afb_instance::init()
+{
+    return this->app.init();
 }
 
 int display_event_callback(sd_event_source *evs, int /*fd*/, uint32_t events,
-                           void * /*data*/) {
-   ST();
-
-   if ((events & EPOLLHUP) != 0) {
-      HMI_ERROR("wm", "The compositor hung up, dying now.");
-      delete g_afb_instance;
-      g_afb_instance = nullptr;
-      goto error;
-   }
-
-   if ((events & EPOLLIN) != 0u) {
-      {
-         STN(display_read_events);
-         g_afb_instance->app.display->read_events();
-         g_afb_instance->app.set_pending_events();
-      }
-      {
-         // We want do dispatch pending wayland events from within
-         // the API context
-         STN(winman_ping_api_call);
-         afb_service_call("windowmanager", "ping", json_object_new_object(),
-                          [](void *c, int st, json_object *j) {
-                             STN(winman_ping_api_call_return);
-                          },
-                          nullptr);
-      }
-   }
-
-   return 0;
+                           void * /*data*/)
+{
+    ST();
+
+    if ((events & EPOLLHUP) != 0)
+    {
+        HMI_ERROR("wm", "The compositor hung up, dying now.");
+        delete g_afb_instance;
+        g_afb_instance = nullptr;
+        goto error;
+    }
+
+    if ((events & EPOLLIN) != 0u)
+    {
+        {
+            STN(display_read_events);
+            g_afb_instance->app.display->read_events();
+            g_afb_instance->app.set_pending_events();
+        }
+        {
+            // We want do dispatch pending wayland events from within
+            // the API context
+            STN(winman_ping_api_call);
+            afb_service_call("windowmanager", "ping", json_object_new_object(),
+                             [](void *c, int st, json_object *j) {
+                                 STN(winman_ping_api_call_return);
+                             },
+                             nullptr);
+        }
+    }
+
+    return 0;
 
 error:
-   sd_event_source_unref(evs);
-   if (getenv("WINMAN_EXIT_ON_HANGUP") != nullptr) {
-   exit(1);
-}
-   return -1;
+    sd_event_source_unref(evs);
+    if (getenv("WINMAN_EXIT_ON_HANGUP") != nullptr)
+    {
+        exit(1);
+    }
+    return -1;
 }
 
-int _binding_init() {
-   HMI_NOTICE("wm", "WinMan ver. %s", WINMAN_VERSION_STRING);
-
-   if (g_afb_instance != nullptr) {
-      HMI_ERROR("wm", "Wayland context already initialized?");
-      return 0;
-   }
-
-   if (getenv("XDG_RUNTIME_DIR") == nullptr) {
-      HMI_ERROR("wm", "Environment variable XDG_RUNTIME_DIR not set");
-      goto error;
-   }
-
-   {
-      // wait until wayland compositor starts up.
-      int cnt = 0;
-      g_afb_instance = new afb_instance;
-      while (!g_afb_instance->display->ok()) {
-         cnt++;
-         if (20 <= cnt) {
-            HMI_ERROR("wm", "Could not connect to compositor");
+int _binding_init()
+{
+    HMI_NOTICE("wm", "WinMan ver. %s", WINMAN_VERSION_STRING);
+
+    if (g_afb_instance != nullptr)
+    {
+        HMI_ERROR("wm", "Wayland context already initialized?");
+        return 0;
+    }
+
+    if (getenv("XDG_RUNTIME_DIR") == nullptr)
+    {
+        HMI_ERROR("wm", "Environment variable XDG_RUNTIME_DIR not set");
+        goto error;
+    }
+
+    {
+        // wait until wayland compositor starts up.
+        int cnt = 0;
+        g_afb_instance = new afb_instance;
+        while (!g_afb_instance->display->ok())
+        {
+            cnt++;
+            if (20 <= cnt)
+            {
+                HMI_ERROR("wm", "Could not connect to compositor");
+                goto error;
+            }
+            HMI_ERROR("wm", "Wait to start weston ...");
+            sleep(1);
+            delete g_afb_instance;
+            g_afb_instance = new afb_instance;
+        }
+    }
+
+    if (g_afb_instance->init() == -1)
+    {
+        HMI_ERROR("wm", "Could not connect to compositor");
+        goto error;
+    }
+
+    {
+        int ret = sd_event_add_io(afb_daemon_get_event_loop(), nullptr,
+                                  g_afb_instance->display->get_fd(), EPOLLIN,
+                                  display_event_callback, g_afb_instance);
+        if (ret < 0)
+        {
+            HMI_ERROR("wm", "Could not initialize afb_instance event handler: %d", -ret);
             goto error;
-         }
-         HMI_ERROR("wm", "Wait to start weston ...");
-         sleep(1);
-         delete g_afb_instance;
-         g_afb_instance = new afb_instance;
-      }
-   }
-
-   if (g_afb_instance->init() == -1) {
-      HMI_ERROR("wm", "Could not connect to compositor");
-      goto error;
-   }
-
-   {
-      int ret = sd_event_add_io(afb_daemon_get_event_loop(), nullptr,
-                                g_afb_instance->display->get_fd(), EPOLLIN,
-                                display_event_callback, g_afb_instance);
-      if (ret < 0) {
-         HMI_ERROR("wm", "Could not initialize afb_instance event handler: %d", -ret);
-         goto error;
-      }
-   }
-
-   atexit([] { delete g_afb_instance; });
-
-   return 0;
+        }
+    }
+
+    atexit([] { delete g_afb_instance; });
+
+    return 0;
 
 error:
-   delete g_afb_instance;
-   g_afb_instance = nullptr;
-   return -1;
+    delete g_afb_instance;
+    g_afb_instance = nullptr;
+    return -1;
 }
 
-int binding_init() noexcept {
-   try {
-      return _binding_init();
-   } catch (std::exception &e) {
-      HMI_ERROR("wm", "Uncaught exception in binding_init(): %s", e.what());
-   }
-   return -1;
+int binding_init() noexcept
+{
+    try
+    {
+        return _binding_init();
+    }
+    catch (std::exception &e)
+    {
+        HMI_ERROR("wm", "Uncaught exception in binding_init(): %s", e.what());
+    }
+    return -1;
 }
 
-static bool checkFirstReq(afb_req req){
-    wmClientCtxt* ctxt = (wmClientCtxt*)afb_req_context_get(req);
+static bool checkFirstReq(afb_req req)
+{
+    wmClientCtxt *ctxt = (wmClientCtxt *)afb_req_context_get(req);
     return (ctxt) ? false : true;
 }
 
-static void cbRemoveClientCtxt(void* data){
-    wmClientCtxt* ctxt = (wmClientCtxt*)data;
-    if(ctxt == nullptr){
+static void cbRemoveClientCtxt(void *data)
+{
+    wmClientCtxt *ctxt = (wmClientCtxt *)data;
+    if (ctxt == nullptr)
+    {
         return;
     }
-    HMI_DEBUG("wm","remove app %s", ctxt->name.c_str());
+    HMI_DEBUG("wm", "remove app %s", ctxt->name.c_str());
     // Lookup surfaceID and remove it because App is dead.
     auto pSid = g_afb_instance->app.id_alloc.lookup(ctxt->name.c_str());
-    if(pSid){
+    if (pSid)
+    {
         auto sid = *pSid;
         g_afb_instance->app.id_alloc.remove_id(sid);
         g_afb_instance->app.layers.remove_surface(sid);
@@ -180,466 +204,538 @@ static void cbRemoveClientCtxt(void* data){
     delete ctxt;
 }
 
-void windowmanager_requestsurface(afb_req req) noexcept {
-   std::lock_guard<std::mutex> guard(binding_m);
-   #ifdef ST
-   ST();
-   #endif
-   if (g_afb_instance == nullptr) {
-      afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
-      return;
-   }
-
-   try {
-   const char* a_drawing_name = afb_req_value(req, "drawing_name");
-   if(!a_drawing_name){
-       afb_req_fail(req, "failed", "Need char const* argument drawing_name");
-       return;
-   }
-
-   /* Create Security Context */
-   bool isFirstReq = checkFirstReq(req);
-   if(!isFirstReq){
-       wmClientCtxt* ctxt = (wmClientCtxt*)afb_req_context_get(req);
-       HMI_DEBUG("wm", "You're %s.", ctxt->name.c_str());
-       if(ctxt->name != std::string(a_drawing_name)){
-           afb_req_fail_f(req, "failed", "Dont request with other name: %s for now", a_drawing_name);
-           HMI_DEBUG("wm", "Don't request with other name: %s for now", a_drawing_name);
-           return;
-       }
-   }
-
-   auto ret = g_afb_instance->app.api_request_surface(
-       afb_req_get_application_id(req), a_drawing_name);
-
-   if(isFirstReq){
-       wmClientCtxt* ctxt = new wmClientCtxt(a_drawing_name);
-       HMI_DEBUG("wm", "create session for %s", ctxt->name.c_str());
-       afb_req_session_set_LOA(req, 1);
-       afb_req_context_set(req, ctxt, cbRemoveClientCtxt);
-   }
-   else{
-       HMI_DEBUG("wm", "session already created for %s", a_drawing_name);
-   }
-
-   if (ret.is_err()) {
-      afb_req_fail(req, "failed", ret.unwrap_err());
-      return;
-   }
-
-   afb_req_success(req, json_object_new_int(ret.unwrap()), "success");
-
-   } catch (std::exception &e) {
-      afb_req_fail_f(req, "failed", "Uncaught exception while calling requestsurface: %s", e.what());
-      return;
-   }
+void windowmanager_requestsurface(afb_req req) noexcept
+{
+    std::lock_guard<std::mutex> guard(binding_m);
+#ifdef ST
+    ST();
+#endif
+    if (g_afb_instance == nullptr)
+    {
+        afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
+        return;
+    }
 
+    try
+    {
+        const char *a_drawing_name = afb_req_value(req, "drawing_name");
+        if (!a_drawing_name)
+        {
+            afb_req_fail(req, "failed", "Need char const* argument drawing_name");
+            return;
+        }
+
+        /* Create Security Context */
+        bool isFirstReq = checkFirstReq(req);
+        if (!isFirstReq)
+        {
+            wmClientCtxt *ctxt = (wmClientCtxt *)afb_req_context_get(req);
+            HMI_DEBUG("wm", "You're %s.", ctxt->name.c_str());
+            if (ctxt->name != std::string(a_drawing_name))
+            {
+                afb_req_fail_f(req, "failed", "Dont request with other name: %s for now", a_drawing_name);
+                HMI_DEBUG("wm", "Don't request with other name: %s for now", a_drawing_name);
+                return;
+            }
+        }
+
+        auto ret = g_afb_instance->app.api_request_surface(
+            afb_req_get_application_id(req), a_drawing_name);
+
+        if (isFirstReq)
+        {
+            wmClientCtxt *ctxt = new wmClientCtxt(a_drawing_name);
+            HMI_DEBUG("wm", "create session for %s", ctxt->name.c_str());
+            afb_req_session_set_LOA(req, 1);
+            afb_req_context_set(req, ctxt, cbRemoveClientCtxt);
+        }
+        else
+        {
+            HMI_DEBUG("wm", "session already created for %s", a_drawing_name);
+        }
+
+        if (ret.is_err())
+        {
+            afb_req_fail(req, "failed", ret.unwrap_err());
+            return;
+        }
+
+        afb_req_success(req, json_object_new_int(ret.unwrap()), "success");
+    }
+    catch (std::exception &e)
+    {
+        afb_req_fail_f(req, "failed", "Uncaught exception while calling requestsurface: %s", e.what());
+        return;
+    }
 }
 
-void windowmanager_requestsurfacexdg(afb_req req) noexcept {
-   std::lock_guard<std::mutex> guard(binding_m);
-   #ifdef ST
-   ST();
-   #endif
-   if (g_afb_instance == nullptr) {
-      afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
-      return;
-   }
-
-   try {
-   json_object *jreq = afb_req_json(req);
-
-   json_object *j_drawing_name = nullptr;
-   if (! json_object_object_get_ex(jreq, "drawing_name", &j_drawing_name)) {
-      afb_req_fail(req, "failed", "Need char const* argument drawing_name");
-      return;
-   }
-   char const* a_drawing_name = json_object_get_string(j_drawing_name);
-
-   json_object *j_ivi_id = nullptr;
-   if (! json_object_object_get_ex(jreq, "ivi_id", &j_ivi_id)) {
-      afb_req_fail(req, "failed", "Need char const* argument ivi_id");
-      return;
-   }
-   char const* a_ivi_id = json_object_get_string(j_ivi_id);
-
-   auto ret = g_afb_instance->app.api_request_surface(
-       afb_req_get_application_id(req), a_drawing_name, a_ivi_id);
-   if (ret != nullptr) {
-      afb_req_fail(req, "failed", ret);
-      return;
-   }
-
-   afb_req_success(req, NULL, "success");
-   } catch (std::exception &e) {
-      afb_req_fail_f(req, "failed", "Uncaught exception while calling requestsurfacexdg: %s", e.what());
-      return;
-   }
+void windowmanager_requestsurfacexdg(afb_req req) noexcept
+{
+    std::lock_guard<std::mutex> guard(binding_m);
+#ifdef ST
+    ST();
+#endif
+    if (g_afb_instance == nullptr)
+    {
+        afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
+        return;
+    }
+
+    try
+    {
+        json_object *jreq = afb_req_json(req);
+
+        json_object *j_drawing_name = nullptr;
+        if (!json_object_object_get_ex(jreq, "drawing_name", &j_drawing_name))
+        {
+            afb_req_fail(req, "failed", "Need char const* argument drawing_name");
+            return;
+        }
+        char const *a_drawing_name = json_object_get_string(j_drawing_name);
+
+        json_object *j_ivi_id = nullptr;
+        if (!json_object_object_get_ex(jreq, "ivi_id", &j_ivi_id))
+        {
+            afb_req_fail(req, "failed", "Need char const* argument ivi_id");
+            return;
+        }
+        char const *a_ivi_id = json_object_get_string(j_ivi_id);
+
+        auto ret = g_afb_instance->app.api_request_surface(
+            afb_req_get_application_id(req), a_drawing_name, a_ivi_id);
+        if (ret != nullptr)
+        {
+            afb_req_fail(req, "failed", ret);
+            return;
+        }
+
+        afb_req_success(req, NULL, "success");
+    }
+    catch (std::exception &e)
+    {
+        afb_req_fail_f(req, "failed", "Uncaught exception while calling requestsurfacexdg: %s", e.what());
+        return;
+    }
 }
 
-void windowmanager_activatesurface(afb_req req) noexcept {
-   std::lock_guard<std::mutex> guard(binding_m);
-   #ifdef ST
-   ST();
-   #endif
-   if (g_afb_instance == nullptr) {
-      afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
-      return;
-   }
-
-   try {
-   const char* a_drawing_name = afb_req_value(req, "drawing_name");
-   if(!a_drawing_name){
-       afb_req_fail(req, "failed", "Need char const* argument drawing_name");
-       return;
-   }
-
-   const char* a_drawing_area = afb_req_value(req, "drawing_area");
-   if(!a_drawing_area){
-       afb_req_fail(req, "failed", "Need char const* argument drawing_area");
-       return;
-   }
-
-   g_afb_instance->app.api_activate_surface(
-      afb_req_get_application_id(req),
-      a_drawing_name, a_drawing_area,
-      [&req](const char* errmsg){
-      if (errmsg != nullptr) {
-         HMI_ERROR("wm", errmsg);
-         afb_req_fail(req, "failed", errmsg);
-         return;
-      }
-      afb_req_success(req, NULL, "success");
-   });
-
-   } catch (std::exception &e) {
-      HMI_WARNING("wm", "failed", "Uncaught exception while calling activatesurface: %s", e.what());
-      return;
-   }
+void windowmanager_activatesurface(afb_req req) noexcept
+{
+    std::lock_guard<std::mutex> guard(binding_m);
+#ifdef ST
+    ST();
+#endif
+    if (g_afb_instance == nullptr)
+    {
+        afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
+        return;
+    }
 
+    try
+    {
+        const char *a_drawing_name = afb_req_value(req, "drawing_name");
+        if (!a_drawing_name)
+        {
+            afb_req_fail(req, "failed", "Need char const* argument drawing_name");
+            return;
+        }
+
+        const char *a_drawing_area = afb_req_value(req, "drawing_area");
+        if (!a_drawing_area)
+        {
+            afb_req_fail(req, "failed", "Need char const* argument drawing_area");
+            return;
+        }
+
+        g_afb_instance->app.api_activate_surface(
+            afb_req_get_application_id(req),
+            a_drawing_name, a_drawing_area,
+            [&req](const char *errmsg) {
+                if (errmsg != nullptr)
+                {
+                    HMI_ERROR("wm", errmsg);
+                    afb_req_fail(req, "failed", errmsg);
+                    return;
+                }
+                afb_req_success(req, NULL, "success");
+            });
+    }
+    catch (std::exception &e)
+    {
+        HMI_WARNING("wm", "failed", "Uncaught exception while calling activatesurface: %s", e.what());
+        return;
+    }
 }
 
-void windowmanager_deactivatesurface(afb_req req) noexcept {
-   std::lock_guard<std::mutex> guard(binding_m);
-   #ifdef ST
-   ST();
-   #endif
-   if (g_afb_instance == nullptr) {
-      afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
-      return;
-   }
-
-   try {
-   const char* a_drawing_name = afb_req_value(req, "drawing_name");
-   if(!a_drawing_name){
-       afb_req_fail(req, "failed", "Need char const* argument drawing_name");
-       return;
-   }
-
-   g_afb_instance->app.api_deactivate_surface(
-       afb_req_get_application_id(req), a_drawing_name,
-      [&req](const char* errmsg){
-      if (errmsg != nullptr) {
-         HMI_ERROR("wm", errmsg);
-         afb_req_fail(req, "failed", errmsg);
-         return;
-      }
-      afb_req_success(req, NULL, "success");
-   });
-
-   } catch (std::exception &e) {
-      HMI_WARNING("wm", "Uncaught exception while calling deactivatesurface: %s", e.what());
-      return;
-   }
+void windowmanager_deactivatesurface(afb_req req) noexcept
+{
+    std::lock_guard<std::mutex> guard(binding_m);
+#ifdef ST
+    ST();
+#endif
+    if (g_afb_instance == nullptr)
+    {
+        afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
+        return;
+    }
+
+    try
+    {
+        const char *a_drawing_name = afb_req_value(req, "drawing_name");
+        if (!a_drawing_name)
+        {
+            afb_req_fail(req, "failed", "Need char const* argument drawing_name");
+            return;
+        }
+
+        g_afb_instance->app.api_deactivate_surface(
+            afb_req_get_application_id(req), a_drawing_name,
+            [&req](const char *errmsg) {
+                if (errmsg != nullptr)
+                {
+                    HMI_ERROR("wm", errmsg);
+                    afb_req_fail(req, "failed", errmsg);
+                    return;
+                }
+                afb_req_success(req, NULL, "success");
+            });
+    }
+    catch (std::exception &e)
+    {
+        HMI_WARNING("wm", "Uncaught exception while calling deactivatesurface: %s", e.what());
+        return;
+    }
 }
 
-void windowmanager_enddraw(afb_req req) noexcept {
-   std::lock_guard<std::mutex> guard(binding_m);
-   #ifdef ST
-   ST();
-   #endif
-   if (g_afb_instance == nullptr) {
-      afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
-      return;
-   }
-
-   try {
-   const char* a_drawing_name = afb_req_value(req, "drawing_name");
-   if(!a_drawing_name){
-       afb_req_fail(req, "failed", "Need char const* argument drawing_name");
-       return;
-   }
-   afb_req_success(req, NULL, "success");
-
-   g_afb_instance->app.api_enddraw(
-       afb_req_get_application_id(req), a_drawing_name);
-
-   } catch (std::exception &e) {
-      HMI_WARNING("wm", "failed", "Uncaught exception while calling enddraw: %s", e.what());
-      return;
-   }
+void windowmanager_enddraw(afb_req req) noexcept
+{
+    std::lock_guard<std::mutex> guard(binding_m);
+#ifdef ST
+    ST();
+#endif
+    if (g_afb_instance == nullptr)
+    {
+        afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
+        return;
+    }
 
+    try
+    {
+        const char *a_drawing_name = afb_req_value(req, "drawing_name");
+        if (!a_drawing_name)
+        {
+            afb_req_fail(req, "failed", "Need char const* argument drawing_name");
+            return;
+        }
+        afb_req_success(req, NULL, "success");
+
+        g_afb_instance->app.api_enddraw(
+            afb_req_get_application_id(req), a_drawing_name);
+    }
+    catch (std::exception &e)
+    {
+        HMI_WARNING("wm", "failed", "Uncaught exception while calling enddraw: %s", e.what());
+        return;
+    }
 }
 
-void windowmanager_getdisplayinfo_thunk(afb_req req) noexcept {
-   std::lock_guard<std::mutex> guard(binding_m);
-   #ifdef ST
-   ST();
-   #endif
-   if (g_afb_instance == nullptr) {
-      afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
-      return;
-   }
-
-   try {
-   auto ret = g_afb_instance->app.api_get_display_info();
-   if (ret.is_err()) {
-      afb_req_fail(req, "failed", ret.unwrap_err());
-      return;
-   }
-
-   afb_req_success(req, ret.unwrap(), "success");
-   } catch (std::exception &e) {
-      afb_req_fail_f(req, "failed", "Uncaught exception while calling getdisplayinfo: %s", e.what());
-      return;
-   }
+void windowmanager_getdisplayinfo_thunk(afb_req req) noexcept
+{
+    std::lock_guard<std::mutex> guard(binding_m);
+#ifdef ST
+    ST();
+#endif
+    if (g_afb_instance == nullptr)
+    {
+        afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
+        return;
+    }
+
+    try
+    {
+        auto ret = g_afb_instance->app.api_get_display_info();
+        if (ret.is_err())
+        {
+            afb_req_fail(req, "failed", ret.unwrap_err());
+            return;
+        }
 
+        afb_req_success(req, ret.unwrap(), "success");
+    }
+    catch (std::exception &e)
+    {
+        afb_req_fail_f(req, "failed", "Uncaught exception while calling getdisplayinfo: %s", e.what());
+        return;
+    }
 }
 
-void windowmanager_getareainfo_thunk(afb_req req) noexcept {
-   std::lock_guard<std::mutex> guard(binding_m);
-   #ifdef ST
-   ST();
-   #endif
-   if (g_afb_instance == nullptr) {
-      afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
-      return;
-   }
-
-   try {
-   json_object *jreq = afb_req_json(req);
-
-   json_object *j_drawing_name = nullptr;
-   if (! json_object_object_get_ex(jreq, "drawing_name", &j_drawing_name)) {
-      afb_req_fail(req, "failed", "Need char const* argument drawing_name");
-      return;
-   }
-   char const* a_drawing_name = json_object_get_string(j_drawing_name);
-
-   auto ret = g_afb_instance->app.api_get_area_info(a_drawing_name);
-   if (ret.is_err()) {
-      afb_req_fail(req, "failed", ret.unwrap_err());
-      return;
-   }
-
-   afb_req_success(req, ret.unwrap(), "success");
-   } catch (std::exception &e) {
-      afb_req_fail_f(req, "failed", "Uncaught exception while calling getareainfo: %s", e.what());
-      return;
-   }
+void windowmanager_getareainfo_thunk(afb_req req) noexcept
+{
+    std::lock_guard<std::mutex> guard(binding_m);
+#ifdef ST
+    ST();
+#endif
+    if (g_afb_instance == nullptr)
+    {
+        afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
+        return;
+    }
 
+    try
+    {
+        json_object *jreq = afb_req_json(req);
+
+        json_object *j_drawing_name = nullptr;
+        if (!json_object_object_get_ex(jreq, "drawing_name", &j_drawing_name))
+        {
+            afb_req_fail(req, "failed", "Need char const* argument drawing_name");
+            return;
+        }
+        char const *a_drawing_name = json_object_get_string(j_drawing_name);
+
+        auto ret = g_afb_instance->app.api_get_area_info(a_drawing_name);
+        if (ret.is_err())
+        {
+            afb_req_fail(req, "failed", ret.unwrap_err());
+            return;
+        }
+
+        afb_req_success(req, ret.unwrap(), "success");
+    }
+    catch (std::exception &e)
+    {
+        afb_req_fail_f(req, "failed", "Uncaught exception while calling getareainfo: %s", e.what());
+        return;
+    }
 }
 
-void windowmanager_wm_subscribe(afb_req req) noexcept {
-   std::lock_guard<std::mutex> guard(binding_m);
-   #ifdef ST
-   ST();
-   #endif
-   if (g_afb_instance == nullptr) {
-      afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
-      return;
-   }
-
-   try {
-   json_object *jreq = afb_req_json(req);
-   json_object *j = nullptr;
-   if (! json_object_object_get_ex(jreq, "event", &j)) {
-      afb_req_fail(req, "failed", "Need char const* argument event");
-      return;
-   }
-   int event_type = json_object_get_int(j);
-   const char *event_name = g_afb_instance->app.kListEventName[event_type];
-   struct afb_event event = g_afb_instance->app.map_afb_event[event_name];
-   int ret = afb_req_subscribe(req, event);
-   if (ret) {
-      afb_req_fail(req, "failed", "Error: afb_req_subscribe()");
-      return;
-   }
-   afb_req_success(req, NULL, "success");
-
-   } catch (std::exception &e) {
-      afb_req_fail_f(req, "failed", "Uncaught exception while calling wm_subscribe: %s", e.what());
-      return;
-   }
+void windowmanager_wm_subscribe(afb_req req) noexcept
+{
+    std::lock_guard<std::mutex> guard(binding_m);
+#ifdef ST
+    ST();
+#endif
+    if (g_afb_instance == nullptr)
+    {
+        afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
+        return;
+    }
 
+    try
+    {
+        json_object *jreq = afb_req_json(req);
+        json_object *j = nullptr;
+        if (!json_object_object_get_ex(jreq, "event", &j))
+        {
+            afb_req_fail(req, "failed", "Need char const* argument event");
+            return;
+        }
+        int event_type = json_object_get_int(j);
+        const char *event_name = g_afb_instance->app.kListEventName[event_type];
+        struct afb_event event = g_afb_instance->app.map_afb_event[event_name];
+        int ret = afb_req_subscribe(req, event);
+        if (ret)
+        {
+            afb_req_fail(req, "failed", "Error: afb_req_subscribe()");
+            return;
+        }
+        afb_req_success(req, NULL, "success");
+    }
+    catch (std::exception &e)
+    {
+        afb_req_fail_f(req, "failed", "Uncaught exception while calling wm_subscribe: %s", e.what());
+        return;
+    }
 }
 
-void windowmanager_list_drawing_names(afb_req req) noexcept {
-   std::lock_guard<std::mutex> guard(binding_m);
-   #ifdef ST
-   ST();
-   #endif
-   if (g_afb_instance == nullptr) {
-      afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
-      return;
-   }
+void windowmanager_list_drawing_names(afb_req req) noexcept
+{
+    std::lock_guard<std::mutex> guard(binding_m);
+#ifdef ST
+    ST();
+#endif
+    if (g_afb_instance == nullptr)
+    {
+        afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
+        return;
+    }
 
-   try {
+    try
+    {
 
-   nlohmann::json j = g_afb_instance->app.id_alloc.name2id;
-   auto ret = wm::Ok(json_tokener_parse(j.dump().c_str()));
-   if (ret.is_err()) {
-      afb_req_fail(req, "failed", ret.unwrap_err());
-      return;
-   }
+        nlohmann::json j = g_afb_instance->app.id_alloc.name2id;
+        auto ret = wm::Ok(json_tokener_parse(j.dump().c_str()));
+        if (ret.is_err())
+        {
+            afb_req_fail(req, "failed", ret.unwrap_err());
+            return;
+        }
 
-   afb_req_success(req, ret.unwrap(), "success");
+        afb_req_success(req, ret.unwrap(), "success");
+    }
+    catch (std::exception &e)
+    {
+        afb_req_fail_f(req, "failed", "Uncaught exception while calling list_drawing_names: %s", e.what());
+        return;
+    }
+}
 
-   } catch (std::exception &e) {
-      afb_req_fail_f(req, "failed", "Uncaught exception while calling list_drawing_names: %s", e.what());
-      return;
-   }
+void windowmanager_ping(afb_req req) noexcept
+{
+    std::lock_guard<std::mutex> guard(binding_m);
+#ifdef ST
+    ST();
+#endif
+    if (g_afb_instance == nullptr)
+    {
+        afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
+        return;
+    }
 
-}
+    try
+    {
 
-void windowmanager_ping(afb_req req) noexcept {
-   std::lock_guard<std::mutex> guard(binding_m);
-   #ifdef ST
-   ST();
-   #endif
-   if (g_afb_instance == nullptr) {
-      afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
-      return;
-   }
+        g_afb_instance->app.api_ping();
 
-   try {
+        afb_req_success(req, NULL, "success");
+    }
+    catch (std::exception &e)
+    {
+        afb_req_fail_f(req, "failed", "Uncaught exception while calling ping: %s", e.what());
+        return;
+    }
+}
 
-   g_afb_instance->app.api_ping();
+void windowmanager_debug_status(afb_req req) noexcept
+{
+    std::lock_guard<std::mutex> guard(binding_m);
+#ifdef ST
+    ST();
+#endif
+    if (g_afb_instance == nullptr)
+    {
+        afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
+        return;
+    }
 
-   afb_req_success(req, NULL, "success");
+    try
+    {
 
-   } catch (std::exception &e) {
-      afb_req_fail_f(req, "failed", "Uncaught exception while calling ping: %s", e.what());
-      return;
-   }
-}
+        json_object *jr = json_object_new_object();
+        json_object_object_add(jr, "surfaces",
+                               to_json(g_afb_instance->app.controller->sprops));
+        json_object_object_add(jr, "layers", to_json(g_afb_instance->app.controller->lprops));
 
-void windowmanager_debug_status(afb_req req) noexcept {
-   std::lock_guard<std::mutex> guard(binding_m);
-   #ifdef ST
-   ST();
-   #endif
-   if (g_afb_instance == nullptr) {
-      afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
-      return;
-   }
-
-   try {
-
-   json_object *jr = json_object_new_object();
-   json_object_object_add(jr, "surfaces",
-                          to_json(g_afb_instance->app.controller->sprops));
-   json_object_object_add(jr, "layers", to_json(g_afb_instance->app.controller->lprops));
-
-   afb_req_success(req, jr, "success");
-
-   } catch (std::exception &e) {
-      afb_req_fail_f(req, "failed", "Uncaught exception while calling debug_status: %s", e.what());
-      return;
-   }
+        afb_req_success(req, jr, "success");
+    }
+    catch (std::exception &e)
+    {
+        afb_req_fail_f(req, "failed", "Uncaught exception while calling debug_status: %s", e.what());
+        return;
+    }
 }
 
-void windowmanager_debug_layers(afb_req req) noexcept {
-   std::lock_guard<std::mutex> guard(binding_m);
-   #ifdef ST
-   ST();
-   #endif
-   if (g_afb_instance == nullptr) {
-      afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
-      return;
-   }
-
-   try {
-   auto ret = wm::Ok(json_tokener_parse(g_afb_instance->app.layers.to_json().dump().c_str()));
-
-   afb_req_success(req, ret, "success");
-
-   } catch (std::exception &e) {
-      afb_req_fail_f(req, "failed", "Uncaught exception while calling debug_layers: %s", e.what());
-      return;
-   }
-}
+void windowmanager_debug_layers(afb_req req) noexcept
+{
+    std::lock_guard<std::mutex> guard(binding_m);
+#ifdef ST
+    ST();
+#endif
+    if (g_afb_instance == nullptr)
+    {
+        afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
+        return;
+    }
 
-void windowmanager_debug_surfaces(afb_req req) noexcept {
-   std::lock_guard<std::mutex> guard(binding_m);
-   #ifdef ST
-   ST();
-   #endif
-   if (g_afb_instance == nullptr) {
-      afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
-      return;
-   }
+    try
+    {
+        auto ret = wm::Ok(json_tokener_parse(g_afb_instance->app.layers.to_json().dump().c_str()));
 
-   try {
+        afb_req_success(req, ret, "success");
+    }
+    catch (std::exception &e)
+    {
+        afb_req_fail_f(req, "failed", "Uncaught exception while calling debug_layers: %s", e.what());
+        return;
+    }
+}
 
-   auto ret = wm::Ok(to_json(g_afb_instance->app.controller->sprops));
-   if (ret.is_err()) {
-      afb_req_fail(req, "failed", ret.unwrap_err());
-      return;
-   }
+void windowmanager_debug_surfaces(afb_req req) noexcept
+{
+    std::lock_guard<std::mutex> guard(binding_m);
+#ifdef ST
+    ST();
+#endif
+    if (g_afb_instance == nullptr)
+    {
+        afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
+        return;
+    }
 
-   afb_req_success(req, ret.unwrap(), "success");
+    try
+    {
 
-   } catch (std::exception &e) {
-      afb_req_fail_f(req, "failed", "Uncaught exception while calling debug_surfaces: %s", e.what());
-      return;
-   }
+        auto ret = wm::Ok(to_json(g_afb_instance->app.controller->sprops));
+        if (ret.is_err())
+        {
+            afb_req_fail(req, "failed", ret.unwrap_err());
+            return;
+        }
 
+        afb_req_success(req, ret.unwrap(), "success");
+    }
+    catch (std::exception &e)
+    {
+        afb_req_fail_f(req, "failed", "Uncaught exception while calling debug_surfaces: %s", e.what());
+        return;
+    }
 }
 
-void windowmanager_debug_terminate(afb_req req) noexcept {
-   std::lock_guard<std::mutex> guard(binding_m);
-   #ifdef ST
-   ST();
-   #endif
-   if (g_afb_instance == nullptr) {
-      afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
-      return;
-   }
-
-   try {
-
-   if (getenv("WINMAN_DEBUG_TERMINATE") != nullptr) {
-      raise(SIGKILL);  // afb-daemon kills it's pgroup using TERM, which
-                       // doesn't play well with perf
-   }
+void windowmanager_debug_terminate(afb_req req) noexcept
+{
+    std::lock_guard<std::mutex> guard(binding_m);
+#ifdef ST
+    ST();
+#endif
+    if (g_afb_instance == nullptr)
+    {
+        afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
+        return;
+    }
 
-   afb_req_success(req, NULL, "success");
+    try
+    {
 
-   } catch (std::exception &e) {
-      afb_req_fail_f(req, "failed", "Uncaught exception while calling debug_terminate: %s", e.what());
-      return;
-   }
+        if (getenv("WINMAN_DEBUG_TERMINATE") != nullptr)
+        {
+            raise(SIGKILL); // afb-daemon kills it's pgroup using TERM, which
+                            // doesn't play well with perf
+        }
 
+        afb_req_success(req, NULL, "success");
+    }
+    catch (std::exception &e)
+    {
+        afb_req_fail_f(req, "failed", "Uncaught exception while calling debug_terminate: %s", e.what());
+        return;
+    }
 }
 
 const struct afb_verb_v2 windowmanager_verbs[] = {
-   { "requestsurface", windowmanager_requestsurface, nullptr, nullptr, AFB_SESSION_NONE },
-   { "requestsurfacexdg", windowmanager_requestsurfacexdg, nullptr, nullptr, AFB_SESSION_NONE },
-   { "activatesurface", windowmanager_activatesurface, nullptr, nullptr, AFB_SESSION_LOA_1 },
-   { "deactivatesurface", windowmanager_deactivatesurface, nullptr, nullptr, AFB_SESSION_LOA_1 },
-   { "enddraw", windowmanager_enddraw, nullptr, nullptr, AFB_SESSION_LOA_1 },
-   { "getdisplayinfo", windowmanager_getdisplayinfo_thunk, nullptr, nullptr, AFB_SESSION_NONE },
-   { "getareainfo", windowmanager_getareainfo_thunk, nullptr, nullptr, AFB_SESSION_LOA_1 },
-   { "wm_subscribe", windowmanager_wm_subscribe, nullptr, nullptr, AFB_SESSION_NONE },
-   { "list_drawing_names", windowmanager_list_drawing_names, nullptr, nullptr, AFB_SESSION_NONE },
-   { "ping", windowmanager_ping, nullptr, nullptr, AFB_SESSION_NONE },
-   { "debug_status", windowmanager_debug_status, nullptr, nullptr, AFB_SESSION_NONE },
-   { "debug_layers", windowmanager_debug_layers, nullptr, nullptr, AFB_SESSION_NONE },
-   { "debug_surfaces", windowmanager_debug_surfaces, nullptr, nullptr, AFB_SESSION_NONE },
-   { "debug_terminate", windowmanager_debug_terminate, nullptr, nullptr, AFB_SESSION_NONE },
-   {}
-};
+    {"requestsurface", windowmanager_requestsurface, nullptr, nullptr, AFB_SESSION_NONE},
+    {"requestsurfacexdg", windowmanager_requestsurfacexdg, nullptr, nullptr, AFB_SESSION_NONE},
+    {"activatesurface", windowmanager_activatesurface, nullptr, nullptr, AFB_SESSION_LOA_1},
+    {"deactivatesurface", windowmanager_deactivatesurface, nullptr, nullptr, AFB_SESSION_LOA_1},
+    {"enddraw", windowmanager_enddraw, nullptr, nullptr, AFB_SESSION_LOA_1},
+    {"getdisplayinfo", windowmanager_getdisplayinfo_thunk, nullptr, nullptr, AFB_SESSION_NONE},
+    {"getareainfo", windowmanager_getareainfo_thunk, nullptr, nullptr, AFB_SESSION_LOA_1},
+    {"wm_subscribe", windowmanager_wm_subscribe, nullptr, nullptr, AFB_SESSION_NONE},
+    {"list_drawing_names", windowmanager_list_drawing_names, nullptr, nullptr, AFB_SESSION_NONE},
+    {"ping", windowmanager_ping, nullptr, nullptr, AFB_SESSION_NONE},
+    {"debug_status", windowmanager_debug_status, nullptr, nullptr, AFB_SESSION_NONE},
+    {"debug_layers", windowmanager_debug_layers, nullptr, nullptr, AFB_SESSION_NONE},
+    {"debug_surfaces", windowmanager_debug_surfaces, nullptr, nullptr, AFB_SESSION_NONE},
+    {"debug_terminate", windowmanager_debug_terminate, nullptr, nullptr, AFB_SESSION_NONE},
+    {}};
 
 extern "C" const struct afb_binding_v2 afbBindingV2 = {
-   "windowmanager", nullptr, nullptr, windowmanager_verbs, nullptr, binding_init, nullptr, 0};
+    "windowmanager", nullptr, nullptr, windowmanager_verbs, nullptr, binding_init, nullptr, 0};
diff --git a/src/policy.hpp b/src/policy.hpp
index 222c8cc..b87f94d 100644
--- a/src/policy.hpp
+++ b/src/policy.hpp
@@ -20,17 +20,20 @@
 #include "layout.hpp"
 #include "hmi-debug.h"
 
-namespace wm {
+namespace wm
+{
 
-class Policy {
-public:
-   bool layout_is_valid(LayoutState const & /* layout */) {
-      // We do not check for policy currently
-      HMI_DEBUG("wm", "Policy check returns positive");
-      return true;
-   }
+class Policy
+{
+  public:
+    bool layout_is_valid(LayoutState const & /* layout */)
+    {
+        // We do not check for policy currently
+        HMI_DEBUG("wm", "Policy check returns positive");
+        return true;
+    }
 };
 
-}  // namespace wm
+} // namespace wm
 
 #endif //TMCAGLWM_POLICY_HPP
diff --git a/src/request.cpp b/src/request.cpp
index 9c69058..97b9f49 100644
--- a/src/request.cpp
+++ b/src/request.cpp
@@ -16,11 +16,12 @@
 
 #include "request.hpp"
 
-namespace wm {
+namespace wm
+{
 
 using std::string;
 
-WMRequest::WMRequest(){}
+WMRequest::WMRequest() {}
 
 WMRequest::WMRequest(string appid, string role, string area, Task task)
     : seq_num(0),
@@ -29,14 +30,15 @@ WMRequest::WMRequest(string appid, string role, string area, Task task)
 {
 }
 
-WMRequest::~WMRequest(){
-
+WMRequest::~WMRequest()
+{
 }
 
-WMRequest::WMRequest(const WMRequest &obj){
+WMRequest::WMRequest(const WMRequest &obj)
+{
     this->seq_num = obj.seq_num;
     this->trigger = obj.trigger;
     this->sync_draw_req = obj.sync_draw_req;
 }
 
-}
\ No newline at end of file
+} // namespace wm
\ No newline at end of file
diff --git a/src/request.hpp b/src/request.hpp
index 08c8fb0..9a97abb 100644
--- a/src/request.hpp
+++ b/src/request.hpp
@@ -20,7 +20,8 @@
 #include <string>
 #include <vector>
 
-namespace wm{
+namespace wm
+{
 
 enum Task
 {
@@ -58,6 +59,6 @@ struct WMRequest
     std::vector<struct WMAction> sync_draw_req;
 };
 
-}
+} // namespace wm
 
 #endif //WMREQUEST_HPP
\ No newline at end of file
diff --git a/src/result.hpp b/src/result.hpp
index 09eadb5..8a59a90 100644
--- a/src/result.hpp
+++ b/src/result.hpp
@@ -20,58 +20,67 @@
 #include <experimental/optional>
 #include <functional>
 
-namespace wm {
+namespace wm
+{
 
-using std::experimental::optional;
 using std::experimental::nullopt;
+using std::experimental::optional;
 
 // We only ever return a string as an error - so just parametrize
 // this over result type T
 template <typename T>
-struct result {
-   char const *e;
-   optional<T> t;
-
-   bool is_ok() const { return this->t != nullopt; }
-   bool is_err() const { return this->e != nullptr; }
-
-   T unwrap() {
-      if (this->e != nullptr) {
-         throw std::logic_error(this->e);
-      }
-      return this->t.value();
-   }
-
-   operator T() { return this->unwrap(); }
-
-   char const *unwrap_err() { return this->e; }
-
-   optional<T> const &ok() const { return this->t; }
-   optional<char const *> err() const {
-      return this->e ? optional<char const *>(this->e) : nullopt;
-   }
-
-   result<T> map_err(std::function<char const *(char const *)> f);
+struct result
+{
+  char const *e;
+  optional<T> t;
+
+  bool is_ok() const { return this->t != nullopt; }
+  bool is_err() const { return this->e != nullptr; }
+
+  T unwrap()
+  {
+    if (this->e != nullptr)
+    {
+      throw std::logic_error(this->e);
+    }
+    return this->t.value();
+  }
+
+  operator T() { return this->unwrap(); }
+
+  char const *unwrap_err() { return this->e; }
+
+  optional<T> const &ok() const { return this->t; }
+  optional<char const *> err() const
+  {
+    return this->e ? optional<char const *>(this->e) : nullopt;
+  }
+
+  result<T> map_err(std::function<char const *(char const *)> f);
 };
 
 template <typename T>
-struct result<T> Err(char const *e) {
-   return result<T>{e, nullopt};
+struct result<T> Err(char const *e)
+{
+  return result<T>{e, nullopt};
 }
 
 template <typename T>
-struct result<T> Ok(T t) {
-   return result<T>{nullptr, t};
+struct result<T> Ok(T t)
+{
+  return result<T>{nullptr, t};
 }
 
 template <typename T>
-result<T> result<T>::map_err(std::function<char const *(char const *)> f) {
-   if (this->is_err()) {
-      return Err<T>(f(this->e));
-   }
-   return *this;
+result<T> result<T>::map_err(std::function<char const *(char const *)> f)
+{
+  if (this->is_err())
+  {
+    return Err<T>(f(this->e));
+  }
+  return *this;
 }
 
-}  // namespace wm
+} // namespace wm
 
-#endif  // TMCAGLWM_RESULT_HPP
+#endif // TMCAGLWM_RESULT_HPP
diff --git a/src/util.cpp b/src/util.cpp
index 2ae856f..19d590e 100644
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -26,14 +26,17 @@
 
 #ifdef SCOPE_TRACING
 thread_local int ScopeTrace::indent = 0;
-ScopeTrace::ScopeTrace(char const *func) : f(func) {
-   fprintf(stderr, "%lu %*s%s -->\n", pthread_self(), 2 * indent++, "", this->f);
+ScopeTrace::ScopeTrace(char const *func) : f(func)
+{
+    fprintf(stderr, "%lu %*s%s -->\n", pthread_self(), 2 * indent++, "", this->f);
 }
 ScopeTrace::~ScopeTrace() { fprintf(stderr, "%lu %*s%s <--\n", pthread_self(), 2 * --indent, "", this->f); }
 #endif
 
-unique_fd::~unique_fd() {
-   if (this->fd != -1) {
-      close(this->fd);
-   }
+unique_fd::~unique_fd()
+{
+    if (this->fd != -1)
+    {
+        close(this->fd);
+    }
 }
diff --git a/src/util.hpp b/src/util.hpp
index f4e6e5f..78d2185 100644
--- a/src/util.hpp
+++ b/src/util.hpp
@@ -24,7 +24,8 @@
 #include <sys/poll.h>
 
 #ifndef DO_NOT_USE_AFB
-extern "C" {
+extern "C"
+{
 #include <afb/afb-binding.h>
 };
 #endif
@@ -34,7 +35,7 @@ extern "C" {
 
 #ifdef __GNUC__
 #define ATTR_FORMAT(stringindex, firsttocheck) \
-   __attribute__((format(printf, stringindex, firsttocheck)))
+    __attribute__((format(printf, stringindex, firsttocheck)))
 #define ATTR_NORETURN __attribute__((noreturn))
 #else
 #define ATTR_FORMAT(stringindex, firsttocheck)
@@ -44,18 +45,20 @@ extern "C" {
 #ifdef AFB_BINDING_VERSION
 #define lognotice(...) AFB_NOTICE(__VA_ARGS__)
 #define logerror(...) AFB_ERROR(__VA_ARGS__)
-#define fatal(...)            \
-   do {                       \
-      AFB_ERROR(__VA_ARGS__); \
-      abort();                \
-   } while (0)
+#define fatal(...)              \
+    do                          \
+    {                           \
+        AFB_ERROR(__VA_ARGS__); \
+        abort();                \
+    } while (0)
 #else
 #define lognotice(...)
 #define logerror(...)
-#define fatal(...)            \
-   do {                       \
-      abort();                \
-   } while (0)
+#define fatal(...) \
+    do             \
+    {              \
+        abort();   \
+    } while (0)
 #endif
 
 #ifdef DEBUG_OUTPUT
@@ -77,30 +80,33 @@ extern "C" {
 #define STN(N) \
     ScopeTrace __attribute__((unused)) CONCAT(named_trace_scope_, __LINE__)(#N)
 
-struct ScopeTrace {
-   thread_local static int indent;
-   char const *f{};
-   explicit ScopeTrace(char const *func);
-   ~ScopeTrace();
+struct ScopeTrace
+{
+    thread_local static int indent;
+    char const *f{};
+    explicit ScopeTrace(char const *func);
+    ~ScopeTrace();
 };
 #endif
 
 /**
  * @struct unique_fd
  */
-struct unique_fd {
-   int fd{-1};
-   unique_fd() = default;
-   explicit unique_fd(int f) : fd{f} {}
-   operator int() const { return fd; }
-   ~unique_fd();
-   unique_fd(unique_fd const &) = delete;
-   unique_fd &operator=(unique_fd const &) = delete;
-   unique_fd(unique_fd &&o) : fd(o.fd) { o.fd = -1; }
-   unique_fd &operator=(unique_fd &&o) {
-      std::swap(this->fd, o.fd);
-      return *this;
-   }
+struct unique_fd
+{
+    int fd{-1};
+    unique_fd() = default;
+    explicit unique_fd(int f) : fd{f} {}
+    operator int() const { return fd; }
+    ~unique_fd();
+    unique_fd(unique_fd const &) = delete;
+    unique_fd &operator=(unique_fd const &) = delete;
+    unique_fd(unique_fd &&o) : fd(o.fd) { o.fd = -1; }
+    unique_fd &operator=(unique_fd &&o)
+    {
+        std::swap(this->fd, o.fd);
+        return *this;
+    }
 };
 
-#endif  // !WM_UTIL_HPP
+#endif // !WM_UTIL_HPP
diff --git a/src/wayland_ivi_wm.cpp b/src/wayland_ivi_wm.cpp
index f1a0c2b..5cc16b2 100644
--- a/src/wayland_ivi_wm.cpp
+++ b/src/wayland_ivi_wm.cpp
@@ -23,15 +23,16 @@
 /**
  * namespace wl
  */
-namespace wl {
+namespace wl
+{
 
 /**
  * display
  */
 display::display()
-   : d(std::unique_ptr<struct wl_display, void (*)(struct wl_display *)>(
-        wl_display_connect(nullptr), &wl_display_disconnect)),
-     r(d.get()) {}
+    : d(std::unique_ptr<struct wl_display, void (*)(struct wl_display *)>(
+          wl_display_connect(nullptr), &wl_display_disconnect)),
+      r(d.get()) {}
 
 bool display::ok() const { return d && wl_display_get_error(d.get()) == 0; }
 
@@ -41,24 +42,29 @@ int display::dispatch() { return wl_display_dispatch(this->d.get()); }
 
 int display::dispatch_pending() { return wl_display_dispatch_pending(this->d.get()); }
 
-int display::read_events() {
-   ST();
-   while (wl_display_prepare_read(this->d.get()) == -1) {
-      STN(pending_events_dispatch);
-      if (wl_display_dispatch_pending(this->d.get()) == -1) {
-         return -1;
-      }
-   }
+int display::read_events()
+{
+    ST();
+    while (wl_display_prepare_read(this->d.get()) == -1)
+    {
+        STN(pending_events_dispatch);
+        if (wl_display_dispatch_pending(this->d.get()) == -1)
+        {
+            return -1;
+        }
+    }
 
-   if (wl_display_flush(this->d.get()) == -1) {
-      return -1;
-   }
+    if (wl_display_flush(this->d.get()) == -1)
+    {
+        return -1;
+    }
 
-   if (wl_display_read_events(this->d.get()) == -1) {
-      wl_display_cancel_read(this->d.get());
-   }
+    if (wl_display_read_events(this->d.get()) == -1)
+    {
+        wl_display_cancel_read(this->d.get());
+    }
 
-   return 0;
+    return 0;
 }
 
 void display::flush() { wl_display_flush(this->d.get()); }
@@ -70,39 +76,47 @@ int display::get_error() { return wl_display_get_error(this->d.get()); }
 /**
  * registry
  */
-namespace {
+namespace
+{
 void registry_global_created(void *data, struct wl_registry * /*r*/, uint32_t name,
-                     char const *iface, uint32_t v) {
-   static_cast<struct registry *>(data)->global_created(name, iface, v);
+                             char const *iface, uint32_t v)
+{
+    static_cast<struct registry *>(data)->global_created(name, iface, v);
 }
 
 void registry_global_removed(void *data, struct wl_registry * /*r*/,
-                            uint32_t name) {
-   static_cast<struct registry *>(data)->global_removed(name);
+                             uint32_t name)
+{
+    static_cast<struct registry *>(data)->global_removed(name);
 }
 
 constexpr struct wl_registry_listener registry_listener = {
-   registry_global_created, registry_global_removed};
+    registry_global_created, registry_global_removed};
 } // namespace
 
 registry::registry(struct wl_display *d)
-   : wayland_proxy(d == nullptr ? nullptr : wl_display_get_registry(d)) {
-   if (this->proxy != nullptr) {
-      wl_registry_add_listener(this->proxy.get(), &registry_listener, this);
-   }
+    : wayland_proxy(d == nullptr ? nullptr : wl_display_get_registry(d))
+{
+    if (this->proxy != nullptr)
+    {
+        wl_registry_add_listener(this->proxy.get(), &registry_listener, this);
+    }
 }
 
-void registry::add_global_handler(char const *iface, binder bind) {
-   this->bindings[iface] = std::move(bind);
+void registry::add_global_handler(char const *iface, binder bind)
+{
+    this->bindings[iface] = std::move(bind);
 }
 
-void registry::global_created(uint32_t name, char const *iface, uint32_t v) {
-   auto b = this->bindings.find(iface);
-   if (b != this->bindings.end()) {
-      b->second(this->proxy.get(), name, v);
-   }
-   HMI_DEBUG("wm", "wl::registry @ %p global n %u i %s v %u", this->proxy.get(), name,
-            iface, v);
+void registry::global_created(uint32_t name, char const *iface, uint32_t v)
+{
+    auto b = this->bindings.find(iface);
+    if (b != this->bindings.end())
+    {
+        b->second(this->proxy.get(), name, v);
+    }
+    HMI_DEBUG("wm", "wl::registry @ %p global n %u i %s v %u", this->proxy.get(), name,
+              iface, v);
 }
 
 void registry::global_removed(uint32_t /*name*/) {}
@@ -110,229 +124,271 @@ void registry::global_removed(uint32_t /*name*/) {}
 /**
  * output
  */
-namespace {
+namespace
+{
 void output_geometry(void *data, struct wl_output * /*wl_output*/, int32_t x,
                      int32_t y, int32_t physical_width, int32_t physical_height,
                      int32_t subpixel, const char *make, const char *model,
-                     int32_t transform) {
-   static_cast<struct output *>(data)->geometry(
-      x, y, physical_width, physical_height, subpixel, make, model, transform);
+                     int32_t transform)
+{
+    static_cast<struct output *>(data)->geometry(
+        x, y, physical_width, physical_height, subpixel, make, model, transform);
 }
 
 void output_mode(void *data, struct wl_output * /*wl_output*/, uint32_t flags,
-                 int32_t width, int32_t height, int32_t refresh) {
-   static_cast<struct output *>(data)->mode(flags, width, height, refresh);
+                 int32_t width, int32_t height, int32_t refresh)
+{
+    static_cast<struct output *>(data)->mode(flags, width, height, refresh);
 }
 
-void output_done(void *data, struct wl_output * /*wl_output*/) {
-   static_cast<struct output *>(data)->done();
+void output_done(void *data, struct wl_output * /*wl_output*/)
+{
+    static_cast<struct output *>(data)->done();
 }
 
 void output_scale(void *data, struct wl_output * /*wl_output*/,
-                  int32_t factor) {
-   static_cast<struct output *>(data)->scale(factor);
+                  int32_t factor)
+{
+    static_cast<struct output *>(data)->scale(factor);
 }
 
 constexpr struct wl_output_listener output_listener = {
-   output_geometry, output_mode, output_done, output_scale};
+    output_geometry, output_mode, output_done, output_scale};
 } // namespace
 
 output::output(struct wl_registry *r, uint32_t name, uint32_t v)
-   : wayland_proxy(wl_registry_bind(r, name, &wl_output_interface, v)) {
-   wl_output_add_listener(this->proxy.get(), &output_listener, this);
+    : wayland_proxy(wl_registry_bind(r, name, &wl_output_interface, v))
+{
+    wl_output_add_listener(this->proxy.get(), &output_listener, this);
 }
 
 void output::geometry(int32_t x, int32_t y, int32_t pw, int32_t ph,
                       int32_t subpel, char const *make, char const *model,
-                      int32_t tx) {
-   HMI_DEBUG("wm",
-      "wl::output %s @ %p x %i y %i w %i h %i spel %x make %s model %s tx %i",
-      __func__, this->proxy.get(), x, y, pw, ph, subpel, make, model, tx);
-   this->physical_width = pw;
-   this->physical_height = ph;
-   this->transform = tx;
-}
-
-void output::mode(uint32_t flags, int32_t w, int32_t h, int32_t r) {
-   HMI_DEBUG("wm", "wl::output %s @ %p f %x w %i h %i r %i", __func__,
-            this->proxy.get(), flags, w, h, r);
-   if ((flags & WL_OUTPUT_MODE_CURRENT) != 0u) {
-      this->width = w;
-      this->height = h;
-      this->refresh = r;
-   }
-}
-
-void output::done() {
-   HMI_DEBUG("wm", "wl::output %s @ %p done", __func__, this->proxy.get());
-   // Pivot and flipped
-   if (this->transform == WL_OUTPUT_TRANSFORM_90 ||
-       this->transform == WL_OUTPUT_TRANSFORM_270 ||
-       this->transform == WL_OUTPUT_TRANSFORM_FLIPPED_90 ||
-       this->transform == WL_OUTPUT_TRANSFORM_FLIPPED_270) {
-      std::swap(this->width, this->height);
-      std::swap(this->physical_width, this->physical_height);
-   }
-}
-
-void output::scale(int32_t factor) {
-   HMI_DEBUG("wm", "wl::output %s @ %p f %i", __func__, this->proxy.get(), factor);
-}
-}  // namespace wl
+                      int32_t tx)
+{
+    HMI_DEBUG("wm",
+              "wl::output %s @ %p x %i y %i w %i h %i spel %x make %s model %s tx %i",
+              __func__, this->proxy.get(), x, y, pw, ph, subpel, make, model, tx);
+    this->physical_width = pw;
+    this->physical_height = ph;
+    this->transform = tx;
+}
+
+void output::mode(uint32_t flags, int32_t w, int32_t h, int32_t r)
+{
+    HMI_DEBUG("wm", "wl::output %s @ %p f %x w %i h %i r %i", __func__,
+              this->proxy.get(), flags, w, h, r);
+    if ((flags & WL_OUTPUT_MODE_CURRENT) != 0u)
+    {
+        this->width = w;
+        this->height = h;
+        this->refresh = r;
+    }
+}
+
+void output::done()
+{
+    HMI_DEBUG("wm", "wl::output %s @ %p done", __func__, this->proxy.get());
+    // Pivot and flipped
+    if (this->transform == WL_OUTPUT_TRANSFORM_90 ||
+        this->transform == WL_OUTPUT_TRANSFORM_270 ||
+        this->transform == WL_OUTPUT_TRANSFORM_FLIPPED_90 ||
+        this->transform == WL_OUTPUT_TRANSFORM_FLIPPED_270)
+    {
+        std::swap(this->width, this->height);
+        std::swap(this->physical_width, this->physical_height);
+    }
+}
+
+void output::scale(int32_t factor)
+{
+    HMI_DEBUG("wm", "wl::output %s @ %p f %i", __func__, this->proxy.get(), factor);
+}
+} // namespace wl
 
 /**
  * namespace compositor
  */
-namespace compositor {
+namespace compositor
+{
 
-namespace {
+namespace
+{
 
 void surface_visibility_changed(
-   void *data, struct ivi_wm * /*ivi_wm*/,
-   uint32_t surface_id, int32_t visibility) {
-   auto s = static_cast<struct surface *>(data);
-   s->parent->surface_visibility_changed(s, visibility);
+    void *data, struct ivi_wm * /*ivi_wm*/,
+    uint32_t surface_id, int32_t visibility)
+{
+    auto s = static_cast<struct surface *>(data);
+    s->parent->surface_visibility_changed(s, visibility);
 }
 
 void surface_opacity_changed(void *data, struct ivi_wm * /*ivi_wm*/,
-                     uint32_t surface_id, wl_fixed_t opacity) {
-   auto s = static_cast<struct surface *>(data);
-   s->parent->surface_opacity_changed(s, float(wl_fixed_to_double(opacity)));
+                             uint32_t surface_id, wl_fixed_t opacity)
+{
+    auto s = static_cast<struct surface *>(data);
+    s->parent->surface_opacity_changed(s, float(wl_fixed_to_double(opacity)));
 }
 
 void surface_source_rectangle_changed(
-   void *data, struct ivi_wm * /*ivi_wm*/, uint32_t surface_id,
-   int32_t x, int32_t y, int32_t width, int32_t height) {
-   auto s = static_cast<struct surface *>(data);
-   s->parent->surface_source_rectangle_changed(s, x, y, width, height);
+    void *data, struct ivi_wm * /*ivi_wm*/, uint32_t surface_id,
+    int32_t x, int32_t y, int32_t width, int32_t height)
+{
+    auto s = static_cast<struct surface *>(data);
+    s->parent->surface_source_rectangle_changed(s, x, y, width, height);
 }
 
 void surface_destination_rectangle_changed(
-   void *data, struct ivi_wm * /*ivi_wm*/, uint32_t surface_id,
-   int32_t x, int32_t y, int32_t width, int32_t height) {
-   auto s = static_cast<struct surface *>(data);
-   s->parent->surface_destination_rectangle_changed(s, x, y, width, height);
+    void *data, struct ivi_wm * /*ivi_wm*/, uint32_t surface_id,
+    int32_t x, int32_t y, int32_t width, int32_t height)
+{
+    auto s = static_cast<struct surface *>(data);
+    s->parent->surface_destination_rectangle_changed(s, x, y, width, height);
 }
 
 void surface_created(void *data, struct ivi_wm * /*ivi_wm*/,
-                        uint32_t id_surface) {
-   static_cast<struct controller *>(data)->surface_created(id_surface);
+                     uint32_t id_surface)
+{
+    static_cast<struct controller *>(data)->surface_created(id_surface);
 }
 
 void surface_destroyed(
-   void *data, struct ivi_wm * /*ivi_wm*/, uint32_t surface_id) {
-   auto s = static_cast<struct surface *>(data);
-   s->parent->surface_destroyed(s, surface_id);
+    void *data, struct ivi_wm * /*ivi_wm*/, uint32_t surface_id)
+{
+    auto s = static_cast<struct surface *>(data);
+    s->parent->surface_destroyed(s, surface_id);
 }
 
 void surface_error_detected(void *data, struct ivi_wm * /*ivi_wm*/, uint32_t object_id,
-                      uint32_t error_code, const char *error_text) {
-   static_cast<struct controller *>(data)->surface_error_detected(
-      object_id, error_code, error_text);
+                            uint32_t error_code, const char *error_text)
+{
+    static_cast<struct controller *>(data)->surface_error_detected(
+        object_id, error_code, error_text);
 }
 
 void surface_size_changed(
-   void *data, struct ivi_wm * /*ivi_wm*/, uint32_t surface_id,
-   int32_t width, int32_t height) {
-   auto s = static_cast<struct surface *>(data);
-   s->parent->surface_size_changed(s, width, height);
+    void *data, struct ivi_wm * /*ivi_wm*/, uint32_t surface_id,
+    int32_t width, int32_t height)
+{
+    auto s = static_cast<struct surface *>(data);
+    s->parent->surface_size_changed(s, width, height);
 }
 
 void surface_stats_received(void *data, struct ivi_wm * /*ivi_wm*/,
-                   uint32_t surface_id, uint32_t frame_count, uint32_t pid) {
-   auto s = static_cast<struct surface *>(data);
-   s->parent->surface_stats_received(s, surface_id, frame_count, pid);
+                            uint32_t surface_id, uint32_t frame_count, uint32_t pid)
+{
+    auto s = static_cast<struct surface *>(data);
+    s->parent->surface_stats_received(s, surface_id, frame_count, pid);
 }
 
 void surface_added_to_layer(void *data, struct ivi_wm * /*ivi_wm*/,
-                   uint32_t layer_id, uint32_t surface_id) {
-   auto s = static_cast<struct surface *>(data);
-   s->parent->surface_added_to_layer(s, layer_id, surface_id);
+                            uint32_t layer_id, uint32_t surface_id)
+{
+    auto s = static_cast<struct surface *>(data);
+    s->parent->surface_added_to_layer(s, layer_id, surface_id);
 }
 
 void layer_visibility_changed(void *data, struct ivi_wm * /*ivi_wm*/,
-                      uint32_t layer_id, int32_t visibility) {
-   auto l = static_cast<struct layer *>(data);
-   l->parent->layer_visibility_changed(l, layer_id, visibility);
+                              uint32_t layer_id, int32_t visibility)
+{
+    auto l = static_cast<struct layer *>(data);
+    l->parent->layer_visibility_changed(l, layer_id, visibility);
 }
 
 void layer_opacity_changed(void *data, struct ivi_wm * /*ivi_wm*/,
-                   uint32_t layer_id, wl_fixed_t opacity) {
-   auto l = static_cast<struct layer *>(data);
-   l->parent->layer_opacity_changed(l, layer_id, float(wl_fixed_to_double(opacity)));
+                           uint32_t layer_id, wl_fixed_t opacity)
+{
+    auto l = static_cast<struct layer *>(data);
+    l->parent->layer_opacity_changed(l, layer_id, float(wl_fixed_to_double(opacity)));
 }
 
 void layer_source_rectangle_changed(
-   void *data, struct ivi_wm * /*ivi_wm*/, uint32_t layer_id,
-   int32_t x, int32_t y, int32_t width, int32_t height) {
-   auto l = static_cast<struct layer *>(data);
-   l->parent->layer_source_rectangle_changed(l, layer_id, x, y, width, height);
+    void *data, struct ivi_wm * /*ivi_wm*/, uint32_t layer_id,
+    int32_t x, int32_t y, int32_t width, int32_t height)
+{
+    auto l = static_cast<struct layer *>(data);
+    l->parent->layer_source_rectangle_changed(l, layer_id, x, y, width, height);
 }
 
 void layer_destination_rectangle_changed(
-   void *data, struct ivi_wm * /*ivi_wm*/, uint32_t layer_id,
-   int32_t x, int32_t y, int32_t width, int32_t height) {
-   auto l = static_cast<struct layer *>(data);
-   l->parent->layer_destination_rectangle_changed(l, layer_id, x, y, width, height);
+    void *data, struct ivi_wm * /*ivi_wm*/, uint32_t layer_id,
+    int32_t x, int32_t y, int32_t width, int32_t height)
+{
+    auto l = static_cast<struct layer *>(data);
+    l->parent->layer_destination_rectangle_changed(l, layer_id, x, y, width, height);
 }
 
 void layer_created(void *data, struct ivi_wm * /*ivi_wm*/,
-                      uint32_t id_layer) {
-   static_cast<struct controller *>(data)->layer_created(id_layer);
+                   uint32_t id_layer)
+{
+    static_cast<struct controller *>(data)->layer_created(id_layer);
 }
 
-void layer_destroyed(void *data, struct ivi_wm * /*ivi_wm*/, uint32_t layer_id) {
-   auto l = static_cast<struct layer *>(data);
-   l->parent->layer_destroyed(l, layer_id);
+void layer_destroyed(void *data, struct ivi_wm * /*ivi_wm*/, uint32_t layer_id)
+{
+    auto l = static_cast<struct layer *>(data);
+    l->parent->layer_destroyed(l, layer_id);
 }
 
 void layer_error_detected(void *data, struct ivi_wm * /*ivi_wm*/, uint32_t object_id,
-                      uint32_t error_code, const char *error_text) {
-   static_cast<struct controller *>(data)->layer_error_detected(
-      object_id, error_code, error_text);
+                          uint32_t error_code, const char *error_text)
+{
+    static_cast<struct controller *>(data)->layer_error_detected(
+        object_id, error_code, error_text);
 }
 
 constexpr struct ivi_wm_listener listener = {
-   surface_visibility_changed,            layer_visibility_changed,
-   surface_opacity_changed,               layer_opacity_changed,
-   surface_source_rectangle_changed,      layer_source_rectangle_changed,
-   surface_destination_rectangle_changed, layer_destination_rectangle_changed,
-   surface_created,                       layer_created,
-   surface_destroyed,                     layer_destroyed,
-   surface_error_detected,                layer_error_detected,
-   surface_size_changed,
-   surface_stats_received,
-   surface_added_to_layer,
+    surface_visibility_changed,
+    layer_visibility_changed,
+    surface_opacity_changed,
+    layer_opacity_changed,
+    surface_source_rectangle_changed,
+    layer_source_rectangle_changed,
+    surface_destination_rectangle_changed,
+    layer_destination_rectangle_changed,
+    surface_created,
+    layer_created,
+    surface_destroyed,
+    layer_destroyed,
+    surface_error_detected,
+    layer_error_detected,
+    surface_size_changed,
+    surface_stats_received,
+    surface_added_to_layer,
 };
 
-void screen_created(void *data, struct ivi_wm_screen *ivi_wm_screen, uint32_t id) {
-   static_cast<struct screen *>(data)->screen_created((struct screen *)data, id);
+void screen_created(void *data, struct ivi_wm_screen *ivi_wm_screen, uint32_t id)
+{
+    static_cast<struct screen *>(data)->screen_created((struct screen *)data, id);
 }
 
 void layer_added(void *data,
-                    struct ivi_wm_screen *ivi_wm_screen,
-                    uint32_t layer_id) {
-   HMI_DEBUG("wm", "added layer_id:%d", layer_id);
+                 struct ivi_wm_screen *ivi_wm_screen,
+                 uint32_t layer_id)
+{
+    HMI_DEBUG("wm", "added layer_id:%d", layer_id);
 }
 
 void connector_name(void *data,
                     struct ivi_wm_screen *ivi_wm_screen,
-                    const char *process_name) {
-   HMI_DEBUG("wm", "process_name:%s", process_name);
+                    const char *process_name)
+{
+    HMI_DEBUG("wm", "process_name:%s", process_name);
 }
 
 void screen_error(void *data,
                   struct ivi_wm_screen *ivi_wm_screen,
                   uint32_t error,
-                  const char *message) {
-   HMI_DEBUG("wm", "screen error:%d message:%s", error, message);
+                  const char *message)
+{
+    HMI_DEBUG("wm", "screen error:%d message:%s", error, message);
 }
 
 constexpr struct ivi_wm_screen_listener screen_listener = {
-   screen_created,
-   layer_added,
-   connector_name,
-   screen_error,
+    screen_created,
+    layer_added,
+    connector_name,
+    screen_error,
 };
 } // namespace
 
@@ -340,311 +396,355 @@ constexpr struct ivi_wm_screen_listener screen_listener = {
  * surface
  */
 surface::surface(uint32_t i, struct controller *c)
-   : controller_child(c, i) {
-   this->parent->add_proxy_to_sid_mapping(this->parent->proxy.get(), i);
+    : controller_child(c, i)
+{
+    this->parent->add_proxy_to_sid_mapping(this->parent->proxy.get(), i);
 }
 
-void surface::set_visibility(uint32_t visibility) {
-   HMI_DEBUG("wm", "compositor::surface id:%d v:%d", this->id, visibility);
-   ivi_wm_set_surface_visibility(this->parent->proxy.get(), this->id, visibility);
+void surface::set_visibility(uint32_t visibility)
+{
+    HMI_DEBUG("wm", "compositor::surface id:%d v:%d", this->id, visibility);
+    ivi_wm_set_surface_visibility(this->parent->proxy.get(), this->id, visibility);
 }
 
 void surface::set_source_rectangle(int32_t x, int32_t y,
-                                   int32_t width, int32_t height) {
-   ivi_wm_set_surface_source_rectangle(this->parent->proxy.get(), this->id,
-                                       x, y, width, height);
+                                   int32_t width, int32_t height)
+{
+    ivi_wm_set_surface_source_rectangle(this->parent->proxy.get(), this->id,
+                                        x, y, width, height);
 }
 
 void surface::set_destination_rectangle(int32_t x, int32_t y,
-                                        int32_t width, int32_t height) {
-   ivi_wm_set_surface_destination_rectangle(this->parent->proxy.get(), this->id,
-                                            x, y, width, height);
+                                        int32_t width, int32_t height)
+{
+    ivi_wm_set_surface_destination_rectangle(this->parent->proxy.get(), this->id,
+                                             x, y, width, height);
 }
 
-
 /**
  * layer
  */
 layer::layer(uint32_t i, struct controller *c) : layer(i, 0, 0, c) {}
 
 layer::layer(uint32_t i, int32_t w, int32_t h, struct controller *c)
-   : controller_child(c, i) {
-   this->parent->add_proxy_to_lid_mapping(this->parent->proxy.get(), i);
-   ivi_wm_create_layout_layer(c->proxy.get(), i, w, h);
+    : controller_child(c, i)
+{
+    this->parent->add_proxy_to_lid_mapping(this->parent->proxy.get(), i);
+    ivi_wm_create_layout_layer(c->proxy.get(), i, w, h);
 }
 
-void layer::set_visibility(uint32_t visibility) {
-   ivi_wm_set_layer_visibility(this->parent->proxy.get(), this->id, visibility);
+void layer::set_visibility(uint32_t visibility)
+{
+    ivi_wm_set_layer_visibility(this->parent->proxy.get(), this->id, visibility);
 }
 
 void layer::set_destination_rectangle(int32_t x, int32_t y,
-                                      int32_t width, int32_t height) {
-   ivi_wm_set_layer_destination_rectangle(this->parent->proxy.get(), this->id,
-                                          x, y, width, height);
+                                      int32_t width, int32_t height)
+{
+    ivi_wm_set_layer_destination_rectangle(this->parent->proxy.get(), this->id,
+                                           x, y, width, height);
 }
 
-void layer::add_surface(uint32_t surface_id) {
-   ivi_wm_layer_add_surface(this->parent->proxy.get(), this->id, surface_id);
+void layer::add_surface(uint32_t surface_id)
+{
+    ivi_wm_layer_add_surface(this->parent->proxy.get(), this->id, surface_id);
 }
 
-void layer::remove_surface(uint32_t surface_id) {
-   ivi_wm_layer_remove_surface(this->parent->proxy.get(), this->id, surface_id);
+void layer::remove_surface(uint32_t surface_id)
+{
+    ivi_wm_layer_remove_surface(this->parent->proxy.get(), this->id, surface_id);
 }
 
-
 /**
  * screen
  */
 screen::screen(uint32_t i, struct controller *c, struct wl_output *o)
-   : wayland_proxy(ivi_wm_create_screen(c->proxy.get(), o)),
-     controller_child(c, i) {
-   HMI_DEBUG("wm", "compositor::screen @ %p id %u o %p", this->proxy.get(), i, o);
+    : wayland_proxy(ivi_wm_create_screen(c->proxy.get(), o)),
+      controller_child(c, i)
+{
+    HMI_DEBUG("wm", "compositor::screen @ %p id %u o %p", this->proxy.get(), i, o);
 
-   // Add listener for screen
-   ivi_wm_screen_add_listener(this->proxy.get(), &screen_listener, this);
+    // Add listener for screen
+    ivi_wm_screen_add_listener(this->proxy.get(), &screen_listener, this);
 }
 
 void screen::clear() { ivi_wm_screen_clear(this->proxy.get()); }
 
-void screen::screen_created(struct screen *screen, uint32_t id) {
-   HMI_DEBUG("wm", "compositor::screen @ %p screen %u (%x) @ %p", this->proxy.get(),
-            id, id, screen);
-   this->id = id;
-   this->parent->screens[id] = screen;
+void screen::screen_created(struct screen *screen, uint32_t id)
+{
+    HMI_DEBUG("wm", "compositor::screen @ %p screen %u (%x) @ %p", this->proxy.get(),
+              id, id, screen);
+    this->id = id;
+    this->parent->screens[id] = screen;
 }
 
-void screen::set_render_order(std::vector<uint32_t> const &ro) {
-   std::size_t i;
+void screen::set_render_order(std::vector<uint32_t> const &ro)
+{
+    std::size_t i;
 
-   // Remove all layers from the screen render order
-   ivi_wm_screen_clear(this->proxy.get());
+    // Remove all layers from the screen render order
+    ivi_wm_screen_clear(this->proxy.get());
 
-   for (i = 0; i < ro.size(); i++) {
-      HMI_DEBUG("wm", "compositor::screen @ %p add layer %u", this->proxy.get(), ro[i]);
-      // Add the layer to screen render order at nearest z-position
-      ivi_wm_screen_add_layer(this->proxy.get(), ro[i]);
-   }
+    for (i = 0; i < ro.size(); i++)
+    {
+        HMI_DEBUG("wm", "compositor::screen @ %p add layer %u", this->proxy.get(), ro[i]);
+        // Add the layer to screen render order at nearest z-position
+        ivi_wm_screen_add_layer(this->proxy.get(), ro[i]);
+    }
 }
 
-
 /**
  * controller
  */
 controller::controller(struct wl_registry *r, uint32_t name, uint32_t version)
-   : wayland_proxy(
-        wl_registry_bind(r, name, &ivi_wm_interface, version)),
-     output_size{} {
-   ivi_wm_add_listener(this->proxy.get(), &listener, this);
+    : wayland_proxy(
+          wl_registry_bind(r, name, &ivi_wm_interface, version)),
+      output_size{}
+{
+    ivi_wm_add_listener(this->proxy.get(), &listener, this);
 }
 
-void controller::layer_create(uint32_t id, int32_t w, int32_t h) {
-   this->layers[id] = std::make_unique<struct layer>(id, w, h, this);
+void controller::layer_create(uint32_t id, int32_t w, int32_t h)
+{
+    this->layers[id] = std::make_unique<struct layer>(id, w, h, this);
 }
 
-void controller::surface_create(uint32_t id) {
-   this->surfaces[id] = std::make_unique<struct surface>(id, this);
+void controller::surface_create(uint32_t id)
+{
+    this->surfaces[id] = std::make_unique<struct surface>(id, this);
 
-   // TODO: If Clipping is necessary, this process should be modified.
-   {
-      // Set surface type:IVI_WM_SURFACE_TYPE_DESKTOP)
-      // for resizing wayland surface when switching from split to full surface.
-      ivi_wm_set_surface_type(this->proxy.get(), id, IVI_WM_SURFACE_TYPE_DESKTOP);
+    // TODO: If Clipping is necessary, this process should be modified.
+    {
+        // Set surface type:IVI_WM_SURFACE_TYPE_DESKTOP)
+        // for resizing wayland surface when switching from split to full surface.
+        ivi_wm_set_surface_type(this->proxy.get(), id, IVI_WM_SURFACE_TYPE_DESKTOP);
 
-      // Set source reactangle even if we should not need to set it
-      // for enable setting for destination region.
-      this->surfaces[id]->set_source_rectangle(0, 0, this->output_size.w, this->output_size.h);
+        // Set source reactangle even if we should not need to set it
+        // for enable setting for destination region.
+        this->surfaces[id]->set_source_rectangle(0, 0, this->output_size.w, this->output_size.h);
 
-      // Flush display
-      this->display->flush();
-   }
+        // Flush display
+        this->display->flush();
+    }
 }
 
-void controller::create_screen(struct wl_output *output) {
-   // TODO: screen id is 0 (WM manages one screen for now)
-   this->screen = std::make_unique<struct screen>(0, this, output);
+void controller::create_screen(struct wl_output *output)
+{
+    // TODO: screen id is 0 (WM manages one screen for now)
+    this->screen = std::make_unique<struct screen>(0, this, output);
 }
 
-void controller::layer_created(uint32_t id) {
-   HMI_DEBUG("wm", "compositor::controller @ %p layer %u (%x)", this->proxy.get(), id, id);
-   if (this->layers.find(id) != this->layers.end()) {
-      HMI_DEBUG("wm", "WindowManager has created layer %u (%x) already", id, id);
-   } else {
-      this->layers[id] = std::make_unique<struct layer>(id, this);
-   }
+void controller::layer_created(uint32_t id)
+{
+    HMI_DEBUG("wm", "compositor::controller @ %p layer %u (%x)", this->proxy.get(), id, id);
+    if (this->layers.find(id) != this->layers.end())
+    {
+        HMI_DEBUG("wm", "WindowManager has created layer %u (%x) already", id, id);
+    }
+    else
+    {
+        this->layers[id] = std::make_unique<struct layer>(id, this);
+    }
 }
 
 void controller::layer_error_detected(uint32_t object_id,
-                                  uint32_t error_code, const char *error_text) {
-   HMI_DEBUG("wm", "compositor::controller @ %p error o %d c %d text %s",
-            this->proxy.get(), object_id, error_code, error_text);
+                                      uint32_t error_code, const char *error_text)
+{
+    HMI_DEBUG("wm", "compositor::controller @ %p error o %d c %d text %s",
+              this->proxy.get(), object_id, error_code, error_text);
 }
 
-void controller::surface_visibility_changed(struct surface *s, int32_t visibility) {
-   HMI_DEBUG("wm", "compositor::surface %s @ %d v %i", __func__, s->id,
-            visibility);
-   this->sprops[s->id].visibility = visibility;
-   this->chooks->surface_visibility(s->id, visibility);
+void controller::surface_visibility_changed(struct surface *s, int32_t visibility)
+{
+    HMI_DEBUG("wm", "compositor::surface %s @ %d v %i", __func__, s->id,
+              visibility);
+    this->sprops[s->id].visibility = visibility;
+    this->chooks->surface_visibility(s->id, visibility);
 }
 
-void controller::surface_opacity_changed(struct surface *s, float opacity) {
-   HMI_DEBUG("wm", "compositor::surface %s @ %d o %f", __func__, s->id,
-            opacity);
-   this->sprops[s->id].opacity = opacity;
+void controller::surface_opacity_changed(struct surface *s, float opacity)
+{
+    HMI_DEBUG("wm", "compositor::surface %s @ %d o %f", __func__, s->id,
+              opacity);
+    this->sprops[s->id].opacity = opacity;
 }
 
 void controller::surface_source_rectangle_changed(struct surface *s, int32_t x,
-                                          int32_t y, int32_t width,
-                                          int32_t height) {
-   HMI_DEBUG("wm", "compositor::surface %s @ %d x %i y %i w %i h %i", __func__,
-            s->id, x, y, width, height);
-   this->sprops[s->id].src_rect = rect{width, height, x, y};
+                                                  int32_t y, int32_t width,
+                                                  int32_t height)
+{
+    HMI_DEBUG("wm", "compositor::surface %s @ %d x %i y %i w %i h %i", __func__,
+              s->id, x, y, width, height);
+    this->sprops[s->id].src_rect = rect{width, height, x, y};
 }
 
 void controller::surface_destination_rectangle_changed(struct surface *s, int32_t x,
-                                               int32_t y, int32_t width,
-                                               int32_t height) {
-   HMI_DEBUG("wm", "compositor::surface %s @ %d x %i y %i w %i h %i", __func__,
-            s->id, x, y, width, height);
-   this->sprops[s->id].dst_rect = rect{width, height, x, y};
-   this->chooks->surface_destination_rectangle(s->id, x, y, width, height);
+                                                       int32_t y, int32_t width,
+                                                       int32_t height)
+{
+    HMI_DEBUG("wm", "compositor::surface %s @ %d x %i y %i w %i h %i", __func__,
+              s->id, x, y, width, height);
+    this->sprops[s->id].dst_rect = rect{width, height, x, y};
+    this->chooks->surface_destination_rectangle(s->id, x, y, width, height);
 }
 
 void controller::surface_size_changed(struct surface *s, int32_t width,
-                                       int32_t height) {
-   HMI_DEBUG("wm", "compositor::surface %s @ %d w %i h %i", __func__, s->id,
-            width, height);
-   this->sprops[s->id].size = size{uint32_t(width), uint32_t(height)};
+                                      int32_t height)
+{
+    HMI_DEBUG("wm", "compositor::surface %s @ %d w %i h %i", __func__, s->id,
+              width, height);
+    this->sprops[s->id].size = size{uint32_t(width), uint32_t(height)};
 }
 
-void controller::surface_added_to_layer(struct surface * s,
-                               uint32_t layer_id, uint32_t surface_id) {
-   HMI_DEBUG("wm", "compositor::surface %s @ %d l %u",
-             __func__, layer_id, surface_id);
+void controller::surface_added_to_layer(struct surface *s,
+                                        uint32_t layer_id, uint32_t surface_id)
+{
+    HMI_DEBUG("wm", "compositor::surface %s @ %d l %u",
+              __func__, layer_id, surface_id);
 }
 
 void controller::surface_stats_received(struct surface *s, uint32_t surface_id,
-                               uint32_t frame_count, uint32_t pid) {
-   HMI_DEBUG("wm", "compositor::surface %s @ %d f %u pid %u",
-             __func__, surface_id, frame_count, pid);
+                                        uint32_t frame_count, uint32_t pid)
+{
+    HMI_DEBUG("wm", "compositor::surface %s @ %d f %u pid %u",
+              __func__, surface_id, frame_count, pid);
 }
 
-void controller::surface_created(uint32_t id) {
-   HMI_DEBUG("wm", "compositor::controller @ %p surface %u (%x)", this->proxy.get(), id,
-            id);
-   if (this->surfaces.find(id) == this->surfaces.end()) {
-      this->surfaces[id] = std::make_unique<struct surface>(id, this);
-      this->chooks->surface_created(id);
+void controller::surface_created(uint32_t id)
+{
+    HMI_DEBUG("wm", "compositor::controller @ %p surface %u (%x)", this->proxy.get(), id,
+              id);
+    if (this->surfaces.find(id) == this->surfaces.end())
+    {
+        this->surfaces[id] = std::make_unique<struct surface>(id, this);
+        this->chooks->surface_created(id);
 
-      // TODO: If Clipping is necessary, this process should be modified.
-      {
-         // Set surface type:IVI_WM_SURFACE_TYPE_DESKTOP)
-         // for resizing wayland surface when switching from split to full surface.
-         ivi_wm_set_surface_type(this->proxy.get(), id, IVI_WM_SURFACE_TYPE_DESKTOP);
+        // TODO: If Clipping is necessary, this process should be modified.
+        {
+            // Set surface type:IVI_WM_SURFACE_TYPE_DESKTOP)
+            // for resizing wayland surface when switching from split to full surface.
+            ivi_wm_set_surface_type(this->proxy.get(), id, IVI_WM_SURFACE_TYPE_DESKTOP);
 
-         // Set source reactangle even if we should not need to set it
-         // for enable setting for destination region.
-         this->surfaces[id]->set_source_rectangle(0, 0, this->output_size.w, this->output_size.h);
+            // Set source reactangle even if we should not need to set it
+            // for enable setting for destination region.
+            this->surfaces[id]->set_source_rectangle(0, 0, this->output_size.w, this->output_size.h);
 
-         // Flush display
-         this->display->flush();
-      }
-   }
+            // Flush display
+            this->display->flush();
+        }
+    }
 }
 
-void controller::surface_destroyed(struct surface *s, uint32_t surface_id) {
-   HMI_DEBUG("wm", "compositor::surface %s @ %d", __func__, surface_id);
-   this->chooks->surface_removed(surface_id);
-   this->sprops.erase(surface_id);
-   this->surfaces.erase(surface_id);
+void controller::surface_destroyed(struct surface *s, uint32_t surface_id)
+{
+    HMI_DEBUG("wm", "compositor::surface %s @ %d", __func__, surface_id);
+    this->chooks->surface_removed(surface_id);
+    this->sprops.erase(surface_id);
+    this->surfaces.erase(surface_id);
 }
 
 void controller::surface_error_detected(uint32_t object_id,
-                                  uint32_t error_code, const char *error_text) {
-   HMI_DEBUG("wm", "compositor::controller @ %p error o %d c %d text %s",
-            this->proxy.get(), object_id, error_code, error_text);
+                                        uint32_t error_code, const char *error_text)
+{
+    HMI_DEBUG("wm", "compositor::controller @ %p error o %d c %d text %s",
+              this->proxy.get(), object_id, error_code, error_text);
 }
 
-void controller::layer_visibility_changed(struct layer *l, uint32_t layer_id, int32_t visibility) {
-   HMI_DEBUG("wm", "compositor::layer %s @ %d v %i", __func__, layer_id, visibility);
-   this->lprops[layer_id].visibility = visibility;
+void controller::layer_visibility_changed(struct layer *l, uint32_t layer_id, int32_t visibility)
+{
+    HMI_DEBUG("wm", "compositor::layer %s @ %d v %i", __func__, layer_id, visibility);
+    this->lprops[layer_id].visibility = visibility;
 }
 
-void controller::layer_opacity_changed(struct layer *l, uint32_t layer_id, float opacity) {
-   HMI_DEBUG("wm", "compositor::layer %s @ %d o %f", __func__, layer_id, opacity);
-   this->lprops[layer_id].opacity = opacity;
+void controller::layer_opacity_changed(struct layer *l, uint32_t layer_id, float opacity)
+{
+    HMI_DEBUG("wm", "compositor::layer %s @ %d o %f", __func__, layer_id, opacity);
+    this->lprops[layer_id].opacity = opacity;
 }
 
 void controller::layer_source_rectangle_changed(struct layer *l, uint32_t layer_id,
-                                        int32_t x, int32_t y,
-                                        int32_t width, int32_t height) {
-   HMI_DEBUG("wm", "compositor::layer %s @ %d x %i y %i w %i h %i",
-             __func__, layer_id, x, y, width, height);
-   this->lprops[layer_id].src_rect = rect{width, height, x, y};
+                                                int32_t x, int32_t y,
+                                                int32_t width, int32_t height)
+{
+    HMI_DEBUG("wm", "compositor::layer %s @ %d x %i y %i w %i h %i",
+              __func__, layer_id, x, y, width, height);
+    this->lprops[layer_id].src_rect = rect{width, height, x, y};
 }
 
 void controller::layer_destination_rectangle_changed(struct layer *l, uint32_t layer_id,
-                                             int32_t x, int32_t y,
-                                             int32_t width, int32_t height) {
-   HMI_DEBUG("wm", "compositor::layer %s @ %d x %i y %i w %i h %i",
-             __func__, layer_id, x, y, width, height);
-   this->lprops[layer_id].dst_rect = rect{width, height, x, y};
+                                                     int32_t x, int32_t y,
+                                                     int32_t width, int32_t height)
+{
+    HMI_DEBUG("wm", "compositor::layer %s @ %d x %i y %i w %i h %i",
+              __func__, layer_id, x, y, width, height);
+    this->lprops[layer_id].dst_rect = rect{width, height, x, y};
 }
 
 void controller::layer_configuration(struct layer *l, int32_t width,
-                                     int32_t height) {
-   HMI_DEBUG("wm", "compositor::layer %s @ %d w %i h %i", __func__, l->id,
-            width, height);
-   this->lprops[l->id].size = size{uint32_t(width), uint32_t(height)};
+                                     int32_t height)
+{
+    HMI_DEBUG("wm", "compositor::layer %s @ %d w %i h %i", __func__, l->id,
+              width, height);
+    this->lprops[l->id].size = size{uint32_t(width), uint32_t(height)};
 }
 
-void controller::layer_orientation(struct layer *l, int32_t orientation) {
-   HMI_DEBUG("wm", "compositor::layer %s @ %d o %i", __func__, l->id,
-            orientation);
-   this->lprops[l->id].orientation = orientation;
+void controller::layer_orientation(struct layer *l, int32_t orientation)
+{
+    HMI_DEBUG("wm", "compositor::layer %s @ %d o %i", __func__, l->id,
+              orientation);
+    this->lprops[l->id].orientation = orientation;
 }
 
-void controller::layer_screen(struct layer *l, struct wl_output *screen) {
-   HMI_DEBUG("wm", "compositor::layer %s @ %d s %p", __func__, l->id, screen);
+void controller::layer_screen(struct layer *l, struct wl_output *screen)
+{
+    HMI_DEBUG("wm", "compositor::layer %s @ %d s %p", __func__, l->id, screen);
 }
 
-void controller::layer_destroyed(struct layer *l, uint32_t layer_id) {
-   HMI_DEBUG("wm", "compositor::layer %s @ %d", __func__, layer_id);
-   this->lprops.erase(layer_id);
-   this->layers.erase(layer_id);
+void controller::layer_destroyed(struct layer *l, uint32_t layer_id)
+{
+    HMI_DEBUG("wm", "compositor::layer %s @ %d", __func__, layer_id);
+    this->lprops.erase(layer_id);
+    this->layers.erase(layer_id);
 }
 
 void controller::add_proxy_to_sid_mapping(struct ivi_wm *p,
-                                         uint32_t id) {
-   HMI_DEBUG("wm", "Add surface proxy mapping for %p (%u)", p, id);
-   this->surface_proxy_to_id[uintptr_t(p)] = id;
-   this->sprops[id].id = id;
+                                          uint32_t id)
+{
+    HMI_DEBUG("wm", "Add surface proxy mapping for %p (%u)", p, id);
+    this->surface_proxy_to_id[uintptr_t(p)] = id;
+    this->sprops[id].id = id;
 }
 
-void controller::remove_proxy_to_sid_mapping(struct ivi_wm *p) {
-   HMI_DEBUG("wm", "Remove surface proxy mapping for %p", p);
-   this->surface_proxy_to_id.erase(uintptr_t(p));
+void controller::remove_proxy_to_sid_mapping(struct ivi_wm *p)
+{
+    HMI_DEBUG("wm", "Remove surface proxy mapping for %p", p);
+    this->surface_proxy_to_id.erase(uintptr_t(p));
 }
 
 void controller::add_proxy_to_lid_mapping(struct ivi_wm *p,
-                                         uint32_t id) {
-   HMI_DEBUG("wm", "Add layer proxy mapping for %p (%u)", p, id);
-   this->layer_proxy_to_id[uintptr_t(p)] = id;
-   this->lprops[id].id = id;
+                                          uint32_t id)
+{
+    HMI_DEBUG("wm", "Add layer proxy mapping for %p (%u)", p, id);
+    this->layer_proxy_to_id[uintptr_t(p)] = id;
+    this->lprops[id].id = id;
 }
 
-void controller::remove_proxy_to_lid_mapping(struct ivi_wm *p) {
-   HMI_DEBUG("wm", "Remove layer proxy mapping for %p", p);
-   this->layer_proxy_to_id.erase(uintptr_t(p));
+void controller::remove_proxy_to_lid_mapping(struct ivi_wm *p)
+{
+    HMI_DEBUG("wm", "Remove layer proxy mapping for %p", p);
+    this->layer_proxy_to_id.erase(uintptr_t(p));
 }
 
-void controller::add_proxy_to_id_mapping(struct wl_output *p, uint32_t id) {
-   HMI_DEBUG("wm", "Add screen proxy mapping for %p (%u)", p, id);
-   this->screen_proxy_to_id[uintptr_t(p)] = id;
+void controller::add_proxy_to_id_mapping(struct wl_output *p, uint32_t id)
+{
+    HMI_DEBUG("wm", "Add screen proxy mapping for %p (%u)", p, id);
+    this->screen_proxy_to_id[uintptr_t(p)] = id;
 }
 
-void controller::remove_proxy_to_id_mapping(struct wl_output *p) {
-   HMI_DEBUG("wm", "Remove screen proxy mapping for %p", p);
-   this->screen_proxy_to_id.erase(uintptr_t(p));
+void controller::remove_proxy_to_id_mapping(struct wl_output *p)
+{
+    HMI_DEBUG("wm", "Remove screen proxy mapping for %p", p);
+    this->screen_proxy_to_id.erase(uintptr_t(p));
 }
 
-}  // namespace compositor
+} // namespace compositor
diff --git a/src/wayland_ivi_wm.hpp b/src/wayland_ivi_wm.hpp
index 872e287..cd69623 100644
--- a/src/wayland_ivi_wm.hpp
+++ b/src/wayland_ivi_wm.hpp
@@ -30,278 +30,296 @@
  * @struct wayland_proxy
  */
 template <typename ProxyT>
-struct wayland_proxy {
-   std::unique_ptr<ProxyT, std::function<void(ProxyT *)>> proxy;
-   wayland_proxy(wayland_proxy const &) = delete;
-   wayland_proxy &operator=(wayland_proxy const &) = delete;
-   wayland_proxy(void *p)
-      : wayland_proxy(p,
-                      reinterpret_cast<void (*)(ProxyT *)>(wl_proxy_destroy)) {}
-   wayland_proxy(void *p, std::function<void(ProxyT *)> &&p_del)
-      : proxy(std::unique_ptr<ProxyT, std::function<void(ProxyT *)>>(
-           static_cast<ProxyT *>(p), p_del)) {}
+struct wayland_proxy
+{
+    std::unique_ptr<ProxyT, std::function<void(ProxyT *)>> proxy;
+    wayland_proxy(wayland_proxy const &) = delete;
+    wayland_proxy &operator=(wayland_proxy const &) = delete;
+    wayland_proxy(void *p)
+        : wayland_proxy(p,
+                        reinterpret_cast<void (*)(ProxyT *)>(wl_proxy_destroy)) {}
+    wayland_proxy(void *p, std::function<void(ProxyT *)> &&p_del)
+        : proxy(std::unique_ptr<ProxyT, std::function<void(ProxyT *)>>(
+              static_cast<ProxyT *>(p), p_del)) {}
 };
 
 /**
  * namespace wl
  */
-namespace wl {
+namespace wl
+{
 
 /**
  * @struct registry
  */
-struct registry : public wayland_proxy<struct wl_registry> {
-   typedef std::function<void(struct wl_registry *, uint32_t, uint32_t)> binder;
-   std::unordered_map<std::string, binder> bindings;
+struct registry : public wayland_proxy<struct wl_registry>
+{
+    typedef std::function<void(struct wl_registry *, uint32_t, uint32_t)> binder;
+    std::unordered_map<std::string, binder> bindings;
 
-   registry(registry const &) = delete;
-   registry &operator=(registry const &) = delete;
-   registry(struct wl_display *d);
+    registry(registry const &) = delete;
+    registry &operator=(registry const &) = delete;
+    registry(struct wl_display *d);
 
-   void add_global_handler(char const *iface, binder bind);
+    void add_global_handler(char const *iface, binder bind);
 
-   // Events
-   void global_created(uint32_t name, char const *iface, uint32_t v);
-   void global_removed(uint32_t name);
+    // Events
+    void global_created(uint32_t name, char const *iface, uint32_t v);
+    void global_removed(uint32_t name);
 };
 
 /**
  * @struct display
  */
-struct display {
-   std::unique_ptr<struct wl_display, void (*)(struct wl_display *)> d;
-   struct registry r;
-
-   display(display const &) = delete;
-   display &operator=(display const &) = delete;
-   display();
-   bool ok() const;
-   void roundtrip();
-   int dispatch();
-   int dispatch_pending();
-   int read_events();
-   void flush();
-   int get_fd() const;
-   int get_error();
-
-   // Lets just proxy this for the registry
-   inline void add_global_handler(char const *iface, registry::binder bind) {
-      this->r.add_global_handler(iface, bind);
-   }
+struct display
+{
+    std::unique_ptr<struct wl_display, void (*)(struct wl_display *)> d;
+    struct registry r;
+
+    display(display const &) = delete;
+    display &operator=(display const &) = delete;
+    display();
+    bool ok() const;
+    void roundtrip();
+    int dispatch();
+    int dispatch_pending();
+    int read_events();
+    void flush();
+    int get_fd() const;
+    int get_error();
+
+    // Lets just proxy this for the registry
+    inline void add_global_handler(char const *iface, registry::binder bind)
+    {
+        this->r.add_global_handler(iface, bind);
+    }
 };
 
 /**
  * @struct output
  */
-struct output : public wayland_proxy<struct wl_output> {
-   int width{};
-   int height{};
-   int physical_width{};
-   int physical_height{};
-   int refresh{};
-   int transform{};
-
-   output(output const &) = delete;
-   output &operator=(output const &) = delete;
-   output(struct wl_registry *r, uint32_t name, uint32_t v);
-
-   // Events
-   void geometry(int32_t x, int32_t y, int32_t pw, int32_t ph, int32_t subpel,
-                 char const *make, char const *model, int32_t tx);
-   void mode(uint32_t flags, int32_t w, int32_t h, int32_t r);
-   void done();
-   void scale(int32_t factor);
+struct output : public wayland_proxy<struct wl_output>
+{
+    int width{};
+    int height{};
+    int physical_width{};
+    int physical_height{};
+    int refresh{};
+    int transform{};
+
+    output(output const &) = delete;
+    output &operator=(output const &) = delete;
+    output(struct wl_registry *r, uint32_t name, uint32_t v);
+
+    // Events
+    void geometry(int32_t x, int32_t y, int32_t pw, int32_t ph, int32_t subpel,
+                  char const *make, char const *model, int32_t tx);
+    void mode(uint32_t flags, int32_t w, int32_t h, int32_t r);
+    void done();
+    void scale(int32_t factor);
 };
-}  // namespace wl
+} // namespace wl
 
 /**
  * namespace compositor
  */
-namespace compositor {
+namespace compositor
+{
 
-struct size {
-   uint32_t w, h;
+struct size
+{
+    uint32_t w, h;
 };
 
-struct rect {
-   int32_t w, h;
-   int32_t x, y;
+struct rect
+{
+    int32_t w, h;
+    int32_t x, y;
 };
 
 static const constexpr rect full_rect = rect{-1, -1, 0, 0};
 
-inline bool operator==(struct rect a, struct rect b) {
-   return a.w == b.w && a.h == b.h && a.x == b.x && a.y == b.y;
+inline bool operator==(struct rect a, struct rect b)
+{
+    return a.w == b.w && a.h == b.h && a.x == b.x && a.y == b.y;
 }
 
 struct controller;
 
-struct controller_child {
-   struct controller *parent;
-   uint32_t id;
+struct controller_child
+{
+    struct controller *parent;
+    uint32_t id;
 
-   controller_child(controller_child const &) = delete;
-   controller_child &operator=(controller_child const &) = delete;
-   controller_child(struct controller *c, uint32_t i) : parent(c), id(i) {}
-   virtual ~controller_child() {}
+    controller_child(controller_child const &) = delete;
+    controller_child &operator=(controller_child const &) = delete;
+    controller_child(struct controller *c, uint32_t i) : parent(c), id(i) {}
+    virtual ~controller_child() {}
 };
 
-struct surface_properties {
-   uint32_t id;  // let's just save an ID here too
-   struct rect dst_rect;
-   struct rect src_rect;
-   struct size size;
-   int32_t orientation;
-   int32_t visibility;
-   float opacity;
+struct surface_properties
+{
+    uint32_t id; // let's just save an ID here too
+    struct rect dst_rect;
+    struct rect src_rect;
+    struct size size;
+    int32_t orientation;
+    int32_t visibility;
+    float opacity;
 };
 
 /**
  * @struct surface
  */
-struct surface : public controller_child {
-   surface(surface const &) = delete;
-   surface &operator=(surface const &) = delete;
-   surface(uint32_t i, struct controller *c);
-
-   // Requests
-   void set_visibility(uint32_t visibility);
-   void set_source_rectangle(int32_t x, int32_t y,
-                             int32_t width, int32_t height);
-   void set_destination_rectangle(int32_t x, int32_t y,
-                                  int32_t width, int32_t height);
+struct surface : public controller_child
+{
+    surface(surface const &) = delete;
+    surface &operator=(surface const &) = delete;
+    surface(uint32_t i, struct controller *c);
+
+    // Requests
+    void set_visibility(uint32_t visibility);
+    void set_source_rectangle(int32_t x, int32_t y,
+                              int32_t width, int32_t height);
+    void set_destination_rectangle(int32_t x, int32_t y,
+                                   int32_t width, int32_t height);
 };
 
 /**
  * @struct layer
  */
-struct layer : public controller_child {
-   layer(layer const &) = delete;
-   layer &operator=(layer const &) = delete;
-   layer(uint32_t i, struct controller *c);
-   layer(uint32_t i, int32_t w, int32_t h, struct controller *c);
-
-   // Requests
-   void set_visibility(uint32_t visibility);
-   void set_destination_rectangle(int32_t x, int32_t y,
-                                  int32_t width, int32_t height);
-   void add_surface(uint32_t surface_id);
-   void remove_surface(uint32_t surface_id);
+struct layer : public controller_child
+{
+    layer(layer const &) = delete;
+    layer &operator=(layer const &) = delete;
+    layer(uint32_t i, struct controller *c);
+    layer(uint32_t i, int32_t w, int32_t h, struct controller *c);
+
+    // Requests
+    void set_visibility(uint32_t visibility);
+    void set_destination_rectangle(int32_t x, int32_t y,
+                                   int32_t width, int32_t height);
+    void add_surface(uint32_t surface_id);
+    void remove_surface(uint32_t surface_id);
 };
 
 /**
  * @struct screen
  */
 struct screen : public wayland_proxy<struct ivi_wm_screen>,
-                public controller_child {
-   screen(screen const &) = delete;
-   screen &operator=(screen const &) = delete;
-   screen(uint32_t i, struct controller *c, struct wl_output *o);
-
-   void clear();
-   void screen_created(struct screen *screen, uint32_t id);
-   void set_render_order(std::vector<uint32_t> const &ro);
+                public controller_child
+{
+    screen(screen const &) = delete;
+    screen &operator=(screen const &) = delete;
+    screen(uint32_t i, struct controller *c, struct wl_output *o);
+
+    void clear();
+    void screen_created(struct screen *screen, uint32_t id);
+    void set_render_order(std::vector<uint32_t> const &ro);
 };
 
 /**
  * @struct controller
  */
-struct controller : public wayland_proxy<struct ivi_wm> {
-   // This controller is still missing ivi-input
-
-   typedef std::unordered_map<uintptr_t, uint32_t> proxy_to_id_map_type;
-   typedef std::unordered_map<uint32_t, std::unique_ptr<struct surface>>
-      surface_map_type;
-   typedef std::unordered_map<uint32_t, std::unique_ptr<struct layer>>
-      layer_map_type;
-   typedef std::unordered_map<uint32_t, struct screen *> screen_map_type;
-   typedef std::unordered_map<uint32_t, struct surface_properties> props_map;
-
-   // HACK:
-   // The order of these member is mandatory, as when objects are destroyed
-   // they will call their parent (that's us right here!) and remove their
-   // proxy-to-id mapping. I.e. the *_proxy_to_id members need to be valid
-   // when the surfaces/layers/screens maps are destroyed. This sucks, but
-   // I cannot see a better solution w/o globals or some other horrible
-   // call-our-parent construct.
-   proxy_to_id_map_type surface_proxy_to_id;
-   proxy_to_id_map_type layer_proxy_to_id;
-   proxy_to_id_map_type screen_proxy_to_id;
-
-   props_map sprops;
-   props_map lprops;
-
-   surface_map_type surfaces;
-   layer_map_type layers;
-   screen_map_type screens;
-
-   std::unique_ptr<struct screen> screen;
-
-   size output_size;   // Display size[pixel]
-   size physical_size; // Display size[mm]
-
-   wm::controller_hooks *chooks;
-
-   struct wl::display *display;
-
-   void add_proxy_to_sid_mapping(struct ivi_wm *p, uint32_t id);
-   void remove_proxy_to_sid_mapping(struct ivi_wm *p);
-
-   void add_proxy_to_lid_mapping(struct ivi_wm *p, uint32_t id);
-   void remove_proxy_to_lid_mapping(struct ivi_wm *p);
-
-   void add_proxy_to_id_mapping(struct wl_output *p, uint32_t id);
-   void remove_proxy_to_id_mapping(struct wl_output *p);
-
-   bool surface_exists(uint32_t id) const {
-      return this->surfaces.find(id) != this->surfaces.end();
-   }
-
-   bool layer_exists(uint32_t id) const {
-      return this->layers.find(id) != this->layers.end();
-   }
-
-   controller(struct wl_registry *r, uint32_t name, uint32_t version);
-
-   // Requests
-   void commit_changes() const {
-      ivi_wm_commit_changes(this->proxy.get());
-   }
-   void layer_create(uint32_t id, int32_t w, int32_t h);
-   void surface_create(uint32_t id);
-   void create_screen(struct wl_output *output);
-
-   // Events
-   void surface_visibility_changed(struct surface *s, int32_t visibility);
-   void surface_opacity_changed(struct surface *s, float opacity);
-   void surface_source_rectangle_changed(struct surface *s, int32_t x, int32_t y,
-                                 int32_t width, int32_t height);
-   void surface_destination_rectangle_changed(struct surface *s, int32_t x, int32_t y,
-                                      int32_t width, int32_t height);
-   void surface_created(uint32_t id);
-   void surface_destroyed(struct surface *s, uint32_t surface_id);
-   void surface_error_detected(uint32_t object_id,
-                      uint32_t error_code, char const *error_text);
-   void surface_size_changed(struct surface *s, int32_t width, int32_t height);
-   void surface_stats_received(struct surface *s, uint32_t surface_id,
-                      uint32_t frame_count, uint32_t pid);
-   void surface_added_to_layer(struct surface *s, uint32_t layer_id, uint32_t surface_id);
-
-   void layer_visibility_changed(struct layer *l, uint32_t layer_id,int32_t visibility);
-   void layer_opacity_changed(struct layer *l, uint32_t layer_id,float opacity);
-   void layer_source_rectangle_changed(struct layer *l, uint32_t layer_id,int32_t x, int32_t y,
-                               int32_t width, int32_t height);
-   void layer_destination_rectangle_changed(struct layer *l, uint32_t layer_id,int32_t x, int32_t y,
-                                    int32_t width, int32_t height);
-   void layer_created(uint32_t id);
-   void layer_destroyed(struct layer *l, uint32_t layer_id);
-   void layer_error_detected(uint32_t object_id,
-                    uint32_t error_code, char const *error_text);
-   void layer_configuration(struct layer *l, int32_t width, int32_t height);
-   void layer_orientation(struct layer *l, int32_t orientation);
-   void layer_screen(struct layer *l, struct wl_output *screen);
-
+struct controller : public wayland_proxy<struct ivi_wm>
+{
+    // This controller is still missing ivi-input
+
+    typedef std::unordered_map<uintptr_t, uint32_t> proxy_to_id_map_type;
+    typedef std::unordered_map<uint32_t, std::unique_ptr<struct surface>>
+        surface_map_type;
+    typedef std::unordered_map<uint32_t, std::unique_ptr<struct layer>>
+        layer_map_type;
+    typedef std::unordered_map<uint32_t, struct screen *> screen_map_type;
+    typedef std::unordered_map<uint32_t, struct surface_properties> props_map;
+
+    // HACK:
+    // The order of these member is mandatory, as when objects are destroyed
+    // they will call their parent (that's us right here!) and remove their
+    // proxy-to-id mapping. I.e. the *_proxy_to_id members need to be valid
+    // when the surfaces/layers/screens maps are destroyed. This sucks, but
+    // I cannot see a better solution w/o globals or some other horrible
+    // call-our-parent construct.
+    proxy_to_id_map_type surface_proxy_to_id;
+    proxy_to_id_map_type layer_proxy_to_id;
+    proxy_to_id_map_type screen_proxy_to_id;
+
+    props_map sprops;
+    props_map lprops;
+
+    surface_map_type surfaces;
+    layer_map_type layers;
+    screen_map_type screens;
+
+    std::unique_ptr<struct screen> screen;
+
+    size output_size;   // Display size[pixel]
+    size physical_size; // Display size[mm]
+
+    wm::controller_hooks *chooks;
+
+    struct wl::display *display;
+
+    void add_proxy_to_sid_mapping(struct ivi_wm *p, uint32_t id);
+    void remove_proxy_to_sid_mapping(struct ivi_wm *p);
+
+    void add_proxy_to_lid_mapping(struct ivi_wm *p, uint32_t id);
+    void remove_proxy_to_lid_mapping(struct ivi_wm *p);
+
+    void add_proxy_to_id_mapping(struct wl_output *p, uint32_t id);
+    void remove_proxy_to_id_mapping(struct wl_output *p);
+
+    bool surface_exists(uint32_t id) const
+    {
+        return this->surfaces.find(id) != this->surfaces.end();
+    }
+
+    bool layer_exists(uint32_t id) const
+    {
+        return this->layers.find(id) != this->layers.end();
+    }
+
+    controller(struct wl_registry *r, uint32_t name, uint32_t version);
+
+    // Requests
+    void commit_changes() const
+    {
+        ivi_wm_commit_changes(this->proxy.get());
+    }
+    void layer_create(uint32_t id, int32_t w, int32_t h);
+    void surface_create(uint32_t id);
+    void create_screen(struct wl_output *output);
+
+    // Events
+    void surface_visibility_changed(struct surface *s, int32_t visibility);
+    void surface_opacity_changed(struct surface *s, float opacity);
+    void surface_source_rectangle_changed(struct surface *s, int32_t x, int32_t y,
+                                          int32_t width, int32_t height);
+    void surface_destination_rectangle_changed(struct surface *s, int32_t x, int32_t y,
+                                               int32_t width, int32_t height);
+    void surface_created(uint32_t id);
+    void surface_destroyed(struct surface *s, uint32_t surface_id);
+    void surface_error_detected(uint32_t object_id,
+                                uint32_t error_code, char const *error_text);
+    void surface_size_changed(struct surface *s, int32_t width, int32_t height);
+    void surface_stats_received(struct surface *s, uint32_t surface_id,
+                                uint32_t frame_count, uint32_t pid);
+    void surface_added_to_layer(struct surface *s, uint32_t layer_id, uint32_t surface_id);
+
+    void layer_visibility_changed(struct layer *l, uint32_t layer_id, int32_t visibility);
+    void layer_opacity_changed(struct layer *l, uint32_t layer_id, float opacity);
+    void layer_source_rectangle_changed(struct layer *l, uint32_t layer_id, int32_t x, int32_t y,
+                                        int32_t width, int32_t height);
+    void layer_destination_rectangle_changed(struct layer *l, uint32_t layer_id, int32_t x, int32_t y,
+                                             int32_t width, int32_t height);
+    void layer_created(uint32_t id);
+    void layer_destroyed(struct layer *l, uint32_t layer_id);
+    void layer_error_detected(uint32_t object_id,
+                              uint32_t error_code, char const *error_text);
+    void layer_configuration(struct layer *l, int32_t width, int32_t height);
+    void layer_orientation(struct layer *l, int32_t orientation);
+    void layer_screen(struct layer *l, struct wl_output *screen);
 };
-}  // namespace compositor
+} // namespace compositor
 
-#endif  // !WM_WAYLAND_HPP
+#endif // !WM_WAYLAND_HPP
diff --git a/src/windowmanager-client.cpp b/src/windowmanager-client.cpp
index bc24978..55d9864 100644
--- a/src/windowmanager-client.cpp
+++ b/src/windowmanager-client.cpp
@@ -14,29 +14,30 @@
  * limitations under the License.
  */
 #include <iostream> // for debug
-using std::cerr;//debug
-using std::cout;//debug
-using std::endl;//debug
+using std::cerr;    //debug
+using std::cout;    //debug
+using std::endl;    //debug
 #include "windowmanager-client.hpp"
 
-namespace wm {
+namespace wm
+{
 
 using std::string;
 
 const std::vector<std::string> wm_events = {
     // Private event for applications
-    "syncDraw", "flushDraw", "visible", "invisible", "active", "inactive"
-};
+    "syncDraw", "flushDraw", "visible", "invisible", "active", "inactive"};
 
 WMClient::WMClient(const string &appid, unsigned layerID, unsigned surfaceID, const string &role)
-    :id(appid),
-     layer(layerID),
-     roles(0),
-     surfaces(0)
+    : id(appid),
+      layer(layerID),
+      roles(0),
+      surfaces(0)
 {
     roles.push_back(role);
     surfaces.push_back(surfaceID);
-    for(auto x: wm_events){
+    for (auto x : wm_events)
+    {
 #if GTEST_ENABLED
         string ev = x;
 #else
@@ -54,7 +55,8 @@ WMClient::WMClient(const string &appid, const string &role)
       event_list(0)
 {
     roles.push_back(role);
-    for(auto x: wm_events){
+    for (auto x : wm_events)
+    {
 #if GTEST_ENABLED
         string ev = x;
 #else
@@ -64,11 +66,13 @@ WMClient::WMClient(const string &appid, const string &role)
     }
 }
 
-WMClient::~WMClient(){
+WMClient::~WMClient()
+{
 }
 
-string WMClient::appID(){
+string WMClient::appID()
+{
     return this->id;
 }
 
-}
\ No newline at end of file
+} // namespace wm
\ No newline at end of file
diff --git a/src/windowmanager-client.hpp b/src/windowmanager-client.hpp
index fccaba7..833187a 100644
--- a/src/windowmanager-client.hpp
+++ b/src/windowmanager-client.hpp
@@ -21,15 +21,18 @@
 #include <string>
 #include <unordered_map>
 
-extern "C" {
+extern "C"
+{
 #define AFB_BINDING_VERSION 2
 #include <afb/afb-binding.h>
 }
 
-namespace wm {
+namespace wm
+{
 
-class WMClient {
-public:
+class WMClient
+{
+  public:
     WMClient();
     WMClient(const std::string &appid, unsigned layerID, unsigned surfaceID, const std::string &role);
     WMClient(const std::string &appid, const std::string &role);
@@ -46,13 +49,13 @@ public:
     std::string id;
     std::vector<std::string> roles;
 #if GTEST_ENABLED
-// This is for unit test. afb_make_event occurs sig11 if call not in afb-binding
+    // This is for unit test. afb_make_event occurs sig11 if call not in afb-binding
     std::unordered_map<std::string, std::string> event_list;
 #else
     std::unordered_map<std::string, struct afb_event> event_list;
 #endif
     //std::vector<Task *> requestingTask;
 };
-}
+} // namespace wm
 
 #endif
\ No newline at end of file