wayland: added notification prototype, be more explicit about struct types

Notification support can be implemented on genivi objects using the
genivi::notify::notifier, it is supposed to be inherited from by the
notification-needing types, e.g. genivi::surface.

Currently no implementation for notifier is present (only an empty
shell) also it is not yet clear, if the notifications will be sent from
the genivi objects method's or e.g. their thunks (which would simplify
the methods considerably).

Added request wrappers for genivi::surface and genivi::layer, just
inline them into the class and be done with it.

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

2 files changed, 212 insertions, 89 deletions

diff --git a/src/wayland.cpp b/src/wayland.cpp
index 4f1dbd1..fef0cc3 100644
--- a/src/wayland.cpp
+++ b/src/wayland.cpp
@@ -15,18 +15,19 @@ namespace wl {
 //  \__,_|_|___/ .__/|_|\__,_|\__, |
 //             |_|            |___/
 display::display()
-   : d(std::unique_ptr<wl_display, void (*)(wl_display *)>(
+   : d(std::unique_ptr<struct wl_display,
+                       std::function<void(struct wl_display *)>>(
         wl_display_connect(NULL),
-        [](wl_display *d) {
-           logdebug("wl::display %s @ %p", __func__, d);
+        [](struct wl_display *d) {
+           logdebug("wl::display ~display @ %p", d);
            wl_display_disconnect(d);
         })),
-     r(std::make_unique<registry>(d.get())) {}
+     r(std::make_unique<struct registry>(d.get())) {}
 
 display::~display() {}
 
 bool display::ok() const {
-   return d.get() != nullptr && wl_display_get_error(d.get()) == 0;
+   return d && wl_display_get_error(d.get()) == 0;
 }
 
 void display::roundtrip() { wl_display_roundtrip(this->d.get()); }
@@ -42,18 +43,19 @@ int display::dispatch() { return wl_display_dispatch(this->d.get()); }
 namespace {
 void registry_global(void *data, struct wl_registry *r, uint32_t name,
                      char const *iface, uint32_t v) {
-   static_cast<registry *>(data)->global(name, iface, v);
+   static_cast<struct registry *>(data)->global(name, iface, v);
 }
 
 void registry_global_remove(void *data, struct wl_registry *r, uint32_t name) {
-   static_cast<registry *>(data)->global_remove(name);
+   static_cast<struct registry *>(data)->global_remove(name);
 }
 
-constexpr wl_registry_listener registry_listener = {registry_global,
-                                                    registry_global_remove};
+constexpr struct wl_registry_listener registry_listener = {
+   registry_global, registry_global_remove};
 }
 
-registry::registry(wl_display *d) : wayland_proxy(wl_display_get_registry(d)) {
+registry::registry(struct wl_display *d)
+   : wayland_proxy(wl_display_get_registry(d)) {
    wl_registry_add_listener(this->proxy, &registry_listener, this);
 }
 
@@ -87,28 +89,28 @@ 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<output *>(data)->geometry(x, y, physical_width, physical_height,
-                                         subpixel, make, model, 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<output *>(data)->mode(flags, width, height, refresh);
+   static_cast<struct output *>(data)->mode(flags, width, height, refresh);
 }
 
 void output_done(void *data, struct wl_output *wl_output) {
-   static_cast<output *>(data)->done();
+   static_cast<struct output *>(data)->done();
 }
 
 void output_scale(void *data, struct wl_output *wl_output, int32_t factor) {
-   static_cast<output *>(data)->scale(factor);
+   static_cast<struct output *>(data)->scale(factor);
 }
 
-constexpr wl_output_listener output_listener = {output_geometry, output_mode,
-                                                output_done, output_scale};
+constexpr struct wl_output_listener output_listener = {
+   output_geometry, output_mode, output_done, output_scale};
 }
 
-output::output(wl_registry *r, uint32_t name, uint32_t v)
+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, &output_listener, this);
 }
@@ -158,31 +160,31 @@ namespace {
 void controller_screen(void *data, struct ivi_controller *ivi_controller,
                        uint32_t id_screen,
                        struct ivi_controller_screen *screen) {
-   static_cast<controller *>(data)->screen(id_screen, screen);
+   static_cast<struct controller *>(data)->screen(id_screen, screen);
 }
 
 void controller_layer(void *data, struct ivi_controller *ivi_controller,
                       uint32_t id_layer) {
-   static_cast<controller *>(data)->layer(id_layer);
+   static_cast<struct controller *>(data)->layer(id_layer);
 }
 
 void controller_surface(void *data, struct ivi_controller *ivi_controller,
                         uint32_t id_surface) {
-   static_cast<controller *>(data)->surface(id_surface);
+   static_cast<struct controller *>(data)->surface(id_surface);
 }
 
 void controller_error(void *data, struct ivi_controller *ivi_controller,
                       int32_t object_id, int32_t object_type,
                       int32_t error_code, const char *error_text) {
-   static_cast<controller *>(data)->error(object_id, object_type, error_code,
-                                          error_text);
+   static_cast<struct controller *>(data)->error(object_id, object_type,
+                                                 error_code, error_text);
 }
 
-constexpr ivi_controller_listener listener = {
+constexpr struct ivi_controller_listener listener = {
    controller_screen, controller_layer, controller_surface, controller_error};
 }
 
-controller::controller(wl_registry *r, uint32_t name, uint32_t version)
+controller::controller(struct wl_registry *r, uint32_t name, uint32_t version)
    : wayland_proxy(
         wl_registry_bind(r, name, &ivi_controller_interface, version)) {
    ivi_controller_add_listener(this->proxy, &listener, this);
@@ -222,51 +224,52 @@ namespace {
 void layer_visibility(void *data,
                       struct ivi_controller_layer *ivi_controller_layer,
                       int32_t visibility) {
-   static_cast<layer *>(data)->visibility(visibility);
+   static_cast<struct layer *>(data)->visibility(visibility);
 }
 
 void layer_opacity(void *data,
                    struct ivi_controller_layer *ivi_controller_layer,
                    wl_fixed_t opacity) {
-   static_cast<layer *>(data)->opacity(wl_fixed_to_double(opacity));
+   static_cast<struct layer *>(data)->opacity(wl_fixed_to_double(opacity));
 }
 
 void layer_source_rectangle(void *data,
                             struct ivi_controller_layer *ivi_controller_layer,
                             int32_t x, int32_t y, int32_t width,
                             int32_t height) {
-   static_cast<layer *>(data)->source_rectangle(x, y, width, height);
+   static_cast<struct layer *>(data)->source_rectangle(x, y, width, height);
 }
 
 void layer_destination_rectangle(
    void *data, struct ivi_controller_layer *ivi_controller_layer, int32_t x,
    int32_t y, int32_t width, int32_t height) {
-   static_cast<layer *>(data)->destination_rectangle(x, y, width, height);
+   static_cast<struct layer *>(data)->destination_rectangle(x, y, width,
+                                                            height);
 }
 
 void layer_configuration(void *data,
                          struct ivi_controller_layer *ivi_controller_layer,
                          int32_t width, int32_t height) {
-   static_cast<layer *>(data)->configuration(width, height);
+   static_cast<struct layer *>(data)->configuration(width, height);
 }
 
 void layer_orientation(void *data,
                        struct ivi_controller_layer *ivi_controller_layer,
                        int32_t orientation) {
-   static_cast<layer *>(data)->orientation(orientation);
+   static_cast<struct layer *>(data)->orientation(orientation);
 }
 
 void layer_screen(void *data, struct ivi_controller_layer *ivi_controller_layer,
                   struct wl_output *screen) {
-   static_cast<layer *>(data)->screen(screen);
+   static_cast<struct layer *>(data)->screen(screen);
 }
 
 void layer_destroyed(void *data,
                      struct ivi_controller_layer *ivi_controller_layer) {
-   static_cast<layer *>(data)->destroyed();
+   static_cast<struct layer *>(data)->destroyed();
 }
 
-constexpr ivi_controller_layer_listener layer_listener = {
+constexpr struct ivi_controller_layer_listener layer_listener = {
    layer_visibility,       layer_opacity,
    layer_source_rectangle, layer_destination_rectangle,
    layer_configuration,    layer_orientation,
@@ -274,7 +277,7 @@ constexpr ivi_controller_layer_listener layer_listener = {
 };
 }
 
-layer::layer(uint32_t i, ivi_controller *c)
+layer::layer(uint32_t i, struct ivi_controller *c)
    : wayland_proxy(ivi_controller_layer_create(c, i, 0, 0)), id(i) {
    ivi_controller_layer_add_listener(this->proxy, &layer_listener, this);
 }
@@ -333,49 +336,50 @@ namespace {
 void surface_visibility(void *data,
                         struct ivi_controller_surface *ivi_controller_surface,
                         int32_t visibility) {
-   static_cast<surface *>(data)->visibility(visibility);
+   static_cast<struct surface *>(data)->visibility(visibility);
 }
 
 void surface_opacity(void *data,
                      struct ivi_controller_surface *ivi_controller_surface,
                      wl_fixed_t opacity) {
-   static_cast<surface *>(data)->opacity(wl_fixed_to_double(opacity));
+   static_cast<struct surface *>(data)->opacity(wl_fixed_to_double(opacity));
 }
 
 void surface_source_rectangle(
    void *data, struct ivi_controller_surface *ivi_controller_surface, int32_t x,
    int32_t y, int32_t width, int32_t height) {
-   static_cast<surface *>(data)->source_rectangle(x, y, width, height);
+   static_cast<struct surface *>(data)->source_rectangle(x, y, width, height);
 }
 
 void surface_destination_rectangle(
    void *data, struct ivi_controller_surface *ivi_controller_surface, int32_t x,
    int32_t y, int32_t width, int32_t height) {
-   static_cast<surface *>(data)->destination_rectangle(x, y, width, height);
+   static_cast<struct surface *>(data)->destination_rectangle(x, y, width,
+                                                              height);
 }
 
 void surface_configuration(
    void *data, struct ivi_controller_surface *ivi_controller_surface,
    int32_t width, int32_t height) {
-   static_cast<surface *>(data)->configuration(width, height);
+   static_cast<struct surface *>(data)->configuration(width, height);
 }
 
 void surface_orientation(void *data,
                          struct ivi_controller_surface *ivi_controller_surface,
                          int32_t orientation) {
-   static_cast<surface *>(data)->orientation(orientation);
+   static_cast<struct surface *>(data)->orientation(orientation);
 }
 
 void surface_pixelformat(void *data,
                          struct ivi_controller_surface *ivi_controller_surface,
                          int32_t pixelformat) {
-   static_cast<surface *>(data)->pixelformat(pixelformat);
+   static_cast<struct surface *>(data)->pixelformat(pixelformat);
 }
 
 void surface_layer(void *data,
                    struct ivi_controller_surface *ivi_controller_surface,
                    struct ivi_controller_layer *layer) {
-   static_cast<surface *>(data)->layer(layer);
+   static_cast<struct surface *>(data)->layer(layer);
 }
 
 void surface_stats(void *data,
@@ -383,22 +387,22 @@ void surface_stats(void *data,
                    uint32_t redraw_count, uint32_t frame_count,
                    uint32_t update_count, uint32_t pid,
                    const char *process_name) {
-   static_cast<surface *>(data)->stats(redraw_count, frame_count, update_count,
-                                       pid, process_name);
+   static_cast<struct surface *>(data)->stats(redraw_count, frame_count,
+                                              update_count, pid, process_name);
 }
 
 void surface_destroyed(void *data,
                        struct ivi_controller_surface *ivi_controller_surface) {
-   static_cast<surface *>(data)->destroyed();
+   static_cast<struct surface *>(data)->destroyed();
 }
 
 void surface_content(void *data,
                      struct ivi_controller_surface *ivi_controller_surface,
                      int32_t content_state) {
-   static_cast<surface *>(data)->content(content_state);
+   static_cast<struct surface *>(data)->content(content_state);
 }
 
-static constexpr ivi_controller_surface_listener surface_listener = {
+constexpr struct ivi_controller_surface_listener surface_listener = {
    surface_visibility,
    surface_opacity,
    surface_source_rectangle,
@@ -413,7 +417,7 @@ static constexpr ivi_controller_surface_listener surface_listener = {
 };
 }
 
-surface::surface(uint32_t i, ivi_controller *c)
+surface::surface(uint32_t i, struct ivi_controller *c)
    : wayland_proxy(ivi_controller_surface_create(c, i)), id(i) {
    ivi_controller_surface_add_listener(this->proxy, &surface_listener, this);
 }
@@ -479,11 +483,11 @@ void surface::content(int32_t content_state) {
 }
 
 //
-// ___  ___ _ __ ___  ___ _ __
-/// __|/ __| '__/ _ \/ _ \ '_ \
-//\__ \ (__| | |  __/  __/ | | |
-//|___/\___|_|  \___|\___|_| |_|
+//  ___  ___ _ __ ___  ___ _ __
+// / __|/ __| '__/ _ \/ _ \ '_ \
+// \__ \ (__| | |  __/  __/ | | |
+// |___/\___|_|  \___|\___|_| |_|
 //
-screen::screen(uint32_t i, ivi_controller_screen *p)
+screen::screen(uint32_t i, struct ivi_controller_screen *p)
    : wayland_proxy(p), id(i) {}
 }
diff --git a/src/wayland.hpp b/src/wayland.hpp
index 38f8946..da01eb3 100644
--- a/src/wayland.hpp
+++ b/src/wayland.hpp
@@ -8,6 +8,7 @@
 #include <functional>
 #include <map>
 #include <memory>
+#include <vector>
 
 //                      _                 _
 // __      ____ _ _   _| | __ _ _ __   __| |     _ __  _ __ _____  ___   _
@@ -26,7 +27,7 @@ struct wayland_proxy {
       // custom wayland dtor
       if (this->proxy) {
          logdebug("%s %p @ %p", __func__, this, this->proxy);
-         wl_proxy_destroy(reinterpret_cast<wl_proxy *>(proxy));
+         wl_proxy_destroy(reinterpret_cast<struct wl_proxy *>(proxy));
       }
    }
 };
@@ -47,8 +48,9 @@ struct registry;
 //  \__,_|_|___/ .__/|_|\__,_|\__, |
 //             |_|            |___/
 struct display {
-   std::unique_ptr<wl_display, void (*)(wl_display *)> d;
-   std::unique_ptr<registry> r;
+   std::unique_ptr<struct wl_display, std::function<void(struct wl_display *)>>
+      d;
+   std::unique_ptr<struct registry> r;
 
    display();
    ~display();
@@ -63,11 +65,11 @@ struct display {
 // | | |  __/ (_| | \__ \ |_| |  | |_| |
 // |_|  \___|\__, |_|___/\__|_|   \__, |
 //           |___/                |___/
-struct registry : public wayland_proxy<wl_registry> {
-   typedef std::function<void(wl_registry *, uint32_t, uint32_t)> binder;
+struct registry : public wayland_proxy<struct wl_registry> {
+   typedef std::function<void(struct wl_registry *, uint32_t, uint32_t)> binder;
    std::map<std::string, binder> bindings;
 
-   registry(wl_display *d);
+   registry(struct wl_display *d);
    ~registry();
 
    void add_global_handler(char const *iface, binder bind);
@@ -83,8 +85,8 @@ struct registry : public wayland_proxy<wl_registry> {
 // | (_) | |_| | |_| |_) | |_| | |_
 //  \___/ \__,_|\__| .__/ \__,_|\__|
 //                 |_|
-struct output : wayland_proxy<wl_output> {
-   output(wl_registry *registry, uint32_t name, uint32_t version);
+struct output : wayland_proxy<struct wl_output> {
+   output(struct wl_registry *registry, uint32_t name, uint32_t version);
 
    // Events
    void geometry(int32_t x, int32_t y, int32_t pw, int32_t ph, int32_t subpel,
@@ -108,16 +110,57 @@ struct output : wayland_proxy<wl_output> {
 //  |___/
 namespace genivi {
 
+//
+//  _ __   __ _ _ __ ___   ___  ___ _ __   __ _  ___ ___
+// | '_ \ / _` | '_ ` _ \ / _ \/ __| '_ \ / _` |/ __/ _ \
+// | | | | (_| | | | | | |  __/\__ \ |_) | (_| | (_|  __/
+// |_| |_|\__,_|_| |_| |_|\___||___/ .__/ \__,_|\___\___|
+//                                 |_|
+//              _   _  __
+//  _ __   ___ | |_(_)/ _|_   _
+// | '_ \ / _ \| __| | |_| | | |
+// | | | | (_) | |_| |  _| |_| |
+// |_| |_|\___/ \__|_|_|  \__, |
+//                        |___/
+namespace notify {
+enum property {
+   Dimensions,  // i.e. configure
+   DestRect,
+   SrcRect,
+   ZOrder,
+   Vibility,
+   Opacity,
+   Layer,
+   Surface,
+   Content,
+   Orientation,
+   Screen,
+};
+
+template <typename ObjectT>
+struct notifier {
+   typedef std::function<void(enum property, ObjectT *)> ReceiverT;
+
+   std::vector<ReceiverT> receivers;
+
+   virtual ~notifier() {}
+
+   void add_receiver(ReceiverT);
+   void notify(enum property) const;
+};
+}
+
 //                  __
 //  ___ _   _ _ __ / _| __ _  ___ ___
 // / __| | | | '__| |_ / _` |/ __/ _ \
 // \__ \ |_| | |  |  _| (_| | (_|  __/
 // |___/\__,_|_|  |_|  \__,_|\___\___|
 //
-struct surface : public wayland_proxy<ivi_controller_surface> {
+struct surface : public wayland_proxy<struct ivi_controller_surface>,
+                 notify::notifier<struct surface> {
    uint32_t id;
 
-   surface(uint32_t i, ivi_controller *c);
+   surface(uint32_t i, struct ivi_controller *c);
    ~surface() override;
 
    // Events
@@ -134,6 +177,45 @@ struct surface : public wayland_proxy<ivi_controller_surface> {
               uint32_t update_count, uint32_t pid, const char *process_name);
    void destroyed();
    void content(int32_t content_state);
+
+   // Requests
+   inline void set_visibility(uint32_t visibility) {
+      ivi_controller_surface_set_visibility(this->proxy, visibility);
+   }
+
+   inline void set_opacity(wl_fixed_t opacity) {
+      ivi_controller_surface_set_opacity(this->proxy, opacity);
+   }
+
+   inline void set_source_rectangle(int32_t x, int32_t y, int32_t width,
+                                    int32_t height) {
+      ivi_controller_surface_set_source_rectangle(this->proxy, x, y, width,
+                                                  height);
+   }
+
+   inline void set_destination_rectangle(int32_t x, int32_t y, int32_t width,
+                                         int32_t height) {
+      ivi_controller_surface_set_destination_rectangle(this->proxy, x, y, width,
+                                                       height);
+   }
+
+   inline void set_configuration(int32_t width, int32_t height) {
+      ivi_controller_surface_set_configuration(this->proxy, width, height);
+   }
+
+   inline void set_orientation(int32_t orientation) {
+      ivi_controller_surface_set_orientation(this->proxy, orientation);
+   }
+
+   inline void screenshot(const char *filename) {
+      ivi_controller_surface_screenshot(this->proxy, filename);
+   }
+
+   inline void send_stats() { ivi_controller_surface_send_stats(this->proxy); }
+
+   inline void destroy(int32_t destroy_scene_object) {
+      ivi_controller_surface_destroy(this->proxy, destroy_scene_object);
+   }
 };
 
 //  _
@@ -142,10 +224,11 @@ struct surface : public wayland_proxy<ivi_controller_surface> {
 // | | (_| | |_| |  __/ |
 // |_|\__,_|\__, |\___|_|
 //          |___/
-struct layer : public wayland_proxy<ivi_controller_layer> {
+struct layer : public wayland_proxy<struct ivi_controller_layer>,
+                      notify::notifier<struct layer> {
    uint32_t id;
 
-   layer(uint32_t i, ivi_controller *c);
+   layer(uint32_t i, struct ivi_controller *c);
    ~layer() override;
 
    // Events
@@ -160,29 +243,65 @@ struct layer : public wayland_proxy<ivi_controller_layer> {
    void destroyed();
 
    // Requests
-   void set_visibility(uint32_t visibility);
-   void set_opacity(wl_fixed_t opacity);
-   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);
-   void set_configuration(int32_t width, int32_t height);
-   void set_orientation(int32_t orientation);
-   void screenshot(const char *filename);
-   void clear_surfaces();
-   void add_surface(struct surface *surface);
-   void remove_surface(struct surface *surface);
-   void set_render_order(struct wl_array *id_surfaces);
+   inline void set_visibility(uint32_t visibility) {
+      ivi_controller_layer_set_visibility(this->proxy, visibility);
+   }
+
+   inline void set_opacity(wl_fixed_t opacity) {
+      ivi_controller_layer_set_opacity(this->proxy, opacity);
+   }
+
+   inline void set_source_rectangle(int32_t x, int32_t y, int32_t width,
+                                    int32_t height) {
+      ivi_controller_layer_set_source_rectangle(this->proxy, x, y, width,
+                                                height);
+   }
+
+   inline void set_destination_rectangle(int32_t x, int32_t y, int32_t width,
+                                         int32_t height) {
+      ivi_controller_layer_set_destination_rectangle(this->proxy, x, y, width,
+                                                     height);
+   }
+
+   inline void set_configuration(int32_t width, int32_t height) {
+      ivi_controller_layer_set_configuration(this->proxy, width, height);
+   }
+
+   inline void set_orientation(int32_t orientation) {
+      ivi_controller_layer_set_orientation(this->proxy, orientation);
+   }
+
+   inline void screenshot(const char *filename) {
+      ivi_controller_layer_screenshot(this->proxy, filename);
+   }
+
+   inline void clear_surfaces() {
+      ivi_controller_layer_clear_surfaces(this->proxy);
+   }
+
+   inline void add_surface(struct surface *surface) {
+      ivi_controller_layer_add_surface(this->proxy, surface->proxy);
+   }
+
+   inline void remove_surface(struct surface *surface) {
+      ivi_controller_layer_remove_surface(this->proxy, surface->proxy);
+   }
+
+   inline void set_render_order(struct wl_array *surfaces) {
+      ivi_controller_layer_set_render_order(this->proxy, surfaces);
+   }
 };
 
 //
-// ___  ___ _ __ ___  ___ _ __
-/// __|/ __| '__/ _ \/ _ \ '_ \
-//\__ \ (__| | |  __/  __/ | | |
-//|___/\___|_|  \___|\___|_| |_|
+//  ___  ___ _ __ ___  ___ _ __
+// / __|/ __| '__/ _ \/ _ \ '_ \
+// \__ \ (__| | |  __/  __/ | | |
+// |___/\___|_|  \___|\___|_| |_|
 //
-struct screen : public wayland_proxy<ivi_controller_screen> {
+struct screen : public wayland_proxy<struct ivi_controller_screen> {
    uint32_t id;
 
-   screen(uint32_t i, ivi_controller_screen *p);
+   screen(uint32_t i, struct ivi_controller_screen *p);
 };
 
 //                  _             _ _
@@ -191,16 +310,16 @@ struct screen : public wayland_proxy<ivi_controller_screen> {
 // | (_| (_) | | | | |_| | | (_) | | |  __/ |
 //  \___\___/|_| |_|\__|_|  \___/|_|_|\___|_|
 //
-struct controller : public wayland_proxy<ivi_controller> {
-   std::map<uint32_t, std::unique_ptr<surface>> surfaces;
-   std::map<uint32_t, std::unique_ptr<layer>> layers;
-   std::map<uint32_t, std::unique_ptr<screen>> screens;
+struct controller : public wayland_proxy<struct ivi_controller> {
+   std::map<uint32_t, std::unique_ptr<struct surface>> surfaces;
+   std::map<uint32_t, std::unique_ptr<struct layer>> layers;
+   std::map<uint32_t, std::unique_ptr<struct screen>> screens;
 
-   controller(wl_registry *r, uint32_t name, uint32_t version);
+   controller(struct wl_registry *r, uint32_t name, uint32_t version);
    ~controller() override;
 
    // Events
-   void screen(uint32_t id, ivi_controller_screen *screen);
+   void screen(uint32_t id, struct ivi_controller_screen *screen);
    void layer(uint32_t id);
    void surface(uint32_t id);
    void error(int32_t oid, int32_t otype, int32_t code, char const *text);