Wayland++ 1.0.0
C++ Bindings for Wayland
Loading...
Searching...
No Matches
wayland-server-protocol-extra.cpp
1#include <wayland-server-protocol-extra.hpp>
2
3using namespace wayland;
4using namespace wayland::detail;
5using namespace wayland::server;
6using namespace wayland::server::detail;
7
8const wl_interface* presentation_interface_destroy_request_server[0] = {
9};
10
11const wl_interface* presentation_interface_feedback_request_server[2] = {
12 &surface_interface,
13 &presentation_feedback_interface,
14};
15
16const wl_interface* presentation_interface_clock_id_event_server[1] = {
17 nullptr,
18};
19
20const 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
33const wl_message presentation_interface_events_server[1] = {
34 {
35 "clock_id",
36 "u",
37 presentation_interface_clock_id_event_server,
38 },
39};
40
41const 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
51const wl_interface* presentation_feedback_interface_sync_output_event_server[1] = {
52 &output_interface,
53};
54
55const 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
65const wl_interface* presentation_feedback_interface_discarded_event_server[0] = {
66};
67
68const wl_message presentation_feedback_interface_requests_server[0] = {
69};
70
71const 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
89const 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
99const wl_interface* viewporter_interface_destroy_request_server[0] = {
100};
101
102const wl_interface* viewporter_interface_get_viewport_request_server[2] = {
103 &viewport_interface,
104 &surface_interface,
105};
106
107const 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
120const wl_message viewporter_interface_events_server[0] = {
121};
122
123const 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
133const wl_interface* viewport_interface_destroy_request_server[0] = {
134};
135
136const wl_interface* viewport_interface_set_source_request_server[4] = {
137 nullptr,
138 nullptr,
139 nullptr,
140 nullptr,
141};
142
143const wl_interface* viewport_interface_set_destination_request_server[2] = {
144 nullptr,
145 nullptr,
146};
147
148const 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
166const wl_message viewport_interface_events_server[0] = {
167};
168
169const 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
179const wl_interface* xdg_wm_base_interface_destroy_request_server[0] = {
180};
181
182const wl_interface* xdg_wm_base_interface_create_positioner_request_server[1] = {
183 &xdg_positioner_interface,
184};
185
186const wl_interface* xdg_wm_base_interface_get_xdg_surface_request_server[2] = {
187 &xdg_surface_interface,
188 &surface_interface,
189};
190
191const wl_interface* xdg_wm_base_interface_pong_request_server[1] = {
192 nullptr,
193};
194
195const wl_interface* xdg_wm_base_interface_ping_event_server[1] = {
196 nullptr,
197};
198
199const 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
222const 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
230const 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
240const wl_interface* xdg_positioner_interface_destroy_request_server[0] = {
241};
242
243const wl_interface* xdg_positioner_interface_set_size_request_server[2] = {
244 nullptr,
245 nullptr,
246};
247
248const wl_interface* xdg_positioner_interface_set_anchor_rect_request_server[4] = {
249 nullptr,
250 nullptr,
251 nullptr,
252 nullptr,
253};
254
255const wl_interface* xdg_positioner_interface_set_anchor_request_server[1] = {
256 nullptr,
257};
258
259const wl_interface* xdg_positioner_interface_set_gravity_request_server[1] = {
260 nullptr,
261};
262
263const wl_interface* xdg_positioner_interface_set_constraint_adjustment_request_server[1] = {
264 nullptr,
265};
266
267const wl_interface* xdg_positioner_interface_set_offset_request_server[2] = {
268 nullptr,
269 nullptr,
270};
271
272const wl_interface* xdg_positioner_interface_set_reactive_request_server[0] = {
273};
274
275const wl_interface* xdg_positioner_interface_set_parent_size_request_server[2] = {
276 nullptr,
277 nullptr,
278};
279
280const wl_interface* xdg_positioner_interface_set_parent_configure_request_server[1] = {
281 nullptr,
282};
283
284const 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
337const wl_message xdg_positioner_interface_events_server[0] = {
338};
339
340const 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
350const wl_interface* xdg_surface_interface_destroy_request_server[0] = {
351};
352
353const wl_interface* xdg_surface_interface_get_toplevel_request_server[1] = {
354 &xdg_toplevel_interface,
355};
356
357const wl_interface* xdg_surface_interface_get_popup_request_server[3] = {
358 &xdg_popup_interface,
359 &xdg_surface_interface,
360 &xdg_positioner_interface,
361};
362
363const wl_interface* xdg_surface_interface_set_window_geometry_request_server[4] = {
364 nullptr,
365 nullptr,
366 nullptr,
367 nullptr,
368};
369
370const wl_interface* xdg_surface_interface_ack_configure_request_server[1] = {
371 nullptr,
372};
373
374const wl_interface* xdg_surface_interface_configure_event_server[1] = {
375 nullptr,
376};
377
378const 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
406const wl_message xdg_surface_interface_events_server[1] = {
407 {
408 "configure",
409 "u",
410 xdg_surface_interface_configure_event_server,
411 },
412};
413
414const 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
424const wl_interface* xdg_toplevel_interface_destroy_request_server[0] = {
425};
426
427const wl_interface* xdg_toplevel_interface_set_parent_request_server[1] = {
428 &xdg_toplevel_interface,
429};
430
431const wl_interface* xdg_toplevel_interface_set_title_request_server[1] = {
432 nullptr,
433};
434
435const wl_interface* xdg_toplevel_interface_set_app_id_request_server[1] = {
436 nullptr,
437};
438
439const wl_interface* xdg_toplevel_interface_show_window_menu_request_server[4] = {
440 &seat_interface,
441 nullptr,
442 nullptr,
443 nullptr,
444};
445
446const wl_interface* xdg_toplevel_interface_move_request_server[2] = {
447 &seat_interface,
448 nullptr,
449};
450
451const wl_interface* xdg_toplevel_interface_resize_request_server[3] = {
452 &seat_interface,
453 nullptr,
454 nullptr,
455};
456
457const wl_interface* xdg_toplevel_interface_set_max_size_request_server[2] = {
458 nullptr,
459 nullptr,
460};
461
462const wl_interface* xdg_toplevel_interface_set_min_size_request_server[2] = {
463 nullptr,
464 nullptr,
465};
466
467const wl_interface* xdg_toplevel_interface_set_maximized_request_server[0] = {
468};
469
470const wl_interface* xdg_toplevel_interface_unset_maximized_request_server[0] = {
471};
472
473const wl_interface* xdg_toplevel_interface_set_fullscreen_request_server[1] = {
474 &output_interface,
475};
476
477const wl_interface* xdg_toplevel_interface_unset_fullscreen_request_server[0] = {
478};
479
480const wl_interface* xdg_toplevel_interface_set_minimized_request_server[0] = {
481};
482
483const wl_interface* xdg_toplevel_interface_configure_event_server[3] = {
484 nullptr,
485 nullptr,
486 nullptr,
487};
488
489const wl_interface* xdg_toplevel_interface_close_event_server[0] = {
490};
491
492const wl_interface* xdg_toplevel_interface_configure_bounds_event_server[2] = {
493 nullptr,
494 nullptr,
495};
496
497const 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
570const 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
588const 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
598const wl_interface* xdg_popup_interface_destroy_request_server[0] = {
599};
600
601const wl_interface* xdg_popup_interface_grab_request_server[2] = {
602 &seat_interface,
603 nullptr,
604};
605
606const wl_interface* xdg_popup_interface_reposition_request_server[2] = {
607 &xdg_positioner_interface,
608 nullptr,
609};
610
611const wl_interface* xdg_popup_interface_configure_event_server[4] = {
612 nullptr,
613 nullptr,
614 nullptr,
615 nullptr,
616};
617
618const wl_interface* xdg_popup_interface_popup_done_event_server[0] = {
619};
620
621const wl_interface* xdg_popup_interface_repositioned_event_server[1] = {
622 nullptr,
623};
624
625const 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
643const 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
661const 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
671presentation_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
677presentation_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
683const std::string presentation_t::interface_name = "wp_presentation";
684
685presentation_t::operator wp_presentation*() const
686{
687 return reinterpret_cast<wp_presentation*> (c_ptr());
688}
689
690std::function<void()> &presentation_t::on_destroy()
691{
692 return std::static_pointer_cast<events_t>(get_events())->destroy;
693}
694
695
697{
698 return std::static_pointer_cast<events_t>(get_events())->feedback;
699}
700
701
702void presentation_t::clock_id(uint32_t clk_id, bool post)
703{
704 send_event(post, 0, clk_id);
705}
706
707void presentation_t::post_invalid_timestamp(std::string const& msg)
708{
709 post_error(static_cast<uint32_t>(presentation_error::invalid_timestamp), msg);
710}
711
712void presentation_t::post_invalid_flag(std::string const& msg)
713{
714 post_error(static_cast<uint32_t>(presentation_error::invalid_flag), msg);
715}
716
717int 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
733presentation_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
739presentation_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
745const std::string presentation_feedback_t::interface_name = "wp_presentation_feedback";
746
747presentation_feedback_t::operator wp_presentation_feedback*() const
748{
749 return reinterpret_cast<wp_presentation_feedback*> (c_ptr());
750}
751
752void 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
757void 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
767int 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}
771const bitfield<4, 1> presentation_feedback_kind::vsync{0x1};
772const bitfield<4, 1> presentation_feedback_kind::hw_clock{0x2};
773const bitfield<4, 1> presentation_feedback_kind::hw_completion{0x4};
774const bitfield<4, 1> presentation_feedback_kind::zero_copy{0x8};
775
776
777viewporter_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
783viewporter_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
789const std::string viewporter_t::interface_name = "wp_viewporter";
790
791viewporter_t::operator wp_viewporter*() const
792{
793 return reinterpret_cast<wp_viewporter*> (c_ptr());
794}
795
796std::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
808void viewporter_t::post_viewport_exists(std::string const& msg)
809{
810 post_error(static_cast<uint32_t>(viewporter_error::viewport_exists), msg);
811}
812
813int 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
829viewport_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
835viewport_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
841const std::string viewport_t::interface_name = "wp_viewport";
842
843viewport_t::operator wp_viewport*() const
844{
845 return reinterpret_cast<wp_viewport*> (c_ptr());
846}
847
848std::function<void()> &viewport_t::on_destroy()
849{
850 return std::static_pointer_cast<events_t>(get_events())->destroy;
851}
852
853
854std::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
860std::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
866void viewport_t::post_bad_value(std::string const& msg)
867{
868 post_error(static_cast<uint32_t>(viewport_error::bad_value), msg);
869}
870
871void viewport_t::post_bad_size(std::string const& msg)
872{
873 post_error(static_cast<uint32_t>(viewport_error::bad_size), msg);
874}
875
876void 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
881void viewport_t::post_no_surface(std::string const& msg)
882{
883 post_error(static_cast<uint32_t>(viewport_error::no_surface), msg);
884}
885
886int 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
905xdg_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
911xdg_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
917const std::string xdg_wm_base_t::interface_name = "xdg_wm_base";
918
919xdg_wm_base_t::operator xdg_wm_base*() const
920{
921 return reinterpret_cast<xdg_wm_base*> (c_ptr());
922}
923
924std::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
942std::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
948void xdg_wm_base_t::ping(uint32_t serial, bool post)
949{
950 send_event(post, 0, serial);
951}
952
953void 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
958void 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
964{
965 post_error(static_cast<uint32_t>(xdg_wm_base_error::not_the_topmost_popup), msg);
966}
967
969{
970 post_error(static_cast<uint32_t>(xdg_wm_base_error::invalid_popup_parent), msg);
971}
972
974{
975 post_error(static_cast<uint32_t>(xdg_wm_base_error::invalid_surface_state), msg);
976}
977
978void 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
983int 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
1005xdg_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
1011xdg_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
1017const std::string xdg_positioner_t::interface_name = "xdg_positioner";
1018
1019xdg_positioner_t::operator xdg_positioner*() const
1020{
1021 return reinterpret_cast<xdg_positioner*> (c_ptr());
1022}
1023
1024std::function<void()> &xdg_positioner_t::on_destroy()
1025{
1026 return std::static_pointer_cast<events_t>(get_events())->destroy;
1027}
1028
1029
1030std::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
1036std::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
1042std::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
1048std::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
1060std::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
1067{
1068 return std::static_pointer_cast<events_t>(get_events())->set_reactive;
1069}
1070
1071
1072std::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
1078std::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
1084void 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
1089int 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
1130const bitfield<2147483649, 8> xdg_positioner_constraint_adjustment::none{0};
1131const bitfield<2147483649, 8> xdg_positioner_constraint_adjustment::slide_x{1};
1132const bitfield<2147483649, 8> xdg_positioner_constraint_adjustment::slide_y{2};
1133const bitfield<2147483649, 8> xdg_positioner_constraint_adjustment::flip_x{4};
1134const bitfield<2147483649, 8> xdg_positioner_constraint_adjustment::flip_y{8};
1135const bitfield<2147483649, 8> xdg_positioner_constraint_adjustment::resize_x{16};
1136const bitfield<2147483649, 8> xdg_positioner_constraint_adjustment::resize_y{32};
1137
1138
1139xdg_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
1145xdg_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
1151const std::string xdg_surface_t::interface_name = "xdg_surface";
1152
1153xdg_surface_t::operator xdg_surface*() const
1154{
1155 return reinterpret_cast<xdg_surface*> (c_ptr());
1156}
1157
1158std::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
1170std::function<void(xdg_popup_t, xdg_surface_t, xdg_positioner_t)> &xdg_surface_t::on_get_popup()
1171{
1172 return std::static_pointer_cast<events_t>(get_events())->get_popup;
1173}
1174
1175
1176std::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
1182std::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
1188void xdg_surface_t::configure(uint32_t serial, bool post)
1189{
1190 send_event(post, 0, serial);
1191}
1192
1193void 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
1199{
1200 post_error(static_cast<uint32_t>(xdg_surface_error::already_constructed), msg);
1201}
1202
1204{
1205 post_error(static_cast<uint32_t>(xdg_surface_error::unconfigured_buffer), msg);
1206}
1207
1208int 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
1233xdg_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
1239xdg_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
1245const std::string xdg_toplevel_t::interface_name = "xdg_toplevel";
1246
1247xdg_toplevel_t::operator xdg_toplevel*() const
1248{
1249 return reinterpret_cast<xdg_toplevel*> (c_ptr());
1250}
1251
1252std::function<void()> &xdg_toplevel_t::on_destroy()
1253{
1254 return std::static_pointer_cast<events_t>(get_events())->destroy;
1255}
1256
1257
1258std::function<void(xdg_toplevel_t)> &xdg_toplevel_t::on_set_parent()
1259{
1260 return std::static_pointer_cast<events_t>(get_events())->set_parent;
1261}
1262
1263
1264std::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
1270std::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
1276std::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
1282std::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
1294std::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
1300std::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
1306std::function<void()> &xdg_toplevel_t::on_set_maximized()
1307{
1308 return std::static_pointer_cast<events_t>(get_events())->set_maximized;
1309}
1310
1311
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
1325{
1326 return std::static_pointer_cast<events_t>(get_events())->unset_fullscreen;
1327}
1328
1329
1330std::function<void()> &xdg_toplevel_t::on_set_minimized()
1331{
1332 return std::static_pointer_cast<events_t>(get_events())->set_minimized;
1333}
1334
1335
1336void 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
1342{
1343 send_event(post, 1);
1344}
1345
1346void 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
1357{
1358 post_error(static_cast<uint32_t>(xdg_toplevel_error::invalid_resize_edge), msg);
1359}
1360
1361int 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
1412const bitfield<2147483649, 11> xdg_toplevel_resize_edge::none{0};
1413const bitfield<2147483649, 11> xdg_toplevel_resize_edge::top{1};
1414const bitfield<2147483649, 11> xdg_toplevel_resize_edge::bottom{2};
1415const bitfield<2147483649, 11> xdg_toplevel_resize_edge::left{4};
1416const bitfield<2147483649, 11> xdg_toplevel_resize_edge::top_left{5};
1417const bitfield<2147483649, 11> xdg_toplevel_resize_edge::bottom_left{6};
1418const bitfield<2147483649, 11> xdg_toplevel_resize_edge::right{8};
1419const bitfield<2147483649, 11> xdg_toplevel_resize_edge::top_right{9};
1420const bitfield<2147483649, 11> xdg_toplevel_resize_edge::bottom_right{10};
1421
1422
1423
1424xdg_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
1430xdg_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
1436const std::string xdg_popup_t::interface_name = "xdg_popup";
1437
1438xdg_popup_t::operator xdg_popup*() const
1439{
1440 return reinterpret_cast<xdg_popup*> (c_ptr());
1441}
1442
1443std::function<void()> &xdg_popup_t::on_destroy()
1444{
1445 return std::static_pointer_cast<events_t>(get_events())->destroy;
1446}
1447
1448
1449std::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
1455std::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
1461void 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
1471void 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
1481void 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
1486int 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
void post_invalid_timestamp(std::string const &msg)
Post error: invalid value in tv_nsec.
std::function< void(surface_t, presentation_feedback_t)> & on_feedback()
request presentation feedback information
std::function< void()> & on_destroy()
unbind from the presentation interface
void post_invalid_flag(std::string const &msg)
Post error: invalid flag.
void clock_id(uint32_t clk_id, bool post=true)
clock ID for timestamps
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.