wayland-client-protocol.hpp

#pragma once
 
#include <array>
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
#include <wayland-client.hpp>
 
struct wl_registry;
struct wl_callback;
struct wl_compositor;
struct wl_shm_pool;
struct wl_shm;
struct wl_buffer;
struct wl_data_offer;
struct wl_data_source;
struct wl_data_device;
struct wl_data_device_manager;
struct wl_shell;
struct wl_shell_surface;
struct wl_surface;
struct wl_seat;
struct wl_pointer;
struct wl_keyboard;
struct wl_touch;
struct wl_output;
struct wl_region;
struct wl_subcompositor;
struct wl_subsurface;
 
namespace wayland
{
class registry_t;
class callback_t;
class compositor_t;
class shm_pool_t;
class shm_t;
enum class shm_error : uint32_t;
enum class shm_format : uint32_t;
class buffer_t;
class data_offer_t;
enum class data_offer_error : uint32_t;
class data_source_t;
enum class data_source_error : uint32_t;
class data_device_t;
enum class data_device_error : uint32_t;
class data_device_manager_t;
struct data_device_manager_dnd_action;
class shell_t;
enum class shell_error : uint32_t;
class shell_surface_t;
struct shell_surface_resize;
struct shell_surface_transient;
enum class shell_surface_fullscreen_method : uint32_t;
class surface_t;
enum class surface_error : uint32_t;
class seat_t;
struct seat_capability;
class pointer_t;
enum class pointer_error : uint32_t;
enum class pointer_button_state : uint32_t;
enum class pointer_axis : uint32_t;
enum class pointer_axis_source : uint32_t;
class keyboard_t;
enum class keyboard_keymap_format : uint32_t;
enum class keyboard_key_state : uint32_t;
class touch_t;
class output_t;
enum class output_subpixel : uint32_t;
struct output_transform;
struct output_mode;
class region_t;
class subcompositor_t;
enum class subcompositor_error : uint32_t;
class subsurface_t;
enum class subsurface_error : uint32_t;
 
namespace detail
{
  extern const wl_interface display_interface;
  extern const wl_interface registry_interface;
  extern const wl_interface callback_interface;
  extern const wl_interface compositor_interface;
  extern const wl_interface shm_pool_interface;
  extern const wl_interface shm_interface;
  extern const wl_interface buffer_interface;
  extern const wl_interface data_offer_interface;
  extern const wl_interface data_source_interface;
  extern const wl_interface data_device_interface;
  extern const wl_interface data_device_manager_interface;
  extern const wl_interface shell_interface;
  extern const wl_interface shell_surface_interface;
  extern const wl_interface surface_interface;
  extern const wl_interface seat_interface;
  extern const wl_interface pointer_interface;
  extern const wl_interface keyboard_interface;
  extern const wl_interface touch_interface;
  extern const wl_interface output_interface;
  extern const wl_interface region_interface;
  extern const wl_interface subcompositor_interface;
  extern const wl_interface subsurface_interface;
}
 
class registry_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(uint32_t, std::string, uint32_t)> global;
    std::function<void(uint32_t)> global_remove;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  registry_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  registry_t();
  explicit registry_t(const proxy_t &proxy);
  registry_t(wl_registry *p, wrapper_type t = wrapper_type::standard);
 
  registry_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator wl_registry*() const;
 
  proxy_t bind(uint32_t name, proxy_t &interface, uint32_t version);
 
  static constexpr std::uint32_t bind_since_version = 1;
 
  std::function<void(uint32_t, std::string, uint32_t)> &on_global();
 
