Format source codes

* Format source codes
* Change indent spaces to 4 from 3
* Remove trailing spaces in config.xml

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

17 files changed, 2901 insertions, 2459 deletions

diff --git a/src/app.cpp b/src/app.cpp
index 937da6a..4076f85 100644
--- a/src/app.cpp
+++ b/src/app.cpp
@@ -35,7 +35,6 @@
 #include <regex>
 #include <thread>
 
-
 namespace wm {
 
 /* DrawingArea name used by "{layout}.{area}" */
@@ -58,602 +57,687 @@ const char kKeyHeightPixel[] = "height_pixel";
 const char kKeyWidthMm[]     = "width_mm";
 const char kKeyHeightMm[]    = "height_mm";
 
-
-namespace {
+namespace
+{
 
 using nlohmann::json;
 
-result<json> file_to_json(char const *filename) {
-   json j;
-   std::ifstream i(filename);
-   if (i.fail()) {
-      HMI_DEBUG("wm", "Could not open config file, so use default layer information");
-      j = default_layers_json;
-   }
-   else {
-      i >> j;
-   }
-
-   return Ok(j);
+result<json> file_to_json(char const *filename)
+{
+    json j;
+    std::ifstream i(filename);
+    if (i.fail())
+    {
+        HMI_DEBUG("wm", "Could not open config file, so use default layer information");
+        j = default_layers_json;
+    }
+    else
+    {
+        i >> j;
+    }
+
+    return Ok(j);
 }
 
-struct result<layer_map> load_layer_map(char const *filename) {
-   HMI_DEBUG("wm", "loading IDs from %s", filename);
+struct result<layer_map> load_layer_map(char const *filename)
+{
+    HMI_DEBUG("wm", "loading IDs from %s", filename);
 
-   auto j = file_to_json(filename);
-   if (j.is_err()) {
-      return Err<layer_map>(j.unwrap_err());
-   }
-   json jids = j.unwrap();
+    auto j = file_to_json(filename);
+    if (j.is_err())
+    {
+        return Err<layer_map>(j.unwrap_err());
+    }
+    json jids = j.unwrap();
 
-   return to_layer_map(jids);
+    return to_layer_map(jids);
 }
 
-}  // namespace
-
+} // namespace
 
 /**
  * App Impl
  */
 App::App(wl::display *d)
-   : chooks{this},
-     display{d},
-     controller{},
-     outputs(),
-     config(),
-     layers(),
-     id_alloc{},
-     pending_events(false),
-     policy{} {
-   try {
-      {
-         auto l = load_layer_map(
-            this->config.get_string("layers.json").value().c_str());
-         if (l.is_ok()) {
-            this->layers = l.unwrap();
-         } else {
-            HMI_ERROR("wm", "%s", l.err().value());
-         }
-      }
-   } catch (std::exception &e) {
-      HMI_ERROR("wm", "Loading of configuration failed: %s", e.what());
-   }
-}
-
-int App::init() {
-   if (!this->display->ok()) {
-      return -1;
-   }
-
-   if (this->layers.mapping.empty()) {
-      HMI_ERROR("wm", "No surface -> layer mapping loaded");
-      return -1;
-   }
-
-   // Make afb event
-   for (int i=Event_Val_Min; i<=Event_Val_Max; i++) {
-      map_afb_event[kListEventName[i]] = afb_daemon_make_event(kListEventName[i]);
-   }
-
-   this->display->add_global_handler(
-      "wl_output", [this](wl_registry *r, uint32_t name, uint32_t v) {
-         this->outputs.emplace_back(std::make_unique<wl::output>(r, name, v));
-      });
-
-   this->display->add_global_handler(
-      "ivi_wm", [this](wl_registry *r, uint32_t name, uint32_t v) {
-         this->controller =
-            std::make_unique<struct compositor::controller>(r, name, v);
-
-         // Init controller hooks
-         this->controller->chooks = &this->chooks;
-
-         // This protocol needs the output, so lets just add our mapping here...
-         this->controller->add_proxy_to_id_mapping(
-            this->outputs.back()->proxy.get(),
-            wl_proxy_get_id(reinterpret_cast<struct wl_proxy *>(
-               this->outputs.back()->proxy.get())));
-
-         // Create screen
-         this->controller->create_screen(this->outputs.back()->proxy.get());
-
-         // Set display to controller
-         this->controller->display = this->display;
-      });
-
-   // First level objects
-   this->display->roundtrip();
-   // Second level objects
-   this->display->roundtrip();
-   // Third level objects
-   this->display->roundtrip();
-
-   return init_layers();
-}
-
-int App::dispatch_pending_events() {
-   if (this->pop_pending_events()) {
-      this->display->dispatch_pending();
-      return 0;
-   }
-   return -1;
-}
-
-bool App::pop_pending_events() {
-   bool x{true};
-   return this->pending_events.compare_exchange_strong(
-      x, false, std::memory_order_consume);
-}
-
-void App::set_pending_events() {
-   this->pending_events.store(true, std::memory_order_release);
-}
-
-optional<int> App::lookup_id(char const *name) {
-   return this->id_alloc.lookup(std::string(name));
-}
-optional<std::string> App::lookup_name(int id) {
-   return this->id_alloc.lookup(id);
+    : chooks{this},
+      display{d},
+      controller{},
+      outputs(),
+      config(),
+      layers(),
+      id_alloc{},
+      pending_events(false),
+      policy{}
+{
+    try
+    {
+        {
+            auto l = load_layer_map(
+                this->config.get_string("layers.json").value().c_str());
+            if (l.is_ok())
+            {
+                this->layers = l.unwrap();
+            }
+            else
+            {
+                HMI_ERROR("wm", "%s", l.err().value());
+            }
+        }
+    }
+    catch (std::exception &e)
+    {
+        HMI_ERROR("wm", "Loading of configuration failed: %s", e.what());
+    }
 }
 
-/**
- * init_layers()
- */
-int App::init_layers() {
-   if (!this->controller) {
-      HMI_ERROR("wm", "ivi_controller global not available");
-      return -1;
-   }
-
-   if (this->outputs.empty()) {
-      HMI_ERROR("wm", "no output was set up!");
-      return -1;
-   }
-
-   auto &c = this->controller;
-
-   auto &o = this->outputs.front();
-   auto &s = c->screens.begin()->second;
-   auto &layers = c->layers;
-
-   // Write output dimensions to ivi controller...
-   c->output_size = compositor::size{uint32_t(o->width), uint32_t(o->height)};
-   c->physical_size = compositor::size{uint32_t(o->physical_width),
-                                       uint32_t(o->physical_height)};
-
-   // Clear scene
-   layers.clear();
-
-   // Clear screen
-   s->clear();
-
-   // Quick and dirty setup of layers
-   for (auto const &i : this->layers.mapping) {
-      c->layer_create(i.second.layer_id, o->width, o->height);
-      auto &l = layers[i.second.layer_id];
-      l->set_destination_rectangle(0, 0, o->width, o->height);
-      l->set_visibility(1);
-      HMI_DEBUG("wm", "Setting up layer %s (%d) for surface role match \"%s\"",
-               i.second.name.c_str(), i.second.layer_id, i.second.role.c_str());
-   }
-
-   // Add layers to screen
-   s->set_render_order(this->layers.layers);
-
-   this->layout_commit();
-
-   return 0;
+int App::init()
+{
+    if (!this->display->ok())
+    {
+        return -1;
+    }
+
+    if (this->layers.mapping.empty())
+    {
+        HMI_ERROR("wm", "No surface -> layer mapping loaded");
+        return -1;
+    }
+
+    // Make afb event
+    for (int i = Event_Val_Min; i <= Event_Val_Max; i++)
+    {
+        map_afb_event[kListEventName[i]] = afb_daemon_make_event(kListEventName[i]);
+    }
+
+    this->display->add_global_handler(
+        "wl_output", [this](wl_registry *r, uint32_t name, uint32_t v) {
+            this->outputs.emplace_back(std::make_unique<wl::output>(r, name, v));
+        });
+
+    this->display->add_global_handler(
+        "ivi_wm", [this](wl_registry *r, uint32_t name, uint32_t v) {
+            this->controller =
+                std::make_unique<struct compositor::controller>(r, name, v);
+
+            // Init controller hooks
+            this->controller->chooks = &this->chooks;
+
+            // This protocol needs the output, so lets just add our mapping here...
+            this->controller->add_proxy_to_id_mapping(
+                this->outputs.back()->proxy.get(),
+                wl_proxy_get_id(reinterpret_cast<struct wl_proxy *>(
+                    this->outputs.back()->proxy.get())));
+
+            // Create screen
+            this->controller->create_screen(this->outputs.back()->proxy.get());
+
+            // Set display to controller
+            this->controller->display = this->display;
+        });
+
+    // First level objects
+    this->display->roundtrip();
+    // Second level objects
+    this->display->roundtrip();
+    // Third level objects
+    this->display->roundtrip();
+
+    return init_layers();
 }
 
-void App::surface_set_layout(int surface_id, optional<int> sub_surface_id) {
-   if (!this->controller->surface_exists(surface_id)) {
-      HMI_ERROR("wm", "Surface %d does not exist", surface_id);
-      return;
-   }
-
-   auto o_layer_id = this->layers.get_layer_id(surface_id);
-
-   if (!o_layer_id) {
-      HMI_ERROR("wm", "Surface %d is not associated with any layer!", surface_id);
-      return;
-   }
-
-   uint32_t layer_id = *o_layer_id;
-
-   auto const &layer = this->layers.get_layer(layer_id);
-   auto rect = layer.value().rect;
-   auto &s = this->controller->surfaces[surface_id];
-
-   int x = rect.x;
-   int y = rect.y;
-   int w = rect.w;
-   int h = rect.h;
-
-   // less-than-0 values refer to MAX + 1 - $VALUE
-   // e.g. MAX is either screen width or height
-   if (w < 0) {
-      w = this->controller->output_size.w + 1 + w;
-   }
-   if (h < 0) {
-      h = this->controller->output_size.h + 1 + h;
-   }
-
-   if (sub_surface_id) {
-      if (o_layer_id != this->layers.get_layer_id(*sub_surface_id)) {
-         HMI_ERROR("wm",
-            "surface_set_layout: layers of surfaces (%d and %d) don't match!",
-            surface_id, *sub_surface_id);
-         return;
-      }
-
-      int x_off = 0;
-      int y_off = 0;
-
-      // split along major axis
-      if (w > h) {
-         w /= 2;
-         x_off = w;
-      } else {
-         h /= 2;
-         y_off = h;
-      }
-
-      auto &ss = this->controller->surfaces[*sub_surface_id];
-
-      HMI_DEBUG("wm", "surface_set_layout for sub surface %u on layer %u",
-               *sub_surface_id, layer_id);
-
-      // set destination to the display rectangle
-      ss->set_destination_rectangle(x + x_off, y + y_off, w, h);
-
-      this->area_info[*sub_surface_id].x = x;
-      this->area_info[*sub_surface_id].y = y;
-      this->area_info[*sub_surface_id].w = w;
-      this->area_info[*sub_surface_id].h = h;
-   }
+int App::dispatch_pending_events()
+{
+    if (this->pop_pending_events())
+    {
+        this->display->dispatch_pending();
+        return 0;
+    }
+    return -1;
+}
 
-   HMI_DEBUG("wm", "surface_set_layout for surface %u on layer %u", surface_id,
-            layer_id);
+bool App::pop_pending_events()
+{
+    bool x{true};
+    return this->pending_events.compare_exchange_strong(
+        x, false, std::memory_order_consume);
+}
 
-   // set destination to the display rectangle
-   s->set_destination_rectangle(x, y, w, h);
-
-   // update area information
-   this->area_info[surface_id].x = x;
-   this->area_info[surface_id].y = y;
-   this->area_info[surface_id].w = w;
-   this->area_info[surface_id].h = h;
+void App::set_pending_events()
+{
+    this->pending_events.store(true, std::memory_order_release);
+}
 
-   HMI_DEBUG("wm", "Surface %u now on layer %u with rect { %d, %d, %d, %d }",
-            surface_id, layer_id, x, y, w, h);
+optional<int> App::lookup_id(char const *name)
+{
+    return this->id_alloc.lookup(std::string(name));
 }
-
-void App::layout_commit() {
-   this->controller->commit_changes();
-   this->display->flush();
+optional<std::string> App::lookup_name(int id)
+{
+    return this->id_alloc.lookup(id);
 }
 
-void App::api_activate_surface(char const *drawing_name, char const *drawing_area, const reply_func &reply) {
-   ST();
-
-   auto const &surface_id = this->lookup_id(drawing_name);
-
-   if (!surface_id) {
-       reply("Surface does not exist");
-       return;
-   }
-
-   if (!this->controller->surface_exists(*surface_id)) {
-      reply("Surface does not exist in controller!");
-      return;
-   }
-
-   auto layer_id = this->layers.get_layer_id(*surface_id);
-
-   if (!layer_id) {
-      reply("Surface is not on any layer!");
-      return;
-   }
-
-   auto o_state = *this->layers.get_layout_state(*surface_id);
-
-   if (o_state == nullptr) {
-      reply("Could not find layer for surface");
-      return;
-   }
-
-   HMI_DEBUG("wm", "surface %d is detected", *surface_id);
-   reply(nullptr);
-
-   struct LayoutState &state = *o_state;
-
-   // disable layers that are above our current layer
-   for (auto const &l : this->layers.mapping) {
-      if (l.second.layer_id <= *layer_id) {
-         continue;
-      }
-
-      bool flush = false;
-      if (l.second.state.main != -1) {
-         this->deactivate(l.second.state.main);
-         l.second.state.main = -1;
-         flush = true;
-      }
-
-      if (l.second.state.sub != -1) {
-         this->deactivate(l.second.state.sub);
-         l.second.state.sub = -1;
-         flush = true;
-      }
-
-      if (flush) {
-         this->layout_commit();
-      }
-   }
+/**
+ * init_layers()
+ */
+int App::init_layers()
+{
+    if (!this->controller)
+    {
+        HMI_ERROR("wm", "ivi_controller global not available");
+        return -1;
+    }
+
+    if (this->outputs.empty())
+    {
+        HMI_ERROR("wm", "no output was set up!");
+        return -1;
+    }
+
+    auto &c = this->controller;
+
+    auto &o = this->outputs.front();
+    auto &s = c->screens.begin()->second;
+    auto &layers = c->layers;
+
+    // Write output dimensions to ivi controller...
+    c->output_size = compositor::size{uint32_t(o->width), uint32_t(o->height)};
+    c->physical_size = compositor::size{uint32_t(o->physical_width),
+                                        uint32_t(o->physical_height)};
+
+    // Clear scene
+    layers.clear();
+
+    // Clear screen
+    s->clear();
+
+    // Quick and dirty setup of layers
+    for (auto const &i : this->layers.mapping)
+    {
+        c->layer_create(i.second.layer_id, o->width, o->height);
+        auto &l = layers[i.second.layer_id];
+        l->set_destination_rectangle(0, 0, o->width, o->height);
+        l->set_visibility(1);
+        HMI_DEBUG("wm", "Setting up layer %s (%d) for surface role match \"%s\"",
+                  i.second.name.c_str(), i.second.layer_id, i.second.role.c_str());
+    }
+
+    // Add layers to screen
+    s->set_render_order(this->layers.layers);
+
+    this->layout_commit();
+
+    return 0;
+}
 
-   auto layer = this->layers.get_layer(*layer_id);
+void App::surface_set_layout(int surface_id, optional<int> sub_surface_id)
+{
+    if (!this->controller->surface_exists(surface_id))
+    {
+        HMI_ERROR("wm", "Surface %d does not exist", surface_id);
+        return;
+    }
+
+    auto o_layer_id = this->layers.get_layer_id(surface_id);
+
+    if (!o_layer_id)
+    {
+        HMI_ERROR("wm", "Surface %d is not associated with any layer!", surface_id);
+        return;
+    }
+
+    uint32_t layer_id = *o_layer_id;
+
+    auto const &layer = this->layers.get_layer(layer_id);
+    auto rect = layer.value().rect;
+    auto &s = this->controller->surfaces[surface_id];
+
+    int x = rect.x;
+    int y = rect.y;
+    int w = rect.w;
+    int h = rect.h;
+
+    // less-than-0 values refer to MAX + 1 - $VALUE
+    // e.g. MAX is either screen width or height
+    if (w < 0)
+    {
+        w = this->controller->output_size.w + 1 + w;
+    }
+    if (h < 0)
+    {
+        h = this->controller->output_size.h + 1 + h;
+    }
+
+    if (sub_surface_id)
+    {
+        if (o_layer_id != this->layers.get_layer_id(*sub_surface_id))
+        {
+            HMI_ERROR("wm",
+                      "surface_set_layout: layers of surfaces (%d and %d) don't match!",
+                      surface_id, *sub_surface_id);
+            return;
+        }
+
+        int x_off = 0;
+        int y_off = 0;
+
+        // split along major axis
+        if (w > h)
+        {
+            w /= 2;
+            x_off = w;
+        }
+        else
+        {
+            h /= 2;
+            y_off = h;
+        }
+
+        auto &ss = this->controller->surfaces[*sub_surface_id];
+
+        HMI_DEBUG("wm", "surface_set_layout for sub surface %u on layer %u",
+                  *sub_surface_id, layer_id);
+
+        // set destination to the display rectangle
+        ss->set_destination_rectangle(x + x_off, y + y_off, w, h);
+
+        this->area_info[*sub_surface_id].x = x;
+        this->area_info[*sub_surface_id].y = y;
+        this->area_info[*sub_surface_id].w = w;
+        this->area_info[*sub_surface_id].h = h;
+    }
+
+    HMI_DEBUG("wm", "surface_set_layout for surface %u on layer %u", surface_id,
+              layer_id);
+
+    // set destination to the display rectangle
+    s->set_destination_rectangle(x, y, w, h);
+
+    // update area information
+    this->area_info[surface_id].x = x;
+    this->area_info[surface_id].y = y;
+    this->area_info[surface_id].w = w;
+    this->area_info[surface_id].h = h;
+
+    HMI_DEBUG("wm", "Surface %u now on layer %u with rect { %d, %d, %d, %d }",
+              surface_id, layer_id, x, y, w, h);
+}
 
-   if (state.main == -1) {
-      this->try_layout(
-         state, LayoutState{*surface_id}, [&] (LayoutState const &nl) {
-            HMI_DEBUG("wm", "Layout: %s", kNameLayoutNormal);
-            this->surface_set_layout(*surface_id);
-            state = nl;
+void App::layout_commit()
+{
+    this->controller->commit_changes();
+    this->display->flush();
+}
 
-            // Commit for configuraton
+void App::api_activate_surface(char const *drawing_name, char const *drawing_area, const reply_func &reply)
+{
+    ST();
+
+    auto const &surface_id = this->lookup_id(drawing_name);
+
+    if (!surface_id)
+    {
+        reply("Surface does not exist");
+        return;
+    }
+
+    if (!this->controller->surface_exists(*surface_id))
+    {
+        reply("Surface does not exist in controller!");
+        return;
+    }
+
+    auto layer_id = this->layers.get_layer_id(*surface_id);
+
+    if (!layer_id)
+    {
+        reply("Surface is not on any layer!");
+        return;
+    }
+
+    auto o_state = *this->layers.get_layout_state(*surface_id);
+
+    if (o_state == nullptr)
+    {
+        reply("Could not find layer for surface");
+        return;
+    }
+
+    HMI_DEBUG("wm", "surface %d is detected", *surface_id);
+    reply(nullptr);
+
+    struct LayoutState &state = *o_state;
+
+    // disable layers that are above our current layer
+    for (auto const &l : this->layers.mapping)
+    {
+        if (l.second.layer_id <= *layer_id)
+        {
+            continue;
+        }
+
+        bool flush = false;
+        if (l.second.state.main != -1)
+        {
+            this->deactivate(l.second.state.main);
+            l.second.state.main = -1;
+            flush = true;
+        }
+
+        if (l.second.state.sub != -1)
+        {
+            this->deactivate(l.second.state.sub);
+            l.second.state.sub = -1;
+            flush = true;
+        }
+
+        if (flush)
+        {
             this->layout_commit();
-
-            std::string str_area = std::string(kNameLayoutNormal) + "." + std::string(kNameAreaFull);
-            compositor::rect area_rect = this->area_info[*surface_id];
-            this->emit_syncdraw(drawing_name, str_area.c_str(),
-                                area_rect.x, area_rect.y, area_rect.w, area_rect.h);
-            this->enqueue_flushdraw(state.main);
-         });
-   } else {
-      if (0 == strcmp(drawing_name, "HomeScreen")) {
-         this->try_layout(
-            state, LayoutState{*surface_id}, [&] (LayoutState const &nl) {
-               HMI_DEBUG("wm", "Layout: %s", kNameLayoutNormal);
-               std::string str_area = std::string(kNameLayoutNormal) + "." + std::string(kNameAreaFull);
-               compositor::rect area_rect = this->area_info[*surface_id];
-               this->emit_syncdraw(drawing_name, str_area.c_str(),
-                                   area_rect.x, area_rect.y, area_rect.w, area_rect.h);
-               this->enqueue_flushdraw(state.main);
+        }
+    }
+
+    auto layer = this->layers.get_layer(*layer_id);
+
+    if (state.main == -1)
+    {
+        this->try_layout(
+            state, LayoutState{*surface_id}, [&](LayoutState const &nl) {
+                HMI_DEBUG("wm", "Layout: %s", kNameLayoutNormal);
+                this->surface_set_layout(*surface_id);
+                state = nl;
+
+                // Commit for configuraton
+                this->layout_commit();
+
+                std::string str_area = std::string(kNameLayoutNormal) + "." + std::string(kNameAreaFull);
+                compositor::rect area_rect = this->area_info[*surface_id];
+                this->emit_syncdraw(drawing_name, str_area.c_str(),
+                                    area_rect.x, area_rect.y, area_rect.w, area_rect.h);
+                this->enqueue_flushdraw(state.main);
             });
-      } else {
-         bool can_split = this->can_split(state, *surface_id);
-
-         if (can_split) {
+    }
+    else
+    {
+        if (0 == strcmp(drawing_name, "HomeScreen"))
+        {
             this->try_layout(
-               state,
-               LayoutState{state.main, *surface_id},
-               [&] (LayoutState const &nl) {
-                  HMI_DEBUG("wm", "Layout: %s", kNameLayoutSplit);
-                  std::string main =
-                     std::move(*this->lookup_name(state.main));
-
-                  this->surface_set_layout(state.main, surface_id);
-                  if (state.sub != *surface_id) {
-                      if (state.sub != -1) {
-                         this->deactivate(state.sub);
-                      }
-                  }
-                  state = nl;
-
-                  // Commit for configuration and visibility(0)
-                  this->layout_commit();
-
-                  std::string str_area_main = std::string(kNameLayoutSplit) + "." + std::string(kNameAreaMain);
-                  std::string str_area_sub = std::string(kNameLayoutSplit) + "." + std::string(kNameAreaSub);
-                  compositor::rect area_rect_main = this->area_info[state.main];
-                  compositor::rect area_rect_sub = this->area_info[*surface_id];
-                  this->emit_syncdraw(main.c_str(), str_area_main.c_str(),
-                                      area_rect_main.x, area_rect_main.y,
-                                      area_rect_main.w, area_rect_main.h);
-                  this->emit_syncdraw(drawing_name, str_area_sub.c_str(),
-                                      area_rect_sub.x, area_rect_sub.y,
-                                      area_rect_sub.w, area_rect_sub.h);
-                  this->enqueue_flushdraw(state.main);
-                  this->enqueue_flushdraw(state.sub);
-               });
-         } else {
+                state, LayoutState{*surface_id}, [&](LayoutState const &nl) {
+                    HMI_DEBUG("wm", "Layout: %s", kNameLayoutNormal);
+                    std::string str_area = std::string(kNameLayoutNormal) + "." + std::string(kNameAreaFull);
+                    compositor::rect area_rect = this->area_info[*surface_id];
+                    this->emit_syncdraw(drawing_name, str_area.c_str(),
+                                        area_rect.x, area_rect.y, area_rect.w, area_rect.h);
+                    this->enqueue_flushdraw(state.main);
+                });
+        }
+        else
+        {
+            bool can_split = this->can_split(state, *surface_id);
+
+            if (can_split)
+            {
+                this->try_layout(
+                    state,
+                    LayoutState{state.main, *surface_id},
+                    [&](LayoutState const &nl) {
+                        HMI_DEBUG("wm", "Layout: %s", kNameLayoutSplit);
+                        std::string main =
+                            std::move(*this->lookup_name(state.main));
+
+                        this->surface_set_layout(state.main, surface_id);
+                        if (state.sub != *surface_id)
+                        {
+                            if (state.sub != -1)
+                            {
+                                this->deactivate(state.sub);
+                            }
+                        }
+                        state = nl;
+
+                        // Commit for configuration and visibility(0)
+                        this->layout_commit();
+
+                        std::string str_area_main = std::string(kNameLayoutSplit) + "." + std::string(kNameAreaMain);
+                        std::string str_area_sub = std::string(kNameLayoutSplit) + "." + std::string(kNameAreaSub);
+                        compositor::rect area_rect_main = this->area_info[state.main];
+                        compositor::rect area_rect_sub = this->area_info[*surface_id];
+                        this->emit_syncdraw(main.c_str(), str_area_main.c_str(),
+                                            area_rect_main.x, area_rect_main.y,
+                                            area_rect_main.w, area_rect_main.h);
+                        this->emit_syncdraw(drawing_name, str_area_sub.c_str(),
+                                            area_rect_sub.x, area_rect_sub.y,
+                                            area_rect_sub.w, area_rect_sub.h);
+                        this->enqueue_flushdraw(state.main);
+                        this->enqueue_flushdraw(state.sub);
+                    });
+            }
+            else
+            {
+                this->try_layout(
+                    state, LayoutState{*surface_id}, [&](LayoutState const &nl) {
+                        HMI_DEBUG("wm", "Layout: %s", kNameLayoutNormal);
+
+                        this->surface_set_layout(*surface_id);
+                        if (state.main != *surface_id)
+                        {
+                            this->deactivate(state.main);
+                        }
+                        if (state.sub != -1)
+                        {
+                            if (state.sub != *surface_id)
+                            {
+                                this->deactivate(state.sub);
+                            }
+                        }
+                        state = nl;
+
+                        // Commit for configuraton and visibility(0)
+                        this->layout_commit();
+
+                        std::string str_area = std::string(kNameLayoutNormal) + "." + std::string(kNameAreaFull);
+                        compositor::rect area_rect = this->area_info[*surface_id];
+                        this->emit_syncdraw(drawing_name, str_area.c_str(),
+                                            area_rect.x, area_rect.y, area_rect.w, area_rect.h);
+                        this->enqueue_flushdraw(state.main);
+                    });
+            }
+        }
+    }
+}
+
+void App::api_deactivate_surface(char const *drawing_name, const reply_func &reply)
+{
+    ST();
+    auto const &surface_id = this->lookup_id(drawing_name);
+
+    if (!surface_id)
+    {
+        reply("Surface does not exist");
+        return;
+    }
+
+    if (*surface_id == this->layers.main_surface)
+    {
+        reply("Cannot deactivate main_surface");
+        return;
+    }
+
+    auto o_state = *this->layers.get_layout_state(*surface_id);
+
+    if (o_state == nullptr)
+    {
+        reply("Could not find layer for surface");
+        return;
+    }
+
+    struct LayoutState &state = *o_state;
+
+    if (state.main == -1)
+    {
+        reply("No surface active");
+        return;
+    }
+
+    // Check against main_surface, main_surface_name is the configuration item.
+    if (*surface_id == this->layers.main_surface)
+    {
+        HMI_DEBUG("wm", "Refusing to deactivate main_surface %d", *surface_id);
+        reply(nullptr);
+        return;
+    }
+    if ((state.main == *surface_id) && (state.sub == *surface_id))
+    {
+        reply("Surface is not active");
+        return;
+    }
+    reply(nullptr);
+
+    if (state.main == *surface_id)
+    {
+        if (state.sub != -1)
+        {
             this->try_layout(
-               state, LayoutState{*surface_id}, [&] (LayoutState const &nl) {
-                  HMI_DEBUG("wm", "Layout: %s", kNameLayoutNormal);
-
-                  this->surface_set_layout(*surface_id);
-                  if (state.main != *surface_id) {
-                      this->deactivate(state.main);
-                  }
-                  if (state.sub != -1) {
-                      if (state.sub != *surface_id) {
-                         this->deactivate(state.sub);
-                      }
-                  }
-                  state = nl;
-
-                  // Commit for configuraton and visibility(0)
-                  this->layout_commit();
-
-                  std::string str_area = std::string(kNameLayoutNormal) + "." + std::string(kNameAreaFull);
-                  compositor::rect area_rect = this->area_info[*surface_id];
-                  this->emit_syncdraw(drawing_name, str_area.c_str(),
-                                      area_rect.x, area_rect.y, area_rect.w, area_rect.h);
-                  this->enqueue_flushdraw(state.main);
-               });
-         }
-      }
-   }
-}
-
-void App::api_deactivate_surface(char const *drawing_name, const reply_func &reply) {
-   ST();
-   auto const &surface_id = this->lookup_id(drawing_name);
-
-   if (!surface_id) {
-      reply ("Surface does not exist");
-      return;
-   }
-
-   if (*surface_id == this->layers.main_surface) {
-      reply("Cannot deactivate main_surface");
-      return;
-   }
-
-   auto o_state = *this->layers.get_layout_state(*surface_id);
-
-   if (o_state == nullptr) {
-      reply("Could not find layer for surface");
-      return;
-   }
-
-   struct LayoutState &state = *o_state;
-
-   if (state.main == -1) {
-      reply("No surface active");
-      return;
-   }
-
-   // Check against main_surface, main_surface_name is the configuration item.
-   if (*surface_id == this->layers.main_surface) {
-      HMI_DEBUG("wm", "Refusing to deactivate main_surface %d", *surface_id);
-      reply(nullptr);
-      return;
-   }
-   if((state.main == *surface_id) && (state.sub == *surface_id)){
-       reply("Surface is not active");
-       return;
-   }
-   reply(nullptr);
-
-   if (state.main == *surface_id) {
-      if (state.sub != -1) {
-         this->try_layout(
-            state, LayoutState{state.sub, -1}, [&] (LayoutState const &nl) {
-               std::string sub = std::move(*this->lookup_name(state.sub));
-
-               this->deactivate(*surface_id);
-               this->surface_set_layout(state.sub);
-               state = nl;
-
-               this->layout_commit();
-               std::string str_area = std::string(kNameLayoutNormal) + "." + std::string(kNameAreaFull);
-               compositor::rect area_rect = this->area_info[state.sub];
-               this->emit_syncdraw(sub.c_str(), str_area.c_str(),
-                                   area_rect.x, area_rect.y, area_rect.w, area_rect.h);
-               this->enqueue_flushdraw(state.sub);
+                state, LayoutState{state.sub, -1}, [&](LayoutState const &nl) {
+                    std::string sub = std::move(*this->lookup_name(state.sub));
+
+                    this->deactivate(*surface_id);
+                    this->surface_set_layout(state.sub);
+                    state = nl;
+
+                    this->layout_commit();
+                    std::string str_area = std::string(kNameLayoutNormal) + "." + std::string(kNameAreaFull);
+                    compositor::rect area_rect = this->area_info[state.sub];
+                    this->emit_syncdraw(sub.c_str(), str_area.c_str(),
+                                        area_rect.x, area_rect.y, area_rect.w, area_rect.h);
+                    this->enqueue_flushdraw(state.sub);
+                });
+        }
+        else
+        {
+            this->try_layout(state, LayoutState{-1, -1}, [&](LayoutState const &nl) {
+                this->deactivate(*surface_id);
+                state = nl;
+                this->layout_commit();
             });
-      } else {
-         this->try_layout(state, LayoutState{-1, -1}, [&] (LayoutState const &nl) {
-            this->deactivate(*surface_id);
-            state = nl;
-            this->layout_commit();
-         });
-      }
-   } else if (state.sub == *surface_id) {
-      this->try_layout(
-         state, LayoutState{state.main, -1}, [&] (LayoutState const &nl) {
-            std::string main = std::move(*this->lookup_name(state.main));
+        }
+    }
+    else if (state.sub == *surface_id)
+    {
+        this->try_layout(
+            state, LayoutState{state.main, -1}, [&](LayoutState const &nl) {
+                std::string main = std::move(*this->lookup_name(state.main));
+
+                this->deactivate(*surface_id);
+                this->surface_set_layout(state.main);
+                state = nl;
+
+                this->layout_commit();
+                std::string str_area = std::string(kNameLayoutNormal) + "." + std::string(kNameAreaFull);
+                compositor::rect area_rect = this->area_info[state.main];
+                this->emit_syncdraw(main.c_str(), str_area.c_str(),
+                                    area_rect.x, area_rect.y, area_rect.w, area_rect.h);
+                this->enqueue_flushdraw(state.main);
+            });
+    }
+}
 
-            this->deactivate(*surface_id);
-            this->surface_set_layout(state.main);
-            state = nl;
+void App::enqueue_flushdraw(int surface_id)
+{
+    this->check_flushdraw(surface_id);
+    HMI_DEBUG("wm", "Enqueuing EndDraw for surface_id %d", surface_id);
+    this->pending_end_draw.push_back(surface_id);
+}
 
-            this->layout_commit();
-            std::string str_area = std::string(kNameLayoutNormal) + "." + std::string(kNameAreaFull);
-            compositor::rect area_rect = this->area_info[state.main];
-            this->emit_syncdraw(main.c_str(), str_area.c_str(),
-                                area_rect.x, area_rect.y, area_rect.w, area_rect.h);
-            this->enqueue_flushdraw(state.main);
-         });
-   }
-}
-
-void App::enqueue_flushdraw(int surface_id) {
-   this->check_flushdraw(surface_id);
-   HMI_DEBUG("wm", "Enqueuing EndDraw for surface_id %d", surface_id);
-   this->pending_end_draw.push_back(surface_id);
-}
-
-void App::check_flushdraw(int surface_id) {
-   auto i = std::find(std::begin(this->pending_end_draw),
-                      std::end(this->pending_end_draw), surface_id);
-   if (i != std::end(this->pending_end_draw)) {
-      auto n = this->lookup_name(surface_id);
-      HMI_ERROR("wm", "Application %s (%d) has pending EndDraw call(s)!",
-               n ? n->c_str() : "unknown-name", surface_id);
-      std::swap(this->pending_end_draw[std::distance(
-                   std::begin(this->pending_end_draw), i)],
-                this->pending_end_draw.back());
-      this->pending_end_draw.resize(this->pending_end_draw.size() - 1);
-   }
-}
-
-void App::api_enddraw(char const *drawing_name) {
-   for (unsigned i = 0, iend = this->pending_end_draw.size(); i < iend; i++) {
-      auto n = this->lookup_name(this->pending_end_draw[i]);
-      if (n && *n == drawing_name) {
-         std::swap(this->pending_end_draw[i], this->pending_end_draw[iend - 1]);
-         this->pending_end_draw.resize(iend - 1);
-         this->activate(this->pending_end_draw[i]);
-         this->emit_flushdraw(drawing_name);
-      }
-   }
+void App::check_flushdraw(int surface_id)
+{
+    auto i = std::find(std::begin(this->pending_end_draw),
+                       std::end(this->pending_end_draw), surface_id);
+    if (i != std::end(this->pending_end_draw))
+    {
+        auto n = this->lookup_name(surface_id);
+        HMI_ERROR("wm", "Application %s (%d) has pending EndDraw call(s)!",
+                  n ? n->c_str() : "unknown-name", surface_id);
+        std::swap(this->pending_end_draw[std::distance(
+                      std::begin(this->pending_end_draw), i)],
+                  this->pending_end_draw.back());
+        this->pending_end_draw.resize(this->pending_end_draw.size() - 1);
+    }
+}
+
+void App::api_enddraw(char const *drawing_name)
+{
+    for (unsigned i = 0, iend = this->pending_end_draw.size(); i < iend; i++)
+    {
+        auto n = this->lookup_name(this->pending_end_draw[i]);
+        if (n && *n == drawing_name)
+        {
+            std::swap(this->pending_end_draw[i], this->pending_end_draw[iend - 1]);
+            this->pending_end_draw.resize(iend - 1);
+            this->activate(this->pending_end_draw[i]);
+            this->emit_flushdraw(drawing_name);
+        }
+    }
 }
 
 void App::api_ping() { this->dispatch_pending_events(); }
 
-void App::send_event(char const *evname, char const *label){
-   HMI_DEBUG("wm", "%s: %s(%s)", __func__, evname, label);
+void App::send_event(char const *evname, char const *label)
+{
+    HMI_DEBUG("wm", "%s: %s(%s)", __func__, evname, label);
 
-   json_object *j = json_object_new_object();
-   json_object_object_add(j, kKeyDrawingName, json_object_new_string(label));
+    json_object *j = json_object_new_object();
+    json_object_object_add(j, kKeyDrawingName, json_object_new_string(label));
 
-   int ret = afb_event_push(this->map_afb_event[evname], j);
-   if (ret != 0) {
-      HMI_DEBUG("wm", "afb_event_push failed: %m");
-   }
+    int ret = afb_event_push(this->map_afb_event[evname], j);
+    if (ret != 0)
+    {
+        HMI_DEBUG("wm", "afb_event_push failed: %m");
+    }
 }
 
 void App::send_event(char const *evname, char const *label, char const *area,
-                             int x, int y, int w, int h) {
-   HMI_DEBUG("wm", "%s: %s(%s, %s) x:%d y:%d w:%d h:%d",
-             __func__, evname, label, area, x, y, w, h);
-
-   json_object *j_rect = json_object_new_object();
-   json_object_object_add(j_rect, kKeyX,      json_object_new_int(x));
-   json_object_object_add(j_rect, kKeyY,      json_object_new_int(y));
-   json_object_object_add(j_rect, kKeyWidth,  json_object_new_int(w));
-   json_object_object_add(j_rect, kKeyHeight, json_object_new_int(h));
-
-   json_object *j = json_object_new_object();
-   json_object_object_add(j, kKeyDrawingName, json_object_new_string(label));
-   json_object_object_add(j, kKeyDrawingArea, json_object_new_string(area));
-   json_object_object_add(j, kKeyDrawingRect, j_rect);
-
-   int ret = afb_event_push(this->map_afb_event[evname], j);
-   if (ret != 0) {
-      HMI_DEBUG("wm", "afb_event_push failed: %m");
-   }
+                     int x, int y, int w, int h)
+{
+    HMI_DEBUG("wm", "%s: %s(%s, %s) x:%d y:%d w:%d h:%d",
+              __func__, evname, label, area, x, y, w, h);
+
+    json_object *j_rect = json_object_new_object();
+    json_object_object_add(j_rect, kKeyX, json_object_new_int(x));
+    json_object_object_add(j_rect, kKeyY, json_object_new_int(y));
+    json_object_object_add(j_rect, kKeyWidth, json_object_new_int(w));
+    json_object_object_add(j_rect, kKeyHeight, json_object_new_int(h));
+
+    json_object *j = json_object_new_object();
+    json_object_object_add(j, kKeyDrawingName, json_object_new_string(label));
+    json_object_object_add(j, kKeyDrawingArea, json_object_new_string(area));
+    json_object_object_add(j, kKeyDrawingRect, j_rect);
+
+    int ret = afb_event_push(this->map_afb_event[evname], j);
+    if (ret != 0)
+    {
+        HMI_DEBUG("wm", "afb_event_push failed: %m");
+    }
 }
 
 /**
  * proxied events
  */
-void App::surface_created(uint32_t surface_id) {
-   auto layer_id = this->layers.get_layer_id(surface_id);
-   if (!layer_id) {
-      HMI_DEBUG("wm", "Newly created surfce %d is not associated with any layer!",
-               surface_id);
-      return;
-   }
-
-   HMI_DEBUG("wm", "surface_id is %u, layer_id is %u", surface_id, *layer_id);
-
-   this->controller->layers[*layer_id]->add_surface(surface_id);
-   this->layout_commit();
-   // activate the main_surface right away
-   /*if (surface_id == static_cast<unsigned>(this->layers.main_surface)) {
+void App::surface_created(uint32_t surface_id)
+{
+    auto layer_id = this->layers.get_layer_id(surface_id);
+    if (!layer_id)
+    {
+        HMI_DEBUG("wm", "Newly created surfce %d is not associated with any layer!",
+                  surface_id);
+        return;
+    }
+
+    HMI_DEBUG("wm", "surface_id is %u, layer_id is %u", surface_id, *layer_id);
+
+    this->controller->layers[*layer_id]->add_surface(surface_id);
+    this->layout_commit();
+    // activate the main_surface right away
+    /*if (surface_id == static_cast<unsigned>(this->layers.main_surface)) {
       HMI_DEBUG("wm", "Activating main_surface (%d)", surface_id);
 
       this->api_activate_surface(
@@ -661,316 +745,364 @@ void App::surface_created(uint32_t surface_id) {
    }*/
 }
 
-void App::surface_removed(uint32_t surface_id) {
-   HMI_DEBUG("wm", "surface_id is %u", surface_id);
-
-   // We cannot normally deactivate the main_surface, so be explicit
-   // about it:
-   if (int(surface_id) == this->layers.main_surface) {
-      this->deactivate_main_surface();
-   } else {
-      auto drawing_name = this->lookup_name(surface_id);
-      if (drawing_name) {
-         this->api_deactivate_surface(drawing_name->c_str(), [](const char*){});
-      }
-   }
-
-   this->id_alloc.remove_id(surface_id);
-   this->layers.remove_surface(surface_id);
+void App::surface_removed(uint32_t surface_id)
+{
+    HMI_DEBUG("wm", "surface_id is %u", surface_id);
+
+    // We cannot normally deactivate the main_surface, so be explicit
+    // about it:
+    if (int(surface_id) == this->layers.main_surface)
+    {
+        this->deactivate_main_surface();
+    }
+    else
+    {
+        auto drawing_name = this->lookup_name(surface_id);
+        if (drawing_name)
+        {
+            this->api_deactivate_surface(drawing_name->c_str(), [](const char *) {});
+        }
+    }
+
+    this->id_alloc.remove_id(surface_id);
+    this->layers.remove_surface(surface_id);
 }
 
-void App::emit_activated(char const *label) {
-   this->send_event(kListEventName[Event_Active], label);
+void App::emit_activated(char const *label)
+{
+    this->send_event(kListEventName[Event_Active], label);
 }
 
-void App::emit_deactivated(char const *label) {
-   this->send_event(kListEventName[Event_Inactive], label);
+void App::emit_deactivated(char const *label)
+{
+    this->send_event(kListEventName[Event_Inactive], label);
 }
 
-void App::emit_syncdraw(char const *label, char const *area, int x, int y, int w, int h) {
-   this->send_event(kListEventName[Event_SyncDraw], label, area, x, y, w, h);
+void App::emit_syncdraw(char const *label, char const *area, int x, int y, int w, int h)
+{
+    this->send_event(kListEventName[Event_SyncDraw], label, area, x, y, w, h);
 }
 
-void App::emit_flushdraw(char const *label) {
-   this->send_event(kListEventName[Event_FlushDraw], label);
+void App::emit_flushdraw(char const *label)
+{
+    this->send_event(kListEventName[Event_FlushDraw], label);
 }
 
-void App::emit_visible(char const *label, bool is_visible) {
-   this->send_event(is_visible ? kListEventName[Event_Visible] : kListEventName[Event_Invisible], label);
+void App::emit_visible(char const *label, bool is_visible)
+{
+    this->send_event(is_visible ? kListEventName[Event_Visible] : kListEventName[Event_Invisible], label);
 }
 
-void App::emit_invisible(char const *label) {
-   return emit_visible(label, false);
+void App::emit_invisible(char const *label)
+{
+    return emit_visible(label, false);
 }
 
 void App::emit_visible(char const *label) { return emit_visible(label, true); }
 
-result<int> App::api_request_surface(char const *drawing_name) {
-   auto lid = this->layers.get_layer_id(std::string(drawing_name));
-   if (!lid) {
-      /**
+result<int> App::api_request_surface(char const *drawing_name)
+{
+    auto lid = this->layers.get_layer_id(std::string(drawing_name));
+    if (!lid)
+    {
+        /**
        * register drawing_name as fallback and make it displayed.
        */
-      lid = this->layers.get_layer_id(std::string("Fallback"));
-      HMI_DEBUG("wm", "%s is not registered in layers.json, then fallback as normal app", drawing_name);
-      if(!lid){
-          return Err<int>("Drawing name does not match any role, Fallback is disabled");
-      }
-   }
+        lid = this->layers.get_layer_id(std::string("Fallback"));
+        HMI_DEBUG("wm", "%s is not registered in layers.json, then fallback as normal app", drawing_name);
+        if (!lid)
+        {
+            return Err<int>("Drawing name does not match any role, Fallback is disabled");
+        }
+    }
+
+    auto rname = this->lookup_id(drawing_name);
+    if (!rname)
+    {
+        // name does not exist yet, allocate surface id...
+        auto id = int(this->id_alloc.generate_id(drawing_name));
+        this->layers.add_surface(id, *lid);
+
+        // set the main_surface[_name] here and now
+        if (!this->layers.main_surface_name.empty() &&
+            this->layers.main_surface_name == drawing_name)
+        {
+            this->layers.main_surface = id;
+            HMI_DEBUG("wm", "Set main_surface id to %u", id);
+        }
+
+        return Ok<int>(id);
+    }
+
+    // Check currently registered drawing names if it is already there.
+    return Err<int>("Surface already present");
+}
 
-   auto rname = this->lookup_id(drawing_name);
-   if (!rname) {
-      // name does not exist yet, allocate surface id...
-      auto id = int(this->id_alloc.generate_id(drawing_name));
-      this->layers.add_surface(id, *lid);
+char const *App::api_request_surface(char const *drawing_name,
+                                     char const *ivi_id)
+{
+    ST();
 
-      // set the main_surface[_name] here and now
-      if (!this->layers.main_surface_name.empty() &&
-          this->layers.main_surface_name == drawing_name) {
-         this->layers.main_surface = id;
-         HMI_DEBUG("wm", "Set main_surface id to %u", id);
-      }
+    auto lid = this->layers.get_layer_id(std::string(drawing_name));
+    unsigned sid = std::stol(ivi_id);
 
-      return Ok<int>(id);
-   }
+    if (!lid)
+    {
+        /**
+       * register drawing_name as fallback and make it displayed.
+       */
+        lid = this->layers.get_layer_id(std::string("Fallback"));
+        HMI_DEBUG("wm", "%s is not registered in layers.json, then fallback as normal app", drawing_name);
+        if (!lid)
+        {
+            return "Drawing name does not match any role, Fallback is disabled";
+        }
+    }
 
-   // Check currently registered drawing names if it is already there.
-   return Err<int>("Surface already present");
+    auto rname = this->lookup_id(drawing_name);
+
+    if (rname)
+    {
+        return "Surface already present";
+    }
+
+    // register pair drawing_name and ivi_id
+    this->id_alloc.register_name_id(drawing_name, sid);
+    this->layers.add_surface(sid, *lid);
+
+    // this surface is already created
+    HMI_DEBUG("wm", "surface_id is %u, layer_id is %u", sid, *lid);
+
+    this->controller->layers[*lid]->add_surface(sid);
+    this->layout_commit();
+
+    return nullptr;
 }
 
-char const *App::api_request_surface(char const *drawing_name,
-                                     char const *ivi_id) {
-   ST();
+result<json_object *> App::api_get_display_info()
+{
+    // Check controller
+    if (!this->controller)
+    {
+        return Err<json_object *>("ivi_controller global not available");
+    }
+
+    // Set display info
+    compositor::size o_size = this->controller->output_size;
+    compositor::size p_size = this->controller->physical_size;
+
+    json_object *object = json_object_new_object();
+    json_object_object_add(object, kKeyWidthPixel, json_object_new_int(o_size.w));
+    json_object_object_add(object, kKeyHeightPixel, json_object_new_int(o_size.h));
+    json_object_object_add(object, kKeyWidthMm, json_object_new_int(p_size.w));
+    json_object_object_add(object, kKeyHeightMm, json_object_new_int(p_size.h));
+
+    return Ok<json_object *>(object);
+}
 
-   auto lid = this->layers.get_layer_id(std::string(drawing_name));
-   unsigned sid = std::stol(ivi_id);
+result<json_object *> App::api_get_area_info(char const *drawing_name)
+{
+    HMI_DEBUG("wm", "called");
+
+    // Check drawing name, surface/layer id
+    auto const &surface_id = this->lookup_id(drawing_name);
+    if (!surface_id)
+    {
+        return Err<json_object *>("Surface does not exist");
+    }
+
+    if (!this->controller->surface_exists(*surface_id))
+    {
+        return Err<json_object *>("Surface does not exist in controller!");
+    }
+
+    auto layer_id = this->layers.get_layer_id(*surface_id);
+    if (!layer_id)
+    {
+        return Err<json_object *>("Surface is not on any layer!");
+    }
+
+    auto o_state = *this->layers.get_layout_state(*surface_id);
+    if (o_state == nullptr)
+    {
+        return Err<json_object *>("Could not find layer for surface");
+    }
+
+    struct LayoutState &state = *o_state;
+    if ((state.main != *surface_id) && (state.sub != *surface_id))
+    {
+        return Err<json_object *>("Surface is inactive");
+    }
+
+    // Set area rectangle
+    compositor::rect area_info = this->area_info[*surface_id];
+    json_object *object = json_object_new_object();
+    json_object_object_add(object, kKeyX, json_object_new_int(area_info.x));
+    json_object_object_add(object, kKeyY, json_object_new_int(area_info.y));
+    json_object_object_add(object, kKeyWidth, json_object_new_int(area_info.w));
+    json_object_object_add(object, kKeyHeight, json_object_new_int(area_info.h));
+
+    return Ok<json_object *>(object);
+}
 
-   if (!lid) {
-      /**
-       * register drawing_name as fallback and make it displayed.
-       */
-      lid = this->layers.get_layer_id(std::string("Fallback"));
-      HMI_DEBUG("wm", "%s is not registered in layers.json, then fallback as normal app", drawing_name);
-      if(!lid){
-          return "Drawing name does not match any role, Fallback is disabled";
-      }
-   }
-
-   auto rname = this->lookup_id(drawing_name);
-
-   if (rname) {
-       return "Surface already present";
-   }
-
-   // register pair drawing_name and ivi_id
-   this->id_alloc.register_name_id(drawing_name, sid);
-   this->layers.add_surface(sid, *lid);
-
-   // this surface is already created
-   HMI_DEBUG("wm", "surface_id is %u, layer_id is %u", sid, *lid);
-
-   this->controller->layers[*lid]->add_surface(sid);
-   this->layout_commit();
-
-   return nullptr;
-}
-
-result<json_object *> App::api_get_display_info() {
-   // Check controller
-   if (!this->controller) {
-      return Err<json_object *>("ivi_controller global not available");
-   }
-
-   // Set display info
-   compositor::size o_size = this->controller->output_size;
-   compositor::size p_size = this->controller->physical_size;
-
-   json_object *object = json_object_new_object();
-   json_object_object_add(object, kKeyWidthPixel,  json_object_new_int(o_size.w));
-   json_object_object_add(object, kKeyHeightPixel, json_object_new_int(o_size.h));
-   json_object_object_add(object, kKeyWidthMm,     json_object_new_int(p_size.w));
-   json_object_object_add(object, kKeyHeightMm,    json_object_new_int(p_size.h));
-
-   return Ok<json_object *>(object);
-}
-
-result<json_object *> App::api_get_area_info(char const *drawing_name) {
-   HMI_DEBUG("wm", "called");
-
-   // Check drawing name, surface/layer id
-   auto const &surface_id = this->lookup_id(drawing_name);
-   if (!surface_id) {
-      return Err<json_object *>("Surface does not exist");
-   }
-
-   if (!this->controller->surface_exists(*surface_id)) {
-      return Err<json_object *>("Surface does not exist in controller!");
-   }
-
-   auto layer_id = this->layers.get_layer_id(*surface_id);
-   if (!layer_id) {
-      return Err<json_object *>("Surface is not on any layer!");
-   }
-
-   auto o_state = *this->layers.get_layout_state(*surface_id);
-   if (o_state == nullptr) {
-      return Err<json_object *>("Could not find layer for surface");
-   }
-
-   struct LayoutState &state = *o_state;
-   if ((state.main != *surface_id) && (state.sub != *surface_id)) {
-      return Err<json_object *>("Surface is inactive");
-   }
-
-   // Set area rectangle
-   compositor::rect area_info = this->area_info[*surface_id];
-   json_object *object = json_object_new_object();
-   json_object_object_add(object, kKeyX,      json_object_new_int(area_info.x));
-   json_object_object_add(object, kKeyY,      json_object_new_int(area_info.y));
-   json_object_object_add(object, kKeyWidth,  json_object_new_int(area_info.w));
-   json_object_object_add(object, kKeyHeight, json_object_new_int(area_info.h));
-
-   return Ok<json_object *>(object);
-}
-
-void App::activate(int id) {
-   auto ip = this->controller->sprops.find(id);
-   if (ip != this->controller->sprops.end()) {
-      this->controller->surfaces[id]->set_visibility(1);
-      char const *label =
-         this->lookup_name(id).value_or("unknown-name").c_str();
-
-      // FOR CES DEMO >>>
-      if ((0 == strcmp(label, "Radio"))
-          || (0 == strcmp(label, "MediaPlayer"))
-          || (0 == strcmp(label, "Music"))
-          || (0 == strcmp(label, "Navigation"))) {
-        for (auto i = surface_bg.begin(); i != surface_bg.end(); ++i) {
-            if (id == *i) {
-               // Remove id
-               this->surface_bg.erase(i);
-
-               // Remove from BG layer (999)
-               HMI_DEBUG("wm", "Remove %s(%d) from BG layer", label, id);
-               this->controller->layers[999]->remove_surface(id);
-
-               // Add to FG layer (1001)
-               HMI_DEBUG("wm", "Add %s(%d) to FG layer", label, id);
-               this->controller->layers[1001]->add_surface(id);
-
-               for (int j : this->surface_bg) {
-                 HMI_DEBUG("wm", "Stored id:%d", j);
-               }
-               break;
+void App::activate(int id)
+{
+    auto ip = this->controller->sprops.find(id);
+    if (ip != this->controller->sprops.end())
+    {
+        this->controller->surfaces[id]->set_visibility(1);
+        char const *label =
+            this->lookup_name(id).value_or("unknown-name").c_str();
+
+        // FOR CES DEMO >>>
+        if ((0 == strcmp(label, "Radio")) || (0 == strcmp(label, "MediaPlayer")) || (0 == strcmp(label, "Music")) || (0 == strcmp(label, "Navigation")))
+        {
+            for (auto i = surface_bg.begin(); i != surface_bg.end(); ++i)
+            {
+                if (id == *i)
+                {
+                    // Remove id
+                    this->surface_bg.erase(i);
+
+                    // Remove from BG layer (999)
+                    HMI_DEBUG("wm", "Remove %s(%d) from BG layer", label, id);
+                    this->controller->layers[999]->remove_surface(id);
+
+                    // Add to FG layer (1001)
+                    HMI_DEBUG("wm", "Add %s(%d) to FG layer", label, id);
+                    this->controller->layers[1001]->add_surface(id);
+
+                    for (int j : this->surface_bg)
+                    {
+                        HMI_DEBUG("wm", "Stored id:%d", j);
+                    }
+                    break;
+                }
+            }
+        }
+        // <<< FOR CES DEMO
+        this->layout_commit();
+
+        this->emit_visible(label);
+        this->emit_activated(label);
+    }
+}
+
+void App::deactivate(int id)
+{
+    auto ip = this->controller->sprops.find(id);
+    if (ip != this->controller->sprops.end())
+    {
+        char const *label =
+            this->lookup_name(id).value_or("unknown-name").c_str();
+
+        // FOR CES DEMO >>>
+        if ((0 == strcmp(label, "Radio"))       ||
+            (0 == strcmp(label, "MediaPlayer")) ||
+            (0 == strcmp(label, "Music"))       ||
+            (0 == strcmp(label, "Navigation")))
+        {
+
+            // Store id
+            this->surface_bg.push_back(id);
+
+            // Remove from FG layer (1001)
+            HMI_DEBUG("wm", "Remove %s(%d) from FG layer", label, id);
+            this->controller->layers[1001]->remove_surface(id);
+
+            // Add to BG layer (999)
+            HMI_DEBUG("wm", "Add %s(%d) to BG layer", label, id);
+            this->controller->layers[999]->add_surface(id);
+
+            for (int j : surface_bg)
+            {
+                HMI_DEBUG("wm", "Stored id:%d", j);
             }
-         }
-      }
-      // <<< FOR CES DEMO
-      this->layout_commit();
-
-      this->emit_visible(label);
-      this->emit_activated(label);
-   }
-}
-
-void App::deactivate(int id) {
-   auto ip = this->controller->sprops.find(id);
-   if (ip != this->controller->sprops.end()) {
-      char const *label =
-         this->lookup_name(id).value_or("unknown-name").c_str();
-
-      // FOR CES DEMO >>>
-      if ((0 == strcmp(label, "Radio"))
-          || (0 == strcmp(label, "MediaPlayer"))
-          || (0 == strcmp(label, "Music"))
-          || (0 == strcmp(label, "Navigation"))) {
-
-         // Store id
-         this->surface_bg.push_back(id);
-
-         // Remove from FG layer (1001)
-         HMI_DEBUG("wm", "Remove %s(%d) from FG layer", label, id);
-         this->controller->layers[1001]->remove_surface(id);
-
-         // Add to BG layer (999)
-         HMI_DEBUG("wm", "Add %s(%d) to BG layer", label, id);
-         this->controller->layers[999]->add_surface(id);
-
-         for (int j : surface_bg) {
-            HMI_DEBUG("wm", "Stored id:%d", j);
-         }
-      }
-      else {
-         this->controller->surfaces[id]->set_visibility(0);
-      }
-      // <<< FOR CES DEMO
-
-      this->emit_deactivated(label);
-      this->emit_invisible(label);
-   }
-}
-
-void App::deactivate_main_surface() {
-   this->layers.main_surface = -1;
-   this->api_deactivate_surface(this->layers.main_surface_name.c_str(), [](const char*){});
-}
-
-bool App::can_split(struct LayoutState const &state, int new_id) {
-   if (state.main != -1 && state.main != new_id) {
-      auto new_id_layer = this->layers.get_layer_id(new_id).value();
-      auto current_id_layer = this->layers.get_layer_id(state.main).value();
-
-      // surfaces are on separate layers, don't bother.
-      if (new_id_layer != current_id_layer) {
-         return false;
-      }
-
-      std::string const &new_id_str = this->lookup_name(new_id).value();
-      std::string const &cur_id_str = this->lookup_name(state.main).value();
-
-      auto const &layer = this->layers.get_layer(new_id_layer);
-
-      HMI_DEBUG("wm", "layer info name: %s", layer->name.c_str());
-
-      if (layer->layouts.empty()) {
-         return false;
-      }
-
-      for (auto i = layer->layouts.cbegin(); i != layer->layouts.cend(); i++) {
-         HMI_DEBUG("wm", "%d main_match '%s'", new_id_layer, i->main_match.c_str());
-         auto rem = std::regex(i->main_match);
-         if (std::regex_match(cur_id_str, rem)) {
-            // build the second one only if the first already matched
-            HMI_DEBUG("wm", "%d sub_match '%s'", new_id_layer, i->sub_match.c_str());
-            auto res = std::regex(i->sub_match);
-            if (std::regex_match(new_id_str, res)) {
-               HMI_DEBUG("wm", "layout matched!");
-               return true;
+        }
+        else
+        {
+            this->controller->surfaces[id]->set_visibility(0);
+        }
+        // <<< FOR CES DEMO
+
+        this->emit_deactivated(label);
+        this->emit_invisible(label);
+    }
+}
+
+void App::deactivate_main_surface()
+{
+    this->layers.main_surface = -1;
+    this->api_deactivate_surface(this->layers.main_surface_name.c_str(), [](const char *) {});
+}
+
+bool App::can_split(struct LayoutState const &state, int new_id)
+{
+    if (state.main != -1 && state.main != new_id)
+    {
+        auto new_id_layer = this->layers.get_layer_id(new_id).value();
+        auto current_id_layer = this->layers.get_layer_id(state.main).value();
+
+        // surfaces are on separate layers, don't bother.
+        if (new_id_layer != current_id_layer)
+        {
+            return false;
+        }
+
+        std::string const &new_id_str = this->lookup_name(new_id).value();
+        std::string const &cur_id_str = this->lookup_name(state.main).value();
+
+        auto const &layer = this->layers.get_layer(new_id_layer);
+
+        HMI_DEBUG("wm", "layer info name: %s", layer->name.c_str());
+
+        if (layer->layouts.empty())
+        {
+            return false;
+        }
+
+        for (auto i = layer->layouts.cbegin(); i != layer->layouts.cend(); i++)
+        {
+            HMI_DEBUG("wm", "%d main_match '%s'", new_id_layer, i->main_match.c_str());
+            auto rem = std::regex(i->main_match);
+            if (std::regex_match(cur_id_str, rem))
+            {
+                // build the second one only if the first already matched
+                HMI_DEBUG("wm", "%d sub_match '%s'", new_id_layer, i->sub_match.c_str());
+                auto res = std::regex(i->sub_match);
+                if (std::regex_match(new_id_str, res))
+                {
+                    HMI_DEBUG("wm", "layout matched!");
+                    return true;
+                }
             }
-         }
-      }
-   }
+        }
+    }
 
-   return false;
+    return false;
 }
 
 void App::try_layout(struct LayoutState & /*state*/,
                      struct LayoutState const &new_layout,
-                     std::function<void(LayoutState const &nl)> apply) {
-   if (this->policy.layout_is_valid(new_layout)) {
-      apply(new_layout);
-   }
+                     std::function<void(LayoutState const &nl)> apply)
+{
+    if (this->policy.layout_is_valid(new_layout))
+    {
+        apply(new_layout);
+    }
 }
 
 /**
  * controller_hooks
  */
-void controller_hooks::surface_created(uint32_t surface_id) {
-   this->app->surface_created(surface_id);
+void controller_hooks::surface_created(uint32_t surface_id)
+{
+    this->app->surface_created(surface_id);
 }
 
-void controller_hooks::surface_removed(uint32_t surface_id) {
-   this->app->surface_removed(surface_id);
+void controller_hooks::surface_removed(uint32_t surface_id)
+{
+    this->app->surface_removed(surface_id);
 }
 
 void controller_hooks::surface_visibility(uint32_t /*surface_id*/,
@@ -982,4 +1114,4 @@ void controller_hooks::surface_destination_rectangle(uint32_t /*surface_id*/,
                                                      uint32_t /*w*/,
                                                      uint32_t /*h*/) {}
 
-}  // namespace wm
+} // namespace wm
diff --git a/src/app.hpp b/src/app.hpp
index d1393c0..a0da1ba 100644
--- a/src/app.hpp
+++ b/src/app.hpp
@@ -33,15 +33,18 @@
 #include "wayland_ivi_wm.hpp"
 #include "hmi-debug.h"
 
-namespace wl {
+namespace wl
+{
 struct display;
 }
 
-namespace compositor {
+namespace compositor
+{
 struct controller;
 }
 
-namespace wm {
+namespace wm
+{
 
 using std::experimental::optional;
 
@@ -65,190 +68,199 @@ 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 *drawing_name);
-   char const *api_request_surface(char const *drawing_name, char const *ivi_id);
-   void api_activate_surface(char const *drawing_name, char const *drawing_area, const reply_func &reply);
-   void api_deactivate_surface(char const *drawing_name, const reply_func &reply);
-   void api_enddraw(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 *drawing_name);
+    char const *api_request_surface(char const *drawing_name, char const *ivi_id);
+    void api_activate_surface(char const *drawing_name, char const *drawing_area, const reply_func &reply);
+    void api_deactivate_surface(char const *drawing_name, const reply_func &reply);
+    void api_enddraw(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);
 
-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);
 
-   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);
 };
 
-}  // namespace wm
+} // namespace wm
 
-#endif  // TMCAGLWM_APP_HPP
+#endif // TMCAGLWM_APP_HPP
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.cpp b/src/json_helper.cpp
index 193a187..2e49778 100644
--- a/src/json_helper.cpp
+++ b/src/json_helper.cpp
@@ -18,85 +18,93 @@
 
 #include <json.h>
 
-json_object *to_json(compositor::surface_properties const &s) {
-   // auto j = json::object({
-   auto j = json_object_new_object();
-
-   //    {"id", s.id},
-   json_object_object_add(j, "id", json_object_new_int(s.id));
-
-   //    {"size", {{"width", s.size.w}, {"height", s.size.h}}},
-   auto jsize = json_object_new_object();
-   json_object_object_add(jsize, "width", json_object_new_int(s.size.w));
-   json_object_object_add(jsize, "height", json_object_new_int(s.size.h));
-   json_object_object_add(j, "size", jsize);
-
-   //    {"dst",
-   //     {{"width", s.dst_rect.w},
-   //      {"height", s.dst_rect.h},
-   //      {"x", s.dst_rect.x},
-   //      {"y", s.dst_rect.y}}},
-   auto jdst = json_object_new_object();
-   json_object_object_add(jdst, "width", json_object_new_int(s.dst_rect.w));
-   json_object_object_add(jdst, "height", json_object_new_int(s.dst_rect.h));
-   json_object_object_add(jdst, "x", json_object_new_int(s.dst_rect.x));
-   json_object_object_add(jdst, "y", json_object_new_int(s.dst_rect.y));
-   json_object_object_add(j, "dst", jdst);
-
-   //    {"src",
-   //     {{"width", s.src_rect.w},
-   //      {"height", s.src_rect.h},
-   //      {"x", s.src_rect.x},
-   //      {"y", s.src_rect.y}}},
-   auto jsrc = json_object_new_object();
-   json_object_object_add(jsrc, "width", json_object_new_int(s.src_rect.w));
-   json_object_object_add(jsrc, "height", json_object_new_int(s.src_rect.h));
-   json_object_object_add(jsrc, "x", json_object_new_int(s.src_rect.x));
-   json_object_object_add(jsrc, "y", json_object_new_int(s.src_rect.y));
-   json_object_object_add(j, "src", jsrc);
-
-   //    {"visibility", s.visibility},
-   json_object_object_add(
-      j, "visibility",
-      json_object_new_boolean(static_cast<json_bool>(s.visibility == 1)));
-
-   //    {"opacity", s.opacity},
-   json_object_object_add(j, "opacity", json_object_new_double(s.opacity));
-
-   //    {"orientation", s.orientation},
-   json_object_object_add(j, "orientation", json_object_new_int(s.orientation));
-
-   // });
-   return j;
+json_object *to_json(compositor::surface_properties const &s)
+{
+    // auto j = json::object({
+    auto j = json_object_new_object();
+
+    //    {"id", s.id},
+    json_object_object_add(j, "id", json_object_new_int(s.id));
+
+    //    {"size", {{"width", s.size.w}, {"height", s.size.h}}},
+    auto jsize = json_object_new_object();
+    json_object_object_add(jsize, "width", json_object_new_int(s.size.w));
+    json_object_object_add(jsize, "height", json_object_new_int(s.size.h));
+    json_object_object_add(j, "size", jsize);
+
+    //    {"dst",
+    //     {{"width", s.dst_rect.w},
+    //      {"height", s.dst_rect.h},
+    //      {"x", s.dst_rect.x},
+    //      {"y", s.dst_rect.y}}},
+    auto jdst = json_object_new_object();
+    json_object_object_add(jdst, "width", json_object_new_int(s.dst_rect.w));
+    json_object_object_add(jdst, "height", json_object_new_int(s.dst_rect.h));
+    json_object_object_add(jdst, "x", json_object_new_int(s.dst_rect.x));
+    json_object_object_add(jdst, "y", json_object_new_int(s.dst_rect.y));
+    json_object_object_add(j, "dst", jdst);
+
+    //    {"src",
+    //     {{"width", s.src_rect.w},
+    //      {"height", s.src_rect.h},
+    //      {"x", s.src_rect.x},
+    //      {"y", s.src_rect.y}}},
+    auto jsrc = json_object_new_object();
+    json_object_object_add(jsrc, "width", json_object_new_int(s.src_rect.w));
+    json_object_object_add(jsrc, "height", json_object_new_int(s.src_rect.h));
+    json_object_object_add(jsrc, "x", json_object_new_int(s.src_rect.x));
+    json_object_object_add(jsrc, "y", json_object_new_int(s.src_rect.y));
+    json_object_object_add(j, "src", jsrc);
+
+    //    {"visibility", s.visibility},
+    json_object_object_add(
+        j, "visibility",
+        json_object_new_boolean(static_cast<json_bool>(s.visibility == 1)));
+
+    //    {"opacity", s.opacity},
+    json_object_object_add(j, "opacity", json_object_new_double(s.opacity));
+
+    //    {"orientation", s.orientation},
+    json_object_object_add(j, "orientation", json_object_new_int(s.orientation));
+
+    // });
+    return j;
 }
 
-json_object *to_json(compositor::screen const *s) {
-   auto o = json_object_new_object();
-   json_object_object_add(o, "id", json_object_new_int(s->id));
-   return o;
+json_object *to_json(compositor::screen const *s)
+{
+    auto o = json_object_new_object();
+    json_object_object_add(o, "id", json_object_new_int(s->id));
+    return o;
 }
 
 template <typename T>
-json_object *to_json_(T const &s) {
-   auto a = json_object_new_array();
-
-   if (!s.empty()) {
-      for (auto const &i : s) {
-         json_object_array_add(a, to_json(i.second));
-      }
-   }
-
-   return a;
+json_object *to_json_(T const &s)
+{
+    auto a = json_object_new_array();
+
+    if (!s.empty())
+    {
+        for (auto const &i : s)
+        {
+            json_object_array_add(a, to_json(i.second));
+        }
+    }
+
+    return a;
 }
 
-json_object *to_json(compositor::controller::props_map const &s) {
-   return to_json_(s);
+json_object *to_json(compositor::controller::props_map const &s)
+{
+    return to_json_(s);
 }
 
-json_object *to_json(std::vector<uint32_t> const &v) {
-   auto a = json_object_new_array();
-   for (const auto i : v) {
-      json_object_array_add(a, json_object_new_int(i));
-   }
-   return a;
+json_object *to_json(std::vector<uint32_t> const &v)
+{
+    auto a = json_object_new_array();
+    for (const auto i : v)
+    {
+        json_object_array_add(a, json_object_new_int(i));
+    }
+    return a;
 }
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..4e7af91 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);
+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");
-         }
-      }
-
-      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());
-   }
+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);
-      }
-   }
-   HMI_DEBUG("wm", "role %s does NOT match any layer", role.c_str());
-   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);
+        }
+    }
+    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..6ecf2e7 100644
--- a/src/layers.hpp
+++ b/src/layers.hpp
@@ -27,87 +27,96 @@
 #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);
@@ -155,6 +164,6 @@ static const nlohmann::json default_layers_json = {
       }
    }}
 };
-}  // namespace wm
+} // 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 2f813a3..744df8b 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,460 +204,532 @@ 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(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", "Don't 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(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(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(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(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(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(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(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(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(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_NONE },
-   { "deactivatesurface", windowmanager_deactivatesurface, nullptr, nullptr, AFB_SESSION_NONE },
-   { "enddraw", windowmanager_enddraw, nullptr, nullptr, AFB_SESSION_NONE },
-   { "getdisplayinfo", windowmanager_getdisplayinfo_thunk, nullptr, nullptr, AFB_SESSION_NONE },
-   { "getareainfo", windowmanager_getareainfo_thunk, nullptr, nullptr, AFB_SESSION_NONE },
-   { "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_NONE},
+    {"deactivatesurface", windowmanager_deactivatesurface, nullptr, nullptr, AFB_SESSION_NONE},
+    {"enddraw", windowmanager_enddraw, nullptr, nullptr, AFB_SESSION_NONE},
+    {"getdisplayinfo", windowmanager_getdisplayinfo_thunk, nullptr, nullptr, AFB_SESSION_NONE},
+    {"getareainfo", windowmanager_getareainfo_thunk, nullptr, nullptr, AFB_SESSION_NONE},
+    {"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/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