Add APIs which can get information of display and area
[apps/agl-service-windowmanager.git] / src / wayland.cpp
1 /*
2  * Copyright (c) 2017 TOYOTA MOTOR CORPORATION
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include <utility>
18
19 #include "util.hpp"
20 #include "wayland.hpp"
21 #include "hmi-debug.h"
22
23 /**
24  * namespace wl
25  */
26 namespace wl {
27
28 /**
29  * display
30  */
31 display::display()
32    : d(std::unique_ptr<struct wl_display, void (*)(struct wl_display *)>(
33         wl_display_connect(nullptr), &wl_display_disconnect)),
34      r(d.get()) {}
35
36 bool display::ok() const { return d && wl_display_get_error(d.get()) == 0; }
37
38 void display::roundtrip() { wl_display_roundtrip(this->d.get()); }
39
40 int display::dispatch() { return wl_display_dispatch(this->d.get()); }
41
42 int display::dispatch_pending() { return wl_display_dispatch_pending(this->d.get()); }
43
44 int display::read_events() {
45    ST();
46    while (wl_display_prepare_read(this->d.get()) == -1) {
47       STN(pending_events_dispatch);
48       if (wl_display_dispatch_pending(this->d.get()) == -1) {
49          return -1;
50       }
51    }
52
53    if (wl_display_flush(this->d.get()) == -1) {
54       return -1;
55    }
56
57    if (wl_display_read_events(this->d.get()) == -1) {
58       wl_display_cancel_read(this->d.get());
59    }
60
61    return 0;
62 }
63
64 void display::flush() { wl_display_flush(this->d.get()); }
65
66 int display::get_fd() const { return wl_display_get_fd(this->d.get()); }
67
68 int display::get_error() { return wl_display_get_error(this->d.get()); }
69
70 /**
71  * registry
72  */
73 namespace {
74 void registry_global(void *data, struct wl_registry * /*r*/, uint32_t name,
75                      char const *iface, uint32_t v) {
76    static_cast<struct registry *>(data)->global(name, iface, v);
77 }
78
79 void registry_global_remove(void *data, struct wl_registry * /*r*/,
80                             uint32_t name) {
81    static_cast<struct registry *>(data)->global_remove(name);
82 }
83
84 constexpr struct wl_registry_listener registry_listener = {
85    registry_global, registry_global_remove};
86 }  // namespace
87
88 registry::registry(struct wl_display *d)
89    : wayland_proxy(d == nullptr ? nullptr : wl_display_get_registry(d)) {
90    if (this->proxy != nullptr) {
91       wl_registry_add_listener(this->proxy.get(), &registry_listener, this);
92    }
93 }
94
95 void registry::add_global_handler(char const *iface, binder bind) {
96    this->bindings[iface] = std::move(bind);
97 }
98
99 void registry::global(uint32_t name, char const *iface, uint32_t v) {
100    auto b = this->bindings.find(iface);
101    if (b != this->bindings.end()) {
102       b->second(this->proxy.get(), name, v);
103    }
104    HMI_DEBUG("wm", "wl::registry @ %p global n %u i %s v %u", this->proxy.get(), name,
105             iface, v);
106 }
107
108 void registry::global_remove(uint32_t /*name*/) {}
109
110 /**
111  * output
112  */
113 namespace {
114 void output_geometry(void *data, struct wl_output * /*wl_output*/, int32_t x,
115                      int32_t y, int32_t physical_width, int32_t physical_height,
116                      int32_t subpixel, const char *make, const char *model,
117                      int32_t transform) {
118    static_cast<struct output *>(data)->geometry(
119       x, y, physical_width, physical_height, subpixel, make, model, transform);
120 }
121
122 void output_mode(void *data, struct wl_output * /*wl_output*/, uint32_t flags,
123                  int32_t width, int32_t height, int32_t refresh) {
124    static_cast<struct output *>(data)->mode(flags, width, height, refresh);
125 }
126
127 void output_done(void *data, struct wl_output * /*wl_output*/) {
128    static_cast<struct output *>(data)->done();
129 }
130
131 void output_scale(void *data, struct wl_output * /*wl_output*/,
132                   int32_t factor) {
133    static_cast<struct output *>(data)->scale(factor);
134 }
135
136 constexpr struct wl_output_listener output_listener = {
137    output_geometry, output_mode, output_done, output_scale};
138 }  // namespace
139
140 output::output(struct wl_registry *r, uint32_t name, uint32_t v)
141    : wayland_proxy(wl_registry_bind(r, name, &wl_output_interface, v)) {
142    wl_output_add_listener(this->proxy.get(), &output_listener, this);
143 }
144
145 void output::geometry(int32_t x, int32_t y, int32_t pw, int32_t ph,
146                       int32_t subpel, char const *make, char const *model,
147                       int32_t tx) {
148    HMI_DEBUG("wm",
149       "wl::output %s @ %p x %i y %i w %i h %i spel %x make %s model %s tx %i",
150       __func__, this->proxy.get(), x, y, pw, ph, subpel, make, model, tx);
151    this->physical_width = pw;
152    this->physical_height = ph;
153    this->transform = tx;
154 }
155
156 void output::mode(uint32_t flags, int32_t w, int32_t h, int32_t r) {
157    HMI_DEBUG("wm", "wl::output %s @ %p f %x w %i h %i r %i", __func__,
158             this->proxy.get(), flags, w, h, r);
159    if ((flags & WL_OUTPUT_MODE_CURRENT) != 0u) {
160       this->width = w;
161       this->height = h;
162       this->refresh = r;
163    }
164 }
165
166 void output::done() {
167    HMI_DEBUG("wm", "wl::output %s @ %p done", __func__, this->proxy.get());
168    // Pivot and flipped
169    if (this->transform == WL_OUTPUT_TRANSFORM_90 ||
170        this->transform == WL_OUTPUT_TRANSFORM_270 ||
171        this->transform == WL_OUTPUT_TRANSFORM_FLIPPED_90 ||
172        this->transform == WL_OUTPUT_TRANSFORM_FLIPPED_270) {
173       std::swap(this->width, this->height);
174       std::swap(this->physical_width, this->physical_height);
175    }
176 }
177
178 void output::scale(int32_t factor) {
179    HMI_DEBUG("wm", "wl::output %s @ %p f %i", __func__, this->proxy.get(), factor);
180 }
181 }  // namespace wl
182
183 /**
184  * namespace compositor
185  */
186 namespace compositor {
187
188 /**
189  * controller
190  */
191 namespace {
192 void controller_screen(void *data, struct ivi_controller * /*ivi_controller*/,
193                        uint32_t id_screen,
194                        struct ivi_controller_screen *screen) {
195    static_cast<struct controller *>(data)->controller_screen(id_screen, screen);
196 }
197
198 void controller_layer(void *data, struct ivi_controller * /*ivi_controller*/,
199                       uint32_t id_layer) {
200    static_cast<struct controller *>(data)->controller_layer(id_layer);
201 }
202
203 void controller_surface(void *data, struct ivi_controller * /*ivi_controller*/,
204                         uint32_t id_surface) {
205    static_cast<struct controller *>(data)->controller_surface(id_surface);
206 }
207
208 void controller_error(void *data, struct ivi_controller * /*ivi_controller*/,
209                       int32_t object_id, int32_t object_type,
210                       int32_t error_code, const char *error_text) {
211    static_cast<struct controller *>(data)->controller_error(
212       object_id, object_type, error_code, error_text);
213 }
214
215 constexpr struct ivi_controller_listener listener = {
216    controller_screen, controller_layer, controller_surface, controller_error};
217 }  // namespace compositor
218
219 controller::controller(struct wl_registry *r, uint32_t name, uint32_t version)
220    : wayland_proxy(
221         wl_registry_bind(r, name, &ivi_controller_interface, version)),
222      output_size{} {
223    ivi_controller_add_listener(this->proxy.get(), &listener, this);
224 }
225
226 void controller::layer_create(uint32_t id, int32_t w, int32_t h) {
227    this->layers[id] = std::make_unique<struct layer>(id, w, h, this);
228 }
229
230 void controller::surface_create(uint32_t id) {
231    this->surfaces[id] = std::make_unique<struct surface>(id, this);
232 }
233
234 void controller::controller_screen(uint32_t id,
235                                    struct ivi_controller_screen *screen) {
236    HMI_DEBUG("wm", "compositor::controller @ %p screen %u (%x) @ %p", this->proxy.get(),
237             id, id, screen);
238    this->screens[id] = std::make_unique<struct screen>(id, this, screen);
239 }
240
241 void controller::controller_layer(uint32_t id) {
242    HMI_DEBUG("wm", "compositor::controller @ %p layer %u (%x)", this->proxy.get(), id, id);
243    if (this->layers.find(id) != this->layers.end()) {
244       HMI_DEBUG("wm", "WindowManager has created layer %u (%x) already", id, id);
245    } else {
246       auto &l = this->layers[id] = std::make_unique<struct layer>(id, this);
247       l->clear_surfaces();
248    }
249 }
250
251 void controller::controller_surface(uint32_t id) {
252    HMI_DEBUG("wm", "compositor::controller @ %p surface %u (%x)", this->proxy.get(), id,
253             id);
254    if (this->surfaces.find(id) == this->surfaces.end()) {
255       this->surfaces[id] = std::make_unique<struct surface>(id, this);
256       this->chooks->surface_created(id);
257    }
258 }
259
260 void controller::controller_error(int32_t object_id, int32_t object_type,
261                                   int32_t error_code, const char *error_text) {
262    HMI_DEBUG("wm", "compositor::controller @ %p error o %i t %i c %i text %s",
263             this->proxy.get(), object_id, object_type, error_code, error_text);
264 }
265
266 /**
267  * layer
268  */
269 namespace {
270 void layer_visibility(void *data,
271                       struct ivi_controller_layer * /*ivi_controller_layer*/,
272                       int32_t visibility) {
273    auto l = static_cast<struct layer *>(data);
274    l->parent->layer_visibility(l, visibility);
275 }
276
277 void layer_opacity(void *data,
278                    struct ivi_controller_layer * /*ivi_controller_layer*/,
279                    wl_fixed_t opacity) {
280    auto l = static_cast<struct layer *>(data);
281    l->parent->layer_opacity(l, float(wl_fixed_to_double(opacity)));
282 }
283
284 void layer_source_rectangle(
285    void *data, struct ivi_controller_layer * /*ivi_controller_layer*/,
286    int32_t x, int32_t y, int32_t width, int32_t height) {
287    auto l = static_cast<struct layer *>(data);
288    l->parent->layer_source_rectangle(l, x, y, width, height);
289 }
290
291 void layer_destination_rectangle(
292    void *data, struct ivi_controller_layer * /*ivi_controller_layer*/,
293    int32_t x, int32_t y, int32_t width, int32_t height) {
294    auto l = static_cast<struct layer *>(data);
295    l->parent->layer_destination_rectangle(l, x, y, width, height);
296 }
297
298 void layer_configuration(void *data,
299                          struct ivi_controller_layer * /*ivi_controller_layer*/,
300                          int32_t width, int32_t height) {
301    auto l = static_cast<struct layer *>(data);
302    l->parent->layer_configuration(l, width, height);
303 }
304
305 void layer_orientation(void *data,
306                        struct ivi_controller_layer * /*ivi_controller_layer*/,
307                        int32_t orientation) {
308    auto l = static_cast<struct layer *>(data);
309    l->parent->layer_orientation(l, orientation);
310 }
311
312 void layer_screen(void *data,
313                   struct ivi_controller_layer * /*ivi_controller_layer*/,
314                   struct wl_output *screen) {
315    auto l = static_cast<struct layer *>(data);
316    l->parent->layer_screen(l, screen);
317 }
318
319 void layer_destroyed(void *data,
320                      struct ivi_controller_layer * /*ivi_controller_layer*/) {
321    auto l = static_cast<struct layer *>(data);
322    l->parent->layer_destroyed(l);
323 }
324
325 constexpr struct ivi_controller_layer_listener layer_listener = {
326    layer_visibility,       layer_opacity,
327    layer_source_rectangle, layer_destination_rectangle,
328    layer_configuration,    layer_orientation,
329    layer_screen,           layer_destroyed,
330 };
331 }  // namespace
332
333 layer::layer(uint32_t i, struct controller *c) : layer(i, 0, 0, c) {}
334
335 layer::layer(uint32_t i, int32_t w, int32_t h, struct controller *c)
336    : wayland_proxy(ivi_controller_layer_create(c->proxy.get(), i, w, h),
337                    [c, i](ivi_controller_layer *l) {
338                       HMI_DEBUG("wm", "~layer layer %i @ %p", i, l);
339                       c->remove_proxy_to_id_mapping(l);
340                       ivi_controller_layer_destroy(l, 1);
341                    }),
342      controller_child(c, i) {
343    this->parent->add_proxy_to_id_mapping(this->proxy.get(), i);
344    ivi_controller_layer_add_listener(this->proxy.get(), &layer_listener, this);
345 }
346
347 void layer::set_visibility(uint32_t visibility) {
348    ivi_controller_layer_set_visibility(this->proxy.get(), visibility);
349 }
350
351 void layer::set_opacity(wl_fixed_t opacity) {
352    ivi_controller_layer_set_opacity(this->proxy.get(), opacity);
353 }
354
355 void layer::set_source_rectangle(int32_t x, int32_t y, int32_t width,
356                                  int32_t height) {
357    ivi_controller_layer_set_source_rectangle(this->proxy.get(), x, y, width,
358                                              height);
359 }
360
361 void layer::set_destination_rectangle(int32_t x, int32_t y, int32_t width,
362                                       int32_t height) {
363    ivi_controller_layer_set_destination_rectangle(this->proxy.get(), x, y,
364                                                   width, height);
365 }
366
367 void layer::set_configuration(int32_t width, int32_t height) {
368    ivi_controller_layer_set_configuration(this->proxy.get(), width, height);
369 }
370
371 void layer::set_orientation(int32_t orientation) {
372    ivi_controller_layer_set_orientation(this->proxy.get(), orientation);
373 }
374
375 void layer::screenshot(const char *filename) {
376    ivi_controller_layer_screenshot(this->proxy.get(), filename);
377 }
378
379 void layer::clear_surfaces() {
380    ivi_controller_layer_clear_surfaces(this->proxy.get());
381 }
382
383 void layer::add_surface(struct surface *surface) {
384    ivi_controller_layer_add_surface(this->proxy.get(), surface->proxy.get());
385 }
386
387 void layer::remove_surface(struct surface *surface) {
388    ivi_controller_layer_remove_surface(this->proxy.get(), surface->proxy.get());
389 }
390
391 void layer::set_render_order(std::vector<uint32_t> const &ro) {
392    struct wl_array wlro {
393       .size = ro.size() * sizeof(ro[0]), .alloc = ro.capacity() * sizeof(ro[0]),
394       .data = const_cast<void *>(static_cast<void const *>(ro.data()))
395    };
396    ivi_controller_layer_set_render_order(this->proxy.get(), &wlro);
397 }
398
399 void controller::layer_visibility(struct layer *l, int32_t visibility) {
400    HMI_DEBUG("wm", "compositor::layer %s @ %d v %i", __func__, l->id, visibility);
401    this->lprops[l->id].visibility = visibility;
402 }
403
404 void controller::layer_opacity(struct layer *l, float opacity) {
405    HMI_DEBUG("wm", "compositor::layer %s @ %d o %f", __func__, l->id, opacity);
406    this->lprops[l->id].opacity = opacity;
407 }
408
409 void controller::layer_source_rectangle(struct layer *l, int32_t x, int32_t y,
410                                         int32_t width, int32_t height) {
411    HMI_DEBUG("wm", "compositor::layer %s @ %d x %i y %i w %i h %i", __func__,
412             l->id, x, y, width, height);
413    this->lprops[l->id].src_rect = rect{width, height, x, y};
414 }
415
416 void controller::layer_destination_rectangle(struct layer *l, int32_t x,
417                                              int32_t y, int32_t width,
418                                              int32_t height) {
419    HMI_DEBUG("wm", "compositor::layer %s @ %d x %i y %i w %i h %i", __func__,
420             l->id, x, y, width, height);
421    this->lprops[l->id].dst_rect = rect{width, height, x, y};
422 }
423
424 void controller::layer_configuration(struct layer *l, int32_t width,
425                                      int32_t height) {
426    HMI_DEBUG("wm", "compositor::layer %s @ %d w %i h %i", __func__, l->id,
427             width, height);
428    this->lprops[l->id].size = size{uint32_t(width), uint32_t(height)};
429 }
430
431 void controller::layer_orientation(struct layer *l, int32_t orientation) {
432    HMI_DEBUG("wm", "compositor::layer %s @ %d o %i", __func__, l->id,
433             orientation);
434    this->lprops[l->id].orientation = orientation;
435 }
436
437 void controller::layer_screen(struct layer *l, struct wl_output *screen) {
438    HMI_DEBUG("wm", "compositor::layer %s @ %d s %p", __func__, l->id, screen);
439 }
440
441 void controller::layer_destroyed(struct layer *l) {
442    HMI_DEBUG("wm", "compositor::layer %s @ %d", __func__, l->id);
443    this->lprops.erase(l->id);
444    this->layers.erase(l->id);
445 }
446
447 /**
448  * surface
449  */
450 namespace {
451
452 void surface_visibility(
453    void *data, struct ivi_controller_surface * /*ivi_controller_surface*/,
454    int32_t visibility) {
455    auto s = static_cast<struct surface *>(data);
456    s->parent->surface_visibility(s, visibility);
457 }
458
459 void surface_opacity(void *data,
460                      struct ivi_controller_surface * /*ivi_controller_surface*/,
461                      wl_fixed_t opacity) {
462    auto s = static_cast<struct surface *>(data);
463    s->parent->surface_opacity(s, float(wl_fixed_to_double(opacity)));
464 }
465
466 void surface_source_rectangle(
467    void *data, struct ivi_controller_surface * /*ivi_controller_surface*/,
468    int32_t x, int32_t y, int32_t width, int32_t height) {
469    auto s = static_cast<struct surface *>(data);
470    s->parent->surface_source_rectangle(s, x, y, width, height);
471 }
472
473 void surface_destination_rectangle(
474    void *data, struct ivi_controller_surface * /*ivi_controller_surface*/,
475    int32_t x, int32_t y, int32_t width, int32_t height) {
476    auto s = static_cast<struct surface *>(data);
477    s->parent->surface_destination_rectangle(s, x, y, width, height);
478 }
479
480 void surface_configuration(
481    void *data, struct ivi_controller_surface * /*ivi_controller_surface*/,
482    int32_t width, int32_t height) {
483    auto s = static_cast<struct surface *>(data);
484    s->parent->surface_configuration(s, width, height);
485 }
486
487 void surface_orientation(
488    void *data, struct ivi_controller_surface * /*ivi_controller_surface*/,
489    int32_t orientation) {
490    auto s = static_cast<struct surface *>(data);
491    s->parent->surface_orientation(s, orientation);
492 }
493
494 void surface_pixelformat(
495    void *data, struct ivi_controller_surface * /*ivi_controller_surface*/,
496    int32_t pixelformat) {
497    auto s = static_cast<struct surface *>(data);
498    s->parent->surface_pixelformat(s, pixelformat);
499 }
500
501 void surface_layer(void *data,
502                    struct ivi_controller_surface * /*ivi_controller_surface*/,
503                    struct ivi_controller_layer *layer) {
504    auto s = static_cast<struct surface *>(data);
505    s->parent->surface_layer(s, layer);
506 }
507
508 void surface_stats(void *data,
509                    struct ivi_controller_surface * /*ivi_controller_surface*/,
510                    uint32_t redraw_count, uint32_t frame_count,
511                    uint32_t update_count, uint32_t pid,
512                    const char *process_name) {
513    auto s = static_cast<struct surface *>(data);
514    s->parent->surface_stats(s, redraw_count, frame_count, update_count, pid,
515                             process_name);
516 }
517
518 void surface_destroyed(
519    void *data, struct ivi_controller_surface * /*ivi_controller_surface*/) {
520    auto s = static_cast<struct surface *>(data);
521    s->parent->surface_destroyed(s);
522 }
523
524 void surface_content(void *data,
525                      struct ivi_controller_surface * /*ivi_controller_surface*/,
526                      int32_t content_state) {
527    auto s = static_cast<struct surface *>(data);
528    s->parent->surface_content(s, content_state);
529 }
530
531 constexpr struct ivi_controller_surface_listener surface_listener = {
532    surface_visibility,
533    surface_opacity,
534    surface_source_rectangle,
535    surface_destination_rectangle,
536    surface_configuration,
537    surface_orientation,
538    surface_pixelformat,
539    surface_layer,
540    surface_stats,
541    surface_destroyed,
542    surface_content,
543 };
544 }  // namespace
545
546 surface::surface(uint32_t i, struct controller *c)
547    : wayland_proxy(ivi_controller_surface_create(c->proxy.get(), i),
548                    [c, i](ivi_controller_surface *s) {
549                       HMI_DEBUG("wm", "~surface surface %i @ %p", i, s);
550                       c->remove_proxy_to_id_mapping(s);
551                       ivi_controller_surface_destroy(s, 1);
552                    }),
553      controller_child(c, i) {
554    this->parent->add_proxy_to_id_mapping(this->proxy.get(), i);
555    ivi_controller_surface_add_listener(this->proxy.get(), &surface_listener,
556                                        this);
557 }
558
559 void surface::set_visibility(uint32_t visibility) {
560    ivi_controller_surface_set_visibility(this->proxy.get(), visibility);
561 }
562
563 void surface::set_opacity(wl_fixed_t opacity) {
564    ivi_controller_surface_set_opacity(this->proxy.get(), opacity);
565 }
566
567 void surface::set_source_rectangle(int32_t x, int32_t y, int32_t width,
568                                    int32_t height) {
569    ivi_controller_surface_set_source_rectangle(this->proxy.get(), x, y, width,
570                                                height);
571 }
572
573 void surface::set_destination_rectangle(int32_t x, int32_t y, int32_t width,
574                                         int32_t height) {
575    ivi_controller_surface_set_destination_rectangle(this->proxy.get(), x, y,
576                                                     width, height);
577 }
578
579 void surface::set_configuration(int32_t width, int32_t height) {
580    ivi_controller_surface_set_configuration(this->proxy.get(), width, height);
581 }
582
583 void surface::set_orientation(int32_t orientation) {
584    ivi_controller_surface_set_orientation(this->proxy.get(), orientation);
585 }
586
587 void surface::screenshot(const char *filename) {
588    ivi_controller_surface_screenshot(this->proxy.get(), filename);
589 }
590
591 void surface::send_stats() {
592    ivi_controller_surface_send_stats(this->proxy.get());
593 }
594
595 void surface::destroy(int32_t destroy_scene_object) {
596    ivi_controller_surface_destroy(this->proxy.get(), destroy_scene_object);
597 }
598
599 void controller::surface_visibility(struct surface *s, int32_t visibility) {
600    HMI_DEBUG("wm", "compositor::surface %s @ %d v %i", __func__, s->id,
601             visibility);
602    this->sprops[s->id].visibility = visibility;
603    this->chooks->surface_visibility(s->id, visibility);
604 }
605
606 void controller::surface_opacity(struct surface *s, float opacity) {
607    HMI_DEBUG("wm", "compositor::surface %s @ %d o %f", __func__, s->id,
608             opacity);
609    this->sprops[s->id].opacity = opacity;
610 }
611
612 void controller::surface_source_rectangle(struct surface *s, int32_t x,
613                                           int32_t y, int32_t width,
614                                           int32_t height) {
615    HMI_DEBUG("wm", "compositor::surface %s @ %d x %i y %i w %i h %i", __func__,
616             s->id, x, y, width, height);
617    this->sprops[s->id].src_rect = rect{width, height, x, y};
618 }
619
620 void controller::surface_destination_rectangle(struct surface *s, int32_t x,
621                                                int32_t y, int32_t width,
622                                                int32_t height) {
623    HMI_DEBUG("wm", "compositor::surface %s @ %d x %i y %i w %i h %i", __func__,
624             s->id, x, y, width, height);
625    this->sprops[s->id].dst_rect = rect{width, height, x, y};
626    this->chooks->surface_destination_rectangle(s->id, x, y, width, height);
627 }
628
629 void controller::surface_configuration(struct surface *s, int32_t width,
630                                        int32_t height) {
631    HMI_DEBUG("wm", "compositor::surface %s @ %d w %i h %i", __func__, s->id,
632             width, height);
633    this->sprops[s->id].size = size{uint32_t(width), uint32_t(height)};
634    is_configured = true;
635 }
636
637 void controller::surface_orientation(struct surface *s, int32_t orientation) {
638    HMI_DEBUG("wm", "compositor::surface %s @ %d o %i", __func__, s->id,
639             orientation);
640    this->sprops[s->id].orientation = orientation;
641 }
642
643 void controller::surface_pixelformat(struct surface * s,
644                                      int32_t pixelformat) {
645    HMI_DEBUG("wm", "compositor::surface %s @ %d f %i", __func__, s->id,
646             pixelformat);
647 }
648
649 void controller::surface_layer(struct surface * s,
650                                struct ivi_controller_layer *layer) {
651    HMI_DEBUG("wm", "compositor::surface %s @ %d l %u @ %p", __func__, s->id,
652             this->layer_proxy_to_id[uintptr_t(layer)], layer);
653 }
654
655 void controller::surface_stats(struct surface *s, uint32_t redraw_count,
656                                uint32_t frame_count, uint32_t update_count,
657                                uint32_t pid, const char *process_name) {
658    HMI_DEBUG("wm", "compositor::surface %s @ %d r %u f %u u %u pid %u p %s", __func__,
659             s->id, redraw_count, frame_count, update_count, pid,
660             process_name);
661 }
662
663 void controller::surface_destroyed(struct surface *s) {
664    HMI_DEBUG("wm", "compositor::surface %s @ %d", __func__, s->id);
665    this->chooks->surface_removed(s->id);
666    this->sprops.erase(s->id);
667    this->surfaces.erase(s->id);
668 }
669
670 void controller::surface_content(struct surface *s, int32_t content_state) {
671    HMI_DEBUG("wm", "compositor::surface %s @ %d s %i", __func__, s->id,
672             content_state);
673    if (content_state == IVI_CONTROLLER_SURFACE_CONTENT_STATE_CONTENT_REMOVED) {
674       this->chooks->surface_removed(s->id);
675       this->sprops.erase(s->id);
676       this->surfaces.erase(s->id);
677    }
678 }
679
680 void controller::add_proxy_to_id_mapping(struct ivi_controller_surface *p,
681                                          uint32_t id) {
682    HMI_DEBUG("wm", "Add surface proxy mapping for %p (%u)", p, id);
683    this->surface_proxy_to_id[uintptr_t(p)] = id;
684    this->sprops[id].id = id;
685 }
686
687 void controller::remove_proxy_to_id_mapping(struct ivi_controller_surface *p) {
688    HMI_DEBUG("wm", "Remove surface proxy mapping for %p", p);
689    this->surface_proxy_to_id.erase(uintptr_t(p));
690 }
691
692 void controller::add_proxy_to_id_mapping(struct ivi_controller_layer *p,
693                                          uint32_t id) {
694    HMI_DEBUG("wm", "Add layer proxy mapping for %p (%u)", p, id);
695    this->layer_proxy_to_id[uintptr_t(p)] = id;
696    this->lprops[id].id = id;
697 }
698
699 void controller::remove_proxy_to_id_mapping(struct ivi_controller_layer *p) {
700    HMI_DEBUG("wm", "Remove layer proxy mapping for %p", p);
701    this->layer_proxy_to_id.erase(uintptr_t(p));
702 }
703
704 void controller::add_proxy_to_id_mapping(struct wl_output *p, uint32_t id) {
705    HMI_DEBUG("wm", "Add screen proxy mapping for %p (%u)", p, id);
706    this->screen_proxy_to_id[uintptr_t(p)] = id;
707 }
708
709 void controller::remove_proxy_to_id_mapping(struct wl_output *p) {
710    HMI_DEBUG("wm", "Remove screen proxy mapping for %p", p);
711    this->screen_proxy_to_id.erase(uintptr_t(p));
712 }
713
714 /**
715  * screen
716  */
717 screen::screen(uint32_t i, struct controller *c,
718                struct ivi_controller_screen *p)
719    : wayland_proxy(p), controller_child(c, i) {
720    HMI_DEBUG("wm", "compositor::screen @ %p id %u", p, i);
721 }
722
723 void screen::clear() { ivi_controller_screen_clear(this->proxy.get()); }
724
725 void screen::add_layer(layer *l) {
726    ivi_controller_screen_add_layer(this->proxy.get(), l->proxy.get());
727 }
728
729 void screen::set_render_order(std::vector<uint32_t> const &ro) {
730    struct wl_array wlro {
731       .size = ro.size() * sizeof(ro[0]), .alloc = ro.capacity() * sizeof(ro[0]),
732       .data = const_cast<void *>(static_cast<void const *>(ro.data()))
733    };
734    ivi_controller_screen_set_render_order(this->proxy.get(), &wlro);
735 }
736
737 }  // namespace compositor