  std::function<void(uint32_t)> &on_global_remove();
 
};
 
 
class callback_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(uint32_t)> done;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  callback_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  callback_t();
  explicit callback_t(const proxy_t &proxy);
  callback_t(wl_callback *p, wrapper_type t = wrapper_type::standard);
 
  callback_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator wl_callback*() const;
 
  std::function<void(uint32_t)> &on_done();
 
};
 
 
class compositor_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  compositor_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  compositor_t();
  explicit compositor_t(const proxy_t &proxy);
  compositor_t(wl_compositor *p, wrapper_type t = wrapper_type::standard);
 
  compositor_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator wl_compositor*() const;
 
  surface_t create_surface();
 
  static constexpr std::uint32_t create_surface_since_version = 1;
 
  region_t create_region();
 
  static constexpr std::uint32_t create_region_since_version = 1;
 
};
 
 
class shm_pool_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  shm_pool_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  shm_pool_t();
  explicit shm_pool_t(const proxy_t &proxy);
  shm_pool_t(wl_shm_pool *p, wrapper_type t = wrapper_type::standard);
 
  shm_pool_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator wl_shm_pool*() const;
 
  buffer_t create_buffer(int32_t offset, int32_t width, int32_t height, int32_t stride, shm_format format);
 
  static constexpr std::uint32_t create_buffer_since_version = 1;
 
  void resize(int32_t size);
 
  static constexpr std::uint32_t resize_since_version = 1;
 
};
 
 
class shm_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(shm_format)> format;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  shm_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  shm_t();
  explicit shm_t(const proxy_t &proxy);
  shm_t(wl_shm *p, wrapper_type t = wrapper_type::standard);
 
  shm_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator wl_shm*() const;
 
  shm_pool_t create_pool(int fd, int32_t size);
 
  static constexpr std::uint32_t create_pool_since_version = 1;
 
  std::function<void(shm_format)> &on_format();
 
};
 
enum class shm_error : uint32_t
  {
  invalid_format = 0,
  invalid_stride = 1,
  invalid_fd = 2
};
 
enum class shm_format : uint32_t
  {
  argb8888 = 0,
  xrgb8888 = 1,
  c8 = 0x20203843,
  rgb332 = 0x38424752,
  bgr233 = 0x38524742,
  xrgb4444 = 0x32315258,
  xbgr4444 = 0x32314258,
  rgbx4444 = 0x32315852,
  bgrx4444 = 0x32315842,
  argb4444 = 0x32315241,
  abgr4444 = 0x32314241,
  rgba4444 = 0x32314152,
  bgra4444 = 0x32314142,
  xrgb1555 = 0x35315258,
  xbgr1555 = 0x35314258,
  rgbx5551 = 0x35315852,
  bgrx5551 = 0x35315842,
  argb1555 = 0x35315241,
  abgr1555 = 0x35314241,
  rgba5551 = 0x35314152,
  bgra5551 = 0x35314142,
  rgb565 = 0x36314752,
  bgr565 = 0x36314742,
  rgb888 = 0x34324752,
  bgr888 = 0x34324742,
  xbgr8888 = 0x34324258,
  rgbx8888 = 0x34325852,
  bgrx8888 = 0x34325842,
  abgr8888 = 0x34324241,
  rgba8888 = 0x34324152,
  bgra8888 = 0x34324142,
  xrgb2101010 = 0x30335258,
  xbgr2101010 = 0x30334258,
  rgbx1010102 = 0x30335852,
  bgrx1010102 = 0x30335842,
  argb2101010 = 0x30335241,
  abgr2101010 = 0x30334241,
  rgba1010102 = 0x30334152,
  bgra1010102 = 0x30334142,
  yuyv = 0x56595559,
  yvyu = 0x55595659,
  uyvy = 0x59565955,
  vyuy = 0x59555956,
  ayuv = 0x56555941,
  nv12 = 0x3231564e,
  nv21 = 0x3132564e,
  nv16 = 0x3631564e,
  nv61 = 0x3136564e,
  yuv410 = 0x39565559,
  yvu410 = 0x39555659,
  yuv411 = 0x31315559,
  yvu411 = 0x31315659,
  yuv420 = 0x32315559,
  yvu420 = 0x32315659,
  yuv422 = 0x36315559,
  yvu422 = 0x36315659,
  yuv444 = 0x34325559,
  yvu444 = 0x34325659
};
 
 
class buffer_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void()> release;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  buffer_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  buffer_t();
  explicit buffer_t(const proxy_t &proxy);
  buffer_t(wl_buffer *p, wrapper_type t = wrapper_type::standard);
 
  buffer_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator wl_buffer*() const;
 
  std::function<void()> &on_release();
 
};
 
 
class data_offer_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(std::string)> offer;
    std::function<void(data_device_manager_dnd_action)> source_actions;
    std::function<void(data_device_manager_dnd_action)> action;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  data_offer_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  data_offer_t();
  explicit data_offer_t(const proxy_t &proxy);
  data_offer_t(wl_data_offer *p, wrapper_type t = wrapper_type::standard);
 
  data_offer_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator wl_data_offer*() const;
 
  void accept(uint32_t serial, std::string mime_type);
 
  static constexpr std::uint32_t accept_since_version = 1;
 
  void receive(std::string mime_type, int fd);
 
  static constexpr std::uint32_t receive_since_version = 1;
 
  void finish();
 
  static constexpr std::uint32_t finish_since_version = 3;
 
  bool can_finish() const;
 
  void set_actions(data_device_manager_dnd_action dnd_actions, data_device_manager_dnd_action preferred_action);
 
  static constexpr std::uint32_t set_actions_since_version = 3;
 
  bool can_set_actions() const;
 
  std::function<void(std::string)> &on_offer();
 
  std::function<void(data_device_manager_dnd_action)> &on_source_actions();
 
  std::function<void(data_device_manager_dnd_action)> &on_action();
 
};
 
