wayland-client-protocol-extra.hpp

#pragma once
 
#include <array>
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
#include <wayland-client.hpp>
 
struct wp_presentation;
struct wp_presentation_feedback;
struct wp_viewporter;
struct wp_viewport;
struct xdg_wm_base;
struct xdg_positioner;
struct xdg_surface;
struct xdg_toplevel;
struct xdg_popup;
 
namespace wayland
{
class presentation_t;
enum class presentation_error : uint32_t;
class presentation_feedback_t;
struct presentation_feedback_kind;
class viewporter_t;
enum class viewporter_error : uint32_t;
class viewport_t;
enum class viewport_error : uint32_t;
class xdg_wm_base_t;
enum class xdg_wm_base_error : uint32_t;
class xdg_positioner_t;
enum class xdg_positioner_error : uint32_t;
enum class xdg_positioner_anchor : uint32_t;
enum class xdg_positioner_gravity : uint32_t;
struct xdg_positioner_constraint_adjustment;
class xdg_surface_t;
enum class xdg_surface_error : uint32_t;
class xdg_toplevel_t;
struct xdg_toplevel_resize_edge;
enum class xdg_toplevel_state : uint32_t;
class xdg_popup_t;
enum class xdg_popup_error : uint32_t;
 
namespace detail
{
  extern const wl_interface presentation_interface;
  extern const wl_interface presentation_feedback_interface;
  extern const wl_interface viewporter_interface;
  extern const wl_interface viewport_interface;
  extern const wl_interface xdg_wm_base_interface;
  extern const wl_interface xdg_positioner_interface;
  extern const wl_interface xdg_surface_interface;
  extern const wl_interface xdg_toplevel_interface;
  extern const wl_interface xdg_popup_interface;
}
 
class presentation_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(uint32_t)> clock_id;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  presentation_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  presentation_t();
  explicit presentation_t(const proxy_t &proxy);
  presentation_t(wp_presentation *p, wrapper_type t = wrapper_type::standard);
 
  presentation_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator wp_presentation*() const;
 
  presentation_feedback_t feedback(surface_t surface);
 
  static constexpr std::uint32_t feedback_since_version = 1;
 
  std::function<void(uint32_t)> &on_clock_id();
 
};
 
enum class presentation_error : uint32_t
  {
  invalid_timestamp = 0,
  invalid_flag = 1
};
 
 
class presentation_feedback_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(output_t)> sync_output;
    std::function<void(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, presentation_feedback_kind)> presented;
    std::function<void()> discarded;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  presentation_feedback_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  presentation_feedback_t();
  explicit presentation_feedback_t(const proxy_t &proxy);
  presentation_feedback_t(wp_presentation_feedback *p, wrapper_type t = wrapper_type::standard);
 
  presentation_feedback_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator wp_presentation_feedback*() const;
 
  std::function<void(output_t)> &on_sync_output();
 
  std::function<void(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, presentation_feedback_kind)> &on_presented();
 
  std::function<void()> &on_discarded();
 
};
 
struct presentation_feedback_kind : public detail::bitfield<4, 1>
{
  presentation_feedback_kind(const detail::bitfield<4, 1> &b)
    : detail::bitfield<4, 1>(b) {}
  presentation_feedback_kind(const uint32_t value)
    : detail::bitfield<4, 1>(value) {}
  static const detail::bitfield<4, 1> vsync;
  static const detail::bitfield<4, 1> hw_clock;
  static const detail::bitfield<4, 1> hw_completion;
  static const detail::bitfield<4, 1> zero_copy;
};
 
 
class viewporter_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);
 
  viewporter_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  viewporter_t();
  explicit viewporter_t(const proxy_t &proxy);
  viewporter_t(wp_viewporter *p, wrapper_type t = wrapper_type::standard);
 
  viewporter_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator wp_viewporter*() const;
 
  viewport_t get_viewport(surface_t surface);
 
  static constexpr std::uint32_t get_viewport_since_version = 1;
 
};
 
enum class viewporter_error : uint32_t
  {
  viewport_exists = 0
};
 
 
class viewport_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);
 
  viewport_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  viewport_t();
  explicit viewport_t(const proxy_t &proxy);
  viewport_t(wp_viewport *p, wrapper_type t = wrapper_type::standard);
 
  viewport_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator wp_viewport*() const;
 
  void set_source(double x, double y, double width, double height);
 
  static constexpr std::uint32_t set_source_since_version = 1;
 
  void set_destination(int32_t width, int32_t height);
 
  static constexpr std::uint32_t set_destination_since_version = 1;
 
};
 
