/* Registry callbacks. */
static void registry_handle_global(void *data, struct wl_registry *reg,
uint32_t id, const char *interface, uint32_t version)
{
struct wl_output *output = NULL;
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)data;
(void)version;
if (string_is_equal_fast(interface, "wl_compositor", 13))
wl->compositor = (struct wl_compositor*)wl_registry_bind(reg,
id, &wl_compositor_interface, 3);
else if (string_is_equal_fast(interface, "wl_output", 9))
{
output = (struct wl_output*)wl_registry_bind(reg,
id, &wl_output_interface, 2);
wl_output_add_listener(output, &output_listener, wl);
wl_display_roundtrip(wl->input.dpy);
}
else if (string_is_equal_fast(interface, "wl_shell", 8))
wl->shell = (struct wl_shell*)
wl_registry_bind(reg, id, &wl_shell_interface, 1);
else if (string_is_equal_fast(interface, "wl_shm", 6))
wl->shm = (struct wl_shm*)wl_registry_bind(reg, id, &wl_shm_interface, 1);
else if (string_is_equal_fast(interface, "wl_seat", 7))
{
wl->seat = (struct wl_seat*)wl_registry_bind(reg, id, &wl_seat_interface, 4);
wl_seat_add_listener(wl->seat, &seat_listener, wl);
}
}
static void registryHandleGlobal(void* data,
struct wl_registry* registry,
uint32_t name,
const char* interface,
uint32_t version)
{
if (strcmp(interface, "wl_compositor") == 0)
{
_glfw.wl.compositor =
wl_registry_bind(registry, name, &wl_compositor_interface, 1);
}
else if (strcmp(interface, "wl_shm") == 0)
{
_glfw.wl.shm =
wl_registry_bind(registry, name, &wl_shm_interface, 1);
}
else if (strcmp(interface, "wl_shell") == 0)
{
_glfw.wl.shell =
wl_registry_bind(registry, name, &wl_shell_interface, 1);
}
else if (strcmp(interface, "wl_output") == 0)
{
_glfwAddOutput(name, version);
}
else if (strcmp(interface, "wl_seat") == 0)
{
if (!_glfw.wl.seat)
{
_glfw.wl.seat =
wl_registry_bind(registry, name, &wl_seat_interface, 1);
wl_seat_add_listener(_glfw.wl.seat, &seatListener, NULL);
}
}
}
static void
registry_handle_global(void *data, struct wl_registry *registry,
uint32_t name, const char *interface, uint32_t version)
{
struct display *d = data;
if (strcmp(interface, "wl_compositor") == 0) {
d->compositor =
wl_registry_bind(registry, name,
&wl_compositor_interface, 1);
} else if (strcmp(interface, "xdg_shell") == 0) {
d->shell = wl_registry_bind(registry, name,
&xdg_shell_interface, 1);
xdg_shell_add_listener(d->shell, &xdg_shell_listener, d);
xdg_shell_use_unstable_version(d->shell, XDG_VERSION);
} else if (strcmp(interface, "wl_seat") == 0) {
d->seat = wl_registry_bind(registry, name,
&wl_seat_interface, 1);
wl_seat_add_listener(d->seat, &seat_listener, d);
} else if (strcmp(interface, "wl_shm") == 0) {
d->shm = wl_registry_bind(registry, name,
&wl_shm_interface, 1);
d->cursor_theme = wl_cursor_theme_load(NULL, 32, d->shm);
d->default_cursor =
wl_cursor_theme_get_cursor(d->cursor_theme, "left_ptr");
}
}
void Seat::Private::setup(wl_seat *s)
{
Q_ASSERT(s);
Q_ASSERT(!seat);
seat.setup(s);
wl_seat_add_listener(seat, &s_listener, this);
}
WaylandDisplay::WaylandDisplay()
{
m_display = wl_display_connect(nullptr);
m_registry = wl_display_get_registry(m_display);
wl_registry_add_listener(m_registry, &g_registryListener, &m_interfaces);
wl_display_roundtrip(m_display);
m_eventSource = g_source_new(&EventSource::sourceFuncs, sizeof(EventSource));
auto* source = reinterpret_cast<EventSource*>(m_eventSource);
source->display = m_display;
source->pfd.fd = wl_display_get_fd(m_display);
source->pfd.events = G_IO_IN | G_IO_ERR | G_IO_HUP;
source->pfd.revents = 0;
g_source_add_poll(m_eventSource, &source->pfd);
g_source_set_name(m_eventSource, "[WPE] WaylandDisplay");
g_source_set_priority(m_eventSource, G_PRIORITY_HIGH + 30);
g_source_set_can_recurse(m_eventSource, TRUE);
g_source_attach(m_eventSource, g_main_context_get_thread_default());
if (m_interfaces.xdg) {
xdg_shell_add_listener(m_interfaces.xdg, &g_xdgShellListener, nullptr);
xdg_shell_use_unstable_version(m_interfaces.xdg, 5);
}
wl_seat_add_listener(m_interfaces.seat, &g_seatListener, &m_seatData);
m_seatData.xkb.context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
m_seatData.xkb.composeTable = xkb_compose_table_new_from_locale(m_seatData.xkb.context, setlocale(LC_CTYPE, nullptr), XKB_COMPOSE_COMPILE_NO_FLAGS);
if (m_seatData.xkb.composeTable)
m_seatData.xkb.composeState = xkb_compose_state_new(m_seatData.xkb.composeTable, XKB_COMPOSE_STATE_NO_FLAGS);
}
static void
registry_handle_global (void *data, struct wl_registry *registry,
uint32_t name, const char *interface, uint32_t version)
{
GstGLWindowWaylandEGL *window_egl = data;
struct display *d = &window_egl->display;
GST_TRACE_OBJECT (window_egl, "registry_handle_global with registry %p, "
"interface %s, version %u", registry, interface, version);
if (g_strcmp0 (interface, "wl_compositor") == 0) {
d->compositor =
wl_registry_bind (registry, name, &wl_compositor_interface, 1);
} else if (g_strcmp0 (interface, "wl_shell") == 0) {
d->shell = wl_registry_bind (registry, name, &wl_shell_interface, 1);
} else if (g_strcmp0 (interface, "wl_seat") == 0) {
d->seat = wl_registry_bind (registry, name, &wl_seat_interface, 1);
wl_seat_add_listener (d->seat, &seat_listener, window_egl);
} else if (g_strcmp0 (interface, "wl_shm") == 0) {
d->shm = wl_registry_bind (registry, name, &wl_shm_interface, 1);
d->cursor_theme = wl_cursor_theme_load (NULL, 32, d->shm);
d->default_cursor =
wl_cursor_theme_get_cursor (d->cursor_theme, "left_ptr");
}
}
void nsRetrievalContextWayland::InitSeat(wl_registry *registry,
uint32_t id, uint32_t version,
void *data)
{
mSeat = (wl_seat*)wl_registry_bind(registry, id, &wl_seat_interface, 1);
wl_seat_add_listener(mSeat, &seat_listener, data);
}
static void
registry_handle_global(void *data, struct wl_registry *registry,
uint32_t name, const char *interface, uint32_t version)
{
if (strcmp(interface, "wl_compositor") == 0) {
GLWin.wl_compositor = (wl_compositor *)
wl_registry_bind(registry, name,
&wl_compositor_interface, 1);
}
else if (strcmp(interface, "wl_shell") == 0) {
GLWin.wl_shell = (wl_shell *)wl_registry_bind(registry, name,
&wl_shell_interface, 1);
}
else if (strcmp(interface, "wl_seat") == 0) {
GLWin.wl_seat = (wl_seat *)wl_registry_bind(registry, name,
&wl_seat_interface, 1);
wl_seat_add_listener(GLWin.wl_seat, &seat_listener, 0);
}
else if (strcmp(interface, "wl_shm") == 0) {
GLWin.wl_shm = (wl_shm *)wl_registry_bind(registry, name,
&wl_shm_interface, 1);
GLWin.wl_cursor_theme = (wl_cursor_theme *)wl_cursor_theme_load(nullptr, 32, GLWin.wl_shm);
GLWin.wl_cursor = (wl_cursor *)
wl_cursor_theme_get_cursor(GLWin.wl_cursor_theme, "left_ptr");
}
}
static void
handle_global(void *data, struct wl_registry *registry, uint32_t id,
const char *interface, uint32_t version)
{
struct display *display = data;
struct input *input;
struct output *output;
if (strcmp(interface, "wl_compositor") == 0) {
display->compositor =
wl_registry_bind(display->registry,
id, &wl_compositor_interface, 1);
} else if (strcmp(interface, "wl_seat") == 0) {
input = calloc(1, sizeof *input);
input->seat = wl_registry_bind(display->registry, id,
&wl_seat_interface, 1);
input->pointer_focus = NULL;
input->keyboard_focus = NULL;
wl_seat_add_listener(input->seat, &seat_listener, input);
display->input = input;
} else if (strcmp(interface, "wl_output") == 0) {
output = malloc(sizeof *output);
output->output = wl_registry_bind(display->registry,
id, &wl_output_interface, 1);
wl_output_add_listener(output->output,
&output_listener, output);
display->output = output;
fprintf(stderr, "test-client: created output global %p\n",
display->output);
}
}
void
_platform_display_inputmanager(struct pilot_display *display, struct wl_registry *registry, uint32_t id)
{
struct platform_display *platform = display->platform;
platform->seat = wl_registry_bind(registry,
id, &wl_seat_interface, 1);
wl_seat_add_listener(platform->seat, &_st_seat_listener, display);
}
/*
* Try initializing the input device(s)
*/
void fgPlatformInitialiseInputDevices( void )
{
wl_seat_add_listener( fgDisplay.pDisplay.seat,
&fghSeatListener,
&fgDisplay.pDisplay );
wl_display_roundtrip( fgDisplay.pDisplay.display );
}
static void
_eventd_nd_wl_registry_handle_global(void *data, struct wl_registry *registry, uint32_t name, const char *interface, uint32_t version)
{
EventdNdBackendContext *self = data;
if ( g_strcmp0(interface, "wl_compositor") == 0 )
{
self->global_names[EVENTD_ND_WL_GLOBAL_COMPOSITOR] = name;
self->compositor = wl_registry_bind(registry, name, &wl_compositor_interface, MIN(version, WL_COMPOSITOR_INTERFACE_VERSION));
}
else if ( g_strcmp0(interface, "zww_notification_area_v1") == 0 )
{
self->global_names[EVENTD_ND_WL_GLOBAL_NOTIFICATION_DAEMON] = name;
self->notification_area = wl_registry_bind(registry, name, &zww_notification_area_v1_interface, WW_NOTIFICATION_AREA_INTERFACE_VERSION);
zww_notification_area_v1_add_listener(self->notification_area, &_eventd_nd_wl_notification_area_listener, self);
}
else if ( g_strcmp0(interface, "wl_shm") == 0 )
{
self->global_names[EVENTD_ND_WL_GLOBAL_SHM] = name;
self->shm = wl_registry_bind(registry, name, &wl_shm_interface, MIN(version, WL_SHM_INTERFACE_VERSION));
wl_shm_add_listener(self->shm, &_eventd_nd_wl_shm_listener, self);
}
else if ( g_strcmp0(interface, "wl_seat") == 0 )
{
EventdNdWlSeat *seat = g_slice_new0(EventdNdWlSeat);
seat->context = self;
seat->global_name = name;
seat->seat = wl_registry_bind(registry, name, &wl_seat_interface, MIN(version, WL_SEAT_INTERFACE_VERSION));
seat->link = self->seats = g_slist_prepend(self->seats, seat);
wl_seat_add_listener(seat->seat, &_eventd_nd_wl_seat_listener, seat);
}
if ( ( self->cursor.theme == NULL ) && ( self->compositor != NULL ) && ( self->shm != NULL ) )
{
self->cursor.theme = wl_cursor_theme_load(self->cursor.theme_name, 32, self->shm);
if ( self->cursor.theme != NULL )
{
const gchar * const *cname = (const gchar * const *) self->cursor.name;
for ( cname = ( cname != NULL ) ? cname : _eventd_nd_cursor_names ; ( self->cursor.cursor == NULL ) && ( *cname != NULL ) ; ++cname )
self->cursor.cursor = wl_cursor_theme_get_cursor(self->cursor.theme, *cname);
if ( self->cursor.cursor == NULL )
{
wl_cursor_theme_destroy(self->cursor.theme);
self->cursor.theme = NULL;
}
else
self->cursor.surface = wl_compositor_create_surface(self->compositor);
}
}
}
static void registryHandleGlobal(void* data,
struct wl_registry* registry,
uint32_t name,
const char* interface,
uint32_t version)
{
if (strcmp(interface, "wl_compositor") == 0)
{
_glfw.wl.compositorVersion = min(3, version);
_glfw.wl.compositor =
wl_registry_bind(registry, name, &wl_compositor_interface,
_glfw.wl.compositorVersion);
}
else if (strcmp(interface, "wl_shm") == 0)
{
_glfw.wl.shm =
wl_registry_bind(registry, name, &wl_shm_interface, 1);
}
else if (strcmp(interface, "wl_shell") == 0)
{
_glfw.wl.shell =
wl_registry_bind(registry, name, &wl_shell_interface, 1);
}
else if (strcmp(interface, "wl_output") == 0)
{
_glfwAddOutputWayland(name, version);
}
else if (strcmp(interface, "wl_seat") == 0)
{
if (!_glfw.wl.seat)
{
_glfw.wl.seat =
wl_registry_bind(registry, name, &wl_seat_interface, 1);
wl_seat_add_listener(_glfw.wl.seat, &seatListener, NULL);
}
}
else if (strcmp(interface, "zwp_relative_pointer_manager_v1") == 0)
{
_glfw.wl.relativePointerManager =
wl_registry_bind(registry, name,
&zwp_relative_pointer_manager_v1_interface,
1);
}
else if (strcmp(interface, "zwp_pointer_constraints_v1") == 0)
{
_glfw.wl.pointerConstraints =
wl_registry_bind(registry, name,
&zwp_pointer_constraints_v1_interface,
1);
}
}
static void
add_seat(struct touch *touch, uint32_t name, uint32_t version)
{
struct seat *seat;
seat = malloc(sizeof *seat);
assert(seat);
seat->touch = touch;
seat->wl_touch = NULL;
seat->seat = wl_registry_bind(touch->registry, name,
&wl_seat_interface, 1);
wl_seat_add_listener(seat->seat, &seat_listener, seat);
}
Seat::Seat(const Display& display)
: display_(display)
, wl_seat_(display.bind<wl_seat>("wl_seat", &wl_seat_interface, 1))
, capabilities_(0)
{
ASSERT(wl_seat_ != NULL);
wl_seat_set_user_data(*this, this);
static const wl_seat_listener listener = {capabilities};
wl_seat_add_listener(*this, &listener, this);
display.roundtrip();
}
static void
handle_global(void *data, struct wl_registry *registry,
uint32_t id, const char *interface, uint32_t version)
{
struct client *client = data;
struct input *input;
struct output *output;
struct test *test;
struct global *global;
global = xzalloc(sizeof *global);
global->name = id;
global->interface = strdup(interface);
assert(interface);
global->version = version;
wl_list_insert(client->global_list.prev, &global->link);
if (strcmp(interface, "wl_compositor") == 0) {
client->wl_compositor =
wl_registry_bind(registry, id,
&wl_compositor_interface, 1);
} else if (strcmp(interface, "wl_seat") == 0) {
input = xzalloc(sizeof *input);
input->wl_seat =
wl_registry_bind(registry, id,
&wl_seat_interface, 1);
wl_seat_add_listener(input->wl_seat, &seat_listener, input);
client->input = input;
} else if (strcmp(interface, "wl_shm") == 0) {
client->wl_shm =
wl_registry_bind(registry, id,
&wl_shm_interface, 1);
wl_shm_add_listener(client->wl_shm, &shm_listener, client);
} else if (strcmp(interface, "wl_output") == 0) {
output = xzalloc(sizeof *output);
output->wl_output =
wl_registry_bind(registry, id,
&wl_output_interface, 1);
wl_output_add_listener(output->wl_output,
&output_listener, output);
client->output = output;
} else if (strcmp(interface, "wl_test") == 0) {
test = xzalloc(sizeof *test);
test->wl_test =
wl_registry_bind(registry, id,
&wl_test_interface, 1);
wl_test_add_listener(test->wl_test, &test_listener, test);
client->test = test;
}
}
inline void
WaylandEventQueue::RegistryHandler(struct wl_registry *registry, uint32_t id,
const char *interface)
{
if (StringIsEqual(interface, "wl_compositor"))
compositor = (wl_compositor *)
wl_registry_bind(registry, id, &wl_compositor_interface, 1);
else if (StringIsEqual(interface, "wl_seat")) {
seat = (wl_seat *)wl_registry_bind(registry, id,
&wl_seat_interface, 1);
wl_seat_add_listener(seat, &seat_listener, this);
} else if (StringIsEqual(interface, "wl_shell"))
shell = (wl_shell *)wl_registry_bind(registry, id,
&wl_shell_interface, 1);
}
static void displayHandleGlobal(void *_data, struct wl_registry *_registry,
uint32_t _id, const char *_interface, uint32_t _version) {
struct ContextData *d = (struct ContextData*) _data;
if (strcmp(_interface, "wl_compositor") == 0) {
d->compositor = (struct wl_compositor *) wl_registry_bind(_registry, _id, &wl_compositor_interface, 1);
} else if (strcmp(_interface, "wl_shell") == 0) {
d->shell = (struct wl_shell *) wl_registry_bind(_registry, _id, &wl_shell_interface, 1);
} else if (strcmp(_interface, "wl_shell_surface") == 0) {
d->shell_surface = (struct wl_shell_surface *) wl_registry_bind(_registry, _id, &wl_shell_surface_interface, 1);
wl_shell_surface_add_listener(d->shell_surface, &shellSurfaceListener, d);
} else if (strcmp(_interface, "wl_seat") == 0) {
d->seat = (struct wl_seat *) wl_registry_bind(_registry, _id, &wl_seat_interface, 1);
wl_seat_add_listener(d->seat, &seatListener, d);
}
}
static void
display_add_seat(struct wayland_compositor *c, uint32_t id)
{
struct wayland_input *input;
input = zalloc(sizeof *input);
if (input == NULL)
return;
weston_seat_init(&input->base, &c->base, "default");
input->compositor = c;
input->seat = wl_registry_bind(c->parent.registry, id,
&wl_seat_interface, 1);
wl_list_insert(c->input_list.prev, &input->link);
wl_seat_add_listener(input->seat, &seat_listener, input);
wl_seat_set_user_data(input->seat, input);
}
void
Wayland_display_add_input(SDL_VideoData *d, uint32_t id)
{
struct SDL_WaylandInput *input;
SDL_WaylandDataDevice *data_device = NULL;
input = SDL_calloc(1, sizeof *input);
if (input == NULL)
return;
input->display = d;
input->seat = wl_registry_bind(d->registry, id, &wl_seat_interface, 1);
input->sx_w = wl_fixed_from_int(0);
input->sy_w = wl_fixed_from_int(0);
d->input = input;
if (d->data_device_manager != NULL) {
data_device = SDL_calloc(1, sizeof *data_device);
if (data_device == NULL) {
return;
}
data_device->data_device = wl_data_device_manager_get_data_device(
d->data_device_manager, input->seat
);
data_device->video_data = d;
if (data_device->data_device == NULL) {
SDL_free(data_device);
} else {
wl_data_device_set_user_data(data_device->data_device, data_device);
wl_data_device_add_listener(data_device->data_device,
&data_device_listener, data_device);
input->data_device = data_device;
}
}
wl_seat_add_listener(input->seat, &seat_listener, input);
wl_seat_set_user_data(input->seat, input);
WAYLAND_wl_display_flush(d->display);
}
void
Wayland_display_add_input(SDL_VideoData *d, uint32_t id)
{
struct SDL_WaylandInput *input;
input = SDL_calloc(1, sizeof *input);
if (input == NULL)
return;
input->display = d;
input->seat = wl_registry_bind(d->registry, id, &wl_seat_interface, 1);
input->sx_w = wl_fixed_from_int(0);
input->sy_w = wl_fixed_from_int(0);
d->input = input;
wl_seat_add_listener(input->seat, &seat_listener, input);
wl_seat_set_user_data(input->seat, input);
WAYLAND_wl_display_flush(d->display);
}
static struct ss_seat *
ss_seat_create(struct shared_output *so, uint32_t id)
{
struct ss_seat *seat;
seat = zalloc(sizeof *seat);
if (seat == NULL)
return NULL;
weston_seat_init(&seat->base, so->output->compositor, "default");
seat->output = so;
seat->parent.seat = wl_registry_bind(so->parent.registry, id,
&wl_seat_interface, 1);
wl_list_insert(so->seat_list.prev, &seat->link);
wl_seat_add_listener(seat->parent.seat, &ss_seat_listener, seat);
wl_seat_set_user_data(seat->parent.seat, seat);
return seat;
}
static void registryHandleGlobal(void *data, struct wl_registry *registry,
uint32_t name, const char *interface, uint32_t version)
{
WaylandModule *wayland = reinterpret_cast<WaylandModule*>(data);
new QTreeWidgetItem(wayland->interfacesItem(), QStringList() << QString::fromUtf8(interface) << QString::number(version));
if (strcmp(interface, "wl_output") == 0) {
QTreeWidgetItem *outputItems = new QTreeWidgetItem(wayland->root(), QStringList() << i18n("Outputs"));
wl_output *output = reinterpret_cast<wl_output *>(wl_registry_bind(registry, name, &wl_output_interface, 1));
wl_output_add_listener(output, &s_outputListener, outputItems);
wayland->flush();
}
if (strcmp(interface, "wl_seat") == 0) {
QTreeWidgetItem *seatItem = new QTreeWidgetItem(wayland->root(), QStringList() << i18n("Seat"));
wl_seat *seat = reinterpret_cast<wl_seat*>(wl_registry_bind(registry, name, &wl_seat_interface, 1));
wl_seat_add_listener(seat, &s_seatListener, seatItem);
wayland->flush();
}
}
void
WLContext::RegistryHandleGlobal(void* data,
struct wl_registry* registry,
uint32_t name,
const char* interface,
uint32_t version)
{
WL_UNUSED(version);
WLContext* surface = static_cast<WLContext*>(data);
assert(surface);
do {
if (!strcmp(interface, "wl_compositor")){
surface->SetWLCompositor(
(wl_compositor*)wl_registry_bind(registry,
name,
&wl_compositor_interface,
1));
break;
}
if (!strcmp(interface, "serverinfo")){
struct serverinfo* wlServerInfo = (struct serverinfo*)wl_registry_bind(
registry, name, &serverinfo_interface, 1);
serverinfo_add_listener(wlServerInfo, &serverInfoListenerList, data);
serverinfo_get_connection_id(wlServerInfo);
surface->SetWLServerInfo(wlServerInfo);
break;
}
if (!strcmp(interface, "wl_seat")){
struct WLContext::seat_data *seat_data = (struct WLContext::seat_data *)calloc(1, sizeof *seat_data);
seat_data->ctx = surface;
seat_data->wlSeat = (wl_seat*)wl_registry_bind(
registry, name, &wl_seat_interface, 1);
wl_seat_add_listener(seat_data->wlSeat, &seatListener,
(void *)seat_data);
}
} while (0);
}
/* local functions */
void
_ecore_wl_input_add(Ecore_Wl_Display *ewd, unsigned int id)
{
Ecore_Wl_Input *input;
LOGFN(__FILE__, __LINE__, __FUNCTION__);
if (!(input = malloc(sizeof(Ecore_Wl_Input)))) return;
memset(input, 0, sizeof(Ecore_Wl_Input));
input->display = ewd;
input->pointer_focus = NULL;
input->keyboard_focus = NULL;
input->touch_focus = NULL;
input->seat =
wl_registry_bind(ewd->wl.registry, id, &wl_seat_interface, 1);
ewd->inputs = eina_inlist_append(ewd->inputs, EINA_INLIST_GET(input));
wl_seat_add_listener(input->seat,
&_ecore_wl_seat_listener, input);
wl_seat_set_user_data(input->seat, input);
wl_array_init(&input->data_types);
if (ewd->wl.data_device_manager)
{
input->data_device =
wl_data_device_manager_get_data_device(ewd->wl.data_device_manager,
input->seat);
wl_data_device_add_listener(input->data_device,
&_ecore_wl_data_listener, input);
}
ewd->input = input;
}
wlfInput* wlf_CreateInput(wlfContext* wlfc)
{
wlfInput* input;
struct wl_seat* seat;
if (!wlfc->display)
return NULL;
if (!wlfc->display->seat)
return NULL;
seat = wlfc->display->seat;
input = (wlfInput*) calloc(1, sizeof(wlfInput));
if (input)
{
input->input = wlfc->context.input;
input->last_x = 0;
input->last_y = 0;
wl_seat_add_listener(seat, &wl_seat_listener, input);
}
return input;
}
static void
handle_global(void *data, struct wl_registry *registry,
uint32_t name, const char *interface, uint32_t version)
{
struct touch *touch = data;
if (strcmp(interface, "wl_compositor") == 0) {
touch->compositor =
wl_registry_bind(registry, name,
&wl_compositor_interface, 1);
} else if (strcmp(interface, "wl_shell") == 0) {
touch->shell =
wl_registry_bind(registry, name,
&wl_shell_interface, 1);
} else if (strcmp(interface, "wl_shm") == 0) {
touch->shm = wl_registry_bind(registry, name,
&wl_shm_interface, 1);
wl_shm_add_listener(touch->shm, &shm_listenter, touch);
} else if (strcmp(interface, "wl_seat") == 0) {
touch->seat = wl_registry_bind(registry, name,
&wl_seat_interface, 1);
wl_seat_add_listener(touch->seat, &seat_listener, touch);
}
}
static void registryHandleGlobal(void* data,
struct wl_registry* registry,
uint32_t name,
const char* interface,
uint32_t version)
{
if (strcmp(interface, "wl_compositor") == 0)
{
_glfw.wl.compositorVersion = min(3, version);
_glfw.wl.compositor =
wl_registry_bind(registry, name, &wl_compositor_interface,
_glfw.wl.compositorVersion);
}
else if (strcmp(interface, "wl_subcompositor") == 0)
{
_glfw.wl.subcompositor =
wl_registry_bind(registry, name, &wl_subcompositor_interface, 1);
}
else if (strcmp(interface, "wl_shm") == 0)
{
_glfw.wl.shm =
wl_registry_bind(registry, name, &wl_shm_interface, 1);
}
else if (strcmp(interface, "wl_shell") == 0)
{
_glfw.wl.shell =
wl_registry_bind(registry, name, &wl_shell_interface, 1);
}
else if (strcmp(interface, "wl_output") == 0)
{
_glfwAddOutputWayland(name, version);
}
else if (strcmp(interface, "wl_seat") == 0)
{
if (!_glfw.wl.seat)
{
_glfw.wl.seatVersion = min(4, version);
_glfw.wl.seat =
wl_registry_bind(registry, name, &wl_seat_interface,
_glfw.wl.seatVersion);
wl_seat_add_listener(_glfw.wl.seat, &seatListener, NULL);
}
}
else if (strcmp(interface, "wl_data_device_manager") == 0)
{
if (!_glfw.wl.dataDeviceManager)
{
_glfw.wl.dataDeviceManager =
wl_registry_bind(registry, name,
&wl_data_device_manager_interface, 1);
}
}
else if (strcmp(interface, "xdg_wm_base") == 0)
{
_glfw.wl.wmBase =
wl_registry_bind(registry, name, &xdg_wm_base_interface, 1);
xdg_wm_base_add_listener(_glfw.wl.wmBase, &wmBaseListener, NULL);
}
else if (strcmp(interface, "zxdg_decoration_manager_v1") == 0)
{
_glfw.wl.decorationManager =
wl_registry_bind(registry, name,
&zxdg_decoration_manager_v1_interface,
1);
}
else if (strcmp(interface, "wp_viewporter") == 0)
{
_glfw.wl.viewporter =
wl_registry_bind(registry, name, &wp_viewporter_interface, 1);
}
else if (strcmp(interface, "zwp_relative_pointer_manager_v1") == 0)
{
_glfw.wl.relativePointerManager =
wl_registry_bind(registry, name,
&zwp_relative_pointer_manager_v1_interface,
1);
}
else if (strcmp(interface, "zwp_pointer_constraints_v1") == 0)
{
_glfw.wl.pointerConstraints =
wl_registry_bind(registry, name,
&zwp_pointer_constraints_v1_interface,
1);
}
else if (strcmp(interface, "zwp_idle_inhibit_manager_v1") == 0)
{
_glfw.wl.idleInhibitManager =
wl_registry_bind(registry, name,
&zwp_idle_inhibit_manager_v1_interface,
1);
}
}
void XdevLWindowEventServerWayland::setSeat() {
wl_seat_add_listener(m_seat, &seatListener, windowEventServer);
wl_seat_set_user_data(m_seat, windowEventServer);
}
/*
* Allow comfortably add listener into client structure
* XXX Do it somehow else.. or let user manually add listeners
*/
void
wit_client_add_listener(struct wit_client *cl, const char *interface,
const void *listener)
{
assertf(cl);
assert(interface);
ifdbg(listener == NULL, "Adding NULL listener (%s)\n", interface);
if (strcmp(interface, "wl_pointer") == 0) {
ifdbg(cl->pointer.listener, "Rewriting pointer listener (%p)\n",
cl->pointer.listener);
cl->pointer.listener = listener;
if (cl->pointer.proxy)
wl_pointer_add_listener(
(struct wl_pointer *) cl->pointer.proxy,
(struct wl_pointer_listener *) cl->pointer.listener,
cl);
else
dbg("Not adding listener."
"Pointer proxy hasn't been created yet.\n");
} else if (strcmp(interface, "wl_keyboard") == 0) {
ifdbg(cl->keyboard.listener, "Rewriting keyboard listener (%p)\n",
cl->keyboard.listener);
cl->keyboard.listener = listener;
if (cl->keyboard.proxy)
wl_keyboard_add_listener(
(struct wl_keyboard *) cl->keyboard.proxy,
(struct wl_keyboard_listener *) cl->keyboard.listener,
cl);
else
dbg("Not adding listener."
"Keyboard proxy hasn't been created yet.\n");
} else if (strcmp(interface, "wl_touch") == 0) {
ifdbg(cl->touch.listener, "Rewriting touch listener (%p)\n",
cl->touch.listener);
cl->touch.listener = listener;
if (cl->touch.proxy)
wl_touch_add_listener(
(struct wl_touch *) cl->touch.proxy,
(struct wl_touch_listener *) cl->touch.listener,
cl);
else
dbg("Not adding listener."
"Touch proxy hasn't been created yet.\n");
} else if (strcmp(interface, "wl_seat") == 0) {
ifdbg(cl->seat.listener, "Rewriting seat listener (%p)\n",
cl->seat.listener);
cl->seat.listener = listener;
if (cl->seat.proxy)
wl_seat_add_listener(
(struct wl_seat *) cl->seat.proxy,
(struct wl_seat_listener *) cl->seat.listener,
cl);
else
dbg("Not adding listener."
"seat proxy hasn't been created yet.\n");
} else if (strcmp(interface, "wl_shm") == 0) {
ifdbg(cl->shm.listener, "Rewriting shm listener (%p)\n",
cl->shm.listener);
cl->shm.listener = listener;
if (cl->shm.proxy)
wl_shm_add_listener(
(struct wl_shm *) cl->shm.proxy,
(struct wl_shm_listener *) cl->shm.listener,
cl);
else
dbg("Not adding listener."
"shm proxy hasn't been created yet.\n");
} else if (strcmp(interface, "wl_registry") == 0) {
ifdbg(cl->registry.listener, "Rewriting registry listener (%p)\n",
cl->registry.listener);
cl->registry.listener = listener;
if (cl->registry.proxy)
wl_registry_add_listener(
(struct wl_registry *) cl->registry.proxy,
(struct wl_registry_listener *) cl->registry.listener,
cl);
else
dbg("Not adding listener."
"registry proxy hasn't been created yet.\n");
} else {
assertf(0, "Unknown type of interface");
}
}