enum class data_offer_error : uint32_t
  {
  invalid_finish = 0,
  invalid_action_mask = 1,
  invalid_action = 2,
  invalid_offer = 3
};
 
 
class data_source_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(std::string)> target;
    std::function<void(std::string, int)> send;
    std::function<void()> cancelled;
    std::function<void()> dnd_drop_performed;
    std::function<void()> dnd_finished;
    std::function<void(data_device_manager_dnd_action)> action;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  data_source_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  data_source_t();
  explicit data_source_t(const proxy_t &proxy);
  data_source_t(wl_data_source *p, wrapper_type t = wrapper_type::standard);
 
  data_source_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator wl_data_source*() const;
 
  void offer(std::string mime_type);
 
  static constexpr std::uint32_t offer_since_version = 1;
 
  void set_actions(data_device_manager_dnd_action dnd_actions);
 
  static constexpr std::uint32_t set_actions_since_version = 3;
 
  bool can_set_actions() const;
 
  std::function<void(std::string)> &on_target();
 
  std::function<void(std::string, int)> &on_send();
 
  std::function<void()> &on_cancelled();
 
  std::function<void()> &on_dnd_drop_performed();
 
  std::function<void()> &on_dnd_finished();
 
  std::function<void(data_device_manager_dnd_action)> &on_action();
 
};
 
enum class data_source_error : uint32_t
  {
  invalid_action_mask = 0,
  invalid_source = 1
};
 
 
class data_device_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(data_offer_t)> data_offer;
    std::function<void(uint32_t, surface_t, double, double, data_offer_t)> enter;
    std::function<void()> leave;
    std::function<void(uint32_t, double, double)> motion;
    std::function<void()> drop;
    std::function<void(data_offer_t)> selection;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  data_device_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  data_device_t();
  explicit data_device_t(const proxy_t &proxy);
  data_device_t(wl_data_device *p, wrapper_type t = wrapper_type::standard);
 
  data_device_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator wl_data_device*() const;
 
  void start_drag(data_source_t source, surface_t origin, surface_t icon, uint32_t serial);
 
  static constexpr std::uint32_t start_drag_since_version = 1;
 
  void set_selection(data_source_t source, uint32_t serial);
 
  static constexpr std::uint32_t set_selection_since_version = 1;
 
  void release();
 
  static constexpr std::uint32_t release_since_version = 2;
 
  bool can_release() const;
 
  std::function<void(data_offer_t)> &on_data_offer();
 
  std::function<void(uint32_t, surface_t, double, double, data_offer_t)> &on_enter();
 
  std::function<void()> &on_leave();
 
  std::function<void(uint32_t, double, double)> &on_motion();
 
  std::function<void()> &on_drop();
 
  std::function<void(data_offer_t)> &on_selection();
 
};
 
enum class data_device_error : uint32_t
  {
  role = 0
};
 
 
class data_device_manager_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  data_device_manager_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  data_device_manager_t();
  explicit data_device_manager_t(const proxy_t &proxy);
  data_device_manager_t(wl_data_device_manager *p, wrapper_type t = wrapper_type::standard);
 
  data_device_manager_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator wl_data_device_manager*() const;
 
  data_source_t create_data_source();
 
  static constexpr std::uint32_t create_data_source_since_version = 1;
 
  data_device_t get_data_device(seat_t seat);
 
  static constexpr std::uint32_t get_data_device_since_version = 1;
 
};
 