enum class viewport_error : uint32_t
  {
  bad_value = 0,
  bad_size = 1,
  out_of_buffer = 2,
  no_surface = 3
};
 
 
class xdg_wm_base_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(uint32_t)> ping;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  xdg_wm_base_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  xdg_wm_base_t();
  explicit xdg_wm_base_t(const proxy_t &proxy);
  xdg_wm_base_t(xdg_wm_base *p, wrapper_type t = wrapper_type::standard);
 
  xdg_wm_base_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator xdg_wm_base*() const;
 
  xdg_positioner_t create_positioner();
 
  static constexpr std::uint32_t create_positioner_since_version = 1;
 
  xdg_surface_t get_xdg_surface(surface_t surface);
 
  static constexpr std::uint32_t get_xdg_surface_since_version = 1;
 
  void pong(uint32_t serial);
 
  static constexpr std::uint32_t pong_since_version = 1;
 
  std::function<void(uint32_t)> &on_ping();
 
};
 
enum class xdg_wm_base_error : uint32_t
  {
  role = 0,
  defunct_surfaces = 1,
  not_the_topmost_popup = 2,
  invalid_popup_parent = 3,
  invalid_surface_state = 4,
  invalid_positioner = 5
};
 
 
class xdg_positioner_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);
 
  xdg_positioner_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  xdg_positioner_t();
  explicit xdg_positioner_t(const proxy_t &proxy);
  xdg_positioner_t(xdg_positioner *p, wrapper_type t = wrapper_type::standard);
 
  xdg_positioner_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator xdg_positioner*() const;
 
  void set_size(int32_t width, int32_t height);
 
  static constexpr std::uint32_t set_size_since_version = 1;
 
  void set_anchor_rect(int32_t x, int32_t y, int32_t width, int32_t height);
 
  static constexpr std::uint32_t set_anchor_rect_since_version = 1;
 
  void set_anchor(xdg_positioner_anchor anchor);
 
  static constexpr std::uint32_t set_anchor_since_version = 1;
 
  void set_gravity(xdg_positioner_gravity gravity);
 
  static constexpr std::uint32_t set_gravity_since_version = 1;
 
  void set_constraint_adjustment(xdg_positioner_constraint_adjustment constraint_adjustment);
 
  static constexpr std::uint32_t set_constraint_adjustment_since_version = 1;
 
  void set_offset(int32_t x, int32_t y);
 
  static constexpr std::uint32_t set_offset_since_version = 1;
 
};
 
enum class xdg_positioner_error : uint32_t
  {
  invalid_input = 0
};
 
enum class xdg_positioner_anchor : uint32_t
  {
  none = 0,
  top = 1,
  bottom = 2,
  left = 3,
  right = 4,
  top_left = 5,
  bottom_left = 6,
  top_right = 7,
  bottom_right = 8
};
 
enum class xdg_positioner_gravity : uint32_t
  {
  none = 0,
  top = 1,
  bottom = 2,
  left = 3,
  right = 4,
  top_left = 5,
  bottom_left = 6,
  top_right = 7,
  bottom_right = 8
};
 
struct xdg_positioner_constraint_adjustment : public detail::bitfield<6, 8>
{
  xdg_positioner_constraint_adjustment(const detail::bitfield<6, 8> &b)
    : detail::bitfield<6, 8>(b) {}
  xdg_positioner_constraint_adjustment(const uint32_t value)
    : detail::bitfield<6, 8>(value) {}
  static const detail::bitfield<6, 8> none;
  static const detail::bitfield<6, 8> slide_x;
  static const detail::bitfield<6, 8> slide_y;
  static const detail::bitfield<6, 8> flip_x;
  static const detail::bitfield<6, 8> flip_y;
  static const detail::bitfield<6, 8> resize_x;
  static const detail::bitfield<6, 8> resize_y;
};
 
 
class xdg_surface_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(uint32_t)> configure;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  xdg_surface_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  xdg_surface_t();
  explicit xdg_surface_t(const proxy_t &proxy);
  xdg_surface_t(xdg_surface *p, wrapper_type t = wrapper_type::standard);
 
  xdg_surface_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator xdg_surface*() const;
 
  xdg_toplevel_t get_toplevel();
 
  static constexpr std::uint32_t get_toplevel_since_version = 1;
 
  xdg_popup_t get_popup(xdg_surface_t parent, xdg_positioner_t positioner);
 
  static constexpr std::uint32_t get_popup_since_version = 1;
 
  void set_window_geometry(int32_t x, int32_t y, int32_t width, int32_t height);
 
  static constexpr std::uint32_t set_window_geometry_since_version = 1;
 
  void ack_configure(uint32_t serial);
 
  static constexpr std::uint32_t ack_configure_since_version = 1;
 
  std::function<void(uint32_t)> &on_configure();
 
};
 
