Wayland++ 1.0.0
C++ Bindings for Wayland
Loading...
Searching...
No Matches
wayland-server-protocol.cpp
1#include <wayland-server-protocol.hpp>
2
3using namespace wayland;
4using namespace wayland::detail;
5using namespace wayland::server;
6using namespace wayland::server::detail;
7
8const wl_interface* display_interface_sync_request_server[1] = {
9 &callback_interface,
10};
11
12const wl_interface* display_interface_get_registry_request_server[1] = {
13 &registry_interface,
14};
15
16const wl_interface* display_interface_error_event_server[3] = {
17 nullptr,
18 nullptr,
19 nullptr,
20};
21
22const wl_interface* display_interface_delete_id_event_server[1] = {
23 nullptr,
24};
25
26const wl_message display_interface_requests_server[2] = {
27 {
28 "sync",
29 "n",
30 display_interface_sync_request_server,
31 },
32 {
33 "get_registry",
34 "n",
35 display_interface_get_registry_request_server,
36 },
37};
38
39const wl_message display_interface_events_server[2] = {
40 {
41 "error",
42 "ous",
43 display_interface_error_event_server,
44 },
45 {
46 "delete_id",
47 "u",
48 display_interface_delete_id_event_server,
49 },
50};
51
52const wl_interface wayland::server::detail::display_interface =
53 {
54 "wl_display",
55 1,
56 2,
57 display_interface_requests_server,
58 2,
59 display_interface_events_server,
60 };
61
62const wl_interface* registry_interface_bind_request_server[2] = {
63 nullptr,
64 nullptr,
65};
66
67const wl_interface* registry_interface_global_event_server[3] = {
68 nullptr,
69 nullptr,
70 nullptr,
71};
72
73const wl_interface* registry_interface_global_remove_event_server[1] = {
74 nullptr,
75};
76
77const wl_message registry_interface_requests_server[1] = {
78 {
79 "bind",
80 "usun",
81 registry_interface_bind_request_server,
82 },
83};
84
85const wl_message registry_interface_events_server[2] = {
86 {
87 "global",
88 "usu",
89 registry_interface_global_event_server,
90 },
91 {
92 "global_remove",
93 "u",
94 registry_interface_global_remove_event_server,
95 },
96};
97
98const wl_interface wayland::server::detail::registry_interface =
99 {
100 "wl_registry",
101 1,
102 1,
103 registry_interface_requests_server,
104 2,
105 registry_interface_events_server,
106 };
107
108const wl_interface* callback_interface_done_event_server[1] = {
109 nullptr,
110};
111
112const wl_message callback_interface_requests_server[0] = {
113};
114
115const wl_message callback_interface_events_server[1] = {
116 {
117 "done",
118 "u",
119 callback_interface_done_event_server,
120 },
121};
122
123const wl_interface wayland::server::detail::callback_interface =
124 {
125 "wl_callback",
126 1,
127 0,
128 callback_interface_requests_server,
129 1,
130 callback_interface_events_server,
131 };
132
133const wl_interface* compositor_interface_create_surface_request_server[1] = {
134 &surface_interface,
135};
136
137const wl_interface* compositor_interface_create_region_request_server[1] = {
138 &region_interface,
139};
140
141const wl_message compositor_interface_requests_server[2] = {
142 {
143 "create_surface",
144 "n",
145 compositor_interface_create_surface_request_server,
146 },
147 {
148 "create_region",
149 "n",
150 compositor_interface_create_region_request_server,
151 },
152};
153
154const wl_message compositor_interface_events_server[0] = {
155};
156
157const wl_interface wayland::server::detail::compositor_interface =
158 {
159 "wl_compositor",
160 5,
161 2,
162 compositor_interface_requests_server,
163 0,
164 compositor_interface_events_server,
165 };
166
167const wl_interface* shm_pool_interface_create_buffer_request_server[6] = {
168 &buffer_interface,
169 nullptr,
170 nullptr,
171 nullptr,
172 nullptr,
173 nullptr,
174};
175
176const wl_interface* shm_pool_interface_destroy_request_server[0] = {
177};
178
179const wl_interface* shm_pool_interface_resize_request_server[1] = {
180 nullptr,
181};
182
183const wl_message shm_pool_interface_requests_server[3] = {
184 {
185 "create_buffer",
186 "niiiiu",
187 shm_pool_interface_create_buffer_request_server,
188 },
189 {
190 "destroy",
191 "",
192 shm_pool_interface_destroy_request_server,
193 },
194 {
195 "resize",
196 "i",
197 shm_pool_interface_resize_request_server,
198 },
199};
200
201const wl_message shm_pool_interface_events_server[0] = {
202};
203
204const wl_interface wayland::server::detail::shm_pool_interface =
205 {
206 "wl_shm_pool",
207 1,
208 3,
209 shm_pool_interface_requests_server,
210 0,
211 shm_pool_interface_events_server,
212 };
213
214const wl_interface* shm_interface_create_pool_request_server[3] = {
215 &shm_pool_interface,
216 nullptr,
217 nullptr,
218};
219
220const wl_interface* shm_interface_format_event_server[1] = {
221 nullptr,
222};
223
224const wl_message shm_interface_requests_server[1] = {
225 {
226 "create_pool",
227 "nhi",
228 shm_interface_create_pool_request_server,
229 },
230};
231
232const wl_message shm_interface_events_server[1] = {
233 {
234 "format",
235 "u",
236 shm_interface_format_event_server,
237 },
238};
239
240const wl_interface wayland::server::detail::shm_interface =
241 {
242 "wl_shm",
243 1,
244 1,
245 shm_interface_requests_server,
246 1,
247 shm_interface_events_server,
248 };
249
250const wl_interface* buffer_interface_destroy_request_server[0] = {
251};
252
253const wl_interface* buffer_interface_release_event_server[0] = {
254};
255
256const wl_message buffer_interface_requests_server[1] = {
257 {
258 "destroy",
259 "",
260 buffer_interface_destroy_request_server,
261 },
262};
263
264const wl_message buffer_interface_events_server[1] = {
265 {
266 "release",
267 "",
268 buffer_interface_release_event_server,
269 },
270};
271
272const wl_interface wayland::server::detail::buffer_interface =
273 {
274 "wl_buffer",
275 1,
276 1,
277 buffer_interface_requests_server,
278 1,
279 buffer_interface_events_server,
280 };
281
282const wl_interface* data_offer_interface_accept_request_server[2] = {
283 nullptr,
284 nullptr,
285};
286
287const wl_interface* data_offer_interface_receive_request_server[2] = {
288 nullptr,
289 nullptr,
290};
291
292const wl_interface* data_offer_interface_destroy_request_server[0] = {
293};
294
295const wl_interface* data_offer_interface_finish_request_server[0] = {
296};
297
298const wl_interface* data_offer_interface_set_actions_request_server[2] = {
299 nullptr,
300 nullptr,
301};
302
303const wl_interface* data_offer_interface_offer_event_server[1] = {
304 nullptr,
305};
306
307const wl_interface* data_offer_interface_source_actions_event_server[1] = {
308 nullptr,
309};
310
311const wl_interface* data_offer_interface_action_event_server[1] = {
312 nullptr,
313};
314
315const wl_message data_offer_interface_requests_server[5] = {
316 {
317 "accept",
318 "u?s",
319 data_offer_interface_accept_request_server,
320 },
321 {
322 "receive",
323 "sh",
324 data_offer_interface_receive_request_server,
325 },
326 {
327 "destroy",
328 "",
329 data_offer_interface_destroy_request_server,
330 },
331 {
332 "finish",
333 "3",
334 data_offer_interface_finish_request_server,
335 },
336 {
337 "set_actions",
338 "3uu",
339 data_offer_interface_set_actions_request_server,
340 },
341};
342
343const wl_message data_offer_interface_events_server[3] = {
344 {
345 "offer",
346 "s",
347 data_offer_interface_offer_event_server,
348 },
349 {
350 "source_actions",
351 "3u",
352 data_offer_interface_source_actions_event_server,
353 },
354 {
355 "action",
356 "3u",
357 data_offer_interface_action_event_server,
358 },
359};
360
361const wl_interface wayland::server::detail::data_offer_interface =
362 {
363 "wl_data_offer",
364 3,
365 5,
366 data_offer_interface_requests_server,
367 3,
368 data_offer_interface_events_server,
369 };
370
371const wl_interface* data_source_interface_offer_request_server[1] = {
372 nullptr,
373};
374
375const wl_interface* data_source_interface_destroy_request_server[0] = {
376};
377
378const wl_interface* data_source_interface_set_actions_request_server[1] = {
379 nullptr,
380};
381
382const wl_interface* data_source_interface_target_event_server[1] = {
383 nullptr,
384};
385
386const wl_interface* data_source_interface_send_event_server[2] = {
387 nullptr,
388 nullptr,
389};
390
391const wl_interface* data_source_interface_cancelled_event_server[0] = {
392};
393
394const wl_interface* data_source_interface_dnd_drop_performed_event_server[0] = {
395};
396
397const wl_interface* data_source_interface_dnd_finished_event_server[0] = {
398};
399
400const wl_interface* data_source_interface_action_event_server[1] = {
401 nullptr,
402};
403
404const wl_message data_source_interface_requests_server[3] = {
405 {
406 "offer",
407 "s",
408 data_source_interface_offer_request_server,
409 },
410 {
411 "destroy",
412 "",
413 data_source_interface_destroy_request_server,
414 },
415 {
416 "set_actions",
417 "3u",
418 data_source_interface_set_actions_request_server,
419 },
420};
421
422const wl_message data_source_interface_events_server[6] = {
423 {
424 "target",
425 "?s",
426 data_source_interface_target_event_server,
427 },
428 {
429 "send",
430 "sh",
431 data_source_interface_send_event_server,
432 },
433 {
434 "cancelled",
435 "",
436 data_source_interface_cancelled_event_server,
437 },
438 {
439 "dnd_drop_performed",
440 "3",
441 data_source_interface_dnd_drop_performed_event_server,
442 },
443 {
444 "dnd_finished",
445 "3",
446 data_source_interface_dnd_finished_event_server,
447 },
448 {
449 "action",
450 "3u",
451 data_source_interface_action_event_server,
452 },
453};
454
455const wl_interface wayland::server::detail::data_source_interface =
456 {
457 "wl_data_source",
458 3,
459 3,
460 data_source_interface_requests_server,
461 6,
462 data_source_interface_events_server,
463 };
464
465const wl_interface* data_device_interface_start_drag_request_server[4] = {
466 &data_source_interface,
467 &surface_interface,
468 &surface_interface,
469 nullptr,
470};
471
472const wl_interface* data_device_interface_set_selection_request_server[2] = {
473 &data_source_interface,
474 nullptr,
475};
476
477const wl_interface* data_device_interface_release_request_server[0] = {
478};
479
480const wl_interface* data_device_interface_data_offer_event_server[1] = {
481 &data_offer_interface,
482};
483
484const wl_interface* data_device_interface_enter_event_server[5] = {
485 nullptr,
486 &surface_interface,
487 nullptr,
488 nullptr,
489 &data_offer_interface,
490};
491
492const wl_interface* data_device_interface_leave_event_server[0] = {
493};
494
495const wl_interface* data_device_interface_motion_event_server[3] = {
496 nullptr,
497 nullptr,
498 nullptr,
499};
500
501const wl_interface* data_device_interface_drop_event_server[0] = {
502};
503
504const wl_interface* data_device_interface_selection_event_server[1] = {
505 &data_offer_interface,
506};
507
508const wl_message data_device_interface_requests_server[3] = {
509 {
510 "start_drag",
511 "?oo?ou",
512 data_device_interface_start_drag_request_server,
513 },
514 {
515 "set_selection",
516 "?ou",
517 data_device_interface_set_selection_request_server,
518 },
519 {
520 "release",
521 "2",
522 data_device_interface_release_request_server,
523 },
524};
525
526const wl_message data_device_interface_events_server[6] = {
527 {
528 "data_offer",
529 "n",
530 data_device_interface_data_offer_event_server,
531 },
532 {
533 "enter",
534 "uoff?o",
535 data_device_interface_enter_event_server,
536 },
537 {
538 "leave",
539 "",
540 data_device_interface_leave_event_server,
541 },
542 {
543 "motion",
544 "uff",
545 data_device_interface_motion_event_server,
546 },
547 {
548 "drop",
549 "",
550 data_device_interface_drop_event_server,
551 },
552 {
553 "selection",
554 "?o",
555 data_device_interface_selection_event_server,
556 },
557};
558
559const wl_interface wayland::server::detail::data_device_interface =
560 {
561 "wl_data_device",
562 3,
563 3,
564 data_device_interface_requests_server,
565 6,
566 data_device_interface_events_server,
567 };
568
569const wl_interface* data_device_manager_interface_create_data_source_request_server[1] = {
570 &data_source_interface,
571};
572
573const wl_interface* data_device_manager_interface_get_data_device_request_server[2] = {
574 &data_device_interface,
575 &seat_interface,
576};
577
578const wl_message data_device_manager_interface_requests_server[2] = {
579 {
580 "create_data_source",
581 "n",
582 data_device_manager_interface_create_data_source_request_server,
583 },
584 {
585 "get_data_device",
586 "no",
587 data_device_manager_interface_get_data_device_request_server,
588 },
589};
590
591const wl_message data_device_manager_interface_events_server[0] = {
592};
593
594const wl_interface wayland::server::detail::data_device_manager_interface =
595 {
596 "wl_data_device_manager",
597 3,
598 2,
599 data_device_manager_interface_requests_server,
600 0,
601 data_device_manager_interface_events_server,
602 };
603
604const wl_interface* shell_interface_get_shell_surface_request_server[2] = {
605 &shell_surface_interface,
606 &surface_interface,
607};
608
609const wl_message shell_interface_requests_server[1] = {
610 {
611 "get_shell_surface",
612 "no",
613 shell_interface_get_shell_surface_request_server,
614 },
615};
616
617const wl_message shell_interface_events_server[0] = {
618};
619
620const wl_interface wayland::server::detail::shell_interface =
621 {
622 "wl_shell",
623 1,
624 1,
625 shell_interface_requests_server,
626 0,
627 shell_interface_events_server,
628 };
629
630const wl_interface* shell_surface_interface_pong_request_server[1] = {
631 nullptr,
632};
633
634const wl_interface* shell_surface_interface_move_request_server[2] = {
635 &seat_interface,
636 nullptr,
637};
638
639const wl_interface* shell_surface_interface_resize_request_server[3] = {
640 &seat_interface,
641 nullptr,
642 nullptr,
643};
644
645const wl_interface* shell_surface_interface_set_toplevel_request_server[0] = {
646};
647
648const wl_interface* shell_surface_interface_set_transient_request_server[4] = {
649 &surface_interface,
650 nullptr,
651 nullptr,
652 nullptr,
653};
654
655const wl_interface* shell_surface_interface_set_fullscreen_request_server[3] = {
656 nullptr,
657 nullptr,
658 &output_interface,
659};
660
661const wl_interface* shell_surface_interface_set_popup_request_server[6] = {
662 &seat_interface,
663 nullptr,
664 &surface_interface,
665 nullptr,
666 nullptr,
667 nullptr,
668};
669
670const wl_interface* shell_surface_interface_set_maximized_request_server[1] = {
671 &output_interface,
672};
673
674const wl_interface* shell_surface_interface_set_title_request_server[1] = {
675 nullptr,
676};
677
678const wl_interface* shell_surface_interface_set_class_request_server[1] = {
679 nullptr,
680};
681
682const wl_interface* shell_surface_interface_ping_event_server[1] = {
683 nullptr,
684};
685
686const wl_interface* shell_surface_interface_configure_event_server[3] = {
687 nullptr,
688 nullptr,
689 nullptr,
690};
691
692const wl_interface* shell_surface_interface_popup_done_event_server[0] = {
693};
694
695const wl_message shell_surface_interface_requests_server[10] = {
696 {
697 "pong",
698 "u",
699 shell_surface_interface_pong_request_server,
700 },
701 {
702 "move",
703 "ou",
704 shell_surface_interface_move_request_server,
705 },
706 {
707 "resize",
708 "ouu",
709 shell_surface_interface_resize_request_server,
710 },
711 {
712 "set_toplevel",
713 "",
714 shell_surface_interface_set_toplevel_request_server,
715 },
716 {
717 "set_transient",
718 "oiiu",
719 shell_surface_interface_set_transient_request_server,
720 },
721 {
722 "set_fullscreen",
723 "uu?o",
724 shell_surface_interface_set_fullscreen_request_server,
725 },
726 {
727 "set_popup",
728 "ouoiiu",
729 shell_surface_interface_set_popup_request_server,
730 },
731 {
732 "set_maximized",
733 "?o",
734 shell_surface_interface_set_maximized_request_server,
735 },
736 {
737 "set_title",
738 "s",
739 shell_surface_interface_set_title_request_server,
740 },
741 {
742 "set_class",
743 "s",
744 shell_surface_interface_set_class_request_server,
745 },
746};
747
748const wl_message shell_surface_interface_events_server[3] = {
749 {
750 "ping",
751 "u",
752 shell_surface_interface_ping_event_server,
753 },
754 {
755 "configure",
756 "uii",
757 shell_surface_interface_configure_event_server,
758 },
759 {
760 "popup_done",
761 "",
762 shell_surface_interface_popup_done_event_server,
763 },
764};
765
766const wl_interface wayland::server::detail::shell_surface_interface =
767 {
768 "wl_shell_surface",
769 1,
770 10,
771 shell_surface_interface_requests_server,
772 3,
773 shell_surface_interface_events_server,
774 };
775
776const wl_interface* surface_interface_destroy_request_server[0] = {
777};
778
779const wl_interface* surface_interface_attach_request_server[3] = {
780 &buffer_interface,
781 nullptr,
782 nullptr,
783};
784
785const wl_interface* surface_interface_damage_request_server[4] = {
786 nullptr,
787 nullptr,
788 nullptr,
789 nullptr,
790};
791
792const wl_interface* surface_interface_frame_request_server[1] = {
793 &callback_interface,
794};
795
796const wl_interface* surface_interface_set_opaque_region_request_server[1] = {
797 &region_interface,
798};
799
800const wl_interface* surface_interface_set_input_region_request_server[1] = {
801 &region_interface,
802};
803
804const wl_interface* surface_interface_commit_request_server[0] = {
805};
806
807const wl_interface* surface_interface_set_buffer_transform_request_server[1] = {
808 nullptr,
809};
810
811const wl_interface* surface_interface_set_buffer_scale_request_server[1] = {
812 nullptr,
813};
814
815const wl_interface* surface_interface_damage_buffer_request_server[4] = {
816 nullptr,
817 nullptr,
818 nullptr,
819 nullptr,
820};
821
822const wl_interface* surface_interface_offset_request_server[2] = {
823 nullptr,
824 nullptr,
825};
826
827const wl_interface* surface_interface_enter_event_server[1] = {
828 &output_interface,
829};
830
831const wl_interface* surface_interface_leave_event_server[1] = {
832 &output_interface,
833};
834
835const wl_message surface_interface_requests_server[11] = {
836 {
837 "destroy",
838 "",
839 surface_interface_destroy_request_server,
840 },
841 {
842 "attach",
843 "?oii",
844 surface_interface_attach_request_server,
845 },
846 {
847 "damage",
848 "iiii",
849 surface_interface_damage_request_server,
850 },
851 {
852 "frame",
853 "n",
854 surface_interface_frame_request_server,
855 },
856 {
857 "set_opaque_region",
858 "?o",
859 surface_interface_set_opaque_region_request_server,
860 },
861 {
862 "set_input_region",
863 "?o",
864 surface_interface_set_input_region_request_server,
865 },
866 {
867 "commit",
868 "",
869 surface_interface_commit_request_server,
870 },
871 {
872 "set_buffer_transform",
873 "2i",
874 surface_interface_set_buffer_transform_request_server,
875 },
876 {
877 "set_buffer_scale",
878 "3i",
879 surface_interface_set_buffer_scale_request_server,
880 },
881 {
882 "damage_buffer",
883 "4iiii",
884 surface_interface_damage_buffer_request_server,
885 },
886 {
887 "offset",
888 "5ii",
889 surface_interface_offset_request_server,
890 },
891};
892
893const wl_message surface_interface_events_server[2] = {
894 {
895 "enter",
896 "o",
897 surface_interface_enter_event_server,
898 },
899 {
900 "leave",
901 "o",
902 surface_interface_leave_event_server,
903 },
904};
905
906const wl_interface wayland::server::detail::surface_interface =
907 {
908 "wl_surface",
909 5,
910 11,
911 surface_interface_requests_server,
912 2,
913 surface_interface_events_server,
914 };
915
916const wl_interface* seat_interface_get_pointer_request_server[1] = {
917 &pointer_interface,
918};
919
920const wl_interface* seat_interface_get_keyboard_request_server[1] = {
921 &keyboard_interface,
922};
923
924const wl_interface* seat_interface_get_touch_request_server[1] = {
925 &touch_interface,
926};
927
928const wl_interface* seat_interface_release_request_server[0] = {
929};
930
931const wl_interface* seat_interface_capabilities_event_server[1] = {
932 nullptr,
933};
934
935const wl_interface* seat_interface_name_event_server[1] = {
936 nullptr,
937};
938
939const wl_message seat_interface_requests_server[4] = {
940 {
941 "get_pointer",
942 "n",
943 seat_interface_get_pointer_request_server,
944 },
945 {
946 "get_keyboard",
947 "n",
948 seat_interface_get_keyboard_request_server,
949 },
950 {
951 "get_touch",
952 "n",
953 seat_interface_get_touch_request_server,
954 },
955 {
956 "release",
957 "5",
958 seat_interface_release_request_server,
959 },
960};
961
962const wl_message seat_interface_events_server[2] = {
963 {
964 "capabilities",
965 "u",
966 seat_interface_capabilities_event_server,
967 },
968 {
969 "name",
970 "2s",
971 seat_interface_name_event_server,
972 },
973};
974
975const wl_interface wayland::server::detail::seat_interface =
976 {
977 "wl_seat",
978 8,
979 4,
980 seat_interface_requests_server,
981 2,
982 seat_interface_events_server,
983 };
984
985const wl_interface* pointer_interface_set_cursor_request_server[4] = {
986 nullptr,
987 &surface_interface,
988 nullptr,
989 nullptr,
990};
991
992const wl_interface* pointer_interface_release_request_server[0] = {
993};
994
995const wl_interface* pointer_interface_enter_event_server[4] = {
996 nullptr,
997 &surface_interface,
998 nullptr,
999 nullptr,
1000};
1001
1002const wl_interface* pointer_interface_leave_event_server[2] = {
1003 nullptr,
1004 &surface_interface,
1005};
1006
1007const wl_interface* pointer_interface_motion_event_server[3] = {
1008 nullptr,
1009 nullptr,
1010 nullptr,
1011};
1012
1013const wl_interface* pointer_interface_button_event_server[4] = {
1014 nullptr,
1015 nullptr,
1016 nullptr,
1017 nullptr,
1018};
1019
1020const wl_interface* pointer_interface_axis_event_server[3] = {
1021 nullptr,
1022 nullptr,
1023 nullptr,
1024};
1025
1026const wl_interface* pointer_interface_frame_event_server[0] = {
1027};
1028
1029const wl_interface* pointer_interface_axis_source_event_server[1] = {
1030 nullptr,
1031};
1032
1033const wl_interface* pointer_interface_axis_stop_event_server[2] = {
1034 nullptr,
1035 nullptr,
1036};
1037
1038const wl_interface* pointer_interface_axis_discrete_event_server[2] = {
1039 nullptr,
1040 nullptr,
1041};
1042
1043const wl_interface* pointer_interface_axis_value120_event_server[2] = {
1044 nullptr,
1045 nullptr,
1046};
1047
1048const wl_message pointer_interface_requests_server[2] = {
1049 {
1050 "set_cursor",
1051 "u?oii",
1052 pointer_interface_set_cursor_request_server,
1053 },
1054 {
1055 "release",
1056 "3",
1057 pointer_interface_release_request_server,
1058 },
1059};
1060
1061const wl_message pointer_interface_events_server[10] = {
1062 {
1063 "enter",
1064 "uoff",
1065 pointer_interface_enter_event_server,
1066 },
1067 {
1068 "leave",
1069 "uo",
1070 pointer_interface_leave_event_server,
1071 },
1072 {
1073 "motion",
1074 "uff",
1075 pointer_interface_motion_event_server,
1076 },
1077 {
1078 "button",
1079 "uuuu",
1080 pointer_interface_button_event_server,
1081 },
1082 {
1083 "axis",
1084 "uuf",
1085 pointer_interface_axis_event_server,
1086 },
1087 {
1088 "frame",
1089 "5",
1090 pointer_interface_frame_event_server,
1091 },
1092 {
1093 "axis_source",
1094 "5u",
1095 pointer_interface_axis_source_event_server,
1096 },
1097 {
1098 "axis_stop",
1099 "5uu",
1100 pointer_interface_axis_stop_event_server,
1101 },
1102 {
1103 "axis_discrete",
1104 "5ui",
1105 pointer_interface_axis_discrete_event_server,
1106 },
1107 {
1108 "axis_value120",
1109 "8ui",
1110 pointer_interface_axis_value120_event_server,
1111 },
1112};
1113
1114const wl_interface wayland::server::detail::pointer_interface =
1115 {
1116 "wl_pointer",
1117 8,
1118 2,
1119 pointer_interface_requests_server,
1120 10,
1121 pointer_interface_events_server,
1122 };
1123
1124const wl_interface* keyboard_interface_release_request_server[0] = {
1125};
1126
1127const wl_interface* keyboard_interface_keymap_event_server[3] = {
1128 nullptr,
1129 nullptr,
1130 nullptr,
1131};
1132
1133const wl_interface* keyboard_interface_enter_event_server[3] = {
1134 nullptr,
1135 &surface_interface,
1136 nullptr,
1137};
1138
1139const wl_interface* keyboard_interface_leave_event_server[2] = {
1140 nullptr,
1141 &surface_interface,
1142};
1143
1144const wl_interface* keyboard_interface_key_event_server[4] = {
1145 nullptr,
1146 nullptr,
1147 nullptr,
1148 nullptr,
1149};
1150
1151const wl_interface* keyboard_interface_modifiers_event_server[5] = {
1152 nullptr,
1153 nullptr,
1154 nullptr,
1155 nullptr,
1156 nullptr,
1157};
1158
1159const wl_interface* keyboard_interface_repeat_info_event_server[2] = {
1160 nullptr,
1161 nullptr,
1162};
1163
1164const wl_message keyboard_interface_requests_server[1] = {
1165 {
1166 "release",
1167 "3",
1168 keyboard_interface_release_request_server,
1169 },
1170};
1171
1172const wl_message keyboard_interface_events_server[6] = {
1173 {
1174 "keymap",
1175 "uhu",
1176 keyboard_interface_keymap_event_server,
1177 },
1178 {
1179 "enter",
1180 "uoa",
1181 keyboard_interface_enter_event_server,
1182 },
1183 {
1184 "leave",
1185 "uo",
1186 keyboard_interface_leave_event_server,
1187 },
1188 {
1189 "key",
1190 "uuuu",
1191 keyboard_interface_key_event_server,
1192 },
1193 {
1194 "modifiers",
1195 "uuuuu",
1196 keyboard_interface_modifiers_event_server,
1197 },
1198 {
1199 "repeat_info",
1200 "4ii",
1201 keyboard_interface_repeat_info_event_server,
1202 },
1203};
1204
1205const wl_interface wayland::server::detail::keyboard_interface =
1206 {
1207 "wl_keyboard",
1208 8,
1209 1,
1210 keyboard_interface_requests_server,
1211 6,
1212 keyboard_interface_events_server,
1213 };
1214
1215const wl_interface* touch_interface_release_request_server[0] = {
1216};
1217
1218const wl_interface* touch_interface_down_event_server[6] = {
1219 nullptr,
1220 nullptr,
1221 &surface_interface,
1222 nullptr,
1223 nullptr,
1224 nullptr,
1225};
1226
1227const wl_interface* touch_interface_up_event_server[3] = {
1228 nullptr,
1229 nullptr,
1230 nullptr,
1231};
1232
1233const wl_interface* touch_interface_motion_event_server[4] = {
1234 nullptr,
1235 nullptr,
1236 nullptr,
1237 nullptr,
1238};
1239
1240const wl_interface* touch_interface_frame_event_server[0] = {
1241};
1242
1243const wl_interface* touch_interface_cancel_event_server[0] = {
1244};
1245
1246const wl_interface* touch_interface_shape_event_server[3] = {
1247 nullptr,
1248 nullptr,
1249 nullptr,
1250};
1251
1252const wl_interface* touch_interface_orientation_event_server[2] = {
1253 nullptr,
1254 nullptr,
1255};
1256
1257const wl_message touch_interface_requests_server[1] = {
1258 {
1259 "release",
1260 "3",
1261 touch_interface_release_request_server,
1262 },
1263};
1264
1265const wl_message touch_interface_events_server[7] = {
1266 {
1267 "down",
1268 "uuoiff",
1269 touch_interface_down_event_server,
1270 },
1271 {
1272 "up",
1273 "uui",
1274 touch_interface_up_event_server,
1275 },
1276 {
1277 "motion",
1278 "uiff",
1279 touch_interface_motion_event_server,
1280 },
1281 {
1282 "frame",
1283 "",
1284 touch_interface_frame_event_server,
1285 },
1286 {
1287 "cancel",
1288 "",
1289 touch_interface_cancel_event_server,
1290 },
1291 {
1292 "shape",
1293 "6iff",
1294 touch_interface_shape_event_server,
1295 },
1296 {
1297 "orientation",
1298 "6if",
1299 touch_interface_orientation_event_server,
1300 },
1301};
1302
1303const wl_interface wayland::server::detail::touch_interface =
1304 {
1305 "wl_touch",
1306 8,
1307 1,
1308 touch_interface_requests_server,
1309 7,
1310 touch_interface_events_server,
1311 };
1312
1313const wl_interface* output_interface_release_request_server[0] = {
1314};
1315
1316const wl_interface* output_interface_geometry_event_server[8] = {
1317 nullptr,
1318 nullptr,
1319 nullptr,
1320 nullptr,
1321 nullptr,
1322 nullptr,
1323 nullptr,
1324 nullptr,
1325};
1326
1327const wl_interface* output_interface_mode_event_server[4] = {
1328 nullptr,
1329 nullptr,
1330 nullptr,
1331 nullptr,
1332};
1333
1334const wl_interface* output_interface_done_event_server[0] = {
1335};
1336
1337const wl_interface* output_interface_scale_event_server[1] = {
1338 nullptr,
1339};
1340
1341const wl_interface* output_interface_name_event_server[1] = {
1342 nullptr,
1343};
1344
1345const wl_interface* output_interface_description_event_server[1] = {
1346 nullptr,
1347};
1348
1349const wl_message output_interface_requests_server[1] = {
1350 {
1351 "release",
1352 "3",
1353 output_interface_release_request_server,
1354 },
1355};
1356
1357const wl_message output_interface_events_server[6] = {
1358 {
1359 "geometry",
1360 "iiiiissi",
1361 output_interface_geometry_event_server,
1362 },
1363 {
1364 "mode",
1365 "uiii",
1366 output_interface_mode_event_server,
1367 },
1368 {
1369 "done",
1370 "2",
1371 output_interface_done_event_server,
1372 },
1373 {
1374 "scale",
1375 "2i",
1376 output_interface_scale_event_server,
1377 },
1378 {
1379 "name",
1380 "4s",
1381 output_interface_name_event_server,
1382 },
1383 {
1384 "description",
1385 "4s",
1386 output_interface_description_event_server,
1387 },
1388};
1389
1390const wl_interface wayland::server::detail::output_interface =
1391 {
1392 "wl_output",
1393 4,
1394 1,
1395 output_interface_requests_server,
1396 6,
1397 output_interface_events_server,
1398 };
1399
1400const wl_interface* region_interface_destroy_request_server[0] = {
1401};
1402
1403const wl_interface* region_interface_add_request_server[4] = {
1404 nullptr,
1405 nullptr,
1406 nullptr,
1407 nullptr,
1408};
1409
1410const wl_interface* region_interface_subtract_request_server[4] = {
1411 nullptr,
1412 nullptr,
1413 nullptr,
1414 nullptr,
1415};
1416
1417const wl_message region_interface_requests_server[3] = {
1418 {
1419 "destroy",
1420 "",
1421 region_interface_destroy_request_server,
1422 },
1423 {
1424 "add",
1425 "iiii",
1426 region_interface_add_request_server,
1427 },
1428 {
1429 "subtract",
1430 "iiii",
1431 region_interface_subtract_request_server,
1432 },
1433};
1434
1435const wl_message region_interface_events_server[0] = {
1436};
1437
1438const wl_interface wayland::server::detail::region_interface =
1439 {
1440 "wl_region",
1441 1,
1442 3,
1443 region_interface_requests_server,
1444 0,
1445 region_interface_events_server,
1446 };
1447
1448const wl_interface* subcompositor_interface_destroy_request_server[0] = {
1449};
1450
1451const wl_interface* subcompositor_interface_get_subsurface_request_server[3] = {
1452 &subsurface_interface,
1453 &surface_interface,
1454 &surface_interface,
1455};
1456
1457const wl_message subcompositor_interface_requests_server[2] = {
1458 {
1459 "destroy",
1460 "",
1461 subcompositor_interface_destroy_request_server,
1462 },
1463 {
1464 "get_subsurface",
1465 "noo",
1466 subcompositor_interface_get_subsurface_request_server,
1467 },
1468};
1469
1470const wl_message subcompositor_interface_events_server[0] = {
1471};
1472
1473const wl_interface wayland::server::detail::subcompositor_interface =
1474 {
1475 "wl_subcompositor",
1476 1,
1477 2,
1478 subcompositor_interface_requests_server,
1479 0,
1480 subcompositor_interface_events_server,
1481 };
1482
1483const wl_interface* subsurface_interface_destroy_request_server[0] = {
1484};
1485
1486const wl_interface* subsurface_interface_set_position_request_server[2] = {
1487 nullptr,
1488 nullptr,
1489};
1490
1491const wl_interface* subsurface_interface_place_above_request_server[1] = {
1492 &surface_interface,
1493};
1494
1495const wl_interface* subsurface_interface_place_below_request_server[1] = {
1496 &surface_interface,
1497};
1498
1499const wl_interface* subsurface_interface_set_sync_request_server[0] = {
1500};
1501
1502const wl_interface* subsurface_interface_set_desync_request_server[0] = {
1503};
1504
1505const wl_message subsurface_interface_requests_server[6] = {
1506 {
1507 "destroy",
1508 "",
1509 subsurface_interface_destroy_request_server,
1510 },
1511 {
1512 "set_position",
1513 "ii",
1514 subsurface_interface_set_position_request_server,
1515 },
1516 {
1517 "place_above",
1518 "o",
1519 subsurface_interface_place_above_request_server,
1520 },
1521 {
1522 "place_below",
1523 "o",
1524 subsurface_interface_place_below_request_server,
1525 },
1526 {
1527 "set_sync",
1528 "",
1529 subsurface_interface_set_sync_request_server,
1530 },
1531 {
1532 "set_desync",
1533 "",
1534 subsurface_interface_set_desync_request_server,
1535 },
1536};
1537
1538const wl_message subsurface_interface_events_server[0] = {
1539};
1540
1541const wl_interface wayland::server::detail::subsurface_interface =
1542 {
1543 "wl_subsurface",
1544 1,
1545 6,
1546 subsurface_interface_requests_server,
1547 0,
1548 subsurface_interface_events_server,
1549 };
1550
1551registry_t::registry_t(const client_t& client, uint32_t id, int version)
1552 : resource_t(client, &server::detail::registry_interface, id, version)
1553{
1554 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
1555}
1556
1557registry_t::registry_t(const resource_t &resource)
1558 : resource_t(resource)
1559{
1560 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
1561}
1562
1563const std::string registry_t::interface_name = "wl_registry";
1564
1565registry_t::operator wl_registry*() const
1566{
1567 return reinterpret_cast<wl_registry*> (c_ptr());
1568}
1569
1570std::function<void(uint32_t, resource_t)> &registry_t::on_bind()
1571{
1572 return std::static_pointer_cast<events_t>(get_events())->bind;
1573}
1574
1575
1576void registry_t::global(uint32_t name, std::string const& interface, uint32_t version, bool post)
1577{
1578 send_event(post, 0, name, interface, version);
1579}
1580
1581void registry_t::global_remove(uint32_t name, bool post)
1582{
1583 send_event(post, 1, name);
1584}
1585
1586int registry_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
1587{
1588 std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
1589 switch(opcode)
1590 {
1591 case 0:
1592 if(events->bind) events->bind(args[0].get<uint32_t>(), args[1].get<resource_t>());
1593 break;
1594 }
1595 return 0;
1596}
1597
1598callback_t::callback_t(const client_t& client, uint32_t id, int version)
1599 : resource_t(client, &server::detail::callback_interface, id, version)
1600{
1601 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
1602}
1603
1604callback_t::callback_t(const resource_t &resource)
1605 : resource_t(resource)
1606{
1607 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
1608}
1609
1610const std::string callback_t::interface_name = "wl_callback";
1611
1612callback_t::operator wl_callback*() const
1613{
1614 return reinterpret_cast<wl_callback*> (c_ptr());
1615}
1616
1617void callback_t::done(uint32_t callback_data, bool post)
1618{
1619 send_event(post, 0, callback_data);
1620}
1621
1622int callback_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
1623{
1624 return 0;
1625}
1626
1627compositor_t::compositor_t(const client_t& client, uint32_t id, int version)
1628 : resource_t(client, &server::detail::compositor_interface, id, version)
1629{
1630 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
1631}
1632
1633compositor_t::compositor_t(const resource_t &resource)
1634 : resource_t(resource)
1635{
1636 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
1637}
1638
1639const std::string compositor_t::interface_name = "wl_compositor";
1640
1641compositor_t::operator wl_compositor*() const
1642{
1643 return reinterpret_cast<wl_compositor*> (c_ptr());
1644}
1645
1647{
1648 return std::static_pointer_cast<events_t>(get_events())->create_surface;
1649}
1650
1651
1653{
1654 return std::static_pointer_cast<events_t>(get_events())->create_region;
1655}
1656
1657
1658int compositor_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
1659{
1660 std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
1661 switch(opcode)
1662 {
1663 case 0:
1664 if(events->create_surface) events->create_surface(surface_t(args[0].get<resource_t>()));
1665 break;
1666 case 1:
1667 if(events->create_region) events->create_region(region_t(args[0].get<resource_t>()));
1668 break;
1669 }
1670 return 0;
1671}
1672
1673shm_pool_t::shm_pool_t(const client_t& client, uint32_t id, int version)
1674 : resource_t(client, &server::detail::shm_pool_interface, id, version)
1675{
1676 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
1677}
1678
1679shm_pool_t::shm_pool_t(const resource_t &resource)
1680 : resource_t(resource)
1681{
1682 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
1683}
1684
1685const std::string shm_pool_t::interface_name = "wl_shm_pool";
1686
1687shm_pool_t::operator wl_shm_pool*() const
1688{
1689 return reinterpret_cast<wl_shm_pool*> (c_ptr());
1690}
1691
1692std::function<void(buffer_t, int32_t, int32_t, int32_t, int32_t, shm_format)> &shm_pool_t::on_create_buffer()
1693{
1694 return std::static_pointer_cast<events_t>(get_events())->create_buffer;
1695}
1696
1697
1698std::function<void()> &shm_pool_t::on_destroy()
1699{
1700 return std::static_pointer_cast<events_t>(get_events())->destroy;
1701}
1702
1703
1704std::function<void(int32_t)> &shm_pool_t::on_resize()
1705{
1706 return std::static_pointer_cast<events_t>(get_events())->resize;
1707}
1708
1709
1710int shm_pool_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
1711{
1712 std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
1713 switch(opcode)
1714 {
1715 case 0:
1716 if(events->create_buffer) events->create_buffer(buffer_t(args[0].get<resource_t>()), args[1].get<int32_t>(), args[2].get<int32_t>(), args[3].get<int32_t>(), args[4].get<int32_t>(), shm_format(args[5].get<uint32_t>()));
1717 break;
1718 case 1:
1719 if(events->destroy) events->destroy();
1720 break;
1721 case 2:
1722 if(events->resize) events->resize(args[0].get<int32_t>());
1723 break;
1724 }
1725 return 0;
1726}
1727
1728shm_t::shm_t(const client_t& client, uint32_t id, int version)
1729 : resource_t(client, &server::detail::shm_interface, id, version)
1730{
1731 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
1732}
1733
1734shm_t::shm_t(const resource_t &resource)
1735 : resource_t(resource)
1736{
1737 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
1738}
1739
1740const std::string shm_t::interface_name = "wl_shm";
1741
1742shm_t::operator wl_shm*() const
1743{
1744 return reinterpret_cast<wl_shm*> (c_ptr());
1745}
1746
1747std::function<void(shm_pool_t, int, int32_t)> &shm_t::on_create_pool()
1748{
1749 return std::static_pointer_cast<events_t>(get_events())->create_pool;
1750}
1751
1752
1753void shm_t::format(shm_format const& format, bool post)
1754{
1755 send_event(post, 0, static_cast<uint32_t>(format));
1756}
1757
1758void shm_t::post_invalid_format(std::string const& msg)
1759{
1760 post_error(static_cast<uint32_t>(shm_error::invalid_format), msg);
1761}
1762
1763void shm_t::post_invalid_stride(std::string const& msg)
1764{
1765 post_error(static_cast<uint32_t>(shm_error::invalid_stride), msg);
1766}
1767
1768void shm_t::post_invalid_fd(std::string const& msg)
1769{
1770 post_error(static_cast<uint32_t>(shm_error::invalid_fd), msg);
1771}
1772
1773int shm_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
1774{
1775 std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
1776 switch(opcode)
1777 {
1778 case 0:
1779 if(events->create_pool) events->create_pool(shm_pool_t(args[0].get<resource_t>()), args[1].get<int>(), args[2].get<int32_t>());
1780 break;
1781 }
1782 return 0;
1783}
1784
1785
1786
1787buffer_t::buffer_t(const client_t& client, uint32_t id, int version)
1788 : resource_t(client, &server::detail::buffer_interface, id, version)
1789{
1790 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
1791}
1792
1793buffer_t::buffer_t(const resource_t &resource)
1794 : resource_t(resource)
1795{
1796 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
1797}
1798
1799const std::string buffer_t::interface_name = "wl_buffer";
1800
1801buffer_t::operator wl_buffer*() const
1802{
1803 return reinterpret_cast<wl_buffer*> (c_ptr());
1804}
1805
1806std::function<void()> &buffer_t::on_destroy()
1807{
1808 return std::static_pointer_cast<events_t>(get_events())->destroy;
1809}
1810
1811
1812void buffer_t::release(bool post)
1813{
1814 send_event(post, 0);
1815}
1816
1817int buffer_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
1818{
1819 std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
1820 switch(opcode)
1821 {
1822 case 0:
1823 if(events->destroy) events->destroy();
1824 break;
1825 }
1826 return 0;
1827}
1828
1829data_offer_t::data_offer_t(const client_t& client, uint32_t id, int version)
1830 : resource_t(client, &server::detail::data_offer_interface, id, version)
1831{
1832 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
1833}
1834
1835data_offer_t::data_offer_t(const resource_t &resource)
1836 : resource_t(resource)
1837{
1838 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
1839}
1840
1841const std::string data_offer_t::interface_name = "wl_data_offer";
1842
1843data_offer_t::operator wl_data_offer*() const
1844{
1845 return reinterpret_cast<wl_data_offer*> (c_ptr());
1846}
1847
1848std::function<void(uint32_t, std::string)> &data_offer_t::on_accept()
1849{
1850 return std::static_pointer_cast<events_t>(get_events())->accept;
1851}
1852
1853
1854std::function<void(std::string, int)> &data_offer_t::on_receive()
1855{
1856 return std::static_pointer_cast<events_t>(get_events())->receive;
1857}
1858
1859
1860std::function<void()> &data_offer_t::on_destroy()
1861{
1862 return std::static_pointer_cast<events_t>(get_events())->destroy;
1863}
1864
1865
1866std::function<void()> &data_offer_t::on_finish()
1867{
1868 return std::static_pointer_cast<events_t>(get_events())->finish;
1869}
1870
1871
1873{
1874 return std::static_pointer_cast<events_t>(get_events())->set_actions;
1875}
1876
1877
1878void data_offer_t::offer(std::string const& mime_type, bool post)
1879{
1880 send_event(post, 0, mime_type);
1881}
1882
1884{
1885 send_event(post, 1, static_cast<uint32_t>(source_actions));
1886}
1887
1889{
1890 return (get_version() >= source_actions_since_version);
1891}
1892
1894{
1895 send_event(post, 2, static_cast<uint32_t>(dnd_action));
1896}
1897
1899{
1900 return (get_version() >= action_since_version);
1901}
1902
1903void data_offer_t::post_invalid_finish(std::string const& msg)
1904{
1905 post_error(static_cast<uint32_t>(data_offer_error::invalid_finish), msg);
1906}
1907
1908void data_offer_t::post_invalid_action_mask(std::string const& msg)
1909{
1910 post_error(static_cast<uint32_t>(data_offer_error::invalid_action_mask), msg);
1911}
1912
1913void data_offer_t::post_invalid_action(std::string const& msg)
1914{
1915 post_error(static_cast<uint32_t>(data_offer_error::invalid_action), msg);
1916}
1917
1918void data_offer_t::post_invalid_offer(std::string const& msg)
1919{
1920 post_error(static_cast<uint32_t>(data_offer_error::invalid_offer), msg);
1921}
1922
1923int data_offer_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
1924{
1925 std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
1926 switch(opcode)
1927 {
1928 case 0:
1929 if(events->accept) events->accept(args[0].get<uint32_t>(), args[1].get<std::string>());
1930 break;
1931 case 1:
1932 if(events->receive) events->receive(args[0].get<std::string>(), args[1].get<int>());
1933 break;
1934 case 2:
1935 if(events->destroy) events->destroy();
1936 break;
1937 case 3:
1938 if(events->finish) events->finish();
1939 break;
1940 case 4:
1941 if(events->set_actions) events->set_actions(data_device_manager_dnd_action(args[0].get<uint32_t>()), data_device_manager_dnd_action(args[1].get<uint32_t>()));
1942 break;
1943 }
1944 return 0;
1945}
1946
1947
1948data_source_t::data_source_t(const client_t& client, uint32_t id, int version)
1949 : resource_t(client, &server::detail::data_source_interface, id, version)
1950{
1951 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
1952}
1953
1954data_source_t::data_source_t(const resource_t &resource)
1955 : resource_t(resource)
1956{
1957 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
1958}
1959
1960const std::string data_source_t::interface_name = "wl_data_source";
1961
1962data_source_t::operator wl_data_source*() const
1963{
1964 return reinterpret_cast<wl_data_source*> (c_ptr());
1965}
1966
1967std::function<void(std::string)> &data_source_t::on_offer()
1968{
1969 return std::static_pointer_cast<events_t>(get_events())->offer;
1970}
1971
1972
1973std::function<void()> &data_source_t::on_destroy()
1974{
1975 return std::static_pointer_cast<events_t>(get_events())->destroy;
1976}
1977
1978
1980{
1981 return std::static_pointer_cast<events_t>(get_events())->set_actions;
1982}
1983
1984
1985void data_source_t::target(std::string const& mime_type, bool post)
1986{
1987 send_event(post, 0, mime_type);
1988}
1989
1990void data_source_t::send(std::string const& mime_type, int fd, bool post)
1991{
1992 send_event(post, 1, mime_type, argument_t::fd(fd));
1993}
1994
1996{
1997 send_event(post, 2);
1998}
1999
2001{
2002 send_event(post, 3);
2003}
2004
2006{
2007 return (get_version() >= dnd_drop_performed_since_version);
2008}
2009
2011{
2012 send_event(post, 4);
2013}
2014
2016{
2017 return (get_version() >= dnd_finished_since_version);
2018}
2019
2021{
2022 send_event(post, 5, static_cast<uint32_t>(dnd_action));
2023}
2024
2026{
2027 return (get_version() >= action_since_version);
2028}
2029
2031{
2032 post_error(static_cast<uint32_t>(data_source_error::invalid_action_mask), msg);
2033}
2034
2035void data_source_t::post_invalid_source(std::string const& msg)
2036{
2037 post_error(static_cast<uint32_t>(data_source_error::invalid_source), msg);
2038}
2039
2040int data_source_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
2041{
2042 std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
2043 switch(opcode)
2044 {
2045 case 0:
2046 if(events->offer) events->offer(args[0].get<std::string>());
2047 break;
2048 case 1:
2049 if(events->destroy) events->destroy();
2050 break;
2051 case 2:
2052 if(events->set_actions) events->set_actions(data_device_manager_dnd_action(args[0].get<uint32_t>()));
2053 break;
2054 }
2055 return 0;
2056}
2057
2058
2059data_device_t::data_device_t(const client_t& client, uint32_t id, int version)
2060 : resource_t(client, &server::detail::data_device_interface, id, version)
2061{
2062 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
2063}
2064
2065data_device_t::data_device_t(const resource_t &resource)
2066 : resource_t(resource)
2067{
2068 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
2069}
2070
2071const std::string data_device_t::interface_name = "wl_data_device";
2072
2073data_device_t::operator wl_data_device*() const
2074{
2075 return reinterpret_cast<wl_data_device*> (c_ptr());
2076}
2077
2079{
2080 return std::static_pointer_cast<events_t>(get_events())->start_drag;
2081}
2082
2083
2084std::function<void(data_source_t, uint32_t)> &data_device_t::on_set_selection()
2085{
2086 return std::static_pointer_cast<events_t>(get_events())->set_selection;
2087}
2088
2089
2090std::function<void()> &data_device_t::on_release()
2091{
2092 return std::static_pointer_cast<events_t>(get_events())->release;
2093}
2094
2095
2097{
2098 send_event(post, 0, nullptr);
2099}
2100
2101void data_device_t::enter(uint32_t serial, surface_t const& surface, double x, double y, data_offer_t const& id, bool post)
2102{
2103 send_event(post, 1, serial, surface.proxy_has_object() ? reinterpret_cast<wl_object*>(surface.c_ptr()) : nullptr, x, y, id.proxy_has_object() ? reinterpret_cast<wl_object*>(id.c_ptr()) : nullptr);
2104}
2105
2107{
2108 send_event(post, 2);
2109}
2110
2111void data_device_t::motion(uint32_t time, double x, double y, bool post)
2112{
2113 send_event(post, 3, time, x, y);
2114}
2115
2116void data_device_t::drop(bool post)
2117{
2118 send_event(post, 4);
2119}
2120
2121void data_device_t::selection(data_offer_t const& id, bool post)
2122{
2123 send_event(post, 5, id.proxy_has_object() ? reinterpret_cast<wl_object*>(id.c_ptr()) : nullptr);
2124}
2125
2126void data_device_t::post_role(std::string const& msg)
2127{
2128 post_error(static_cast<uint32_t>(data_device_error::role), msg);
2129}
2130
2131int data_device_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
2132{
2133 std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
2134 switch(opcode)
2135 {
2136 case 0:
2137 if(events->start_drag) events->start_drag(data_source_t(args[0].get<resource_t>()), surface_t(args[1].get<resource_t>()), surface_t(args[2].get<resource_t>()), args[3].get<uint32_t>());
2138 break;
2139 case 1:
2140 if(events->set_selection) events->set_selection(data_source_t(args[0].get<resource_t>()), args[1].get<uint32_t>());
2141 break;
2142 case 2:
2143 if(events->release) events->release();
2144 break;
2145 }
2146 return 0;
2147}
2148
2149
2150data_device_manager_t::data_device_manager_t(const client_t& client, uint32_t id, int version)
2151 : resource_t(client, &server::detail::data_device_manager_interface, id, version)
2152{
2153 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
2154}
2155
2156data_device_manager_t::data_device_manager_t(const resource_t &resource)
2157 : resource_t(resource)
2158{
2159 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
2160}
2161
2162const std::string data_device_manager_t::interface_name = "wl_data_device_manager";
2163
2164data_device_manager_t::operator wl_data_device_manager*() const
2165{
2166 return reinterpret_cast<wl_data_device_manager*> (c_ptr());
2167}
2168
2170{
2171 return std::static_pointer_cast<events_t>(get_events())->create_data_source;
2172}
2173
2174
2176{
2177 return std::static_pointer_cast<events_t>(get_events())->get_data_device;
2178}
2179
2180
2181int data_device_manager_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
2182{
2183 std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
2184 switch(opcode)
2185 {
2186 case 0:
2187 if(events->create_data_source) events->create_data_source(data_source_t(args[0].get<resource_t>()));
2188 break;
2189 case 1:
2190 if(events->get_data_device) events->get_data_device(data_device_t(args[0].get<resource_t>()), seat_t(args[1].get<resource_t>()));
2191 break;
2192 }
2193 return 0;
2194}
2195const bitfield<2147483649, 6> data_device_manager_dnd_action::none{0};
2196const bitfield<2147483649, 6> data_device_manager_dnd_action::copy{1};
2197const bitfield<2147483649, 6> data_device_manager_dnd_action::move{2};
2198const bitfield<2147483649, 6> data_device_manager_dnd_action::ask{4};
2199
2200
2201shell_t::shell_t(const client_t& client, uint32_t id, int version)
2202 : resource_t(client, &server::detail::shell_interface, id, version)
2203{
2204 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
2205}
2206
2207shell_t::shell_t(const resource_t &resource)
2208 : resource_t(resource)
2209{
2210 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
2211}
2212
2213const std::string shell_t::interface_name = "wl_shell";
2214
2215shell_t::operator wl_shell*() const
2216{
2217 return reinterpret_cast<wl_shell*> (c_ptr());
2218}
2219
2221{
2222 return std::static_pointer_cast<events_t>(get_events())->get_shell_surface;
2223}
2224
2225
2226void shell_t::post_role(std::string const& msg)
2227{
2228 post_error(static_cast<uint32_t>(shell_error::role), msg);
2229}
2230
2231int shell_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
2232{
2233 std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
2234 switch(opcode)
2235 {
2236 case 0:
2237 if(events->get_shell_surface) events->get_shell_surface(shell_surface_t(args[0].get<resource_t>()), surface_t(args[1].get<resource_t>()));
2238 break;
2239 }
2240 return 0;
2241}
2242
2243
2244shell_surface_t::shell_surface_t(const client_t& client, uint32_t id, int version)
2245 : resource_t(client, &server::detail::shell_surface_interface, id, version)
2246{
2247 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
2248}
2249
2250shell_surface_t::shell_surface_t(const resource_t &resource)
2251 : resource_t(resource)
2252{
2253 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
2254}
2255
2256const std::string shell_surface_t::interface_name = "wl_shell_surface";
2257
2258shell_surface_t::operator wl_shell_surface*() const
2259{
2260 return reinterpret_cast<wl_shell_surface*> (c_ptr());
2261}
2262
2263std::function<void(uint32_t)> &shell_surface_t::on_pong()
2264{
2265 return std::static_pointer_cast<events_t>(get_events())->pong;
2266}
2267
2268
2269std::function<void(seat_t, uint32_t)> &shell_surface_t::on_move()
2270{
2271 return std::static_pointer_cast<events_t>(get_events())->move;
2272}
2273
2274
2276{
2277 return std::static_pointer_cast<events_t>(get_events())->resize;
2278}
2279
2280
2281std::function<void()> &shell_surface_t::on_set_toplevel()
2282{
2283 return std::static_pointer_cast<events_t>(get_events())->set_toplevel;
2284}
2285
2286
2288{
2289 return std::static_pointer_cast<events_t>(get_events())->set_transient;
2290}
2291
2292
2293std::function<void(shell_surface_fullscreen_method, uint32_t, output_t)> &shell_surface_t::on_set_fullscreen()
2294{
2295 return std::static_pointer_cast<events_t>(get_events())->set_fullscreen;
2296}
2297
2298
2299std::function<void(seat_t, uint32_t, surface_t, int32_t, int32_t, shell_surface_transient)> &shell_surface_t::on_set_popup()
2300{
2301 return std::static_pointer_cast<events_t>(get_events())->set_popup;
2302}
2303
2304
2306{
2307 return std::static_pointer_cast<events_t>(get_events())->set_maximized;
2308}
2309
2310
2311std::function<void(std::string)> &shell_surface_t::on_set_title()
2312{
2313 return std::static_pointer_cast<events_t>(get_events())->set_title;
2314}
2315
2316
2317std::function<void(std::string)> &shell_surface_t::on_set_class()
2318{
2319 return std::static_pointer_cast<events_t>(get_events())->set_class;
2320}
2321
2322
2323void shell_surface_t::ping(uint32_t serial, bool post)
2324{
2325 send_event(post, 0, serial);
2326}
2327
2328void shell_surface_t::configure(shell_surface_resize const& edges, int32_t width, int32_t height, bool post)
2329{
2330 send_event(post, 1, static_cast<uint32_t>(edges), width, height);
2331}
2332
2334{
2335 send_event(post, 2);
2336}
2337
2338int shell_surface_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
2339{
2340 std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
2341 switch(opcode)
2342 {
2343 case 0:
2344 if(events->pong) events->pong(args[0].get<uint32_t>());
2345 break;
2346 case 1:
2347 if(events->move) events->move(seat_t(args[0].get<resource_t>()), args[1].get<uint32_t>());
2348 break;
2349 case 2:
2350 if(events->resize) events->resize(seat_t(args[0].get<resource_t>()), args[1].get<uint32_t>(), shell_surface_resize(args[2].get<uint32_t>()));
2351 break;
2352 case 3:
2353 if(events->set_toplevel) events->set_toplevel();
2354 break;
2355 case 4:
2356 if(events->set_transient) events->set_transient(surface_t(args[0].get<resource_t>()), args[1].get<int32_t>(), args[2].get<int32_t>(), shell_surface_transient(args[3].get<uint32_t>()));
2357 break;
2358 case 5:
2359 if(events->set_fullscreen) events->set_fullscreen(shell_surface_fullscreen_method(args[0].get<uint32_t>()), args[1].get<uint32_t>(), output_t(args[2].get<resource_t>()));
2360 break;
2361 case 6:
2362 if(events->set_popup) events->set_popup(seat_t(args[0].get<resource_t>()), args[1].get<uint32_t>(), surface_t(args[2].get<resource_t>()), args[3].get<int32_t>(), args[4].get<int32_t>(), shell_surface_transient(args[5].get<uint32_t>()));
2363 break;
2364 case 7:
2365 if(events->set_maximized) events->set_maximized(output_t(args[0].get<resource_t>()));
2366 break;
2367 case 8:
2368 if(events->set_title) events->set_title(args[0].get<std::string>());
2369 break;
2370 case 9:
2371 if(events->set_class) events->set_class(args[0].get<std::string>());
2372 break;
2373 }
2374 return 0;
2375}
2376const bitfield<2147483649, 8> shell_surface_resize::none{0};
2377const bitfield<2147483649, 8> shell_surface_resize::top{1};
2378const bitfield<2147483649, 8> shell_surface_resize::bottom{2};
2379const bitfield<2147483649, 8> shell_surface_resize::left{4};
2380const bitfield<2147483649, 8> shell_surface_resize::top_left{5};
2381const bitfield<2147483649, 8> shell_surface_resize::bottom_left{6};
2382const bitfield<2147483649, 8> shell_surface_resize::right{8};
2383const bitfield<2147483649, 8> shell_surface_resize::top_right{9};
2384const bitfield<2147483649, 8> shell_surface_resize::bottom_right{10};
2385
2386const bitfield<1, 9> shell_surface_transient::inactive{0x1};
2387
2388
2389
2390surface_t::surface_t(const client_t& client, uint32_t id, int version)
2391 : resource_t(client, &server::detail::surface_interface, id, version)
2392{
2393 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
2394}
2395
2396surface_t::surface_t(const resource_t &resource)
2397 : resource_t(resource)
2398{
2399 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
2400}
2401
2402const std::string surface_t::interface_name = "wl_surface";
2403
2404surface_t::operator wl_surface*() const
2405{
2406 return reinterpret_cast<wl_surface*> (c_ptr());
2407}
2408
2409std::function<void()> &surface_t::on_destroy()
2410{
2411 return std::static_pointer_cast<events_t>(get_events())->destroy;
2412}
2413
2414
2415std::function<void(buffer_t, int32_t, int32_t)> &surface_t::on_attach()
2416{
2417 return std::static_pointer_cast<events_t>(get_events())->attach;
2418}
2419
2420
2421std::function<void(int32_t, int32_t, int32_t, int32_t)> &surface_t::on_damage()
2422{
2423 return std::static_pointer_cast<events_t>(get_events())->damage;
2424}
2425
2426
2427std::function<void(callback_t)> &surface_t::on_frame()
2428{
2429 return std::static_pointer_cast<events_t>(get_events())->frame;
2430}
2431
2432
2434{
2435 return std::static_pointer_cast<events_t>(get_events())->set_opaque_region;
2436}
2437
2438
2440{
2441 return std::static_pointer_cast<events_t>(get_events())->set_input_region;
2442}
2443
2444
2445std::function<void()> &surface_t::on_commit()
2446{
2447 return std::static_pointer_cast<events_t>(get_events())->commit;
2448}
2449
2450
2452{
2453 return std::static_pointer_cast<events_t>(get_events())->set_buffer_transform;
2454}
2455
2456
2457std::function<void(int32_t)> &surface_t::on_set_buffer_scale()
2458{
2459 return std::static_pointer_cast<events_t>(get_events())->set_buffer_scale;
2460}
2461
2462
2463std::function<void(int32_t, int32_t, int32_t, int32_t)> &surface_t::on_damage_buffer()
2464{
2465 return std::static_pointer_cast<events_t>(get_events())->damage_buffer;
2466}
2467
2468
2469std::function<void(int32_t, int32_t)> &surface_t::on_offset()
2470{
2471 return std::static_pointer_cast<events_t>(get_events())->offset;
2472}
2473
2474
2475void surface_t::enter(output_t const& output, bool post)
2476{
2477 send_event(post, 0, output.proxy_has_object() ? reinterpret_cast<wl_object*>(output.c_ptr()) : nullptr);
2478}
2479
2480void surface_t::leave(output_t const& output, bool post)
2481{
2482 send_event(post, 1, output.proxy_has_object() ? reinterpret_cast<wl_object*>(output.c_ptr()) : nullptr);
2483}
2484
2485void surface_t::post_invalid_scale(std::string const& msg)
2486{
2487 post_error(static_cast<uint32_t>(surface_error::invalid_scale), msg);
2488}
2489
2490void surface_t::post_invalid_transform(std::string const& msg)
2491{
2492 post_error(static_cast<uint32_t>(surface_error::invalid_transform), msg);
2493}
2494
2495void surface_t::post_invalid_size(std::string const& msg)
2496{
2497 post_error(static_cast<uint32_t>(surface_error::invalid_size), msg);
2498}
2499
2500void surface_t::post_invalid_offset(std::string const& msg)
2501{
2502 post_error(static_cast<uint32_t>(surface_error::invalid_offset), msg);
2503}
2504
2505int surface_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
2506{
2507 std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
2508 switch(opcode)
2509 {
2510 case 0:
2511 if(events->destroy) events->destroy();
2512 break;
2513 case 1:
2514 if(events->attach) events->attach(buffer_t(args[0].get<resource_t>()), args[1].get<int32_t>(), args[2].get<int32_t>());
2515 break;
2516 case 2:
2517 if(events->damage) events->damage(args[0].get<int32_t>(), args[1].get<int32_t>(), args[2].get<int32_t>(), args[3].get<int32_t>());
2518 break;
2519 case 3:
2520 if(events->frame) events->frame(callback_t(args[0].get<resource_t>()));
2521 break;
2522 case 4:
2523 if(events->set_opaque_region) events->set_opaque_region(region_t(args[0].get<resource_t>()));
2524 break;
2525 case 5:
2526 if(events->set_input_region) events->set_input_region(region_t(args[0].get<resource_t>()));
2527 break;
2528 case 6:
2529 if(events->commit) events->commit();
2530 break;
2531 case 7:
2532 if(events->set_buffer_transform) events->set_buffer_transform(output_transform(args[0].get<int32_t>()));
2533 break;
2534 case 8:
2535 if(events->set_buffer_scale) events->set_buffer_scale(args[0].get<int32_t>());
2536 break;
2537 case 9:
2538 if(events->damage_buffer) events->damage_buffer(args[0].get<int32_t>(), args[1].get<int32_t>(), args[2].get<int32_t>(), args[3].get<int32_t>());
2539 break;
2540 case 10:
2541 if(events->offset) events->offset(args[0].get<int32_t>(), args[1].get<int32_t>());
2542 break;
2543 }
2544 return 0;
2545}
2546
2547
2548seat_t::seat_t(const client_t& client, uint32_t id, int version)
2549 : resource_t(client, &server::detail::seat_interface, id, version)
2550{
2551 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
2552}
2553
2554seat_t::seat_t(const resource_t &resource)
2555 : resource_t(resource)
2556{
2557 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
2558}
2559
2560const std::string seat_t::interface_name = "wl_seat";
2561
2562seat_t::operator wl_seat*() const
2563{
2564 return reinterpret_cast<wl_seat*> (c_ptr());
2565}
2566
2567std::function<void(pointer_t)> &seat_t::on_get_pointer()
2568{
2569 return std::static_pointer_cast<events_t>(get_events())->get_pointer;
2570}
2571
2572
2574{
2575 return std::static_pointer_cast<events_t>(get_events())->get_keyboard;
2576}
2577
2578
2579std::function<void(touch_t)> &seat_t::on_get_touch()
2580{
2581 return std::static_pointer_cast<events_t>(get_events())->get_touch;
2582}
2583
2584
2585std::function<void()> &seat_t::on_release()
2586{
2587 return std::static_pointer_cast<events_t>(get_events())->release;
2588}
2589
2590
2592{
2593 send_event(post, 0, static_cast<uint32_t>(capabilities));
2594}
2595
2596void seat_t::name(std::string const& name, bool post)
2597{
2598 send_event(post, 1, name);
2599}
2600
2602{
2603 return (get_version() >= name_since_version);
2604}
2605
2606void seat_t::post_missing_capability(std::string const& msg)
2607{
2608 post_error(static_cast<uint32_t>(seat_error::missing_capability), msg);
2609}
2610
2611int seat_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
2612{
2613 std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
2614 switch(opcode)
2615 {
2616 case 0:
2617 if(events->get_pointer) events->get_pointer(pointer_t(args[0].get<resource_t>()));
2618 break;
2619 case 1:
2620 if(events->get_keyboard) events->get_keyboard(keyboard_t(args[0].get<resource_t>()));
2621 break;
2622 case 2:
2623 if(events->get_touch) events->get_touch(touch_t(args[0].get<resource_t>()));
2624 break;
2625 case 3:
2626 if(events->release) events->release();
2627 break;
2628 }
2629 return 0;
2630}
2631const bitfield<3, 12> seat_capability::pointer{1};
2632const bitfield<3, 12> seat_capability::keyboard{2};
2633const bitfield<3, 12> seat_capability::touch{4};
2634
2635
2636
2637pointer_t::pointer_t(const client_t& client, uint32_t id, int version)
2638 : resource_t(client, &server::detail::pointer_interface, id, version)
2639{
2640 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
2641}
2642
2643pointer_t::pointer_t(const resource_t &resource)
2644 : resource_t(resource)
2645{
2646 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
2647}
2648
2649const std::string pointer_t::interface_name = "wl_pointer";
2650
2651pointer_t::operator wl_pointer*() const
2652{
2653 return reinterpret_cast<wl_pointer*> (c_ptr());
2654}
2655
2656std::function<void(uint32_t, surface_t, int32_t, int32_t)> &pointer_t::on_set_cursor()
2657{
2658 return std::static_pointer_cast<events_t>(get_events())->set_cursor;
2659}
2660
2661
2662std::function<void()> &pointer_t::on_release()
2663{
2664 return std::static_pointer_cast<events_t>(get_events())->release;
2665}
2666
2667
2668void pointer_t::enter(uint32_t serial, surface_t const& surface, double surface_x, double surface_y, bool post)
2669{
2670 send_event(post, 0, serial, surface.proxy_has_object() ? reinterpret_cast<wl_object*>(surface.c_ptr()) : nullptr, surface_x, surface_y);
2671}
2672
2673void pointer_t::leave(uint32_t serial, surface_t const& surface, bool post)
2674{
2675 send_event(post, 1, serial, surface.proxy_has_object() ? reinterpret_cast<wl_object*>(surface.c_ptr()) : nullptr);
2676}
2677
2678void pointer_t::motion(uint32_t time, double surface_x, double surface_y, bool post)
2679{
2680 send_event(post, 2, time, surface_x, surface_y);
2681}
2682
2683void pointer_t::button(uint32_t serial, uint32_t time, uint32_t button, pointer_button_state const& state, bool post)
2684{
2685 send_event(post, 3, serial, time, button, static_cast<uint32_t>(state));
2686}
2687
2688void pointer_t::axis(uint32_t time, pointer_axis const& axis, double value, bool post)
2689{
2690 send_event(post, 4, time, static_cast<uint32_t>(axis), value);
2691}
2692
2693void pointer_t::frame(bool post)
2694{
2695 send_event(post, 5);
2696}
2697
2699{
2700 return (get_version() >= frame_since_version);
2701}
2702
2703void pointer_t::axis_source(pointer_axis_source const& axis_source, bool post)
2704{
2705 send_event(post, 6, static_cast<uint32_t>(axis_source));
2706}
2707
2709{
2710 return (get_version() >= axis_source_since_version);
2711}
2712
2713void pointer_t::axis_stop(uint32_t time, pointer_axis const& axis, bool post)
2714{
2715 send_event(post, 7, time, static_cast<uint32_t>(axis));
2716}
2717
2719{
2720 return (get_version() >= axis_stop_since_version);
2721}
2722
2723void pointer_t::axis_discrete(pointer_axis const& axis, int32_t discrete, bool post)
2724{
2725 send_event(post, 8, static_cast<uint32_t>(axis), discrete);
2726}
2727
2729{
2730 return (get_version() >= axis_discrete_since_version);
2731}
2732
2733void pointer_t::axis_value120(pointer_axis const& axis, int32_t value120, bool post)
2734{
2735 send_event(post, 9, static_cast<uint32_t>(axis), value120);
2736}
2737
2739{
2740 return (get_version() >= axis_value120_since_version);
2741}
2742
2743void pointer_t::post_role(std::string const& msg)
2744{
2745 post_error(static_cast<uint32_t>(pointer_error::role), msg);
2746}
2747
2748int pointer_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
2749{
2750 std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
2751 switch(opcode)
2752 {
2753 case 0:
2754 if(events->set_cursor) events->set_cursor(args[0].get<uint32_t>(), surface_t(args[1].get<resource_t>()), args[2].get<int32_t>(), args[3].get<int32_t>());
2755 break;
2756 case 1:
2757 if(events->release) events->release();
2758 break;
2759 }
2760 return 0;
2761}
2762
2763
2764
2765
2766
2767keyboard_t::keyboard_t(const client_t& client, uint32_t id, int version)
2768 : resource_t(client, &server::detail::keyboard_interface, id, version)
2769{
2770 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
2771}
2772
2773keyboard_t::keyboard_t(const resource_t &resource)
2774 : resource_t(resource)
2775{
2776 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
2777}
2778
2779const std::string keyboard_t::interface_name = "wl_keyboard";
2780
2781keyboard_t::operator wl_keyboard*() const
2782{
2783 return reinterpret_cast<wl_keyboard*> (c_ptr());
2784}
2785
2786std::function<void()> &keyboard_t::on_release()
2787{
2788 return std::static_pointer_cast<events_t>(get_events())->release;
2789}
2790
2791
2792void keyboard_t::keymap(keyboard_keymap_format const& format, int fd, uint32_t size, bool post)
2793{
2794 send_event(post, 0, static_cast<uint32_t>(format), argument_t::fd(fd), size);
2795}
2796
2797void keyboard_t::enter(uint32_t serial, surface_t const& surface, array_t const& keys, bool post)
2798{
2799 send_event(post, 1, serial, surface.proxy_has_object() ? reinterpret_cast<wl_object*>(surface.c_ptr()) : nullptr, keys);
2800}
2801
2802void keyboard_t::leave(uint32_t serial, surface_t const& surface, bool post)
2803{
2804 send_event(post, 2, serial, surface.proxy_has_object() ? reinterpret_cast<wl_object*>(surface.c_ptr()) : nullptr);
2805}
2806
2807void keyboard_t::key(uint32_t serial, uint32_t time, uint32_t key, keyboard_key_state const& state, bool post)
2808{
2809 send_event(post, 3, serial, time, key, static_cast<uint32_t>(state));
2810}
2811
2812void keyboard_t::modifiers(uint32_t serial, uint32_t mods_depressed, uint32_t mods_latched, uint32_t mods_locked, uint32_t group, bool post)
2813{
2814 send_event(post, 4, serial, mods_depressed, mods_latched, mods_locked, group);
2815}
2816
2817void keyboard_t::repeat_info(int32_t rate, int32_t delay, bool post)
2818{
2819 send_event(post, 5, rate, delay);
2820}
2821
2823{
2824 return (get_version() >= repeat_info_since_version);
2825}
2826
2827int keyboard_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
2828{
2829 std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
2830 switch(opcode)
2831 {
2832 case 0:
2833 if(events->release) events->release();
2834 break;
2835 }
2836 return 0;
2837}
2838
2839
2840
2841touch_t::touch_t(const client_t& client, uint32_t id, int version)
2842 : resource_t(client, &server::detail::touch_interface, id, version)
2843{
2844 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
2845}
2846
2847touch_t::touch_t(const resource_t &resource)
2848 : resource_t(resource)
2849{
2850 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
2851}
2852
2853const std::string touch_t::interface_name = "wl_touch";
2854
2855touch_t::operator wl_touch*() const
2856{
2857 return reinterpret_cast<wl_touch*> (c_ptr());
2858}
2859
2860std::function<void()> &touch_t::on_release()
2861{
2862 return std::static_pointer_cast<events_t>(get_events())->release;
2863}
2864
2865
2866void touch_t::down(uint32_t serial, uint32_t time, surface_t const& surface, int32_t id, double x, double y, bool post)
2867{
2868 send_event(post, 0, serial, time, surface.proxy_has_object() ? reinterpret_cast<wl_object*>(surface.c_ptr()) : nullptr, id, x, y);
2869}
2870
2871void touch_t::up(uint32_t serial, uint32_t time, int32_t id, bool post)
2872{
2873 send_event(post, 1, serial, time, id);
2874}
2875
2876void touch_t::motion(uint32_t time, int32_t id, double x, double y, bool post)
2877{
2878 send_event(post, 2, time, id, x, y);
2879}
2880
2881void touch_t::frame(bool post)
2882{
2883 send_event(post, 3);
2884}
2885
2886void touch_t::cancel(bool post)
2887{
2888 send_event(post, 4);
2889}
2890
2891void touch_t::shape(int32_t id, double major, double minor, bool post)
2892{
2893 send_event(post, 5, id, major, minor);
2894}
2895
2897{
2898 return (get_version() >= shape_since_version);
2899}
2900
2901void touch_t::orientation(int32_t id, double orientation, bool post)
2902{
2903 send_event(post, 6, id, orientation);
2904}
2905
2907{
2908 return (get_version() >= orientation_since_version);
2909}
2910
2911int touch_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
2912{
2913 std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
2914 switch(opcode)
2915 {
2916 case 0:
2917 if(events->release) events->release();
2918 break;
2919 }
2920 return 0;
2921}
2922
2923output_t::output_t(const client_t& client, uint32_t id, int version)
2924 : resource_t(client, &server::detail::output_interface, id, version)
2925{
2926 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
2927}
2928
2929output_t::output_t(const resource_t &resource)
2930 : resource_t(resource)
2931{
2932 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
2933}
2934
2935const std::string output_t::interface_name = "wl_output";
2936
2937output_t::operator wl_output*() const
2938{
2939 return reinterpret_cast<wl_output*> (c_ptr());
2940}
2941
2942std::function<void()> &output_t::on_release()
2943{
2944 return std::static_pointer_cast<events_t>(get_events())->release;
2945}
2946
2947
2948void output_t::geometry(int32_t x, int32_t y, int32_t physical_width, int32_t physical_height, output_subpixel const& subpixel, std::string const& make, std::string const& model, output_transform const& transform, bool post)
2949{
2950 send_event(post, 0, x, y, physical_width, physical_height, static_cast<int32_t>(subpixel), make, model, static_cast<int32_t>(transform));
2951}
2952
2953void output_t::mode(output_mode const& flags, int32_t width, int32_t height, int32_t refresh, bool post)
2954{
2955 send_event(post, 1, static_cast<uint32_t>(flags), width, height, refresh);
2956}
2957
2958void output_t::done(bool post)
2959{
2960 send_event(post, 2);
2961}
2962
2964{
2965 return (get_version() >= done_since_version);
2966}
2967
2968void output_t::scale(int32_t factor, bool post)
2969{
2970 send_event(post, 3, factor);
2971}
2972
2974{
2975 return (get_version() >= scale_since_version);
2976}
2977
2978void output_t::name(std::string const& name, bool post)
2979{
2980 send_event(post, 4, name);
2981}
2982
2984{
2985 return (get_version() >= name_since_version);
2986}
2987
2988void output_t::description(std::string const& description, bool post)
2989{
2990 send_event(post, 5, description);
2991}
2992
2994{
2995 return (get_version() >= description_since_version);
2996}
2997
2998int output_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
2999{
3000 std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
3001 switch(opcode)
3002 {
3003 case 0:
3004 if(events->release) events->release();
3005 break;
3006 }
3007 return 0;
3008}
3009
3010const bitfield<2147483649, 21> output_transform::normal{0};
3011const bitfield<2147483649, 21> output_transform::_90{1};
3012const bitfield<2147483649, 21> output_transform::_180{2};
3013const bitfield<2147483649, 21> output_transform::_270{3};
3014const bitfield<2147483649, 21> output_transform::flipped{4};
3015const bitfield<2147483649, 21> output_transform::flipped_90{5};
3016const bitfield<2147483649, 21> output_transform::flipped_180{6};
3017const bitfield<2147483649, 21> output_transform::flipped_270{7};
3018
3019const bitfield<2, 22> output_mode::current{0x1};
3020const bitfield<2, 22> output_mode::preferred{0x2};
3021
3022
3023region_t::region_t(const client_t& client, uint32_t id, int version)
3024 : resource_t(client, &server::detail::region_interface, id, version)
3025{
3026 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
3027}
3028
3029region_t::region_t(const resource_t &resource)
3030 : resource_t(resource)
3031{
3032 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
3033}
3034
3035const std::string region_t::interface_name = "wl_region";
3036
3037region_t::operator wl_region*() const
3038{
3039 return reinterpret_cast<wl_region*> (c_ptr());
3040}
3041
3042std::function<void()> &region_t::on_destroy()
3043{
3044 return std::static_pointer_cast<events_t>(get_events())->destroy;
3045}
3046
3047
3048std::function<void(int32_t, int32_t, int32_t, int32_t)> &region_t::on_add()
3049{
3050 return std::static_pointer_cast<events_t>(get_events())->add;
3051}
3052
3053
3054std::function<void(int32_t, int32_t, int32_t, int32_t)> &region_t::on_subtract()
3055{
3056 return std::static_pointer_cast<events_t>(get_events())->subtract;
3057}
3058
3059
3060int region_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
3061{
3062 std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
3063 switch(opcode)
3064 {
3065 case 0:
3066 if(events->destroy) events->destroy();
3067 break;
3068 case 1:
3069 if(events->add) events->add(args[0].get<int32_t>(), args[1].get<int32_t>(), args[2].get<int32_t>(), args[3].get<int32_t>());
3070 break;
3071 case 2:
3072 if(events->subtract) events->subtract(args[0].get<int32_t>(), args[1].get<int32_t>(), args[2].get<int32_t>(), args[3].get<int32_t>());
3073 break;
3074 }
3075 return 0;
3076}
3077
3078subcompositor_t::subcompositor_t(const client_t& client, uint32_t id, int version)
3079 : resource_t(client, &server::detail::subcompositor_interface, id, version)
3080{
3081 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
3082}
3083
3084subcompositor_t::subcompositor_t(const resource_t &resource)
3085 : resource_t(resource)
3086{
3087 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
3088}
3089
3090const std::string subcompositor_t::interface_name = "wl_subcompositor";
3091
3092subcompositor_t::operator wl_subcompositor*() const
3093{
3094 return reinterpret_cast<wl_subcompositor*> (c_ptr());
3095}
3096
3097std::function<void()> &subcompositor_t::on_destroy()
3098{
3099 return std::static_pointer_cast<events_t>(get_events())->destroy;
3100}
3101
3102
3104{
3105 return std::static_pointer_cast<events_t>(get_events())->get_subsurface;
3106}
3107
3108
3109void subcompositor_t::post_bad_surface(std::string const& msg)
3110{
3111 post_error(static_cast<uint32_t>(subcompositor_error::bad_surface), msg);
3112}
3113
3114int subcompositor_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
3115{
3116 std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
3117 switch(opcode)
3118 {
3119 case 0:
3120 if(events->destroy) events->destroy();
3121 break;
3122 case 1:
3123 if(events->get_subsurface) events->get_subsurface(subsurface_t(args[0].get<resource_t>()), surface_t(args[1].get<resource_t>()), surface_t(args[2].get<resource_t>()));
3124 break;
3125 }
3126 return 0;
3127}
3128
3129
3130subsurface_t::subsurface_t(const client_t& client, uint32_t id, int version)
3131 : resource_t(client, &server::detail::subsurface_interface, id, version)
3132{
3133 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
3134}
3135
3136subsurface_t::subsurface_t(const resource_t &resource)
3137 : resource_t(resource)
3138{
3139 set_events(std::shared_ptr<resource_t::events_base_t>(new events_t), dispatcher);
3140}
3141
3142const std::string subsurface_t::interface_name = "wl_subsurface";
3143
3144subsurface_t::operator wl_subsurface*() const
3145{
3146 return reinterpret_cast<wl_subsurface*> (c_ptr());
3147}
3148
3149std::function<void()> &subsurface_t::on_destroy()
3150{
3151 return std::static_pointer_cast<events_t>(get_events())->destroy;
3152}
3153
3154
3155std::function<void(int32_t, int32_t)> &subsurface_t::on_set_position()
3156{
3157 return std::static_pointer_cast<events_t>(get_events())->set_position;
3158}
3159
3160
3162{
3163 return std::static_pointer_cast<events_t>(get_events())->place_above;
3164}
3165
3166
3168{
3169 return std::static_pointer_cast<events_t>(get_events())->place_below;
3170}
3171
3172
3173std::function<void()> &subsurface_t::on_set_sync()
3174{
3175 return std::static_pointer_cast<events_t>(get_events())->set_sync;
3176}
3177
3178
3179std::function<void()> &subsurface_t::on_set_desync()
3180{
3181 return std::static_pointer_cast<events_t>(get_events())->set_desync;
3182}
3183
3184
3185void subsurface_t::post_bad_surface(std::string const& msg)
3186{
3187 post_error(static_cast<uint32_t>(subsurface_error::bad_surface), msg);
3188}
3189
3190int subsurface_t::dispatcher(int opcode, const std::vector<any>& args, const std::shared_ptr<resource_t::events_base_t>& e)
3191{
3192 std::shared_ptr<events_t> events = std::static_pointer_cast<events_t>(e);
3193 switch(opcode)
3194 {
3195 case 0:
3196 if(events->destroy) events->destroy();
3197 break;
3198 case 1:
3199 if(events->set_position) events->set_position(args[0].get<int32_t>(), args[1].get<int32_t>());
3200 break;
3201 case 2:
3202 if(events->place_above) events->place_above(surface_t(args[0].get<resource_t>()));
3203 break;
3204 case 3:
3205 if(events->place_below) events->place_below(surface_t(args[0].get<resource_t>()));
3206 break;
3207 case 4:
3208 if(events->set_sync) events->set_sync();
3209 break;
3210 case 5:
3211 if(events->set_desync) events->set_desync();
3212 break;
3213 }
3214 return 0;
3215}
3216
3217
3218
void release(bool post=true)
compositor releases buffer
std::function< void()> & on_destroy()
destroy a buffer
void done(uint32_t callback_data, bool post=true)
done event
std::function< void(surface_t)> & on_create_surface()
create new surface
std::function< void(region_t)> & on_create_region()
create new region
std::function< void(data_device_t, seat_t)> & on_get_data_device()
create a new data device
std::function< void(data_source_t)> & on_create_data_source()
create a new data source
void post_role(std::string const &msg)
Post error: given wl_surface has another role.
std::function< void(data_source_t, uint32_t)> & on_set_selection()
copy data to the selection
std::function< void()> & on_release()
destroy data device
void enter(uint32_t serial, surface_t const &surface, double x, double y, data_offer_t const &id, bool post=true)
initiate drag-and-drop session
void leave(bool post=true)
end drag-and-drop session
void data_offer(bool post=true)
introduce a new wl_data_offer
void motion(uint32_t time, double x, double y, bool post=true)
drag-and-drop session motion
std::function< void(data_source_t, surface_t, surface_t, uint32_t)> & on_start_drag()
start drag-and-drop operation
void drop(bool post=true)
end drag-and-drop session successfully
void selection(data_offer_t const &id, bool post=true)
advertise new selection
void offer(std::string const &mime_type, bool post=true)
advertise offered mime type
std::function< void()> & on_destroy()
destroy data offer
std::function< void(std::string, int)> & on_receive()
request that the data is transferred
std::function< void(data_device_manager_dnd_action, data_device_manager_dnd_action)> & on_set_actions()
set the available/preferred drag-and-drop actions
void source_actions(data_device_manager_dnd_action const &source_actions, bool post=true)
notify the source-side available actions
std::function< void(uint32_t, std::string)> & on_accept()
accept one of the offered mime types
void post_invalid_finish(std::string const &msg)
Post error: finish request was called untimely.
bool can_source_actions() const
Check whether the source_actions function is available with the currently bound version of the protoc...
bool can_action() const
Check whether the action function is available with the currently bound version of the protocol.
std::function< void()> & on_finish()
the offer will no longer be used
static constexpr std::uint32_t source_actions_since_version
Minimum protocol version required for the source_actions function.
void post_invalid_action(std::string const &msg)
Post error: action argument has an invalid value.
static constexpr std::uint32_t action_since_version
Minimum protocol version required for the action function.
void post_invalid_offer(std::string const &msg)
Post error: offer doesn't accept this request.
void post_invalid_action_mask(std::string const &msg)
Post error: action mask contains invalid values.
void action(data_device_manager_dnd_action const &dnd_action, bool post=true)
notify the selected action
void cancelled(bool post=true)
selection was cancelled
static constexpr std::uint32_t dnd_drop_performed_since_version
Minimum protocol version required for the dnd_drop_performed function.
void dnd_drop_performed(bool post=true)
the drag-and-drop operation physically finished
void post_invalid_action_mask(std::string const &msg)
Post error: action mask contains invalid values.
static constexpr std::uint32_t dnd_finished_since_version
Minimum protocol version required for the dnd_finished function.
bool can_dnd_drop_performed() const
Check whether the dnd_drop_performed function is available with the currently bound version of the pr...
bool can_action() const
Check whether the action function is available with the currently bound version of the protocol.
std::function< void(data_device_manager_dnd_action)> & on_set_actions()
set the available drag-and-drop actions
std::function< void(std::string)> & on_offer()
add an offered mime type
std::function< void()> & on_destroy()
destroy the data source
static constexpr std::uint32_t action_since_version
Minimum protocol version required for the action function.
void send(std::string const &mime_type, int fd, bool post=true)
send the data
bool can_dnd_finished() const
Check whether the dnd_finished function is available with the currently bound version of the protocol...
void action(data_device_manager_dnd_action const &dnd_action, bool post=true)
notify the selected action
void target(std::string const &mime_type, bool post=true)
a target accepts an offered mime type
void dnd_finished(bool post=true)
the drag-and-drop operation concluded
void post_invalid_source(std::string const &msg)
Post error: source doesn't accept this request.
void enter(uint32_t serial, surface_t const &surface, array_t const &keys, bool post=true)
enter event
void modifiers(uint32_t serial, uint32_t mods_depressed, uint32_t mods_latched, uint32_t mods_locked, uint32_t group, bool post=true)
modifier and group state
void keymap(keyboard_keymap_format const &format, int fd, uint32_t size, bool post=true)
keyboard mapping
void repeat_info(int32_t rate, int32_t delay, bool post=true)
repeat rate and delay
void leave(uint32_t serial, surface_t const &surface, bool post=true)
leave event
void key(uint32_t serial, uint32_t time, uint32_t key, keyboard_key_state const &state, bool post=true)
key event
static constexpr std::uint32_t repeat_info_since_version
Minimum protocol version required for the repeat_info function.
std::function< void()> & on_release()
release the keyboard object
bool can_repeat_info() const
Check whether the repeat_info function is available with the currently bound version of the protocol.
static constexpr std::uint32_t done_since_version
Minimum protocol version required for the done function.
std::function< void()> & on_release()
release the output object
bool can_name() const
Check whether the name function is available with the currently bound version of the protocol.
void name(std::string const &name, bool post=true)
name of this output
void mode(output_mode const &flags, int32_t width, int32_t height, int32_t refresh, bool post=true)
advertise available modes for the output
void done(bool post=true)
sent all information about output
void geometry(int32_t x, int32_t y, int32_t physical_width, int32_t physical_height, output_subpixel const &subpixel, std::string const &make, std::string const &model, output_transform const &transform, bool post=true)
properties of the output
static constexpr std::uint32_t name_since_version
Minimum protocol version required for the name function.
void scale(int32_t factor, bool post=true)
output scaling properties
bool can_scale() const
Check whether the scale function is available with the currently bound version of the protocol.
bool can_done() const
Check whether the done function is available with the currently bound version of the protocol.
void description(std::string const &description, bool post=true)
human-readable description of this output
bool can_description() const
Check whether the description function is available with the currently bound version of the protocol.
static constexpr std::uint32_t scale_since_version
Minimum protocol version required for the scale function.
static constexpr std::uint32_t description_since_version
Minimum protocol version required for the description function.
void motion(uint32_t time, double surface_x, double surface_y, bool post=true)
pointer motion event
void axis(uint32_t time, pointer_axis const &axis, double value, bool post=true)
axis event
void axis_stop(uint32_t time, pointer_axis const &axis, bool post=true)
axis stop event
std::function< void(uint32_t, surface_t, int32_t, int32_t)> & on_set_cursor()
set the pointer surface
void frame(bool post=true)
end of a pointer event sequence
static constexpr std::uint32_t axis_source_since_version
Minimum protocol version required for the axis_source function.
void post_role(std::string const &msg)
Post error: given wl_surface has another role.
void leave(uint32_t serial, surface_t const &surface, bool post=true)
leave event
bool can_axis_discrete() const
Check whether the axis_discrete function is available with the currently bound version of the protoco...
static constexpr std::uint32_t frame_since_version
Minimum protocol version required for the frame function.
bool can_axis_source() const
Check whether the axis_source function is available with the currently bound version of the protocol.
void axis_discrete(pointer_axis const &axis, int32_t discrete, bool post=true)
axis click event
static constexpr std::uint32_t axis_discrete_since_version
Minimum protocol version required for the axis_discrete function.
std::function< void()> & on_release()
release the pointer object
void axis_value120(pointer_axis const &axis, int32_t value120, bool post=true)
axis high-resolution scroll event
void button(uint32_t serial, uint32_t time, uint32_t button, pointer_button_state const &state, bool post=true)
pointer button event
void axis_source(pointer_axis_source const &axis_source, bool post=true)
axis source event
bool can_axis_value120() const
Check whether the axis_value120 function is available with the currently bound version of the protoco...
void enter(uint32_t serial, surface_t const &surface, double surface_x, double surface_y, bool post=true)
enter event
bool can_axis_stop() const
Check whether the axis_stop function is available with the currently bound version of the protocol.
bool can_frame() const
Check whether the frame function is available with the currently bound version of the protocol.
static constexpr std::uint32_t axis_stop_since_version
Minimum protocol version required for the axis_stop function.
static constexpr std::uint32_t axis_value120_since_version
Minimum protocol version required for the axis_value120 function.
std::function< void()> & on_destroy()
destroy region
std::function< void(int32_t, int32_t, int32_t, int32_t)> & on_add()
add rectangle to region
std::function< void(int32_t, int32_t, int32_t, int32_t)> & on_subtract()
subtract rectangle from region
void global(uint32_t name, std::string const &interface, uint32_t version, bool post=true)
announce global object
std::function< void(uint32_t, resource_t)> & on_bind()
bind an object to the display
void global_remove(uint32_t name, bool post=true)
announce removal of global object
void name(std::string const &name, bool post=true)
unique identifier for this seat
std::function< void(pointer_t)> & on_get_pointer()
return pointer object
void post_missing_capability(std::string const &msg)
Post error: get_pointer, get_keyboard or get_touch called on seat without the matching capability.
std::function< void(keyboard_t)> & on_get_keyboard()
return keyboard object
std::function< void(touch_t)> & on_get_touch()
return touch object
std::function< void()> & on_release()
release the seat object
void capabilities(seat_capability const &capabilities, bool post=true)
seat capabilities changed
bool can_name() const
Check whether the name function is available with the currently bound version of the protocol.
static constexpr std::uint32_t name_since_version
Minimum protocol version required for the name function.
desktop-style metadata interface
std::function< void(seat_t, uint32_t)> & on_move()
start an interactive move
std::function< void(std::string)> & on_set_class()
set surface class
std::function< void(seat_t, uint32_t, shell_surface_resize)> & on_resize()
start an interactive resize
std::function< void(std::string)> & on_set_title()
set surface title
std::function< void(surface_t, int32_t, int32_t, shell_surface_transient)> & on_set_transient()
make the surface a transient surface
std::function< void(output_t)> & on_set_maximized()
make the surface a maximized surface
void ping(uint32_t serial, bool post=true)
ping client
std::function< void(shell_surface_fullscreen_method, uint32_t, output_t)> & on_set_fullscreen()
make the surface a fullscreen surface
std::function< void()> & on_set_toplevel()
make the surface a toplevel surface
std::function< void(uint32_t)> & on_pong()
respond to a ping event
void popup_done(bool post=true)
popup interaction is done
void configure(shell_surface_resize const &edges, int32_t width, int32_t height, bool post=true)
suggest resize
std::function< void(seat_t, uint32_t, surface_t, int32_t, int32_t, shell_surface_transient)> & on_set_popup()
make the surface a popup surface
std::function< void(shell_surface_t, surface_t)> & on_get_shell_surface()
create a shell surface from a surface
void post_role(std::string const &msg)
Post error: given wl_surface has another role.
std::function< void()> & on_destroy()
destroy the pool
std::function< void(int32_t)> & on_resize()
change the size of the pool mapping
std::function< void(buffer_t, int32_t, int32_t, int32_t, int32_t, shm_format)> & on_create_buffer()
create a buffer from the pool
void post_invalid_format(std::string const &msg)
Post error: buffer format is not known.
std::function< void(shm_pool_t, int, int32_t)> & on_create_pool()
create a shm pool
void post_invalid_fd(std::string const &msg)
Post error: mmapping the file descriptor failed.
void format(shm_format const &format, bool post=true)
pixel format description
void post_invalid_stride(std::string const &msg)
Post error: invalid size or stride during pool or buffer creation.
std::function< void(subsurface_t, surface_t, surface_t)> & on_get_subsurface()
give a surface the role sub-surface
std::function< void()> & on_destroy()
unbind from the subcompositor interface
void post_bad_surface(std::string const &msg)
Post error: the to-be sub-surface is invalid.
sub-surface interface to a wl_surface
std::function< void()> & on_set_sync()
set sub-surface to synchronized mode
std::function< void()> & on_set_desync()
set sub-surface to desynchronized mode
std::function< void(int32_t, int32_t)> & on_set_position()
reposition the sub-surface
std::function< void(surface_t)> & on_place_below()
restack the sub-surface
std::function< void(surface_t)> & on_place_above()
restack the sub-surface
void post_bad_surface(std::string const &msg)
Post error: wl_surface is not a sibling or the parent.
std::function< void()> & on_destroy()
remove sub-surface interface
void enter(output_t const &output, bool post=true)
surface enters an output
std::function< void(buffer_t, int32_t, int32_t)> & on_attach()
set the surface contents
void post_invalid_offset(std::string const &msg)
Post error: buffer offset is invalid.
std::function< void(region_t)> & on_set_input_region()
set input region
void post_invalid_scale(std::string const &msg)
Post error: buffer scale value is invalid.
std::function< void(int32_t, int32_t, int32_t, int32_t)> & on_damage()
mark part of the surface damaged
std::function< void(callback_t)> & on_frame()
request a frame throttling hint
std::function< void(int32_t, int32_t)> & on_offset()
set the surface contents offset
std::function< void(int32_t)> & on_set_buffer_scale()
sets the buffer scaling factor
void post_invalid_size(std::string const &msg)
Post error: buffer size is invalid.
std::function< void(region_t)> & on_set_opaque_region()
set opaque region
std::function< void()> & on_commit()
commit pending surface state
std::function< void(int32_t, int32_t, int32_t, int32_t)> & on_damage_buffer()
mark part of the surface damaged using buffer coordinates
void leave(output_t const &output, bool post=true)
surface leaves an output
std::function< void()> & on_destroy()
delete surface
void post_invalid_transform(std::string const &msg)
Post error: buffer transform value is invalid.
std::function< void(output_transform)> & on_set_buffer_transform()
sets the buffer transformation
void cancel(bool post=true)
touch session cancelled
void motion(uint32_t time, int32_t id, double x, double y, bool post=true)
update of touch point coordinates
void orientation(int32_t id, double orientation, bool post=true)
update orientation of touch point
void up(uint32_t serial, uint32_t time, int32_t id, bool post=true)
end of a touch event sequence
void down(uint32_t serial, uint32_t time, surface_t const &surface, int32_t id, double x, double y, bool post=true)
touch down event and beginning of a touch sequence
void shape(int32_t id, double major, double minor, bool post=true)
update shape of touch point
static constexpr std::uint32_t shape_since_version
Minimum protocol version required for the shape function.
bool can_shape() const
Check whether the shape function is available with the currently bound version of the protocol.
static constexpr std::uint32_t orientation_since_version
Minimum protocol version required for the orientation function.
void frame(bool post=true)
end of touch frame event
bool can_orientation() const
Check whether the orientation function is available with the currently bound version of the protocol.
std::function< void()> & on_release()
release the touch object
static const wayland::detail::bitfield< 2147483649, 6 > none
no action
static const wayland::detail::bitfield< 2147483649, 21 > normal
no transform
static const wayland::detail::bitfield< 3, 12 > pointer
the seat has pointer devices
static const wayland::detail::bitfield< 2147483649, 6 > move
move action
static const wayland::detail::bitfield< 2147483649, 6 > ask
ask action
static const wayland::detail::bitfield< 2147483649, 6 > copy
copy action
static const wayland::detail::bitfield< 2, 22 > current
indicates this is the current mode
static const wayland::detail::bitfield< 2, 22 > preferred
indicates this is the preferred mode
transform from framebuffer to output
static const wayland::detail::bitfield< 2147483649, 21 > _270
270 degrees counter-clockwise
static const wayland::detail::bitfield< 2147483649, 21 > _90
90 degrees counter-clockwise
static const wayland::detail::bitfield< 2147483649, 21 > flipped_180
flip and rotate 180 degrees counter-clockwise
static const wayland::detail::bitfield< 2147483649, 21 > flipped_270
flip and rotate 270 degrees counter-clockwise
static const wayland::detail::bitfield< 2147483649, 21 > _180
180 degrees counter-clockwise
static const wayland::detail::bitfield< 2147483649, 21 > flipped
180 degree flip around a vertical axis
static const wayland::detail::bitfield< 2147483649, 21 > flipped_90
flip and rotate 90 degrees counter-clockwise
static const wayland::detail::bitfield< 3, 12 > keyboard
the seat has one or more keyboards
static const wayland::detail::bitfield< 3, 12 > touch
the seat has touch devices
static const wayland::detail::bitfield< 2147483649, 8 > bottom_right
bottom and right edges
static const wayland::detail::bitfield< 2147483649, 8 > top
top edge
static const wayland::detail::bitfield< 2147483649, 8 > top_left
top and left edges
static const wayland::detail::bitfield< 2147483649, 8 > right
right edge
static const wayland::detail::bitfield< 2147483649, 8 > top_right
top and right edges
static const wayland::detail::bitfield< 2147483649, 8 > bottom_left
bottom and left edges
static const wayland::detail::bitfield< 2147483649, 8 > left
left edge
static const wayland::detail::bitfield< 2147483649, 8 > bottom
bottom edge
static const wayland::detail::bitfield< 1, 9 > inactive
do not set keyboard focus
static const wayland::detail::bitfield< 2147483649, 8 > none
no edge