struct data_device_manager_dnd_action : public detail::bitfield<3, 6>
{
  data_device_manager_dnd_action(const detail::bitfield<3, 6> &b)
    : detail::bitfield<3, 6>(b) {}
  data_device_manager_dnd_action(const uint32_t value)
    : detail::bitfield<3, 6>(value) {}
  static const detail::bitfield<3, 6> none;
  static const detail::bitfield<3, 6> copy;
  static const detail::bitfield<3, 6> move;
  static const detail::bitfield<3, 6> ask;
};
 
 
class shell_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  shell_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  shell_t();
  explicit shell_t(const proxy_t &proxy);
  shell_t(wl_shell *p, wrapper_type t = wrapper_type::standard);
 
  shell_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator wl_shell*() const;
 
  shell_surface_t get_shell_surface(surface_t surface);
 
  static constexpr std::uint32_t get_shell_surface_since_version = 1;
 
};
 
enum class shell_error : uint32_t
  {
  role = 0
};
 
 
class shell_surface_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(uint32_t)> ping;
    std::function<void(shell_surface_resize, int32_t, int32_t)> configure;
    std::function<void()> popup_done;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  shell_surface_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  shell_surface_t();
  explicit shell_surface_t(const proxy_t &proxy);
  shell_surface_t(wl_shell_surface *p, wrapper_type t = wrapper_type::standard);
 
  shell_surface_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator wl_shell_surface*() const;
 
  void pong(uint32_t serial);
 
  static constexpr std::uint32_t pong_since_version = 1;
 
  void move(seat_t seat, uint32_t serial);
 
  static constexpr std::uint32_t move_since_version = 1;
 
  void resize(seat_t seat, uint32_t serial, shell_surface_resize edges);
 
  static constexpr std::uint32_t resize_since_version = 1;
 
  void set_toplevel();
 
  static constexpr std::uint32_t set_toplevel_since_version = 1;
 
  void set_transient(surface_t parent, int32_t x, int32_t y, shell_surface_transient flags);
 
  static constexpr std::uint32_t set_transient_since_version = 1;
 
  void set_fullscreen(shell_surface_fullscreen_method method, uint32_t framerate, output_t output);
 
  static constexpr std::uint32_t set_fullscreen_since_version = 1;
 
  void set_popup(seat_t seat, uint32_t serial, surface_t parent, int32_t x, int32_t y, shell_surface_transient flags);
 
  static constexpr std::uint32_t set_popup_since_version = 1;
 
  void set_maximized(output_t output);
 
  static constexpr std::uint32_t set_maximized_since_version = 1;
 
  void set_title(std::string title);
 
  static constexpr std::uint32_t set_title_since_version = 1;
 
  void set_class(std::string class_);
 
  static constexpr std::uint32_t set_class_since_version = 1;
 
  std::function<void(uint32_t)> &on_ping();
 
  std::function<void(shell_surface_resize, int32_t, int32_t)> &on_configure();
 
  std::function<void()> &on_popup_done();
 
};
 
struct shell_surface_resize : public detail::bitfield<4, 8>
{
  shell_surface_resize(const detail::bitfield<4, 8> &b)
    : detail::bitfield<4, 8>(b) {}
  shell_surface_resize(const uint32_t value)
    : detail::bitfield<4, 8>(value) {}
  static const detail::bitfield<4, 8> none;
  static const detail::bitfield<4, 8> top;
  static const detail::bitfield<4, 8> bottom;
  static const detail::bitfield<4, 8> left;
  static const detail::bitfield<4, 8> top_left;
  static const detail::bitfield<4, 8> bottom_left;
  static const detail::bitfield<4, 8> right;
  static const detail::bitfield<4, 8> top_right;
  static const detail::bitfield<4, 8> bottom_right;
};
 
struct shell_surface_transient : public detail::bitfield<1, 9>
{
  shell_surface_transient(const detail::bitfield<1, 9> &b)
    : detail::bitfield<1, 9>(b) {}
  shell_surface_transient(const uint32_t value)
    : detail::bitfield<1, 9>(value) {}
  static const detail::bitfield<1, 9> inactive;
};
 