enum class xdg_surface_error : uint32_t
  {
  not_constructed = 1,
  already_constructed = 2,
  unconfigured_buffer = 3
};
 
 
class xdg_toplevel_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(int32_t, int32_t, array_t)> configure;
    std::function<void()> close;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  xdg_toplevel_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  xdg_toplevel_t();
  explicit xdg_toplevel_t(const proxy_t &proxy);
  xdg_toplevel_t(xdg_toplevel *p, wrapper_type t = wrapper_type::standard);
 
  xdg_toplevel_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator xdg_toplevel*() const;
 
  void set_parent(xdg_toplevel_t parent);
 
  static constexpr std::uint32_t set_parent_since_version = 1;
 
  void set_title(std::string title);
 
  static constexpr std::uint32_t set_title_since_version = 1;
 
  void set_app_id(std::string app_id);
 
  static constexpr std::uint32_t set_app_id_since_version = 1;
 
  void show_window_menu(seat_t seat, uint32_t serial, int32_t x, int32_t y);
 
  static constexpr std::uint32_t show_window_menu_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, xdg_toplevel_resize_edge edges);
 
  static constexpr std::uint32_t resize_since_version = 1;
 
  void set_max_size(int32_t width, int32_t height);
 
  static constexpr std::uint32_t set_max_size_since_version = 1;
 
  void set_min_size(int32_t width, int32_t height);
 
  static constexpr std::uint32_t set_min_size_since_version = 1;
 
  void set_maximized();
 
  static constexpr std::uint32_t set_maximized_since_version = 1;
 
  void unset_maximized();
 
  static constexpr std::uint32_t unset_maximized_since_version = 1;
 
  void set_fullscreen(output_t output);
 
  static constexpr std::uint32_t set_fullscreen_since_version = 1;
 
  void unset_fullscreen();
 
  static constexpr std::uint32_t unset_fullscreen_since_version = 1;
 
  void set_minimized();
 
  static constexpr std::uint32_t set_minimized_since_version = 1;
 
  std::function<void(int32_t, int32_t, array_t)> &on_configure();
 
  std::function<void()> &on_close();
 
};
 
struct xdg_toplevel_resize_edge : public detail::bitfield<4, 10>
{
  xdg_toplevel_resize_edge(const detail::bitfield<4, 10> &b)
    : detail::bitfield<4, 10>(b) {}
  xdg_toplevel_resize_edge(const uint32_t value)
    : detail::bitfield<4, 10>(value) {}
  static const detail::bitfield<4, 10> none;
  static const detail::bitfield<4, 10> top;
  static const detail::bitfield<4, 10> bottom;
  static const detail::bitfield<4, 10> left;
  static const detail::bitfield<4, 10> top_left;
  static const detail::bitfield<4, 10> bottom_left;
  static const detail::bitfield<4, 10> right;
  static const detail::bitfield<4, 10> top_right;
  static const detail::bitfield<4, 10> bottom_right;
};
 
enum class xdg_toplevel_state : uint32_t
  {
  maximized = 1,
  fullscreen = 2,
  resizing = 3,
  activated = 4,
  tiled_left = 5,
  tiled_right = 6,
  tiled_top = 7,
  tiled_bottom = 8
};
 
 
class xdg_popup_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(int32_t, int32_t, 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);
 
  xdg_popup_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  xdg_popup_t();
  explicit xdg_popup_t(const proxy_t &proxy);
  xdg_popup_t(xdg_popup *p, wrapper_type t = wrapper_type::standard);
 
  xdg_popup_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator xdg_popup*() const;
 
  void grab(seat_t seat, uint32_t serial);
 
  static constexpr std::uint32_t grab_since_version = 1;
 
  std::function<void(int32_t, int32_t, int32_t, int32_t)> &on_configure();
 
  std::function<void()> &on_popup_done();
 
};
 
enum class xdg_popup_error : uint32_t
  {
  invalid_grab = 0
};
 
 
 
}