Wayland++  1.0.0
C++ Bindings for Wayland
wayland-server-protocol-extra.cpp
1 #include <wayland-server-protocol-extra.hpp>
2 
3 using namespace wayland;
4 using namespace wayland::detail;
5 using namespace wayland::server;
6 using namespace wayland::server::detail;
7 
8 const wl_interface* presentation_interface_destroy_request_server[0] = {
9 };
10 
11 const wl_interface* presentation_interface_feedback_request_server[2] = {
12  &surface_interface,
13  &presentation_feedback_interface,
14 };
15 
16 const wl_interface* presentation_interface_clock_id_event_server[1] = {
17  nullptr,
18 };
19 
20 const wl_message presentation_interface_requests_server[2] = {
21  {
22  "destroy",
23  "",
24  presentation_interface_destroy_request_server,
25  },
26  {
27  "feedback",
28  "on",
29  presentation_interface_feedback_request_server,
30  },
31 };
32 
33 const wl_message presentation_interface_events_server[1] = {
34  {
35  "clock_id",
36  "u",
37  presentation_interface_clock_id_event_server,
38  },
39 };
40 
41 const wl_interface wayland::server::detail::presentation_interface =
42  {
43  "wp_presentation",
44  1,
45  2,
46  presentation_interface_requests_server,
47  1,
48  presentation_interface_events_server,
49  };
50 
51 const wl_interface* presentation_feedback_interface_sync_output_event_server[1] = {
52  &output_interface,
53 };
54 
55 const wl_interface* presentation_feedback_interface_presented_event_server[7] = {
56  nullptr,
57  nullptr,
58  nullptr,
59  nullptr,
60  nullptr,
61  nullptr,
62  nullptr,
63 };
64 
65 const wl_interface* presentation_feedback_interface_discarded_event_server[0] = {
66 };
67 
68 const wl_message presentation_feedback_interface_requests_server[0] = {
69 };
70 
71 const wl_message presentation_feedback_interface_events_server[3] = {
72  {
73  "sync_output",
74  "o",
75  presentation_feedback_interface_sync_output_event_server,
76  },
77  {
78  "presented",
79  "uuuuuuu",
80  presentation_feedback_interface_presented_event_server,
81  },
82  {
83  "discarded",
84  "",
85  presentation_feedback_interface_discarded_event_server,
86  },
87 };
88 
89 const wl_interface wayland::server::detail::presentation_feedback_interface =
90  {
91  "wp_presentation_feedback",
92  1,
93  0,
94  presentation_feedback_interface_requests_server,
95  3,
96  presentation_feedback_interface_events_server,
97  };
98 
99 const wl_interface* viewporter_interface_destroy_request_server[0] = {
100 };
101 
102 const wl_interface* viewporter_interface_get_viewport_request_server[2] = {
103  &viewport_interface,
104  &surface_interface,
105 };
106 
107 const wl_message viewporter_interface_requests_server[2] = {
108  {
109  "destroy",
110  "",
111  viewporter_interface_destroy_request_server,
112  },
113  {
114  "get_viewport",
115  "no",
116  viewporter_interface_get_viewport_request_server,
117  },
118 };
119 
120 const wl_message viewporter_interface_events_server[0] = {
121 };
122 
123 const wl_interface wayland::server::detail::viewporter_interface =
124  {
125  "wp_viewporter",
126  1,
127  2,
128  viewporter_interface_requests_server,
129  0,
130  viewporter_interface_events_server,
131  };
132 
133 const wl_interface* viewport_interface_destroy_request_server[0] = {
134 };
135 
136 const wl_interface* viewport_interface_set_source_request_server[4] = {
137  nullptr,
138  nullptr,
139  nullptr,
140  nullptr,
141 };
142 
143 const wl_interface* viewport_interface_set_destination_request_server[2] = {
144  nullptr,
145  nullptr,
146 };
147 
148 const wl_message viewport_interface_requests_server[3] = {
149  {
150  "destroy",
151  "",
152  viewport_interface_destroy_request_server,
153  },
154  {
155  "set_source",
156  "ffff",
157  viewport_interface_set_source_request_server,
158  },
159  {
160  "set_destination",
161  "ii",
162  viewport_interface_set_destination_request_server,
163  },
164 };
165 
166 const wl_message viewport_interface_events_server[0] = {
167 };
168 
169 const wl_interface wayland::server::detail::viewport_interface =
170  {
171  "wp_viewport",
172  1,
173  3,
174  viewport_interface_requests_server,
175  0,
176  viewport_interface_events_server,
177  };
178 
179 const wl_interface* xdg_wm_base_interface_destroy_request_server[0] = {
180 };
181 
182 const wl_interface* xdg_wm_base_interface_create_positioner_request_server[1] = {
183  &xdg_positioner_interface,
184 };
185 
186 const wl_interface* xdg_wm_base_interface_get_xdg_surface_request_server[2] = {
187  &xdg_surface_interface,
188  &surface_interface,
189 };
190 
191 const wl_interface* xdg_wm_base_interface_pong_request_server[1] = {
192  nullptr,
193 };
194 
195 const wl_interface* xdg_wm_base_interface_ping_event_server[1] = {
196  nullptr,
197 };
198 
199 const wl_message xdg_wm_base_interface_requests_server[4] = {
200  {
201  "destroy",
202  "",
203  xdg_wm_base_interface_destroy_request_server,
204  },
205  {
206  "create_positioner",
207  "n",
208  xdg_wm_base_interface_create_positioner_request_server,
209  },
210  {
211  "get_xdg_surface",
212  "no",
213  xdg_wm_base_interface_get_xdg_surface_request_server,
214  },
215  {
216  "pong",
217  "u",
218  xdg_wm_base_interface_pong_request_server,
219  },
220 };
221 
222 const wl_message xdg_wm_base_interface_events_server[1] = {
223  {
224  "ping",
225  "u",
226  xdg_wm_base_interface_ping_event_server,
227  },
228 };
229 
230 const wl_interface wayland::server::detail::xdg_wm_base_interface =
231  {
232  "xdg_wm_base",
233  4,
234  4,
235  xdg_wm_base_interface_requests_server,
236  1,
237  xdg_wm_base_interface_events_server,
238  };
239 
240 const wl_interface* xdg_positioner_interface_destroy_request_server[0] = {
241 };
242 
243 const wl_interface* xdg_positioner_interface_set_size_request_server[2] = {
244  nullptr,
245  nullptr,
246 };
247 
248 const wl_interface* xdg_positioner_interface_set_anchor_rect_request_server[4] = {
249  nullptr,
250  nullptr,
251  nullptr,
252  nullptr,
253 };
254 
255 const wl_interface* xdg_positioner_interface_set_anchor_request_server[1] = {
256  nullptr,
257 };
258 
259 const wl_interface* xdg_positioner_interface_set_gravity_request_server[1] = {
260  nullptr,
261 };
262 
263 const wl_interface* xdg_positioner_interface_set_constraint_adjustment_request_server[1] = {
264  nullptr,
265 };
266 
267 const wl_interface* xdg_positioner_interface_set_offset_request_server[2] = {
268  nullptr,
269  nullptr,
270 };
271 
272 const wl_interface* xdg_positioner_interface_set_reactive_request_server[0] = {
273 };
274 
275 const wl_interface* xdg_positioner_interface_set_parent_size_request_server[2] = {
276  nullptr,
277  nullptr,
278 };
279 
280 const wl_interface* xdg_positioner_interface_set_parent_configure_request_server[1] = {
281  nullptr,
282 };
283 
284 const wl_message xdg_positioner_interface_requests_server[10] = {
285  {
286  "destroy",
287  "",
288  xdg_positioner_interface_destroy_request_server,
289  },
290  {
291  "set_size",
292  "ii",
293  xdg_positioner_interface_set_size_request_server,
294  },
295  {
296  "set_anchor_rect",
297  "iiii",
298  xdg_positioner_interface_set_anchor_rect_request_server,
299  },
300  {
301  "set_anchor",
302  "u",
303  xdg_positioner_interface_set_anchor_request_server,
304  },
305  {
306  "set_gravity",
307  "u",
308  xdg_positioner_interface_set_gravity_request_server,
309  },
310  {
311  "set_constraint_adjustment",
312  "u",
313  xdg_positioner_interface_set_constraint_adjustment_request_server,
314  },
315  {
316  "set_offset",
317  "ii",
318  xdg_positioner_interface_set_offset_request_server,
319  },
320  {
321  "set_reactive",
322  "3",
323  xdg_positioner_interface_set_reactive_request_server,
324  },
325  {
326  "set_parent_size",
327  "3ii",
328  xdg_positioner_interface_set_parent_size_request_server,
329  },
330  {
331  "set_parent_configure",
332  "3u",
333  xdg_positioner_interface_set_parent_configure_request_server,
334  },
335 };
336 
337 const wl_message xdg_positioner_interface_events_server[0] = {
338 };
339 
340 const wl_interface wayland::server::detail::xdg_positioner_interface =
341  {
342  "xdg_positioner",
343  4,
344  10,
345  xdg_positioner_interface_requests_server,
346  0,
347  xdg_positioner_interface_events_server,
348  };
349 
350 const wl_interface* xdg_surface_interface_destroy_request_server[0] = {
351 };
352 
353 const wl_interface* xdg_surface_interface_get_toplevel_request_server[1] = {
354  &xdg_toplevel_interface,
355 };
356 
357 const wl_interface* xdg_surface_interface_get_popup_request_server[3] = {
358  &xdg_popup_interface,
359  &xdg_surface_interface,
360  &xdg_positioner_interface,
361 };
362 
363 const wl_interface* xdg_surface_interface_set_window_geometry_request_server[4] = {
364  nullptr,
365  nullptr,
366  nullptr,
367  nullptr,
368 };
369 
370 const wl_interface* xdg_surface_interface_ack_configure_request_server[1] = {
371  nullptr,
372 };
373 
374 const wl_interface* xdg_surface_interface_configure_event_server[1] = {
375  nullptr,
376 };
377 
378 const wl_message xdg_surface_interface_requests_server[5] = {
379  {
380  "destroy",
381  "",
382  xdg_surface_interface_destroy_request_server,
383  },
384  {
385  "get_toplevel",
386  "n",
387  xdg_surface_interface_get_toplevel_request_server,
388  },
389  {
390  "get_popup",
391  "n?oo",
392  xdg_surface_interface_get_popup_request_server,
393  },
394  {
395  "set_window_geometry",
396  "iiii",
397  xdg_surface_interface_set_window_geometry_request_server,
398  },
399  {
400  "ack_configure",
401  "u",
402  xdg_surface_interface_ack_configure_request_server,
403  },
404 };
405 
406 const wl_message xdg_surface_interface_events_server[1] = {
407  {
408  "configure",
409  "u",
410  xdg_surface_interface_configure_event_server,
411  },
412 };
413 
414 const wl_interface wayland::server::detail::xdg_surface_interface =
415  {
416  "xdg_surface",
417  4,
418  5,
419  xdg_surface_interface_requests_server,
420  1,
421  xdg_surface_interface_events_server,
422  };
423 
424 const wl_interface* xdg_toplevel_interface_destroy_request_server[0] = {
425 };
426 
427 const wl_interface* xdg_toplevel_interface_set_parent_request_server[1] = {
428  &xdg_toplevel_interface,
429 };
430 
431 const wl_interface* xdg_toplevel_interface_set_title_request_server[1] = {
432  nullptr,
433 };
434 
435 const wl_interface* xdg_toplevel_interface_set_app_id_request_server[1] = {
436  nullptr,
437 };
438 
439 const wl_interface* xdg_toplevel_interface_show_window_menu_request_server[4] = {
440  &seat_interface,
441  nullptr,
442  nullptr,
443  nullptr,
444 };
445 
446 const wl_interface* xdg_toplevel_interface_move_request_server[2] = {
447  &seat_interface,
448  nullptr,
449 };
450 
451 const wl_interface* xdg_toplevel_interface_resize_request_server[3] = {
452  &seat_interface,
453  nullptr,
454  nullptr,
455 };
456 
457 const wl_interface* xdg_toplevel_interface_set_max_size_request_server[2] = {
458  nullptr,
459  nullptr,
460 };
461 
462 const wl_interface* xdg_toplevel_interface_set_min_size_request_server[2] = {
463  nullptr,
464  nullptr,
465 };
466 
467 const wl_interface* xdg_toplevel_interface_set_maximized_request_server[0] = {
468 };
469 
470 const wl_interface* xdg_toplevel_interface_unset_maximized_request_server[0] = {
471 };
472 
473 const wl_interface* xdg_toplevel_interface_set_fullscreen_request_server[1] = {
474  &output_interface,
475 };
476 
477 const wl_interface* xdg_toplevel_interface_unset_fullscreen_request_server[0] = {
478 };
479 
480 const wl_interface* xdg_toplevel_interface_set_minimized_request_server[0] = {
481 };
482 
483 const wl_interface* xdg_toplevel_interface_configure_event_server[3] = {
484  nullptr,
485  nullptr,
486  nullptr,
487 };
488 
489 const wl_interface* xdg_toplevel_interface_close_event_server[0] = {
490 };
491 
492 const wl_interface* xdg_toplevel_interface_configure_bounds_event_server[2] = {
493  nullptr,
494  nullptr,
495 };
496 
497 const wl_message xdg_toplevel_interface_requests_server[14] = {
498  {
499  "destroy",
500  "",
501  xdg_toplevel_interface_destroy_request_server,
502  },
503  {
504  "set_parent",
505  "?o",
506  xdg_toplevel_interface_set_parent_request_server,
507  },
508  {
509  "set_title",
510  "s",
511  xdg_toplevel_interface_set_title_request_server,
512  },
513  {
514  "set_app_id",
515  "s",
516  xdg_toplevel_interface_set_app_id_request_server,
517  },
518  {
519  "show_window_menu",
520  "ouii",
521  xdg_toplevel_interface_show_window_menu_request_server,
522  },
523  {
524  "move",
525  "ou",
526  xdg_toplevel_interface_move_request_server,
527  },
528  {
529  "resize",
530  "ouu",
531  xdg_toplevel_interface_resize_request_server,
532  },
533  {
534  "set_max_size",
535  "ii",
536  xdg_toplevel_interface_set_max_size_request_server,
537  },
538  {
539  "set_min_size",
540  "ii",
541  xdg_toplevel_interface_set_min_size_request_server,
542  },
543  {
544  "set_maximized",
545  "",
546  xdg_toplevel_interface_set_maximized_request_server,
547  },
548  {
549  "unset_maximized",
550  "",
551  xdg_toplevel_interface_unset_maximized_request_server,
552  },
553  {
554  "set_fullscreen",
555  "?o",
556  xdg_toplevel_interface_set_fullscreen_request_server,
557  },
558  {
559  "unset_fullscreen",
560  "",
561  xdg_toplevel_interface_unset_fullscreen_request_server,
562  },
563  {
564  "set_minimized",
565  "",
566  xdg_toplevel_interface_set_minimized_request_server,
567  },
568 };
569 
570 const wl_message xdg_toplevel_interface_events_server[3] = {
571  {
572  "configure",
573  "iia",
574  xdg_toplevel_interface_configure_event_server,
575  },
576  {
577  "close",
578  "",
579  xdg_toplevel_interface_close_event_server,
580  },
581  {
582  "configure_bounds",
583  "4ii",
584  xdg_toplevel_interface_configure_bounds_event_server,
585  },
586 };
587 
588 const wl_interface wayland::server::detail::xdg_toplevel_interface =
589  {
590  "xdg_toplevel",
591  4,
592  14,
593  xdg_toplevel_interface_requests_server,
594  3,
595  xdg_toplevel_interface_events_server,
596  };
597 
598 const wl_interface* xdg_popup_interface_destroy_request_server[0] = {
599 };
600 
601 const wl_interface* xdg_popup_interface_grab_request_server[2] = {
602  &seat_interface,
603  nullptr,
604 };
605 
606 const wl_interface* xdg_popup_interface_reposition_request_server[2] = {
607  &xdg_positioner_interface,
608  nullptr,
609 };
610 
611 const wl_interface* xdg_popup_interface_configure_event_server[4] = {
612  nullptr,
613  nullptr,
614  nullptr,
615  nullptr,
616 };
617 
618 const wl_interface* xdg_popup_interface_popup_done_event_server[0] = {
619 };
620 
621 const wl_interface* xdg_popup_interface_repositioned_event_server[1] = {
622  nullptr,
623 };
624 
625 const wl_message xdg_popup_interface_requests_server[3] = {
626  {
627  "destroy",
628  "",
629  xdg_popup_interface_destroy_request_server,
630  },
631  {
632  "grab",
633  "ou",
634  xdg_popup_interface_grab_request_server,
635  },
636  {
637  "reposition",
638  "3ou",
639  xdg_popup_interface_reposition_request_server,
640  },
641 };
642 
643 const wl_message xdg_popup_interface_events_server[3] = {
644  {
645  "configure",
646  "iiii",
647  xdg_popup_interface_configure_event_server,
648  },
649  {
650  "popup_done",
651  "",
652  xdg_popup_interface_popup_done_event_server,
653  },
654  {
655  "repositioned",
656  "3u",
657  xdg_popup_interface_repositioned_event_server,
658  },
659 };
660 
661 const wl_interface wayland::server::detail::xdg_popup_interface =
662  {
663  "xdg_popup",
664  4,
665  3,
666  xdg_popup_interface_requests_server,
667  3,
668  xdg_popup_interface_events_server,
669  };
670 
671 presentation_t::presentation_t(const client_t& client, uint32_t id, int version)
672  : resource_t(client, &server::detail::presentation_interface, id, version)
673 {
674  set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
675 }
676 
677 presentation_t::presentation_t(const resource_t &resource)
678  : resource_t(resource)
679 {
680  set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
681 }
682 
683 const std::string presentation_t::interface_name = "wp_presentation";
684 
685 presentation_t::operator wp_presentation*() const
686 {
687  return reinterpret_cast<wp_presentation*> (c_ptr());
688 }
689 
690 std::function<void()> &presentation_t::on_destroy()
691 {
692  return std::static_pointer_cast<events_t>(get_events())->destroy;
693 }
694 
695 
696 std::function<void(surface_t, presentation_feedback_t)> &presentation_t::on_feedback()
697 {
698  return std::static_pointer_cast<events_t>(get_events())->feedback;
699 }
700 
701 
702 void presentation_t::clock_id(uint32_t clk_id, bool post)
703 {
704  send_event(post, 0, clk_id);
705 }
706 
707 void presentation_t::post_invalid_timestamp(std::string const& msg)
708 {
709  post_error(static_cast<uint32_t>(presentation_error::invalid_timestamp), msg);
710 }
711 
712 void presentation_t::post_invalid_flag(std::string const& msg)
713 {
714  post_error(static_cast<uint32_t>(presentation_error::invalid_flag), msg);
715 }
716 
717 int presentation_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
718 {
719  std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
720  switch(opcode)
721  {
722  case 0:
723  if(events->destroy) events->destroy();
724  break;
725  case 1:
726  if(events->feedback) events->feedback(surface_t(args[0].get<resource_t>()), presentation_feedback_t(args[1].get<resource_t>()));
727  break;
728  }
729  return 0;
730 }
731 
732 
733 presentation_feedback_t::presentation_feedback_t(const client_t& client, uint32_t id, int version)
734  : resource_t(client, &server::detail::presentation_feedback_interface, id, version)
735 {
736  set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
737 }
738 
739 presentation_feedback_t::presentation_feedback_t(const resource_t &resource)
740  : resource_t(resource)
741 {
742  set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
743 }
744 
745 const std::string presentation_feedback_t::interface_name = "wp_presentation_feedback";
746 
747 presentation_feedback_t::operator wp_presentation_feedback*() const
748 {
749  return reinterpret_cast<wp_presentation_feedback*> (c_ptr());
750 }
751 
752 void presentation_feedback_t::sync_output(output_t const& output, bool post)
753 {
754  send_event(post, 0, output.proxy_has_object() ? reinterpret_cast<wl_object*>(output.c_ptr()) : nullptr);
755 }
756 
757 void presentation_feedback_t::presented(uint32_t tv_sec_hi, uint32_t tv_sec_lo, uint32_t tv_nsec, uint32_t refresh, uint32_t seq_hi, uint32_t seq_lo, presentation_feedback_kind const& flags, bool post)
758 {
759  send_event(post, 1, tv_sec_hi, tv_sec_lo, tv_nsec, refresh, seq_hi, seq_lo, static_cast<uint32_t>(flags));
760 }
761 
763 {
764  send_event(post, 2);
765 }
766 
767 int presentation_feedback_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
768 {
769  return 0;
770 }
771 const bitfield<4, 1> presentation_feedback_kind::vsync{0x1};
772 const bitfield<4, 1> presentation_feedback_kind::hw_clock{0x2};
773 const bitfield<4, 1> presentation_feedback_kind::hw_completion{0x4};
774 const bitfield<4, 1> presentation_feedback_kind::zero_copy{0x8};
775 
776 
777 viewporter_t::viewporter_t(const client_t& client, uint32_t id, int version)
778  : resource_t(client, &server::detail::viewporter_interface, id, version)
779 {
780  set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
781 }
782 
783 viewporter_t::viewporter_t(const resource_t &resource)
784  : resource_t(resource)
785 {
786  set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
787 }
788 
789 const std::string viewporter_t::interface_name = "wp_viewporter";
790 
791 viewporter_t::operator wp_viewporter*() const
792 {
793  return reinterpret_cast<wp_viewporter*> (c_ptr());
794 }
795 
796 std::function<void()> &viewporter_t::on_destroy()
797 {
798  return std::static_pointer_cast<events_t>(get_events())->destroy;
799 }
800 
801 
803 {
804  return std::static_pointer_cast<events_t>(get_events())->get_viewport;
805 }
806 
807 
808 void viewporter_t::post_viewport_exists(std::string const& msg)
809 {
810  post_error(static_cast<uint32_t>(viewporter_error::viewport_exists), msg);
811 }
812 
813 int viewporter_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
814 {
815  std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
816  switch(opcode)
817  {
818  case 0:
819  if(events->destroy) events->destroy();
820  break;
821  case 1:
822  if(events->get_viewport) events->get_viewport(viewport_t(args[0].get<resource_t>()), surface_t(args[1].get<resource_t>()));
823  break;
824  }
825  return 0;
826 }
827 
828 
829 viewport_t::viewport_t(const client_t& client, uint32_t id, int version)
830  : resource_t(client, &server::detail::viewport_interface, id, version)
831 {
832  set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
833 }
834 
835 viewport_t::viewport_t(const resource_t &resource)
836  : resource_t(resource)
837 {
838  set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
839 }
840 
841 const std::string viewport_t::interface_name = "wp_viewport";
842 
843 viewport_t::operator wp_viewport*() const
844 {
845  return reinterpret_cast<wp_viewport*> (c_ptr());
846 }
847 
848 std::function<void()> &viewport_t::on_destroy()
849 {
850  return std::static_pointer_cast<events_t>(get_events())->destroy;
851 }
852 
853 
854 std::function<void(double, double, double, double)> &viewport_t::on_set_source()
855 {
856  return std::static_pointer_cast<events_t>(get_events())->set_source;
857 }
858 
859 
860 std::function<void(int32_t, int32_t)> &viewport_t::on_set_destination()
861 {
862  return std::static_pointer_cast<events_t>(get_events())->set_destination;
863 }
864 
865 
866 void viewport_t::post_bad_value(std::string const& msg)
867 {
868  post_error(static_cast<uint32_t>(viewport_error::bad_value), msg);
869 }
870 
871 void viewport_t::post_bad_size(std::string const& msg)
872 {
873  post_error(static_cast<uint32_t>(viewport_error::bad_size), msg);
874 }
875 
876 void viewport_t::post_out_of_buffer(std::string const& msg)
877 {
878  post_error(static_cast<uint32_t>(viewport_error::out_of_buffer), msg);
879 }
880 
881 void viewport_t::post_no_surface(std::string const& msg)
882 {
883  post_error(static_cast<uint32_t>(viewport_error::no_surface), msg);
884 }
885 
886 int viewport_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
887 {
888  std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
889  switch(opcode)
890  {
891  case 0:
892  if(events->destroy) events->destroy();
893  break;
894  case 1:
895  if(events->set_source) events->set_source(args[0].get<double>(), args[1].get<double>(), args[2].get<double>(), args[3].get<double>());
896  break;
897  case 2:
898  if(events->set_destination) events->set_destination(args[0].get<int32_t>(), args[1].get<int32_t>());
899  break;
900  }
901  return 0;
902 }
903 
904 
905 xdg_wm_base_t::xdg_wm_base_t(const client_t& client, uint32_t id, int version)
906  : resource_t(client, &server::detail::xdg_wm_base_interface, id, version)
907 {
908  set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
909 }
910 
911 xdg_wm_base_t::xdg_wm_base_t(const resource_t &resource)
912  : resource_t(resource)
913 {
914  set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
915 }
916 
917 const std::string xdg_wm_base_t::interface_name = "xdg_wm_base";
918 
919 xdg_wm_base_t::operator xdg_wm_base*() const
920 {
921  return reinterpret_cast<xdg_wm_base*> (c_ptr());
922 }
923 
924 std::function<void()> &xdg_wm_base_t::on_destroy()
925 {
926  return std::static_pointer_cast<events_t>(get_events())->destroy;
927 }
928 
929 
931 {
932  return std::static_pointer_cast<events_t>(get_events())->create_positioner;
933 }
934 
935 
937 {
938  return std::static_pointer_cast<events_t>(get_events())->get_xdg_surface;
939 }
940 
941 
942 std::function<void(uint32_t)> &xdg_wm_base_t::on_pong()
943 {
944  return std::static_pointer_cast<events_t>(get_events())->pong;
945 }
946 
947 
948 void xdg_wm_base_t::ping(uint32_t serial, bool post)
949 {
950  send_event(post, 0, serial);
951 }
952 
953 void xdg_wm_base_t::post_role(std::string const& msg)
954 {
955  post_error(static_cast<uint32_t>(xdg_wm_base_error::role), msg);
956 }
957 
958 void xdg_wm_base_t::post_defunct_surfaces(std::string const& msg)
959 {
960  post_error(static_cast<uint32_t>(xdg_wm_base_error::defunct_surfaces), msg);
961 }
962 
963 void xdg_wm_base_t::post_not_the_topmost_popup(std::string const& msg)
964 {
965  post_error(static_cast<uint32_t>(xdg_wm_base_error::not_the_topmost_popup), msg);
966 }
967 
968 void xdg_wm_base_t::post_invalid_popup_parent(std::string const& msg)
969 {
970  post_error(static_cast<uint32_t>(xdg_wm_base_error::invalid_popup_parent), msg);
971 }
972 
973 void xdg_wm_base_t::post_invalid_surface_state(std::string const& msg)
974 {
975  post_error(static_cast<uint32_t>(xdg_wm_base_error::invalid_surface_state), msg);
976 }
977 
978 void xdg_wm_base_t::post_invalid_positioner(std::string const& msg)
979 {
980  post_error(static_cast<uint32_t>(xdg_wm_base_error::invalid_positioner), msg);
981 }
982 
983 int xdg_wm_base_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
984 {
985  std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
986  switch(opcode)
987  {
988  case 0:
989  if(events->destroy) events->destroy();
990  break;
991  case 1:
992  if(events->create_positioner) events->create_positioner(xdg_positioner_t(args[0].get<resource_t>()));
993  break;
994  case 2:
995  if(events->get_xdg_surface) events->get_xdg_surface(xdg_surface_t(args[0].get<resource_t>()), surface_t(args[1].get<resource_t>()));
996  break;
997  case 3:
998  if(events->pong) events->pong(args[0].get<uint32_t>());
999  break;
1000  }
1001  return 0;
1002 }
1003 
1004 
1005 xdg_positioner_t::xdg_positioner_t(const client_t& client, uint32_t id, int version)
1006  : resource_t(client, &server::detail::xdg_positioner_interface, id, version)
1007 {
1008  set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
1009 }
1010 
1011 xdg_positioner_t::xdg_positioner_t(const resource_t &resource)
1012  : resource_t(resource)
1013 {
1014  set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
1015 }
1016 
1017 const std::string xdg_positioner_t::interface_name = "xdg_positioner";
1018 
1019 xdg_positioner_t::operator xdg_positioner*() const
1020 {
1021  return reinterpret_cast<xdg_positioner*> (c_ptr());
1022 }
1023 
1024 std::function<void()> &xdg_positioner_t::on_destroy()
1025 {
1026  return std::static_pointer_cast<events_t>(get_events())->destroy;
1027 }
1028 
1029 
1030 std::function<void(int32_t, int32_t)> &xdg_positioner_t::on_set_size()
1031 {
1032  return std::static_pointer_cast<events_t>(get_events())->set_size;
1033 }
1034 
1035 
1036 std::function<void(int32_t, int32_t, int32_t, int32_t)> &xdg_positioner_t::on_set_anchor_rect()
1037 {
1038  return std::static_pointer_cast<events_t>(get_events())->set_anchor_rect;
1039 }
1040 
1041 
1042 std::function<void(xdg_positioner_anchor)> &xdg_positioner_t::on_set_anchor()
1043 {
1044  return std::static_pointer_cast<events_t>(get_events())->set_anchor;
1045 }
1046 
1047 
1048 std::function<void(xdg_positioner_gravity)> &xdg_positioner_t::on_set_gravity()
1049 {
1050  return std::static_pointer_cast<events_t>(get_events())->set_gravity;
1051 }
1052 
1053 
1055 {
1056  return std::static_pointer_cast<events_t>(get_events())->set_constraint_adjustment;
1057 }
1058 
1059 
1060 std::function<void(int32_t, int32_t)> &xdg_positioner_t::on_set_offset()
1061 {
1062  return std::static_pointer_cast<events_t>(get_events())->set_offset;
1063 }
1064 
1065 
1066 std::function<void()> &xdg_positioner_t::on_set_reactive()
1067 {
1068  return std::static_pointer_cast<events_t>(get_events())->set_reactive;
1069 }
1070 
1071 
1072 std::function<void(int32_t, int32_t)> &xdg_positioner_t::on_set_parent_size()
1073 {
1074  return std::static_pointer_cast<events_t>(get_events())->set_parent_size;
1075 }
1076 
1077 
1078 std::function<void(uint32_t)> &xdg_positioner_t::on_set_parent_configure()
1079 {
1080  return std::static_pointer_cast<events_t>(get_events())->set_parent_configure;
1081 }
1082 
1083 
1084 void xdg_positioner_t::post_invalid_input(std::string const& msg)
1085 {
1086  post_error(static_cast<uint32_t>(xdg_positioner_error::invalid_input), msg);
1087 }
1088 
1089 int xdg_positioner_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
1090 {
1091  std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
1092  switch(opcode)
1093  {
1094  case 0:
1095  if(events->destroy) events->destroy();
1096  break;
1097  case 1:
1098  if(events->set_size) events->set_size(args[0].get<int32_t>(), args[1].get<int32_t>());
1099  break;
1100  case 2:
1101  if(events->set_anchor_rect) events->set_anchor_rect(args[0].get<int32_t>(), args[1].get<int32_t>(), args[2].get<int32_t>(), args[3].get<int32_t>());
1102  break;
1103  case 3:
1104  if(events->set_anchor) events->set_anchor(xdg_positioner_anchor(args[0].get<uint32_t>()));
1105  break;
1106  case 4:
1107  if(events->set_gravity) events->set_gravity(xdg_positioner_gravity(args[0].get<uint32_t>()));
1108  break;
1109  case 5:
1110  if(events->set_constraint_adjustment) events->set_constraint_adjustment(xdg_positioner_constraint_adjustment(args[0].get<uint32_t>()));
1111  break;
1112  case 6:
1113  if(events->set_offset) events->set_offset(args[0].get<int32_t>(), args[1].get<int32_t>());
1114  break;
1115  case 7:
1116  if(events->set_reactive) events->set_reactive();
1117  break;
1118  case 8:
1119  if(events->set_parent_size) events->set_parent_size(args[0].get<int32_t>(), args[1].get<int32_t>());
1120  break;
1121  case 9:
1122  if(events->set_parent_configure) events->set_parent_configure(args[0].get<uint32_t>());
1123  break;
1124  }
1125  return 0;
1126 }
1127 
1128 
1129 
1130 const bitfield<2147483649, 8> xdg_positioner_constraint_adjustment::none{0};
1131 const bitfield<2147483649, 8> xdg_positioner_constraint_adjustment::slide_x{1};
1132 const bitfield<2147483649, 8> xdg_positioner_constraint_adjustment::slide_y{2};
1133 const bitfield<2147483649, 8> xdg_positioner_constraint_adjustment::flip_x{4};
1134 const bitfield<2147483649, 8> xdg_positioner_constraint_adjustment::flip_y{8};
1135 const bitfield<2147483649, 8> xdg_positioner_constraint_adjustment::resize_x{16};
1136 const bitfield<2147483649, 8> xdg_positioner_constraint_adjustment::resize_y{32};
1137 
1138 
1139 xdg_surface_t::xdg_surface_t(const client_t& client, uint32_t id, int version)
1140  : resource_t(client, &server::detail::xdg_surface_interface, id, version)
1141 {
1142  set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
1143 }
1144 
1145 xdg_surface_t::xdg_surface_t(const resource_t &resource)
1146  : resource_t(resource)
1147 {
1148  set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
1149 }
1150 
1151 const std::string xdg_surface_t::interface_name = "xdg_surface";
1152 
1153 xdg_surface_t::operator xdg_surface*() const
1154 {
1155  return reinterpret_cast<xdg_surface*> (c_ptr());
1156 }
1157 
1158 std::function<void()> &xdg_surface_t::on_destroy()
1159 {
1160  return std::static_pointer_cast<events_t>(get_events())->destroy;
1161 }
1162 
1163 
1165 {
1166  return std::static_pointer_cast<events_t>(get_events())->get_toplevel;
1167 }
1168 
1169 
1171 {
1172  return std::static_pointer_cast<events_t>(get_events())->get_popup;
1173 }
1174 
1175 
1176 std::function<void(int32_t, int32_t, int32_t, int32_t)> &xdg_surface_t::on_set_window_geometry()
1177 {
1178  return std::static_pointer_cast<events_t>(get_events())->set_window_geometry;
1179 }
1180 
1181 
1182 std::function<void(uint32_t)> &xdg_surface_t::on_ack_configure()
1183 {
1184  return std::static_pointer_cast<events_t>(get_events())->ack_configure;
1185 }
1186 
1187 
1188 void xdg_surface_t::configure(uint32_t serial, bool post)
1189 {
1190  send_event(post, 0, serial);
1191 }
1192 
1193 void xdg_surface_t::post_not_constructed(std::string const& msg)
1194 {
1195  post_error(static_cast<uint32_t>(xdg_surface_error::not_constructed), msg);
1196 }
1197 
1198 void xdg_surface_t::post_already_constructed(std::string const& msg)
1199 {
1200  post_error(static_cast<uint32_t>(xdg_surface_error::already_constructed), msg);
1201 }
1202 
1203 void xdg_surface_t::post_unconfigured_buffer(std::string const& msg)
1204 {
1205  post_error(static_cast<uint32_t>(xdg_surface_error::unconfigured_buffer), msg);
1206 }
1207 
1208 int xdg_surface_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
1209 {
1210  std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
1211  switch(opcode)
1212  {
1213  case 0:
1214  if(events->destroy) events->destroy();
1215  break;
1216  case 1:
1217  if(events->get_toplevel) events->get_toplevel(xdg_toplevel_t(args[0].get<resource_t>()));
1218  break;
1219  case 2:
1220  if(events->get_popup) events->get_popup(xdg_popup_t(args[0].get<resource_t>()), xdg_surface_t(args[1].get<resource_t>()), xdg_positioner_t(args[2].get<resource_t>()));
1221  break;
1222  case 3:
1223  if(events->set_window_geometry) events->set_window_geometry(args[0].get<int32_t>(), args[1].get<int32_t>(), args[2].get<int32_t>(), args[3].get<int32_t>());
1224  break;
1225  case 4:
1226  if(events->ack_configure) events->ack_configure(args[0].get<uint32_t>());
1227  break;
1228  }
1229  return 0;
1230 }
1231 
1232 
1233 xdg_toplevel_t::xdg_toplevel_t(const client_t& client, uint32_t id, int version)
1234  : resource_t(client, &server::detail::xdg_toplevel_interface, id, version)
1235 {
1236  set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
1237 }
1238 
1239 xdg_toplevel_t::xdg_toplevel_t(const resource_t &resource)
1240  : resource_t(resource)
1241 {
1242  set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
1243 }
1244 
1245 const std::string xdg_toplevel_t::interface_name = "xdg_toplevel";
1246 
1247 xdg_toplevel_t::operator xdg_toplevel*() const
1248 {
1249  return reinterpret_cast<xdg_toplevel*> (c_ptr());
1250 }
1251 
1252 std::function<void()> &xdg_toplevel_t::on_destroy()
1253 {
1254  return std::static_pointer_cast<events_t>(get_events())->destroy;
1255 }
1256 
1257 
1259 {
1260  return std::static_pointer_cast<events_t>(get_events())->set_parent;
1261 }
1262 
1263 
1264 std::function<void(std::string)> &xdg_toplevel_t::on_set_title()
1265 {
1266  return std::static_pointer_cast<events_t>(get_events())->set_title;
1267 }
1268 
1269 
1270 std::function<void(std::string)> &xdg_toplevel_t::on_set_app_id()
1271 {
1272  return std::static_pointer_cast<events_t>(get_events())->set_app_id;
1273 }
1274 
1275 
1276 std::function<void(seat_t, uint32_t, int32_t, int32_t)> &xdg_toplevel_t::on_show_window_menu()
1277 {
1278  return std::static_pointer_cast<events_t>(get_events())->show_window_menu;
1279 }
1280 
1281 
1282 std::function<void(seat_t, uint32_t)> &xdg_toplevel_t::on_move()
1283 {
1284  return std::static_pointer_cast<events_t>(get_events())->move;
1285 }
1286 
1287 
1289 {
1290  return std::static_pointer_cast<events_t>(get_events())->resize;
1291 }
1292 
1293 
1294 std::function<void(int32_t, int32_t)> &xdg_toplevel_t::on_set_max_size()
1295 {
1296  return std::static_pointer_cast<events_t>(get_events())->set_max_size;
1297 }
1298 
1299 
1300 std::function<void(int32_t, int32_t)> &xdg_toplevel_t::on_set_min_size()
1301 {
1302  return std::static_pointer_cast<events_t>(get_events())->set_min_size;
1303 }
1304 
1305 
1306 std::function<void()> &xdg_toplevel_t::on_set_maximized()
1307 {
1308  return std::static_pointer_cast<events_t>(get_events())->set_maximized;
1309 }
1310 
1311 
1312 std::function<void()> &xdg_toplevel_t::on_unset_maximized()
1313 {
1314  return std::static_pointer_cast<events_t>(get_events())->unset_maximized;
1315 }
1316 
1317 
1319 {
1320  return std::static_pointer_cast<events_t>(get_events())->set_fullscreen;
1321 }
1322 
1323 
1324 std::function<void()> &xdg_toplevel_t::on_unset_fullscreen()
1325 {
1326  return std::static_pointer_cast<events_t>(get_events())->unset_fullscreen;
1327 }
1328 
1329 
1330 std::function<void()> &xdg_toplevel_t::on_set_minimized()
1331 {
1332  return std::static_pointer_cast<events_t>(get_events())->set_minimized;
1333 }
1334 
1335 
1336 void xdg_toplevel_t::configure(int32_t width, int32_t height, array_t const& states, bool post)
1337 {
1338  send_event(post, 0, width, height, states);
1339 }
1340 
1341 void xdg_toplevel_t::close(bool post)
1342 {
1343  send_event(post, 1);
1344 }
1345 
1346 void xdg_toplevel_t::configure_bounds(int32_t width, int32_t height, bool post)
1347 {
1348  send_event(post, 2, width, height);
1349 }
1350 
1352 {
1353  return (get_version() >= configure_bounds_since_version);
1354 }
1355 
1356 void xdg_toplevel_t::post_invalid_resize_edge(std::string const& msg)
1357 {
1358  post_error(static_cast<uint32_t>(xdg_toplevel_error::invalid_resize_edge), msg);
1359 }
1360 
1361 int xdg_toplevel_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
1362 {
1363  std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
1364  switch(opcode)
1365  {
1366  case 0:
1367  if(events->destroy) events->destroy();
1368  break;
1369  case 1:
1370  if(events->set_parent) events->set_parent(xdg_toplevel_t(args[0].get<resource_t>()));
1371  break;
1372  case 2:
1373  if(events->set_title) events->set_title(args[0].get<std::string>());
1374  break;
1375  case 3:
1376  if(events->set_app_id) events->set_app_id(args[0].get<std::string>());
1377  break;
1378  case 4:
1379  if(events->show_window_menu) events->show_window_menu(seat_t(args[0].get<resource_t>()), args[1].get<uint32_t>(), args[2].get<int32_t>(), args[3].get<int32_t>());
1380  break;
1381  case 5:
1382  if(events->move) events->move(seat_t(args[0].get<resource_t>()), args[1].get<uint32_t>());
1383  break;
1384  case 6:
1385  if(events->resize) events->resize(seat_t(args[0].get<resource_t>()), args[1].get<uint32_t>(), xdg_toplevel_resize_edge(args[2].get<uint32_t>()));
1386  break;
1387  case 7:
1388  if(events->set_max_size) events->set_max_size(args[0].get<int32_t>(), args[1].get<int32_t>());
1389  break;
1390  case 8:
1391  if(events->set_min_size) events->set_min_size(args[0].get<int32_t>(), args[1].get<int32_t>());
1392  break;
1393  case 9:
1394  if(events->set_maximized) events->set_maximized();
1395  break;
1396  case 10:
1397  if(events->unset_maximized) events->unset_maximized();
1398  break;
1399  case 11:
1400  if(events->set_fullscreen) events->set_fullscreen(output_t(args[0].get<resource_t>()));
1401  break;
1402  case 12:
1403  if(events->unset_fullscreen) events->unset_fullscreen();
1404  break;
1405  case 13:
1406  if(events->set_minimized) events->set_minimized();
1407  break;
1408  }
1409  return 0;
1410 }
1411 
1412 const bitfield<2147483649, 11> xdg_toplevel_resize_edge::none{0};
1413 const bitfield<2147483649, 11> xdg_toplevel_resize_edge::top{1};
1414 const bitfield<2147483649, 11> xdg_toplevel_resize_edge::bottom{2};
1415 const bitfield<2147483649, 11> xdg_toplevel_resize_edge::left{4};
1416 const bitfield<2147483649, 11> xdg_toplevel_resize_edge::top_left{5};
1417 const bitfield<2147483649, 11> xdg_toplevel_resize_edge::bottom_left{6};
1418 const bitfield<2147483649, 11> xdg_toplevel_resize_edge::right{8};
1419 const bitfield<2147483649, 11> xdg_toplevel_resize_edge::top_right{9};
1420 const bitfield<2147483649, 11> xdg_toplevel_resize_edge::bottom_right{10};
1421 
1422 
1423 
1424 xdg_popup_t::xdg_popup_t(const client_t& client, uint32_t id, int version)
1425  : resource_t(client, &server::detail::xdg_popup_interface, id, version)
1426 {
1427  set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
1428 }
1429 
1430 xdg_popup_t::xdg_popup_t(const resource_t &resource)
1431  : resource_t(resource)
1432 {
1433  set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
1434 }
1435 
1436 const std::string xdg_popup_t::interface_name = "xdg_popup";
1437 
1438 xdg_popup_t::operator xdg_popup*() const
1439 {
1440  return reinterpret_cast<xdg_popup*> (c_ptr());
1441 }
1442 
1443 std::function<void()> &xdg_popup_t::on_destroy()
1444 {
1445  return std::static_pointer_cast<events_t>(get_events())->destroy;
1446 }
1447 
1448 
1449 std::function<void(seat_t, uint32_t)> &xdg_popup_t::on_grab()
1450 {
1451  return std::static_pointer_cast<events_t>(get_events())->grab;
1452 }
1453 
1454 
1455 std::function<void(xdg_positioner_t, uint32_t)> &xdg_popup_t::on_reposition()
1456 {
1457  return std::static_pointer_cast<events_t>(get_events())->reposition;
1458 }
1459 
1460 
1461 void xdg_popup_t::configure(int32_t x, int32_t y, int32_t width, int32_t height, bool post)
1462 {
1463  send_event(post, 0, x, y, width, height);
1464 }
1465 
1467 {
1468  send_event(post, 1);
1469 }
1470 
1471 void xdg_popup_t::repositioned(uint32_t token, bool post)
1472 {
1473  send_event(post, 2, token);
1474 }
1475 
1477 {
1478  return (get_version() >= repositioned_since_version);
1479 }
1480 
1481 void xdg_popup_t::post_invalid_grab(std::string const& msg)
1482 {
1483  post_error(static_cast<uint32_t>(xdg_popup_error::invalid_grab), msg);
1484 }
1485 
1486 int xdg_popup_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
1487 {
1488  std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
1489  switch(opcode)
1490  {
1491  case 0:
1492  if(events->destroy) events->destroy();
1493  break;
1494  case 1:
1495  if(events->grab) events->grab(seat_t(args[0].get<resource_t>()), args[1].get<uint32_t>());
1496  break;
1497  case 2:
1498  if(events->reposition) events->reposition(xdg_positioner_t(args[0].get<resource_t>()), args[1].get<uint32_t>());
1499  break;
1500  }
1501  return 0;
1502 }
1503 
1504 
1505 
void discarded(bool post=true)
the content update was not displayed
void presented(uint32_t tv_sec_hi, uint32_t tv_sec_lo, uint32_t tv_nsec, uint32_t refresh, uint32_t seq_hi, uint32_t seq_lo, presentation_feedback_kind const &flags, bool post=true)
the content update was displayed
void sync_output(output_t const &output, bool post=true)
presentation synchronized to this output
crop and scale interface to a wl_surface
void post_bad_size(std::string const &msg)
Post error: destination size is not integer.
std::function< void(int32_t, int32_t)> & on_set_destination()
set the surface size for scaling
void post_no_surface(std::string const &msg)
Post error: the wl_surface was destroyed.
std::function< void()> & on_destroy()
remove scaling and cropping from the surface
void post_bad_value(std::string const &msg)
Post error: negative or zero values in width or height.
void post_out_of_buffer(std::string const &msg)
Post error: source rectangle extends outside of the content area.
std::function< void(double, double, double, double)> & on_set_source()
set the source rectangle for cropping
std::function< void(viewport_t, surface_t)> & on_get_viewport()
extend surface interface for crop and scale
std::function< void()> & on_destroy()
unbind from the cropping and scaling interface
void post_viewport_exists(std::string const &msg)
Post error: the surface already has a viewport object associated.
short-lived, popup surfaces for menus
std::function< void(seat_t, uint32_t)> & on_grab()
make the popup take an explicit grab
bool can_repositioned() const
Check whether the repositioned function is available with the currently bound version of the protocol...
void configure(int32_t x, int32_t y, int32_t width, int32_t height, bool post=true)
configure the popup surface
std::function< void(xdg_positioner_t, uint32_t)> & on_reposition()
recalculate the popup's location
void popup_done(bool post=true)
popup interaction is done
void post_invalid_grab(std::string const &msg)
Post error: tried to grab after being mapped.
void repositioned(uint32_t token, bool post=true)
signal the completion of a repositioned request
static constexpr std::uint32_t repositioned_since_version
Minimum protocol version required for the repositioned function.
std::function< void()> & on_destroy()
remove xdg_popup interface
std::function< void(xdg_positioner_gravity)> & on_set_gravity()
set child surface gravity
void post_invalid_input(std::string const &msg)
Post error: invalid input provided.
std::function< void(int32_t, int32_t)> & on_set_size()
set the size of the to-be positioned rectangle
std::function< void(xdg_positioner_anchor)> & on_set_anchor()
set anchor rectangle anchor
std::function< void()> & on_destroy()
destroy the xdg_positioner object
std::function< void(xdg_positioner_constraint_adjustment)> & on_set_constraint_adjustment()
set the adjustment to be done when constrained
std::function< void(int32_t, int32_t)> & on_set_offset()
set surface position offset
std::function< void(int32_t, int32_t)> & on_set_parent_size()
std::function< void()> & on_set_reactive()
continuously reconstrain the surface
std::function< void(uint32_t)> & on_set_parent_configure()
set parent configure this is a response to
std::function< void(int32_t, int32_t, int32_t, int32_t)> & on_set_anchor_rect()
set the anchor rectangle within the parent surface
desktop user interface surface base interface
std::function< void()> & on_destroy()
destroy the xdg_surface
void post_not_constructed(std::string const &msg)
Post error:
void post_already_constructed(std::string const &msg)
Post error:
std::function< void(xdg_toplevel_t)> & on_get_toplevel()
assign the xdg_toplevel surface role
void post_unconfigured_buffer(std::string const &msg)
Post error:
void configure(uint32_t serial, bool post=true)
suggest a surface change
std::function< void(int32_t, int32_t, int32_t, int32_t)> & on_set_window_geometry()
set the new window geometry
std::function< void(uint32_t)> & on_ack_configure()
ack a configure event
std::function< void(xdg_popup_t, xdg_surface_t, xdg_positioner_t)> & on_get_popup()
assign the xdg_popup surface role
std::function< void(int32_t, int32_t)> & on_set_min_size()
set the minimum size
std::function< void(seat_t, uint32_t, int32_t, int32_t)> & on_show_window_menu()
show the window menu
std::function< void()> & on_unset_maximized()
unmaximize the window
static constexpr std::uint32_t configure_bounds_since_version
Minimum protocol version required for the configure_bounds function.
std::function< void()> & on_unset_fullscreen()
unset the window as fullscreen
bool can_configure_bounds() const
Check whether the configure_bounds function is available with the currently bound version of the prot...
std::function< void(xdg_toplevel_t)> & on_set_parent()
set the parent of this surface
std::function< void(std::string)> & on_set_app_id()
set application ID
std::function< void(int32_t, int32_t)> & on_set_max_size()
set the maximum size
void close(bool post=true)
surface wants to be closed
void post_invalid_resize_edge(std::string const &msg)
Post error: provided value is not a valid variant of the resize_edge enum.
std::function< void(std::string)> & on_set_title()
set surface title
std::function< void(seat_t, uint32_t)> & on_move()
start an interactive move
std::function< void()> & on_set_maximized()
maximize the window
std::function< void(seat_t, uint32_t, xdg_toplevel_resize_edge)> & on_resize()
start an interactive resize
std::function< void(output_t)> & on_set_fullscreen()
set the window as fullscreen on an output
std::function< void()> & on_set_minimized()
set the window as minimized
void configure_bounds(int32_t width, int32_t height, bool post=true)
recommended window geometry bounds
void configure(int32_t width, int32_t height, array_t const &states, bool post=true)
suggest a surface change
std::function< void()> & on_destroy()
destroy the xdg_toplevel
std::function< void()> & on_destroy()
destroy xdg_wm_base
std::function< void(uint32_t)> & on_pong()
respond to a ping event
void post_invalid_surface_state(std::string const &msg)
Post error: the client provided an invalid surface state.
void post_invalid_popup_parent(std::string const &msg)
Post error: the client specified an invalid popup parent surface.
void post_role(std::string const &msg)
Post error: given wl_surface has another role.
void post_defunct_surfaces(std::string const &msg)
Post error: xdg_wm_base was destroyed before children.
void ping(uint32_t serial, bool post=true)
check if the client is alive
std::function< void(xdg_positioner_t)> & on_create_positioner()
create a positioner object
void post_invalid_positioner(std::string const &msg)
Post error: the client provided an invalid positioner.
std::function< void(xdg_surface_t, surface_t)> & on_get_xdg_surface()
create a shell surface from a surface
void post_not_the_topmost_popup(std::string const &msg)
Post error: the client tried to map or destroy a non-topmost popup.