enum class shell_surface_fullscreen_method : uint32_t
  {
  _default = 0,
  scale = 1,
  driver = 2,
  fill = 3
};
 
 
class surface_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(output_t)> enter;
    std::function<void(output_t)> leave;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  surface_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  surface_t();
  explicit surface_t(const proxy_t &proxy);
  surface_t(wl_surface *p, wrapper_type t = wrapper_type::standard);
 
  surface_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator wl_surface*() const;
 
  void attach(buffer_t buffer, int32_t x, int32_t y);
 
  static constexpr std::uint32_t attach_since_version = 1;
 
  void damage(int32_t x, int32_t y, int32_t width, int32_t height);
 
  static constexpr std::uint32_t damage_since_version = 1;
 
  callback_t frame();
 
  static constexpr std::uint32_t frame_since_version = 1;
 
  void set_opaque_region(region_t region);
 
  static constexpr std::uint32_t set_opaque_region_since_version = 1;
 
  void set_input_region(region_t region);
 
  static constexpr std::uint32_t set_input_region_since_version = 1;
 
  void commit();
 
  static constexpr std::uint32_t commit_since_version = 1;
 
  void set_buffer_transform(output_transform transform);
 
  static constexpr std::uint32_t set_buffer_transform_since_version = 2;
 
  bool can_set_buffer_transform() const;
 
  void set_buffer_scale(int32_t scale);
 
  static constexpr std::uint32_t set_buffer_scale_since_version = 3;
 
  bool can_set_buffer_scale() const;
 
  void damage_buffer(int32_t x, int32_t y, int32_t width, int32_t height);
 
  static constexpr std::uint32_t damage_buffer_since_version = 4;
 
  bool can_damage_buffer() const;
 
  std::function<void(output_t)> &on_enter();
 
  std::function<void(output_t)> &on_leave();
 
};
 
enum class surface_error : uint32_t
  {
  invalid_scale = 0,
  invalid_transform = 1
};
 
 
class seat_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(seat_capability)> capabilities;
    std::function<void(std::string)> name;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  seat_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  seat_t();
  explicit seat_t(const proxy_t &proxy);
  seat_t(wl_seat *p, wrapper_type t = wrapper_type::standard);
 
  seat_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator wl_seat*() const;
 
  pointer_t get_pointer();
 
  static constexpr std::uint32_t get_pointer_since_version = 1;
 
  keyboard_t get_keyboard();
 
  static constexpr std::uint32_t get_keyboard_since_version = 1;
 
  touch_t get_touch();
 
  static constexpr std::uint32_t get_touch_since_version = 1;
 
  void release();
 
  static constexpr std::uint32_t release_since_version = 5;
 
  bool can_release() const;
 
  std::function<void(seat_capability)> &on_capabilities();
 
  std::function<void(std::string)> &on_name();
 
};
 
struct seat_capability : public detail::bitfield<3, 12>
{
  seat_capability(const detail::bitfield<3, 12> &b)
    : detail::bitfield<3, 12>(b) {}
  seat_capability(const uint32_t value)
    : detail::bitfield<3, 12>(value) {}
  static const detail::bitfield<3, 12> pointer;
  static const detail::bitfield<3, 12> keyboard;
  static const detail::bitfield<3, 12> touch;
};
 
 
class pointer_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(uint32_t, surface_t, double, double)> enter;
    std::function<void(uint32_t, surface_t)> leave;
    std::function<void(uint32_t, double, double)> motion;
    std::function<void(uint32_t, uint32_t, uint32_t, pointer_button_state)> button;
    std::function<void(uint32_t, pointer_axis, double)> axis;
    std::function<void()> frame;
    std::function<void(pointer_axis_source)> axis_source;
    std::function<void(uint32_t, pointer_axis)> axis_stop;
    std::function<void(pointer_axis, int32_t)> axis_discrete;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  pointer_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  pointer_t();
  explicit pointer_t(const proxy_t &proxy);
  pointer_t(wl_pointer *p, wrapper_type t = wrapper_type::standard);
 
  pointer_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator wl_pointer*() const;
 
  void set_cursor(uint32_t serial, surface_t surface, int32_t hotspot_x, int32_t hotspot_y);
 
  static constexpr std::uint32_t set_cursor_since_version = 1;
 
  void release();
 
  static constexpr std::uint32_t release_since_version = 3;
 
  bool can_release() const;
 
  std::function<void(uint32_t, surface_t, double, double)> &on_enter();
 
  std::function<void(uint32_t, surface_t)> &on_leave();
 
  std::function<void(uint32_t, double, double)> &on_motion();
 
  std::function<void(uint32_t, uint32_t, uint32_t, pointer_button_state)> &on_button();
 
  std::function<void(uint32_t, pointer_axis, double)> &on_axis();
 
  std::function<void()> &on_frame();
 
  std::function<void(pointer_axis_source)> &on_axis_source();
 
  std::function<void(uint32_t, pointer_axis)> &on_axis_stop();
 
  std::function<void(pointer_axis, int32_t)> &on_axis_discrete();
 
};
 
