Wayland++  1.0.0
C++ Bindings for Wayland
wayland-server-protocol.cpp
1 #include <wayland-server-protocol.hpp>
2 
3 using namespace wayland;
4 using namespace wayland::detail;
5 using namespace wayland::server;
6 using namespace wayland::server::detail;
7 
8 const wl_interface* display_interface_sync_request_server[1] = {
9  &callback_interface,
10 };
11 
12 const wl_interface* display_interface_get_registry_request_server[1] = {
13  &registry_interface,
14 };
15 
16 const wl_interface* display_interface_error_event_server[3] = {
17  nullptr,
18  nullptr,
19  nullptr,
20 };
21 
22 const wl_interface* display_interface_delete_id_event_server[1] = {
23  nullptr,
24 };
25 
26 const 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 
39 const 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 
52 const 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 
62 const wl_interface* registry_interface_bind_request_server[2] = {
63  nullptr,
64  nullptr,
65 };
66 
67 const wl_interface* registry_interface_global_event_server[3] = {
68  nullptr,
69  nullptr,
70  nullptr,
71 };
72 
73 const wl_interface* registry_interface_global_remove_event_server[1] = {
74  nullptr,
75 };
76 
77 const wl_message registry_interface_requests_server[1] = {
78  {
79  "bind",
80  "usun",
81  registry_interface_bind_request_server,
82  },
83 };
84 
85 const 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 
98 const 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 
108 const wl_interface* callback_interface_done_event_server[1] = {
109  nullptr,
110 };
111 
112 const wl_message callback_interface_requests_server[0] = {
113 };
114 
115 const wl_message callback_interface_events_server[1] = {
116  {
117  "done",
118  "u",
119  callback_interface_done_event_server,
120  },
121 };
122 
123 const 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 
133 const wl_interface* compositor_interface_create_surface_request_server[1] = {
134  &surface_interface,
135 };
136 
137 const wl_interface* compositor_interface_create_region_request_server[1] = {
138  &region_interface,
139 };
140 
141 const 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 
154 const wl_message compositor_interface_events_server[0] = {
155 };
156 
157 const 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 
167 const 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 
176 const wl_interface* shm_pool_interface_destroy_request_server[0] = {
177 };
178 
179 const wl_interface* shm_pool_interface_resize_request_server[1] = {
180  nullptr,
181 };
182 
183 const 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 
201 const wl_message shm_pool_interface_events_server[0] = {
202 };
203 
204 const 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 
214 const wl_interface* shm_interface_create_pool_request_server[3] = {
215  &shm_pool_interface,
216  nullptr,
217  nullptr,
218 };
219 
220 const wl_interface* shm_interface_format_event_server[1] = {
221  nullptr,
222 };
223 
224 const wl_message shm_interface_requests_server[1] = {
225  {
226  "create_pool",
227  "nhi",
228  shm_interface_create_pool_request_server,
229  },
230 };
231 
232 const wl_message shm_interface_events_server[1] = {
233  {
234  "format",
235  "u",
236  shm_interface_format_event_server,
237  },
238 };
239 
240 const 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 
250 const wl_interface* buffer_interface_destroy_request_server[0] = {
251 };
252 
253 const wl_interface* buffer_interface_release_event_server[0] = {
254 };
255 
256 const wl_message buffer_interface_requests_server[1] = {
257  {
258  "destroy",
259  "",
260  buffer_interface_destroy_request_server,
261  },
262 };
263 
264 const wl_message buffer_interface_events_server[1] = {
265  {
266  "release",
267  "",
268  buffer_interface_release_event_server,
269  },
270 };
271 
272 const 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 
282 const wl_interface* data_offer_interface_accept_request_server[2] = {
283  nullptr,
284  nullptr,
285 };
286 
287 const wl_interface* data_offer_interface_receive_request_server[2] = {
288  nullptr,
289  nullptr,
290 };
291 
292 const wl_interface* data_offer_interface_destroy_request_server[0] = {
293 };
294 
295 const wl_interface* data_offer_interface_finish_request_server[0] = {
296 };
297 
298 const wl_interface* data_offer_interface_set_actions_request_server[2] = {
299  nullptr,
300  nullptr,
301 };
302 
303 const wl_interface* data_offer_interface_offer_event_server[1] = {
304  nullptr,
305 };
306 
307 const wl_interface* data_offer_interface_source_actions_event_server[1] = {
308  nullptr,
309 };
310 
311 const wl_interface* data_offer_interface_action_event_server[1] = {
312  nullptr,
313 };
314 
315 const 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 
343 const 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 
361 const 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 
371 const wl_interface* data_source_interface_offer_request_server[1] = {
372  nullptr,
373 };
374 
375 const wl_interface* data_source_interface_destroy_request_server[0] = {
376 };
377 
378 const wl_interface* data_source_interface_set_actions_request_server[1] = {
379  nullptr,
380 };
381 
382 const wl_interface* data_source_interface_target_event_server[1] = {
383  nullptr,
384 };
385 
386 const wl_interface* data_source_interface_send_event_server[2] = {
387  nullptr,
388  nullptr,
389 };
390 
391 const wl_interface* data_source_interface_cancelled_event_server[0] = {
392 };
393 
394 const wl_interface* data_source_interface_dnd_drop_performed_event_server[0] = {
395 };
396 
397 const wl_interface* data_source_interface_dnd_finished_event_server[0] = {
398 };
399 
400 const wl_interface* data_source_interface_action_event_server[1] = {
401  nullptr,
402 };
403 
404 const 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 
422 const 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 
455 const 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 
465 const wl_interface* data_device_interface_start_drag_request_server[4] = {
466  &data_source_interface,
467  &surface_interface,
468  &surface_interface,
469  nullptr,
470 };
471 
472 const wl_interface* data_device_interface_set_selection_request_server[2] = {
473  &data_source_interface,
474  nullptr,
475 };
476 
477 const wl_interface* data_device_interface_release_request_server[0] = {
478 };
479 
480 const wl_interface* data_device_interface_data_offer_event_server[1] = {
481  &data_offer_interface,
482 };
483 
484 const wl_interface* data_device_interface_enter_event_server[5] = {
485  nullptr,
486  &surface_interface,
487  nullptr,
488  nullptr,
489  &data_offer_interface,
490 };
491 
492 const wl_interface* data_device_interface_leave_event_server[0] = {
493 };
494 
495 const wl_interface* data_device_interface_motion_event_server[3] = {
496  nullptr,
497  nullptr,
498  nullptr,
499 };
500 
501 const wl_interface* data_device_interface_drop_event_server[0] = {
502 };
503 
504 const wl_interface* data_device_interface_selection_event_server[1] = {
505  &data_offer_interface,
506 };
507 
508 const 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 
526 const 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 
559 const 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 
569 const wl_interface* data_device_manager_interface_create_data_source_request_server[1] = {
570  &data_source_interface,
571 };
572 
573 const wl_interface* data_device_manager_interface_get_data_device_request_server[2] = {
574  &data_device_interface,
575  &seat_interface,
576 };
577 
578 const 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 
591 const wl_message data_device_manager_interface_events_server[0] = {
592 };
593 
594 const 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 
604 const wl_interface* shell_interface_get_shell_surface_request_server[2] = {
605  &shell_surface_interface,
606  &surface_interface,
607 };
608 
609 const 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 
617 const wl_message shell_interface_events_server[0] = {
618 };
619 
620 const 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 
630 const wl_interface* shell_surface_interface_pong_request_server[1] = {
631  nullptr,
632 };
633 
634 const wl_interface* shell_surface_interface_move_request_server[2] = {
635  &seat_interface,
636  nullptr,
637 };
638 
639 const wl_interface* shell_surface_interface_resize_request_server[3] = {
640  &seat_interface,
641  nullptr,
642  nullptr,
643 };
644 
645 const wl_interface* shell_surface_interface_set_toplevel_request_server[0] = {
646 };
647 
648 const wl_interface* shell_surface_interface_set_transient_request_server[4] = {
649  &surface_interface,
650  nullptr,
651  nullptr,
652  nullptr,
653 };
654 
655 const wl_interface* shell_surface_interface_set_fullscreen_request_server[3] = {
656  nullptr,
657  nullptr,
658  &output_interface,
659 };
660 
661 const 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 
670 const wl_interface* shell_surface_interface_set_maximized_request_server[1] = {
671  &output_interface,
672 };
673 
674 const wl_interface* shell_surface_interface_set_title_request_server[1] = {
675  nullptr,
676 };
677 
678 const wl_interface* shell_surface_interface_set_class_request_server[1] = {
679  nullptr,
680 };
681 
682 const wl_interface* shell_surface_interface_ping_event_server[1] = {
683  nullptr,
684 };
685 
686 const wl_interface* shell_surface_interface_configure_event_server[3] = {
687  nullptr,
688  nullptr,
689  nullptr,
690 };
691 
692 const wl_interface* shell_surface_interface_popup_done_event_server[0] = {
693 };
694 
695 const 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 
748 const 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 
766 const 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 
776 const wl_interface* surface_interface_destroy_request_server[0] = {
777 };
778 
779 const wl_interface* surface_interface_attach_request_server[3] = {
780  &buffer_interface,
781  nullptr,
782  nullptr,
783 };
784 
785 const wl_interface* surface_interface_damage_request_server[4] = {
786  nullptr,
787  nullptr,
788  nullptr,
789  nullptr,
790 };
791 
792 const wl_interface* surface_interface_frame_request_server[1] = {
793  &callback_interface,
794 };
795 
796 const wl_interface* surface_interface_set_opaque_region_request_server[1] = {
797  &region_interface,
798 };
799 
800 const wl_interface* surface_interface_set_input_region_request_server[1] = {
801  &region_interface,
802 };
803 
804 const wl_interface* surface_interface_commit_request_server[0] = {
805 };
806 
807 const wl_interface* surface_interface_set_buffer_transform_request_server[1] = {
808  nullptr,
809 };
810 
811 const wl_interface* surface_interface_set_buffer_scale_request_server[1] = {
812  nullptr,
813 };
814 
815 const wl_interface* surface_interface_damage_buffer_request_server[4] = {
816  nullptr,
817  nullptr,
818  nullptr,
819  nullptr,
820 };
821 
822 const wl_interface* surface_interface_offset_request_server[2] = {
823  nullptr,
824  nullptr,
825 };
826 
827 const wl_interface* surface_interface_enter_event_server[1] = {
828  &output_interface,
829 };
830 
831 const wl_interface* surface_interface_leave_event_server[1] = {
832  &output_interface,
833 };
834 
835 const 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 
893 const 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 
906 const 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 
916 const wl_interface* seat_interface_get_pointer_request_server[1] = {
917  &pointer_interface,
918 };
919 
920 const wl_interface* seat_interface_get_keyboard_request_server[1] = {
921  &keyboard_interface,
922 };
923 
924 const wl_interface* seat_interface_get_touch_request_server[1] = {
925  &touch_interface,
926 };
927 
928 const wl_interface* seat_interface_release_request_server[0] = {
929 };
930 
931 const wl_interface* seat_interface_capabilities_event_server[1] = {
932  nullptr,
933 };
934 
935 const wl_interface* seat_interface_name_event_server[1] = {
936  nullptr,
937 };
938 
939 const 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 
962 const 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 
975 const 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 
985 const wl_interface* pointer_interface_set_cursor_request_server[4] = {
986  nullptr,
987  &surface_interface,
988  nullptr,
989  nullptr,
990 };
991 
992 const wl_interface* pointer_interface_release_request_server[0] = {
993 };
994 
995 const wl_interface* pointer_interface_enter_event_server[4] = {
996  nullptr,
997  &surface_interface,
998  nullptr,
999  nullptr,
1000 };
1001 
1002 const wl_interface* pointer_interface_leave_event_server[2] = {
1003  nullptr,
1004  &surface_interface,
1005 };
1006 
1007 const wl_interface* pointer_interface_motion_event_server[3] = {
1008  nullptr,
1009  nullptr,
1010  nullptr,
1011 };
1012 
1013 const wl_interface* pointer_interface_button_event_server[4] = {
1014  nullptr,
1015  nullptr,
1016  nullptr,
1017  nullptr,
1018 };
1019 
1020 const wl_interface* pointer_interface_axis_event_server[3] = {
1021  nullptr,
1022  nullptr,
1023  nullptr,
1024 };
1025 
1026 const wl_interface* pointer_interface_frame_event_server[0] = {
1027 };
1028 
1029 const wl_interface* pointer_interface_axis_source_event_server[1] = {
1030  nullptr,
1031 };
1032 
1033 const wl_interface* pointer_interface_axis_stop_event_server[2] = {
1034  nullptr,
1035  nullptr,
1036 };
1037 
1038 const wl_interface* pointer_interface_axis_discrete_event_server[2] = {
1039  nullptr,
1040  nullptr,
1041 };
1042 
1043 const wl_interface* pointer_interface_axis_value120_event_server[2] = {
1044  nullptr,
1045  nullptr,
1046 };
1047 
1048 const 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 
1061 const 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 
1114 const 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 
1124 const wl_interface* keyboard_interface_release_request_server[0] = {
1125 };
1126 
1127 const wl_interface* keyboard_interface_keymap_event_server[3] = {
1128  nullptr,
1129  nullptr,
1130  nullptr,
1131 };
1132 
1133 const wl_interface* keyboard_interface_enter_event_server[3] = {
1134  nullptr,
1135  &surface_interface,
1136  nullptr,
1137 };
1138 
1139 const wl_interface* keyboard_interface_leave_event_server[2] = {
1140  nullptr,
1141  &surface_interface,
1142 };
1143 
1144 const wl_interface* keyboard_interface_key_event_server[4] = {
1145  nullptr,
1146  nullptr,
1147  nullptr,
1148  nullptr,
1149 };
1150 
1151 const wl_interface* keyboard_interface_modifiers_event_server[5] = {
1152  nullptr,
1153  nullptr,
1154  nullptr,
1155  nullptr,
1156  nullptr,
1157 };
1158 
1159 const wl_interface* keyboard_interface_repeat_info_event_server[2] = {
1160  nullptr,
1161  nullptr,
1162 };
1163 
1164 const wl_message keyboard_interface_requests_server[1] = {
1165  {
1166  "release",
1167  "3",
1168  keyboard_interface_release_request_server,
1169  },
1170 };
1171 
1172 const 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 
1205 const 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 
1215 const wl_interface* touch_interface_release_request_server[0] = {
1216 };
1217 
1218 const wl_interface* touch_interface_down_event_server[6] = {
1219  nullptr,
1220  nullptr,
1221  &surface_interface,
1222  nullptr,
1223  nullptr,
1224  nullptr,
1225 };
1226 
1227 const wl_interface* touch_interface_up_event_server[3] = {
1228  nullptr,
1229  nullptr,
1230  nullptr,
1231 };
1232 
1233 const wl_interface* touch_interface_motion_event_server[4] = {
1234  nullptr,
1235  nullptr,
1236  nullptr,
1237  nullptr,
1238 };
1239 
1240 const wl_interface* touch_interface_frame_event_server[0] = {
1241 };
1242 
1243 const wl_interface* touch_interface_cancel_event_server[0] = {
1244 };
1245 
1246 const wl_interface* touch_interface_shape_event_server[3] = {
1247  nullptr,
1248  nullptr,
1249  nullptr,
1250 };
1251 
1252 const wl_interface* touch_interface_orientation_event_server[2] = {
1253  nullptr,
1254  nullptr,
1255 };
1256 
1257 const wl_message touch_interface_requests_server[1] = {
1258  {
1259  "release",
1260  "3",
1261  touch_interface_release_request_server,
1262  },
1263 };
1264 
1265 const 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 
1303 const 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 
1313 const wl_interface* output_interface_release_request_server[0] = {
1314 };
1315 
1316 const 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 
1327 const wl_interface* output_interface_mode_event_server[4] = {
1328  nullptr,
1329  nullptr,
1330  nullptr,
1331  nullptr,
1332 };
1333 
1334 const wl_interface* output_interface_done_event_server[0] = {
1335 };
1336 
1337 const wl_interface* output_interface_scale_event_server[1] = {
1338  nullptr,
1339 };
1340 
1341 const wl_interface* output_interface_name_event_server[1] = {
1342  nullptr,
1343 };
1344 
1345 const wl_interface* output_interface_description_event_server[1] = {
1346  nullptr,
1347 };
1348 
1349 const wl_message output_interface_requests_server[1] = {
1350  {
1351  "release",
1352  "3",
1353  output_interface_release_request_server,
1354  },
1355 };
1356 
1357 const 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 
1390 const 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 
1400 const wl_interface* region_interface_destroy_request_server[0] = {
1401 };
1402 
1403 const wl_interface* region_interface_add_request_server[4] = {
1404  nullptr,
1405  nullptr,
1406  nullptr,
1407  nullptr,
1408 };
1409 
1410 const wl_interface* region_interface_subtract_request_server[4] = {
1411  nullptr,
1412  nullptr,
1413  nullptr,
1414  nullptr,
1415 };
1416 
1417 const 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 
1435 const wl_message region_interface_events_server[0] = {
1436 };
1437 
1438 const 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 
1448 const wl_interface* subcompositor_interface_destroy_request_server[0] = {
1449 };
1450 
1451 const wl_interface* subcompositor_interface_get_subsurface_request_server[3] = {
1452  &subsurface_interface,
1453  &surface_interface,
1454  &surface_interface,
1455 };
1456 
1457 const 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 
1470 const wl_message subcompositor_interface_events_server[0] = {
1471 };
1472 
1473 const 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 
1483 const wl_interface* subsurface_interface_destroy_request_server[0] = {
1484 };
1485 
1486 const wl_interface* subsurface_interface_set_position_request_server[2] = {
1487  nullptr,
1488  nullptr,
1489 };
1490 
1491 const wl_interface* subsurface_interface_place_above_request_server[1] = {
1492  &surface_interface,
1493 };
1494 
1495 const wl_interface* subsurface_interface_place_below_request_server[1] = {
1496  &surface_interface,
1497 };
1498 
1499 const wl_interface* subsurface_interface_set_sync_request_server[0] = {
1500 };
1501 
1502 const wl_interface* subsurface_interface_set_desync_request_server[0] = {
1503 };
1504 
1505 const 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 
1538 const wl_message subsurface_interface_events_server[0] = {
1539 };
1540 
1541 const 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 
1551 registry_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 
1557 registry_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 
1563 const std::string registry_t::interface_name = "wl_registry";
1564 
1565 registry_t::operator wl_registry*() const
1566 {
1567  return reinterpret_cast<wl_registry*> (c_ptr());
1568 }
1569 
1570 std::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 
1576 void 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 
1581 void registry_t::global_remove(uint32_t name, bool post)
1582 {
1583  send_event(post, 1, name);
1584 }
1585 
1586 int 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 
1598 callback_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 
1604 callback_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 
1610 const std::string callback_t::interface_name = "wl_callback";
1611 
1612 callback_t::operator wl_callback*() const
1613 {
1614  return reinterpret_cast<wl_callback*> (c_ptr());
1615 }
1616 
1617 void callback_t::done(uint32_t callback_data, bool post)
1618 {
1619  send_event(post, 0, callback_data);
1620 }
1621 
1622 int 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 
1627 compositor_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 
1633 compositor_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 
1639 const std::string compositor_t::interface_name = "wl_compositor";
1640 
1641 compositor_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 
1658 int 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 
1673 shm_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 
1679 shm_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 
1685 const std::string shm_pool_t::interface_name = "wl_shm_pool";
1686 
1687 shm_pool_t::operator wl_shm_pool*() const
1688 {
1689  return reinterpret_cast<wl_shm_pool*> (c_ptr());
1690 }
1691 
1692 std::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 
1698 std::function<void()> &shm_pool_t::on_destroy()
1699 {
1700  return std::static_pointer_cast<events_t>(get_events())->destroy;
1701 }
1702 
1703 
1704 std::function<void(int32_t)> &shm_pool_t::on_resize()
1705 {
1706  return std::static_pointer_cast<events_t>(get_events())->resize;
1707 }
1708 
1709 
1710 int 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 
1728 shm_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 
1734 shm_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 
1740 const std::string shm_t::interface_name = "wl_shm";
1741 
1742 shm_t::operator wl_shm*() const
1743 {
1744  return reinterpret_cast<wl_shm*> (c_ptr());
1745 }
1746 
1747 std::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 
1753 void shm_t::format(shm_format const& format, bool post)
1754 {
1755  send_event(post, 0, static_cast<uint32_t>(format));
1756 }
1757 
1758 void shm_t::post_invalid_format(std::string const& msg)
1759 {
1760  post_error(static_cast<uint32_t>(shm_error::invalid_format), msg);
1761 }
1762 
1763 void shm_t::post_invalid_stride(std::string const& msg)
1764 {
1765  post_error(static_cast<uint32_t>(shm_error::invalid_stride), msg);
1766 }
1767 
1768 void shm_t::post_invalid_fd(std::string const& msg)
1769 {
1770  post_error(static_cast<uint32_t>(shm_error::invalid_fd), msg);
1771 }
1772 
1773 int 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 
1787 buffer_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 
1793 buffer_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 
1799 const std::string buffer_t::interface_name = "wl_buffer";
1800 
1801 buffer_t::operator wl_buffer*() const
1802 {
1803  return reinterpret_cast<wl_buffer*> (c_ptr());
1804 }
1805 
1806 std::function<void()> &buffer_t::on_destroy()
1807 {
1808  return std::static_pointer_cast<events_t>(get_events())->destroy;
1809 }
1810 
1811 
1812 void buffer_t::release(bool post)
1813 {
1814  send_event(post, 0);
1815 }
1816 
1817 int 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 
1829 data_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 
1835 data_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 
1841 const std::string data_offer_t::interface_name = "wl_data_offer";
1842 
1843 data_offer_t::operator wl_data_offer*() const
1844 {
1845  return reinterpret_cast<wl_data_offer*> (c_ptr());
1846 }
1847 
1848 std::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 
1854 std::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 
1860 std::function<void()> &data_offer_t::on_destroy()
1861 {
1862  return std::static_pointer_cast<events_t>(get_events())->destroy;
1863 }
1864 
1865 
1866 std::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 
1878 void data_offer_t::offer(std::string const& mime_type, bool post)
1879 {
1880  send_event(post, 0, mime_type);
1881 }
1882 
1883 void data_offer_t::source_actions(data_device_manager_dnd_action const& source_actions, bool post)
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 
1893 void data_offer_t::action(data_device_manager_dnd_action const& dnd_action, bool post)
1894 {
1895  send_event(post, 2, static_cast<uint32_t>(dnd_action));
1896 }
1897 
1899 {
1900  return (get_version() >= action_since_version);
1901 }
1902 
1903 void 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 
1908 void 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 
1913 void 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 
1918 void 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 
1923 int 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 
1948 data_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 
1954 data_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 
1960 const std::string data_source_t::interface_name = "wl_data_source";
1961 
1962 data_source_t::operator wl_data_source*() const
1963 {
1964  return reinterpret_cast<wl_data_source*> (c_ptr());
1965 }
1966 
1967 std::function<void(std::string)> &data_source_t::on_offer()
1968 {
1969  return std::static_pointer_cast<events_t>(get_events())->offer;
1970 }
1971 
1972 
1973 std::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 
1985 void data_source_t::target(std::string const& mime_type, bool post)
1986 {
1987  send_event(post, 0, mime_type);
1988 }
1989 
1990 void 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 
2020 void data_source_t::action(data_device_manager_dnd_action const& dnd_action, bool post)
2021 {
2022  send_event(post, 5, static_cast<uint32_t>(dnd_action));
2023 }
2024 
2026 {
2027  return (get_version() >= action_since_version);
2028 }
2029 
2030 void data_source_t::post_invalid_action_mask(std::string const& msg)
2031 {
2032  post_error(static_cast<uint32_t>(data_source_error::invalid_action_mask), msg);
2033 }
2034 
2035 void 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 
2040 int 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 
2059 data_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 
2065 data_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 
2071 const std::string data_device_t::interface_name = "wl_data_device";
2072 
2073 data_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 
2084 std::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 
2090 std::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 
2101 void 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 
2106 void data_device_t::leave(bool post)
2107 {
2108  send_event(post, 2);
2109 }
2110 
2111 void data_device_t::motion(uint32_t time, double x, double y, bool post)
2112 {
2113  send_event(post, 3, time, x, y);
2114 }
2115 
2116 void data_device_t::drop(bool post)
2117 {
2118  send_event(post, 4);
2119 }
2120 
2121 void 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 
2126 void data_device_t::post_role(std::string const& msg)
2127 {
2128  post_error(static_cast<uint32_t>(data_device_error::role), msg);
2129 }
2130 
2131 int 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 
2150 data_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 
2156 data_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 
2162 const std::string data_device_manager_t::interface_name = "wl_data_device_manager";
2163 
2164 data_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 
2181 int 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 }
2195 const bitfield<3, 6> data_device_manager_dnd_action::none{0};
2196 const bitfield<3, 6> data_device_manager_dnd_action::copy{1};
2197 const bitfield<3, 6> data_device_manager_dnd_action::move{2};
2198 const bitfield<3, 6> data_device_manager_dnd_action::ask{4};
2199 
2200 
2201 shell_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 
2207 shell_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 
2213 const std::string shell_t::interface_name = "wl_shell";
2214 
2215 shell_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 
2226 void shell_t::post_role(std::string const& msg)
2227 {
2228  post_error(static_cast<uint32_t>(shell_error::role), msg);
2229 }
2230 
2231 int 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 
2244 shell_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 
2250 shell_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 
2256 const std::string shell_surface_t::interface_name = "wl_shell_surface";
2257 
2258 shell_surface_t::operator wl_shell_surface*() const
2259 {
2260  return reinterpret_cast<wl_shell_surface*> (c_ptr());
2261 }
2262 
2263 std::function<void(uint32_t)> &shell_surface_t::on_pong()
2264 {
2265  return std::static_pointer_cast<events_t>(get_events())->pong;
2266 }
2267 
2268 
2269 std::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 
2275 std::function<void(seat_t, uint32_t, shell_surface_resize)> &shell_surface_t::on_resize()
2276 {
2277  return std::static_pointer_cast<events_t>(get_events())->resize;
2278 }
2279 
2280 
2281 std::function<void()> &shell_surface_t::on_set_toplevel()
2282 {
2283  return std::static_pointer_cast<events_t>(get_events())->set_toplevel;
2284 }
2285 
2286 
2287 std::function<void(surface_t, int32_t, int32_t, shell_surface_transient)> &shell_surface_t::on_set_transient()
2288 {
2289  return std::static_pointer_cast<events_t>(get_events())->set_transient;
2290 }
2291 
2292 
2293 std::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 
2299 std::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 
2311 std::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 
2317 std::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 
2323 void shell_surface_t::ping(uint32_t serial, bool post)
2324 {
2325  send_event(post, 0, serial);
2326 }
2327 
2328 void 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 
2338 int 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 }
2376 const bitfield<4, 8> shell_surface_resize::none{0};
2377 const bitfield<4, 8> shell_surface_resize::top{1};
2378 const bitfield<4, 8> shell_surface_resize::bottom{2};
2379 const bitfield<4, 8> shell_surface_resize::left{4};
2380 const bitfield<4, 8> shell_surface_resize::top_left{5};
2381 const bitfield<4, 8> shell_surface_resize::bottom_left{6};
2382 const bitfield<4, 8> shell_surface_resize::right{8};
2383 const bitfield<4, 8> shell_surface_resize::top_right{9};
2384 const bitfield<4, 8> shell_surface_resize::bottom_right{10};
2385 
2386 const bitfield<1, 9> shell_surface_transient::inactive{0x1};
2387 
2388 
2389 
2390 surface_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 
2396 surface_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 
2402 const std::string surface_t::interface_name = "wl_surface";
2403 
2404 surface_t::operator wl_surface*() const
2405 {
2406  return reinterpret_cast<wl_surface*> (c_ptr());
2407 }
2408 
2409 std::function<void()> &surface_t::on_destroy()
2410 {
2411  return std::static_pointer_cast<events_t>(get_events())->destroy;
2412 }
2413 
2414 
2415 std::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 
2421 std::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 
2427 std::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 
2445 std::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 
2457 std::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 
2463 std::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 
2469 std::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 
2475 void 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 
2480 void 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 
2485 void surface_t::post_invalid_scale(std::string const& msg)
2486 {
2487  post_error(static_cast<uint32_t>(surface_error::invalid_scale), msg);
2488 }
2489 
2490 void surface_t::post_invalid_transform(std::string const& msg)
2491 {
2492  post_error(static_cast<uint32_t>(surface_error::invalid_transform), msg);
2493 }
2494 
2495 void surface_t::post_invalid_size(std::string const& msg)
2496 {
2497  post_error(static_cast<uint32_t>(surface_error::invalid_size), msg);
2498 }
2499 
2500 void surface_t::post_invalid_offset(std::string const& msg)
2501 {
2502  post_error(static_cast<uint32_t>(surface_error::invalid_offset), msg);
2503 }
2504 
2505 int 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 
2548 seat_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 
2554 seat_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 
2560 const std::string seat_t::interface_name = "wl_seat";
2561 
2562 seat_t::operator wl_seat*() const
2563 {
2564  return reinterpret_cast<wl_seat*> (c_ptr());
2565 }
2566 
2567 std::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 
2573 std::function<void(keyboard_t)> &seat_t::on_get_keyboard()
2574 {
2575  return std::static_pointer_cast<events_t>(get_events())->get_keyboard;
2576 }
2577 
2578 
2579 std::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 
2585 std::function<void()> &seat_t::on_release()
2586 {
2587  return std::static_pointer_cast<events_t>(get_events())->release;
2588 }
2589 
2590 
2591 void seat_t::capabilities(seat_capability const& capabilities, bool post)
2592 {
2593  send_event(post, 0, static_cast<uint32_t>(capabilities));
2594 }
2595 
2596 void seat_t::name(std::string const& name, bool post)
2597 {
2598  send_event(post, 1, name);
2599 }
2600 
2601 bool seat_t::can_name() const
2602 {
2603  return (get_version() >= name_since_version);
2604 }
2605 
2606 void seat_t::post_missing_capability(std::string const& msg)
2607 {
2608  post_error(static_cast<uint32_t>(seat_error::missing_capability), msg);
2609 }
2610 
2611 int 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 }
2631 const bitfield<3, 12> seat_capability::pointer{1};
2632 const bitfield<3, 12> seat_capability::keyboard{2};
2633 const bitfield<3, 12> seat_capability::touch{4};
2634 
2635 
2636 
2637 pointer_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 
2643 pointer_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 
2649 const std::string pointer_t::interface_name = "wl_pointer";
2650 
2651 pointer_t::operator wl_pointer*() const
2652 {
2653  return reinterpret_cast<wl_pointer*> (c_ptr());
2654 }
2655 
2656 std::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 
2662 std::function<void()> &pointer_t::on_release()
2663 {
2664  return std::static_pointer_cast<events_t>(get_events())->release;
2665 }
2666 
2667 
2668 void 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 
2673 void 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 
2678 void 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 
2683 void 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 
2688 void 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 
2693 void pointer_t::frame(bool post)
2694 {
2695  send_event(post, 5);
2696 }
2697 
2699 {
2700  return (get_version() >= frame_since_version);
2701 }
2702 
2703 void 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 
2713 void 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 
2723 void 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 
2733 void 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 
2743 void pointer_t::post_role(std::string const& msg)
2744 {
2745  post_error(static_cast<uint32_t>(pointer_error::role), msg);
2746 }
2747 
2748 int 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 
2767 keyboard_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 
2773 keyboard_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 
2779 const std::string keyboard_t::interface_name = "wl_keyboard";
2780 
2781 keyboard_t::operator wl_keyboard*() const
2782 {
2783  return reinterpret_cast<wl_keyboard*> (c_ptr());
2784 }
2785 
2786 std::function<void()> &keyboard_t::on_release()
2787 {
2788  return std::static_pointer_cast<events_t>(get_events())->release;
2789 }
2790 
2791 
2792 void 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 
2797 void 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 
2802 void 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 
2807 void 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 
2812 void 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 
2817 void 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 
2827 int 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 
2841 touch_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 
2847 touch_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 
2853 const std::string touch_t::interface_name = "wl_touch";
2854 
2855 touch_t::operator wl_touch*() const
2856 {
2857  return reinterpret_cast<wl_touch*> (c_ptr());
2858 }
2859 
2860 std::function<void()> &touch_t::on_release()
2861 {
2862  return std::static_pointer_cast<events_t>(get_events())->release;
2863 }
2864 
2865 
2866 void 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 
2871 void 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 
2876 void 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 
2881 void touch_t::frame(bool post)
2882 {
2883  send_event(post, 3);
2884 }
2885 
2886 void touch_t::cancel(bool post)
2887 {
2888  send_event(post, 4);
2889 }
2890 
2891 void 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 
2901 void 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 
2911 int 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 
2923 output_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 
2929 output_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 
2935 const std::string output_t::interface_name = "wl_output";
2936 
2937 output_t::operator wl_output*() const
2938 {
2939  return reinterpret_cast<wl_output*> (c_ptr());
2940 }
2941 
2942 std::function<void()> &output_t::on_release()
2943 {
2944  return std::static_pointer_cast<events_t>(get_events())->release;
2945 }
2946 
2947 
2948 void 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 
2953 void 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 
2958 void output_t::done(bool post)
2959 {
2960  send_event(post, 2);
2961 }
2962 
2964 {
2965  return (get_version() >= done_since_version);
2966 }
2967 
2968 void 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 
2978 void 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 
2988 void 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 
2998 int 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 
3010 const bitfield<3, 21> output_transform::normal{0};
3011 const bitfield<3, 21> output_transform::_90{1};
3012 const bitfield<3, 21> output_transform::_180{2};
3013 const bitfield<3, 21> output_transform::_270{3};
3014 const bitfield<3, 21> output_transform::flipped{4};
3015 const bitfield<3, 21> output_transform::flipped_90{5};
3016 const bitfield<3, 21> output_transform::flipped_180{6};
3017 const bitfield<3, 21> output_transform::flipped_270{7};
3018 
3019 const bitfield<2, 22> output_mode::current{0x1};
3020 const bitfield<2, 22> output_mode::preferred{0x2};
3021 
3022 
3023 region_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 
3029 region_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 
3035 const std::string region_t::interface_name = "wl_region";
3036 
3037 region_t::operator wl_region*() const
3038 {
3039  return reinterpret_cast<wl_region*> (c_ptr());
3040 }
3041 
3042 std::function<void()> &region_t::on_destroy()
3043 {
3044  return std::static_pointer_cast<events_t>(get_events())->destroy;
3045 }
3046 
3047 
3048 std::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 
3054 std::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 
3060 int 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 
3078 subcompositor_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 
3084 subcompositor_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 
3090 const std::string subcompositor_t::interface_name = "wl_subcompositor";
3091 
3092 subcompositor_t::operator wl_subcompositor*() const
3093 {
3094  return reinterpret_cast<wl_subcompositor*> (c_ptr());
3095 }
3096 
3097 std::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 
3109 void subcompositor_t::post_bad_surface(std::string const& msg)
3110 {
3111  post_error(static_cast<uint32_t>(subcompositor_error::bad_surface), msg);
3112 }
3113 
3114 int 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 
3130 subsurface_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 
3136 subsurface_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 
3142 const std::string subsurface_t::interface_name = "wl_subsurface";
3143 
3144 subsurface_t::operator wl_subsurface*() const
3145 {
3146  return reinterpret_cast<wl_subsurface*> (c_ptr());
3147 }
3148 
3149 std::function<void()> &subsurface_t::on_destroy()
3150 {
3151  return std::static_pointer_cast<events_t>(get_events())->destroy;
3152 }
3153 
3154 
3155 std::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 
3173 std::function<void()> &subsurface_t::on_set_sync()
3174 {
3175  return std::static_pointer_cast<events_t>(get_events())->set_sync;
3176 }
3177 
3178 
3179 std::function<void()> &subsurface_t::on_set_desync()
3180 {
3181  return std::static_pointer_cast<events_t>(get_events())->set_desync;
3182 }
3183 
3184 
3185 void subsurface_t::post_bad_surface(std::string const& msg)
3186 {
3187  post_error(static_cast<uint32_t>(subsurface_error::bad_surface), msg);
3188 }
3189 
3190 int 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 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< 3, 6 > copy
copy action
static const wayland::detail::bitfield< 3, 6 > move
move action
static const wayland::detail::bitfield< 3, 6 > ask
ask action
static const wayland::detail::bitfield< 3, 6 > none
no 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< 3, 21 > normal
no transform
static const wayland::detail::bitfield< 3, 21 > flipped_180
flip and rotate 180 degrees counter-clockwise
static const wayland::detail::bitfield< 3, 21 > flipped
180 degree flip around a vertical axis
static const wayland::detail::bitfield< 3, 21 > _270
270 degrees counter-clockwise
static const wayland::detail::bitfield< 3, 21 > _180
180 degrees counter-clockwise
static const wayland::detail::bitfield< 3, 21 > flipped_90
flip and rotate 90 degrees counter-clockwise
static const wayland::detail::bitfield< 3, 21 > flipped_270
flip and rotate 270 degrees counter-clockwise
static const wayland::detail::bitfield< 3, 21 > _90
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< 3, 12 > pointer
the seat has pointer devices
static const wayland::detail::bitfield< 4, 8 > bottom_left
bottom and left edges
static const wayland::detail::bitfield< 4, 8 > top_right
top and right edges
static const wayland::detail::bitfield< 4, 8 > bottom_right
bottom and right edges
static const wayland::detail::bitfield< 4, 8 > bottom
bottom edge
static const wayland::detail::bitfield< 4, 8 > right
right edge
static const wayland::detail::bitfield< 4, 8 > left
left edge
static const wayland::detail::bitfield< 4, 8 > none
no edge
static const wayland::detail::bitfield< 4, 8 > top
top edge
static const wayland::detail::bitfield< 4, 8 > top_left
top and left edges
static const wayland::detail::bitfield< 1, 9 > inactive
do not set keyboard focus