Track surface/layer properties with one struct

As both share the exact same properties this makes sense, we now can
write code once and work on both layer and surface properties. This
however is only relevant in the wayland "level" of things, as in WM
semantics layers are always fullscreen.

Signed-off-by: Marcus Fritzsch <marcus_fritzsch@mentor.com>

5 files changed, 64 insertions, 109 deletions

diff --git a/src/json_helper.cpp b/src/json_helper.cpp
index 823c030..07f18a8 100644
--- a/src/json_helper.cpp
+++ b/src/json_helper.cpp
@@ -6,32 +6,27 @@
 
 using json = nlohmann::json;
 
-template <typename T>
-json_object *to_json_(T const *s) {
+json_object *to_json(genivi::surface_properties const &s) {
    auto j = json::object({
-      {"id", s->id},
-      {"size", {{"width", s->size.w}, {"height", s->size.h}}},
+      {"id", s.id},
+      {"size", {{"width", s.size.w}, {"height", s.size.h}}},
       {"dst",
-       {{"width", s->dst_rect.w},
-        {"height", s->dst_rect.h},
-        {"x", s->dst_rect.x},
-        {"y", s->dst_rect.y}}},
+       {{"width", s.dst_rect.w},
+        {"height", s.dst_rect.h},
+        {"x", s.dst_rect.x},
+        {"y", s.dst_rect.y}}},
       {"src",
-       {{"width", s->src_rect.w},
-        {"height", s->src_rect.h},
-        {"x", s->src_rect.x},
-        {"y", s->src_rect.y}}},
-      {"visibility", s->visibility},
-      {"opacity", s->opacity},
-      {"orientation", s->orientation},
+       {{"width", s.src_rect.w},
+        {"height", s.src_rect.h},
+        {"x", s.src_rect.x},
+        {"y", s.src_rect.y}}},
+      {"visibility", s.visibility},
+      {"opacity", s.opacity},
+      {"orientation", s.orientation},
    });
    return json_tokener_parse(j.dump().c_str());
 }
 
-json_object *to_json(genivi::surface const *s) { return to_json_(s); }
-
-json_object *to_json(genivi::layer const *l) { return to_json_(l); }
-
 json_object *to_json(genivi::screen const *s) {
    auto o = json_object_new_object();
    json_object_object_add(o, "id", json_object_new_int(s->id));
@@ -44,22 +39,14 @@ json_object *to_json_(T const &s) {
 
    if (!s.empty()) {
       for (auto const &i : s) {
-         json_object_array_add(a, to_json(i.second.get()));
+         json_object_array_add(a, to_json(i.second));
       }
    }
 
    return a;
 }
 
-json_object *to_json(genivi::controller::surface_map_type const &s) {
-   return to_json_(s);
-}
-
-json_object *to_json(genivi::controller::layer_map_type const &l) {
-   return to_json_(l);
-}
-
-json_object *to_json(genivi::controller::screen_map_type const &s) {
+json_object *to_json(genivi::controller::props_map const &s) {
    return to_json_(s);
 }
 
diff --git a/src/json_helper.hpp b/src/json_helper.hpp
index 4a536d3..7d5d26f 100644
--- a/src/json_helper.hpp
+++ b/src/json_helper.hpp
@@ -5,12 +5,8 @@
 
 struct json_object;
 
-json_object *to_json(genivi::surface const *s);
-json_object *to_json(genivi::layer const *l);
 json_object *to_json(genivi::screen const *s);
-json_object *to_json(genivi::controller::surface_map_type const &s);
-json_object *to_json(genivi::controller::layer_map_type const &l);
-json_object *to_json(genivi::controller::screen_map_type const &s);
+json_object *to_json(genivi::controller::props_map const &s);
 json_object *to_json(std::vector<uint32_t> const &v);
 
 #endif  // TMCAGLWM_JSON_HELPER_HPP
diff --git a/src/main.cpp b/src/main.cpp
index ba0ff4e..965599d 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -211,20 +211,20 @@ void debug_status(struct afb_req req) {
 
    auto o = json_object_new_object();
    json_object_object_add(o, "surfaces",
-                          to_json(g_wayland->controller->surfaces));
-   json_object_object_add(o, "layers", to_json(g_wayland->controller->layers));
-   json_object_object_add(o, "screens",
-                          to_json(g_wayland->controller->screens));
+                          to_json(g_wayland->controller->sprops));
+   json_object_object_add(o, "layers", to_json(g_wayland->controller->lprops));
+//   json_object_object_add(o, "screens",
+//                          to_json(g_wayland->controller->screens));
 
    afb_req_success(req, o, "status");
 }
 
 void debug_surfaces(afb_req req) {
-   afb_req_success(req, to_json(g_wayland->controller->surfaces), "surfaces");
+   afb_req_success(req, to_json(g_wayland->controller->sprops), "surfaces");
 }
 
 void debug_layers(afb_req req) {
-   afb_req_success(req, to_json(g_wayland->controller->layers), "layers");
+   afb_req_success(req, to_json(g_wayland->controller->lprops), "layers");
 }
 
 // Dummy register_surface implementation
diff --git a/src/wayland.cpp b/src/wayland.cpp
index cf03d02..e12f155 100644
--- a/src/wayland.cpp
+++ b/src/wayland.cpp
@@ -323,13 +323,7 @@ layer::layer(uint32_t i, int32_t w, int32_t h, struct controller *c)
                       c->remove_proxy_to_id_mapping(l);
                       ivi_controller_layer_destroy(l, 1);
                    }),