enum class pointer_error : uint32_t
  {
  role = 0
};
 
enum class pointer_button_state : uint32_t
  {
  released = 0,
  pressed = 1
};
 
enum class pointer_axis : uint32_t
  {
  vertical_scroll = 0,
  horizontal_scroll = 1
};
 
enum class pointer_axis_source : uint32_t
  {
  wheel = 0,
  finger = 1,
  continuous = 2,
  wheel_tilt = 3
};
 
 
class keyboard_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(keyboard_keymap_format, int, uint32_t)> keymap;
    std::function<void(uint32_t, surface_t, array_t)> enter;
    std::function<void(uint32_t, surface_t)> leave;
    std::function<void(uint32_t, uint32_t, uint32_t, keyboard_key_state)> key;
    std::function<void(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t)> modifiers;
    std::function<void(int32_t, int32_t)> repeat_info;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  keyboard_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  keyboard_t();
  explicit keyboard_t(const proxy_t &proxy);
  keyboard_t(wl_keyboard *p, wrapper_type t = wrapper_type::standard);
 
  keyboard_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator wl_keyboard*() const;
 
  void release();
 
  static constexpr std::uint32_t release_since_version = 3;
 
  bool can_release() const;
 
  std::function<void(keyboard_keymap_format, int, uint32_t)> &on_keymap();
 
  std::function<void(uint32_t, surface_t, array_t)> &on_enter();
 
  std::function<void(uint32_t, surface_t)> &on_leave();
 
  std::function<void(uint32_t, uint32_t, uint32_t, keyboard_key_state)> &on_key();
 
  std::function<void(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t)> &on_modifiers();
 
  std::function<void(int32_t, int32_t)> &on_repeat_info();
 
};
 
enum class keyboard_keymap_format : uint32_t
  {
  no_keymap = 0,
  xkb_v1 = 1
};
 
enum class keyboard_key_state : uint32_t
  {
  released = 0,
  pressed = 1
};
 
 
class touch_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(uint32_t, uint32_t, surface_t, int32_t, double, double)> down;
    std::function<void(uint32_t, uint32_t, int32_t)> up;
    std::function<void(uint32_t, int32_t, double, double)> motion;
    std::function<void()> frame;
    std::function<void()> cancel;
    std::function<void(int32_t, double, double)> shape;
    std::function<void(int32_t, double)> orientation;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  touch_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  touch_t();
  explicit touch_t(const proxy_t &proxy);
  touch_t(wl_touch *p, wrapper_type t = wrapper_type::standard);
 
  touch_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator wl_touch*() const;
 
  void release();
 
  static constexpr std::uint32_t release_since_version = 3;
 
  bool can_release() const;
 
  std::function<void(uint32_t, uint32_t, surface_t, int32_t, double, double)> &on_down();
 
  std::function<void(uint32_t, uint32_t, int32_t)> &on_up();
 
  std::function<void(uint32_t, int32_t, double, double)> &on_motion();
 
  std::function<void()> &on_frame();
 
  std::function<void()> &on_cancel();
 
  std::function<void(int32_t, double, double)> &on_shape();
 
  std::function<void(int32_t, double)> &on_orientation();
 
};
 
 
class output_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(int32_t, int32_t, int32_t, int32_t, output_subpixel, std::string, std::string, output_transform)> geometry;
    std::function<void(output_mode, int32_t, int32_t, int32_t)> mode;
    std::function<void()> done;
    std::function<void(int32_t)> scale;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  output_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  output_t();
  explicit output_t(const proxy_t &proxy);
  output_t(wl_output *p, wrapper_type t = wrapper_type::standard);
 
  output_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator wl_output*() const;
 
  void release();
 
  static constexpr std::uint32_t release_since_version = 3;
 
  bool can_release() const;
 
  std::function<void(int32_t, int32_t, int32_t, int32_t, output_subpixel, std::string, std::string, output_transform)> &on_geometry();
 
  std::function<void(output_mode, int32_t, int32_t, int32_t)> &on_mode();
 
  std::function<void()> &on_done();
 
  std::function<void(int32_t)> &on_scale();
 
};
 
enum class output_subpixel : uint32_t
  {
  unknown = 0,
  none = 1,
  horizontal_rgb = 2,
  horizontal_bgr = 3,
  vertical_rgb = 4,
  vertical_bgr = 5
};
 
struct output_transform : public detail::bitfield<3, 20>
{
  output_transform(const detail::bitfield<3, 20> &b)
    : detail::bitfield<3, 20>(b) {}
  output_transform(const uint32_t value)
    : detail::bitfield<3, 20>(value) {}
  static const detail::bitfield<3, 20> normal;
  static const detail::bitfield<3, 20> _90;
  static const detail::bitfield<3, 20> _180;
  static const detail::bitfield<3, 20> _270;
  static const detail::bitfield<3, 20> flipped;
  static const detail::bitfield<3, 20> flipped_90;
  static const detail::bitfield<3, 20> flipped_180;
  static const detail::bitfield<3, 20> flipped_270;
};
 
struct output_mode : public detail::bitfield<2, 21>
{
  output_mode(const detail::bitfield<2, 21> &b)
    : detail::bitfield<2, 21>(b) {}
  output_mode(const uint32_t value)
    : detail::bitfield<2, 21>(value) {}
  static const detail::bitfield<2, 21> current;
  static const detail::bitfield<2, 21> preferred;
};
 
 
class region_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  region_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  region_t();
  explicit region_t(const proxy_t &proxy);
  region_t(wl_region *p, wrapper_type t = wrapper_type::standard);
 
  region_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator wl_region*() const;
 
  void add(int32_t x, int32_t y, int32_t width, int32_t height);
 
  static constexpr std::uint32_t add_since_version = 1;
 
  void subtract(int32_t x, int32_t y, int32_t width, int32_t height);
 
  static constexpr std::uint32_t subtract_since_version = 1;
 
};
 
 
class subcompositor_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  subcompositor_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  subcompositor_t();
  explicit subcompositor_t(const proxy_t &proxy);
  subcompositor_t(wl_subcompositor *p, wrapper_type t = wrapper_type::standard);
 
  subcompositor_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator wl_subcompositor*() const;
 
  subsurface_t get_subsurface(surface_t surface, surface_t parent);
 
  static constexpr std::uint32_t get_subsurface_since_version = 1;
 
};
 
enum class subcompositor_error : uint32_t
  {
  bad_surface = 0
};
 
 
class subsurface_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  subsurface_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  subsurface_t();
  explicit subsurface_t(const proxy_t &proxy);
  subsurface_t(wl_subsurface *p, wrapper_type t = wrapper_type::standard);
 
  subsurface_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator wl_subsurface*() const;
 
  void set_position(int32_t x, int32_t y);
 
  static constexpr std::uint32_t set_position_since_version = 1;
 
  void place_above(surface_t sibling);
 
  static constexpr std::uint32_t place_above_since_version = 1;
 
  void place_below(surface_t sibling);
 
  static constexpr std::uint32_t place_below_since_version = 1;
 
  void set_sync();
 
  static constexpr std::uint32_t set_sync_since_version = 1;
 
  void set_desync();
 
  static constexpr std::uint32_t set_desync_since_version = 1;
 
};
 
enum class subsurface_error : uint32_t
  {
  bad_surface = 0
};
 
 
 
}