-     controller_child(c, i),
-     dst_rect{},
-     src_rect{},
-     size{},
-     orientation{},
-     visibility{},
-     opacity{} {
+     controller_child(c, i) {
    this->parent->add_proxy_to_id_mapping(this->proxy.get(), i);
    ivi_controller_layer_add_listener(this->proxy.get(), &layer_listener, this);
 }
@@ -389,19 +383,19 @@ void layer::set_render_order(std::vector<uint32_t> const &ro) {
 void controller::layer_visibility(struct layer *l, int32_t visibility) {
    logdebug("genivi::layer %s @ %p v %i", __func__, this->proxy.get(),
             visibility);
-   l->visibility = visibility;
+   this->lprops[l->id].visibility = visibility;
 }
 
 void controller::layer_opacity(struct layer *l, float opacity) {
    logdebug("genivi::layer %s @ %p o %f", __func__, this->proxy.get(), opacity);
-   l->opacity = opacity;
+   this->lprops[l->id].opacity = opacity;
 }
 
 void controller::layer_source_rectangle(struct layer *l, int32_t x, int32_t y,
                                         int32_t width, int32_t height) {
    logdebug("genivi::layer %s @ %p x %i y %i w %i h %i", __func__,
             this->proxy.get(), x, y, width, height);
-   l->src_rect = rect{uint32_t(width), uint32_t(height), x, y};
+   this->lprops[l->id].src_rect = rect{uint32_t(width), uint32_t(height), x, y};
 }
 
 void controller::layer_destination_rectangle(struct layer *l, int32_t x,
@@ -409,20 +403,20 @@ void controller::layer_destination_rectangle(struct layer *l, int32_t x,
                                              int32_t height) {
    logdebug("genivi::layer %s @ %p x %i y %i w %i h %i", __func__,
             this->proxy.get(), x, y, width, height);
-   l->dst_rect = rect{uint32_t(width), uint32_t(height), x, y};
+   this->lprops[l->id].dst_rect = rect{uint32_t(width), uint32_t(height), x, y};
 }
 
 void controller::layer_configuration(struct layer *l, int32_t width,
                                      int32_t height) {
    logdebug("genivi::layer %s @ %p w %i h %i", __func__, this->proxy.get(),
             width, height);
-   l->size = size{uint32_t(width), uint32_t(height)};
+   this->lprops[l->id].size = size{uint32_t(width), uint32_t(height)};
 }
 
 void controller::layer_orientation(struct layer *l, int32_t orientation) {
    logdebug("genivi::layer %s @ %p o %i", __func__, this->proxy.get(),
             orientation);
-   l->orientation = orientation;
+   this->lprops[l->id].orientation = orientation;
 }
 
 void controller::layer_screen(struct layer * /*l*/, struct wl_output *screen) {
@@ -432,7 +426,10 @@ void controller::layer_screen(struct layer * /*l*/, struct wl_output *screen) {
 void controller::layer_destroyed(struct layer *l) {
    logdebug("genivi::layer %s @ %p", __func__, this->proxy.get());
    add_task("remove layer",
-            [l](struct controller *c) { c->layers.erase(l->id); });
+            [l](struct controller *c) {
+                c->lprops.erase(l->id);
+                c->layers.erase(l->id);
+            });
 }
 
 //                  __
@@ -544,13 +541,7 @@ surface::surface(uint32_t i, struct controller *c)
                       c->remove_proxy_to_id_mapping(s);
                       ivi_controller_surface_destroy(s, 1);
                    }),
-     controller_child(c, i),
-     dst_rect{},
-     src_rect{},
-     size{},
-     orientation{},
-     visibility{},
-     opacity{1.f} {
+     controller_child(c, i) {
    this->parent->add_proxy_to_id_mapping(this->proxy.get(), i);
    ivi_controller_surface_add_listener(this->proxy.get(), &surface_listener,
                                        this);
@@ -599,13 +590,13 @@ void surface::destroy(int32_t destroy_scene_object) {
 void controller::surface_visibility(struct surface *s, int32_t visibility) {
    logdebug("genivi::surface %s @ %p v %i", __func__, this->proxy.get(),
             visibility);
-   s->visibility = visibility;
+   this->sprops[s->id].visibility = visibility;
 }
 
 void controller::surface_opacity(struct surface *s, float opacity) {
    logdebug("genivi::surface %s @ %p o %f", __func__, this->proxy.get(),
             opacity);
-   s->opacity = opacity;
+   this->sprops[s->id].opacity = opacity;
 }
 
 void controller::surface_source_rectangle(struct surface *s, int32_t x,
@@ -613,7 +604,7 @@ void controller::surface_source_rectangle(struct surface *s, int32_t x,
                                           int32_t height) {
    logdebug("genivi::surface %s @ %p x %i y %i w %i h %i", __func__,
             this->proxy.get(), x, y, width, height);
-   s->src_rect = rect{uint32_t(width), uint32_t(height), x, y};
+   this->sprops[s->id].src_rect = rect{uint32_t(width), uint32_t(height), x, y};
 }
 
 void controller::surface_destination_rectangle(struct surface *s, int32_t x,
@@ -621,20 +612,20 @@ void controller::surface_destination_rectangle(struct surface *s, int32_t x,
                                                int32_t height) {
    logdebug("genivi::surface %s @ %p x %i y %i w %i h %i", __func__,
             this->proxy.get(), x, y, width, height);
-   s->dst_rect = rect{uint32_t(width), uint32_t(height), x, y};
+   this->sprops[s->id].dst_rect = rect{uint32_t(width), uint32_t(height), x, y};
 }
 
 void controller::surface_configuration(struct surface *s, int32_t width,
                                        int32_t height) {
    logdebug("genivi::surface %s @ %p w %i h %i", __func__, this->proxy.get(),
             width, height);
-   s->size = size{uint32_t(width), uint32_t(height)};
+   this->sprops[s->id].size = size{uint32_t(width), uint32_t(height)};
 }
 
 void controller::surface_orientation(struct surface *s, int32_t orientation) {
    logdebug("genivi::surface %s @ %p o %i", __func__, this->proxy.get(),
             orientation);
-   s->orientation = orientation;
+   this->sprops[s->id].orientation = orientation;
 }
 
 void controller::surface_pixelformat(struct surface * /*s*/,
@@ -659,6 +650,7 @@ void controller::surface_stats(struct surface * /*s*/, uint32_t redraw_count,
 
 void controller::surface_destroyed(struct surface *s) {
    logdebug("genivi::surface %s @ %p", __func__, this->proxy.get());
+   this->sprops.erase(s->id);
    this->surfaces.erase(s->id);
 }
 
@@ -667,14 +659,18 @@ void controller::surface_content(struct surface *s, int32_t content_state) {
             content_state);
    if (content_state == IVI_CONTROLLER_SURFACE_CONTENT_STATE_CONTENT_REMOVED) {
       add_task("remove surface",
-               [s](struct controller *c) { c->surfaces.erase(s->id); });
+               [s](struct controller *c) {
+                   c->sprops.erase(s->id);
+                   c->surfaces.erase(s->id);
+               });
    }
 }
 
 void controller::add_proxy_to_id_mapping(struct ivi_controller_surface *p,
                                          uint32_t id) {
-   this->surface_proxy_to_id[uintptr_t(p)] = id;
    logdebug("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_id_mapping(struct ivi_controller_surface *p) {
@@ -686,6 +682,7 @@ void controller::add_proxy_to_id_mapping(struct ivi_controller_layer *p,
                                          uint32_t id) {
    logdebug("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_id_mapping(struct ivi_controller_layer *p) {
@@ -720,30 +717,6 @@ void controller::execute_pending() {
    }
 }
 
-void controller::debug_dump_current_status() {
-   if (!this->surfaces.empty()) {
-      puts("Surfaces:");
-      for (auto const &i : this->surfaces) {
-         auto const &r = i.second->dst_rect;
-         auto const &s = i.second->size;
-         printf("%d [%ux%u] (%ux%u@%dx%d), ", i.first, s.w, s.h, r.w, r.h, r.x,
-                r.y);
-      }
-      puts("\b\b ");
-   }
-
-   if (!this->layers.empty()) {
-      puts("Layers:");
-      for (auto const &i : this->layers) {
-         auto const &r = i.second->dst_rect;
-         auto const &s = i.second->size;
-         printf("%d [%ux%u] (%ux%u@%dx%d), ", i.first, s.w, s.h, r.w, r.h, r.x,
-                r.y);
-      }
-      puts("\b\b ");
-   }
-}
-
 //
 //  ___  ___ _ __ ___  ___ _ __
 // / __|/ __| '__/ _ \/ _ \ '_ \
diff --git a/src/wayland.hpp b/src/wayland.hpp
index 7e005f1..740a703 100644
--- a/src/wayland.hpp
+++ b/src/wayland.hpp
@@ -136,6 +136,16 @@ struct controller_child {
    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;
+};
+
 //                  __
 //  ___ _   _ _ __ / _| __ _  ___ ___
 // / __| | | | '__| |_ / _` |/ __/ _ \
@@ -144,13 +154,6 @@ struct controller_child {
 //
 struct surface : public wayland_proxy<struct ivi_controller_surface>,
                  controller_child {
-   struct rect dst_rect;
-   struct rect src_rect;
-   struct size size;
-   int32_t orientation;
-   int32_t visibility;
-   float opacity;
-
    surface(surface const &) = delete;
    surface &operator=(surface const &) = delete;
    surface(uint32_t i, struct controller *c);
@@ -177,13 +180,6 @@ struct surface : public wayland_proxy<struct ivi_controller_surface>,
 //          |___/
 struct layer : public wayland_proxy<struct ivi_controller_layer>,
                controller_child {
-   struct rect dst_rect;
-   struct rect src_rect;
-   struct size size;
-   int32_t orientation;
-   int32_t visibility;
-   float opacity;
-
    layer(layer const &) = delete;
    layer &operator=(layer const &) = delete;
    layer(uint32_t i, struct controller *c);
@@ -236,6 +232,8 @@ struct controller : public wayland_proxy<struct ivi_controller> {
    typedef std::unordered_map<uint32_t, std::unique_ptr<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
@@ -251,14 +249,15 @@ struct controller : public wayland_proxy<struct ivi_controller> {
    layer_map_type layers;
    screen_map_type screens;
 
+   props_map sprops;
+   props_map lprops;
+
    typedef std::pair<char const *, std::function<void(struct controller *)>>
       name_task_pair;
    std::vector<name_task_pair> pending;
 
    size output_size;
 
-   void debug_dump_current_status();
-
    void add_proxy_to_id_mapping(struct ivi_controller_surface *p, uint32_t id);
    void remove_proxy_to_id_mapping(struct ivi_controller_surface *p);
    void add_proxy_to_id_mapping(struct ivi_controller_layer *p, uint32_t id);