/** Background thread for Wayland shell events handling */
static void *Thread(void *data)
{
vout_window_t *wnd = data;
struct wl_display *display = wnd->display.wl;
struct pollfd ufd[1];
int canc = vlc_savecancel();
vlc_cleanup_push(cleanup_wl_display_read, display);
ufd[0].fd = wl_display_get_fd(display);
ufd[0].events = POLLIN;
for (;;)
{
while (wl_display_prepare_read(display) != 0)
wl_display_dispatch_pending(display);
wl_display_flush(display);
vlc_restorecancel(canc);
while (poll(ufd, 1, -1) < 0);
canc = vlc_savecancel();
wl_display_read_events(display);
wl_display_dispatch_pending(display);
}
vlc_assert_unreachable();
vlc_cleanup_pop();
//vlc_restorecancel(canc);
//return NULL;
}
static void egl_create_window(struct vo_wayland_state *wl)
{
wl->egl_context.egl_window = wl_egl_window_create(wl->window.video_surface,
wl->window.width,
wl->window.height);
wl->egl_context.egl_surface = eglCreateWindowSurface(wl->egl_context.egl.dpy,
wl->egl_context.egl.conf,
wl->egl_context.egl_window,
NULL);
eglMakeCurrent(wl->egl_context.egl.dpy,
wl->egl_context.egl_surface,
wl->egl_context.egl_surface,
wl->egl_context.egl.ctx);
wl_display_dispatch_pending(wl->display.display);
/**
* <http://lists.freedesktop.org/archives/wayland-devel/2013-November/012019.html>
*
* The main change is that if the swap interval is 0 then Mesa won't install a
* frame callback so that eglSwapBuffers can be executed as often as necessary.
* Instead it will do a sync request after the swap buffers. It will block for
* sync complete event in get_back_bo instead of the frame callback. The
* compositor is likely to send a release event while processing the new buffer
* attach and this makes sure we will receive that before deciding whether to
* allocate a new buffer.
*/
eglSwapInterval(wl->egl_context.egl.dpy, 0);
}
void flush_wayland_fd(void *data)
{
struct pollfd fd = {0};
input_ctx_wayland_data_t *wl = (input_ctx_wayland_data_t*)data;
wl_display_dispatch_pending(wl->dpy);
wl_display_flush(wl->dpy);
fd.fd = wl->fd;
fd.events = POLLIN | POLLOUT | POLLERR | POLLHUP;
if (poll(&fd, 1, 0) > 0)
{
if (fd.revents & (POLLERR | POLLHUP))
{
close(wl->fd);
frontend_driver_set_signal_handler_state(1);
}
if (fd.revents & POLLIN)
wl_display_dispatch(wl->dpy);
if (fd.revents & POLLOUT)
wl_display_flush(wl->dpy);
}
}
static gboolean
gdk_event_source_prepare(GSource *base, gint *timeout)
{
GdkWaylandEventSource *source = (GdkWaylandEventSource *) base;
GdkWaylandDisplay *display = (GdkWaylandDisplay *) source->display;
*timeout = -1;
if (source->display->event_pause_count > 0)
return _gdk_event_queue_find_first (source->display) != NULL;
/* We have to add/remove the GPollFD if we want to update our
* poll event mask dynamically. Instead, let's just flush all
* write on idle instead, which is what this amounts to. */
if (_gdk_event_queue_find_first (source->display) != NULL)
return TRUE;
if (wl_display_flush (display->wl_display) < 0)
g_error ("Error flushing display: %s", g_strerror (errno));
if (wl_display_dispatch_pending (display->wl_display) < 0)
g_error ("Error dispatching display: %s", g_strerror (errno));
return FALSE;
}
void fgPlatformProcessSingleEvent( void )
{
SFG_Window *win = fgStructure.CurrentWindow;
wl_display_dispatch_pending( fgDisplay.pDisplay.display );
INVOKE_WCB( *win, Display, ( ) );
}
xdl_int XdevLWindowEventServerWayland::update() {
while(wl_display_prepare_read(display) < 0) {
wl_display_dispatch_pending(display);
}
wl_display_flush(display);
wl_display_read_events(display);
return ERR_OK;
}
void bar_run(struct bar *bar) {
int pfds = bar->outputs->length + 2;
struct pollfd *pfd = malloc(pfds * sizeof(struct pollfd));
bool dirty = true;
pfd[0].fd = bar->ipc_event_socketfd;
pfd[0].events = POLLIN;
pfd[1].fd = bar->status_read_fd;
pfd[1].events = POLLIN;
int i;
for (i = 0; i < bar->outputs->length; ++i) {
struct output *output = bar->outputs->items[i];
pfd[i+2].fd = wl_display_get_fd(output->registry->display);
pfd[i+2].events = POLLIN;
}
while (1) {
if (dirty) {
int i;
for (i = 0; i < bar->outputs->length; ++i) {
struct output *output = bar->outputs->items[i];
if (window_prerender(output->window) && output->window->cairo) {
render(output, bar->config, bar->status);
window_render(output->window);
wl_display_flush(output->registry->display);
}
}
}
dirty = false;
poll(pfd, pfds, -1);
if (pfd[0].revents & POLLIN) {
sway_log(L_DEBUG, "Got IPC event.");
dirty = handle_ipc_event(bar);
}
if (bar->config->status_command && pfd[1].revents & POLLIN) {
sway_log(L_DEBUG, "Got update from status command.");
dirty = handle_status_line(bar);
}
// dispatch wl_display events
for (i = 0; i < bar->outputs->length; ++i) {
struct output *output = bar->outputs->items[i];
if (pfd[i+2].revents & POLLIN) {
if (wl_display_dispatch(output->registry->display) == -1) {
sway_log(L_ERROR, "failed to dispatch wl: %d", errno);
}
} else {
wl_display_dispatch_pending(output->registry->display);
}
}
}
}
static void *Thread(void *data)
{
demux_t *demux = data;
demux_sys_t *sys = demux->p_sys;
struct wl_display *display = sys->display;
struct pollfd ufd[1];
unsigned interval = lroundf(CLOCK_FREQ / (sys->rate * 1000.f));
int canc = vlc_savecancel();
vlc_cleanup_push(cleanup_wl_display_read, display);
ufd[0].fd = wl_display_get_fd(display);
ufd[0].events = POLLIN;
for (;;)
{
if (DisplayError(demux, display))
break;
if (sys->es != NULL)
{
block_t *block = Shoot(demux);
block->i_pts = block->i_dts = vlc_tick_now();
es_out_SetPCR(demux->out, block->i_pts);
es_out_Send(demux->out, sys->es, block);
}
while (wl_display_prepare_read(display) != 0)
wl_display_dispatch_pending(display);
wl_display_flush(display);
vlc_restorecancel(canc);
while (poll(ufd, 1, interval) < 0);
canc = vlc_savecancel();
wl_display_read_events(display);
wl_display_dispatch_pending(display);
}
vlc_cleanup_pop();
vlc_restorecancel(canc);
return NULL;
}
void _glfwPlatformWaitEvents(void)
{
struct wl_display* display = _glfw.wl.display;
struct pollfd fds[] = {
{ wl_display_get_fd(display), POLLIN },
};
while (wl_display_prepare_read(display) != 0)
wl_display_dispatch_pending(display);
wl_display_flush(display);
if (poll(fds, 1, -1) > 0)
{
wl_display_read_events(display);
wl_display_dispatch_pending(display);
}
else
{
wl_display_cancel_read(display);
}
}
static void
kick_display(struct wit_client *c)
{
assert(c);
wl_display_flush(c->display);
wl_display_dispatch_pending(c->display);
int stat = kill(getppid(), SIGUSR1);
assertf(stat == 0,
"Failed sending SIGUSR1 signal to display");
}
void WaylandCore::pollEvents() {
if( mDisplay == NULL || mRegistry == NULL ) {
mShouldClose = true;
return;
}
pollfd fds[] = {
{ wl_display_get_fd(mDisplay), POLLIN },
};
while( wl_display_prepare_read(mDisplay) != 0 )
{
wl_display_dispatch_pending(mDisplay);
}
wl_display_flush(mDisplay);
if( poll(fds,1,0) > 0 )
{
wl_display_read_events(mDisplay);
wl_display_dispatch_pending(mDisplay);
} else {
wl_display_cancel_read(mDisplay);
}
}
static void
sync_callback(void *data, struct wl_callback *callback, uint32_t serial)
{
struct multiple_queues_state *state = data;
state->done = true;
wl_callback_destroy(callback);
wl_display_dispatch_pending(state->display);
wl_callback_destroy(state->callback2);
}
static void
handleEvents(int timeout)
{
struct wl_display* display = _glfw.wl.display;
struct pollfd fds[] = {
{ wl_display_get_fd(display), POLLIN },
};
while (wl_display_prepare_read(display) != 0)
wl_display_dispatch_pending(display);
// If an error different from EAGAIN happens, we have likely been
// disconnected from the Wayland session, try to handle that the best we
// can.
if (wl_display_flush(display) < 0 && errno != EAGAIN)
{
_GLFWwindow* window = _glfw.windowListHead;
while (window)
{
_glfwInputWindowCloseRequest(window);
window = window->next;
}
wl_display_cancel_read(display);
return;
}
if (poll(fds, 1, timeout) > 0)
{
wl_display_read_events(display);
wl_display_dispatch_pending(display);
}
else
{
wl_display_cancel_read(display);
}
}
void fgPlatformSleepForEvents( fg_time_t msec )
{
struct pollfd pfd;
int err;
pfd.fd = wl_display_get_fd( fgDisplay.pDisplay.display );
pfd.events = POLLIN | POLLERR | POLLHUP;
wl_display_dispatch_pending( fgDisplay.pDisplay.display );
if ( ! wl_display_flush( fgDisplay.pDisplay.display ) )
{
err = poll( &pfd, 1, msec );
if( ( -1 == err ) && ( errno != EINTR ) )
fgWarning ( "freeglut poll() error: %d", errno );
}
}
static int
wayland_compositor_handle_event(int fd, uint32_t mask, void *data)
{
struct wayland_compositor *c = data;
int count = 0;
if (mask & WL_EVENT_READABLE)
count = wl_display_dispatch(c->parent.wl_display);
if (mask & WL_EVENT_WRITABLE)
wl_display_flush(c->parent.wl_display);
if (mask == 0) {
count = wl_display_dispatch_pending(c->parent.wl_display);
wl_display_flush(c->parent.wl_display);
}
return count;
}
static void egl_create_window(struct vo_wayland_state *wl)
{
wl->egl_context.egl_window = wl_egl_window_create(wl->window.video_surface,
wl->window.width,
wl->window.height);
wl->egl_context.egl_surface = eglCreateWindowSurface(wl->egl_context.egl.dpy,
wl->egl_context.egl.conf,
wl->egl_context.egl_window,
NULL);
eglMakeCurrent(wl->egl_context.egl.dpy,
wl->egl_context.egl_surface,
wl->egl_context.egl_surface,
wl->egl_context.egl.ctx);
wl_display_dispatch_pending(wl->display.display);
}
static void
leak_after_error(void)
{
struct client *c = client_connect();
/* this should return -1, because we'll send error
* from server. */
assert(stop_display(c, 1) == -1);
assert(wl_display_dispatch_pending(c->wl_display) == -1);
assert(wl_display_get_error(c->wl_display) == ENOMEM);
/* after we got error, we have display_resume event
* in the queue. It should be freed in wl_display_disconnect().
* Let's see! */
wl_proxy_destroy((struct wl_proxy *) c->tc);
wl_display_disconnect(c->wl_display);
free(c);
}
static int64_t
prepare_wayland_display_events (void *user_data)
{
CoglRenderer *renderer = user_data;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererWayland *wayland_renderer = egl_renderer->platform;
int flush_ret;
flush_ret = wl_display_flush (wayland_renderer->wayland_display);
if (flush_ret == -1)
{
/* If the socket buffer became full then we need to wake up the
* main loop once it is writable again */
if (errno == EAGAIN)
{
_cogl_poll_renderer_modify_fd (renderer,
wayland_renderer->fd,
COGL_POLL_FD_EVENT_IN |
COGL_POLL_FD_EVENT_OUT);
}
else if (errno != EINTR)
{
/* If the flush failed for some other reason then it's
* likely that it's going to consistently fail so we'll stop
* waiting on the file descriptor instead of making the
* application take up 100% CPU. FIXME: it would be nice if
* there was some way to report this to the application so
* that it can quit or recover */
_cogl_poll_renderer_remove_fd (renderer, wayland_renderer->fd);
}
}
/* Calling this here is a bit dodgy because Cogl usually tries to
* say that it won't do any event processing until
* cogl_poll_renderer_dispatch is called. However Wayland doesn't
* seem to provide any way to query whether the event queue is empty
* and we would need to do that in order to force the main loop to
* wake up to call it from dispatch. */
wl_display_dispatch_pending (wayland_renderer->wayland_display);
return -1;
}
int main () {
display = wl_display_connect (NULL);
struct wl_registry *registry = wl_display_get_registry (display);
wl_registry_add_listener (registry, ®istry_listener, NULL);
wl_display_roundtrip (display);
egl_display = eglGetDisplay (display);
eglInitialize (egl_display, NULL, NULL);
struct window window;
create_window (&window, WIDTH, HEIGHT);
while (running) {
wl_display_dispatch_pending (display);
draw_window (&window);
}
delete_window (&window);
eglTerminate (egl_display);
wl_display_disconnect (display);
return 0;
}
static void egl_create_window(struct vo_wayland_state *wl,
struct egl_context *egl_ctx,
uint32_t width,
uint32_t height)
{
egl_ctx->egl_window = wl_egl_window_create(wl->window->surface,
wl->window->width,
wl->window->height);
egl_ctx->egl_surface = eglCreateWindowSurface(egl_ctx->egl.dpy,
egl_ctx->egl.conf,
egl_ctx->egl_window,
NULL);
eglMakeCurrent(egl_ctx->egl.dpy,
egl_ctx->egl_surface,
egl_ctx->egl_surface,
egl_ctx->egl.ctx);
wl_display_dispatch_pending(wl->display->display);
}
/* Test that when receiving the first of two synchronization
* callback events, destroying the second one doesn't cause any
* errors even if the delete_id event is handled out of order. */
static int
client_test_multiple_queues(void)
{
struct wl_event_queue *queue;
struct wl_callback *callback1;
struct multiple_queues_state state;
int ret = 0;
state.display = wl_display_connect(SOCKET_NAME);
client_assert(state.display);
/* Make the current thread the display thread. This is because
* wl_display_dispatch_queue() will only read the display fd if
* the main display thread has been set. */
wl_display_dispatch_pending(state.display);
queue = wl_display_create_queue(state.display);
client_assert(queue);
state.done = false;
callback1 = wl_display_sync(state.display);
wl_callback_add_listener(callback1, &sync_listener, &state);
wl_proxy_set_queue((struct wl_proxy *) callback1, queue);
state.callback2 = wl_display_sync(state.display);
wl_callback_add_listener(state.callback2, &sync_listener, NULL);
wl_proxy_set_queue((struct wl_proxy *) state.callback2, queue);
wl_display_flush(state.display);
while (!state.done && !ret)
ret = wl_display_dispatch_queue(state.display, queue);
wl_display_disconnect(state.display);
return ret == -1 ? -1 : 0;
}
static void flush_wayland_fd(gfx_ctx_wayland_data_t *wl)
{
struct pollfd fd = {0};
wl_display_dispatch_pending(wl->dpy);
wl_display_flush(wl->dpy);
fd.fd = wl->fd;
fd.events = POLLIN | POLLOUT | POLLERR | POLLHUP;
if (poll(&fd, 1, 0) > 0)
{
if (fd.revents & (POLLERR | POLLHUP))
{
close(wl->fd);
g_egl_quit = true;
}
if (fd.revents & POLLIN)
wl_display_dispatch(wl->dpy);
if (fd.revents & POLLOUT)
wl_display_flush(wl->dpy);
}
}
namespace ViewBackend {
class EventSource {
public:
static GSourceFuncs sourceFuncs;
GSource source;
GPollFD pfd;
struct wl_display* display;
};
GSourceFuncs EventSource::sourceFuncs = {
// prepare
[](GSource* base, gint* timeout) -> gboolean
{
auto* source = reinterpret_cast<EventSource*>(base);
struct wl_display* display = source->display;
*timeout = -1;
wl_display_flush(display);
wl_display_dispatch_pending(display);
return FALSE;
},
// check
[](GSource* base) -> gboolean
{
auto* source = reinterpret_cast<EventSource*>(base);
return !!source->pfd.revents;
},
// dispatch
[](GSource* base, GSourceFunc, gpointer) -> gboolean
{
auto* source = reinterpret_cast<EventSource*>(base);
struct wl_display* display = source->display;
if (source->pfd.revents & G_IO_IN)
wl_display_dispatch(display);
if (source->pfd.revents & (G_IO_ERR | G_IO_HUP))
return FALSE;
source->pfd.revents = 0;
return TRUE;
},
nullptr, // finalize
nullptr, // closure_callback
nullptr, // closure_marshall
};
const struct wl_registry_listener g_registryListener = {
// global
[](void* data, struct wl_registry* registry, uint32_t name, const char* interface, uint32_t)
{
auto& interfaces = *static_cast<WaylandDisplay::Interfaces*>(data);
if (!std::strcmp(interface, "wl_compositor"))
interfaces.compositor = static_cast<struct wl_compositor*>(wl_registry_bind(registry, name, &wl_compositor_interface, 1));
if (!std::strcmp(interface, "wl_drm"))
interfaces.drm = static_cast<struct wl_drm*>(wl_registry_bind(registry, name, &wl_drm_interface, 2));
if (!std::strcmp(interface, "wl_seat"))
interfaces.seat = static_cast<struct wl_seat*>(wl_registry_bind(registry, name, &wl_seat_interface, 4));
if (!std::strcmp(interface, "xdg_shell"))
interfaces.xdg = static_cast<struct xdg_shell*>(wl_registry_bind(registry, name, &xdg_shell_interface, 1));
if (!std::strcmp(interface, "ivi_application"))
interfaces.ivi_application = static_cast<struct ivi_application*>(wl_registry_bind(registry, name, &ivi_application_interface, 1));
},
// global_remove
[](void*, struct wl_registry*, uint32_t) { },
};
static const struct xdg_shell_listener g_xdgShellListener = {
// ping
[](void*, struct xdg_shell* shell, uint32_t serial)
{
xdg_shell_pong(shell, serial);
},
};
const WaylandDisplay& WaylandDisplay::singleton()
{
static WaylandDisplay display;
return display;
}
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);
}
}
WaylandDisplay::~WaylandDisplay()
{
if (m_eventSource)
g_source_unref(m_eventSource);
m_eventSource = nullptr;
if (m_interfaces.compositor)
wl_compositor_destroy(m_interfaces.compositor);
if (m_interfaces.drm)
wl_drm_destroy(m_interfaces.drm);
if (m_interfaces.seat)
wl_seat_destroy(m_interfaces.seat);
if (m_interfaces.xdg)
xdg_shell_destroy(m_interfaces.xdg);
if (m_interfaces.ivi_application)
ivi_application_destroy(m_interfaces.ivi_application);
m_interfaces = { nullptr, nullptr, nullptr, nullptr, nullptr };
if (m_registry)
wl_registry_destroy(m_registry);
m_registry = nullptr;
if (m_display)
wl_display_disconnect(m_display);
m_display = nullptr;
}
} // namespace ViewBackend
namespace ViewBackend {
class EventSource {
public:
static GSourceFuncs sourceFuncs;
GSource source;
GPollFD pfd;
struct wl_display* display;
};
GSourceFuncs EventSource::sourceFuncs = {
// prepare
[](GSource* base, gint* timeout) -> gboolean
{
auto* source = reinterpret_cast<EventSource*>(base);
struct wl_display* display = source->display;
*timeout = -1;
wl_display_flush(display);
wl_display_dispatch_pending(display);
return FALSE;
},
// check
[](GSource* base) -> gboolean
{
auto* source = reinterpret_cast<EventSource*>(base);
return !!source->pfd.revents;
},
// dispatch
[](GSource* base, GSourceFunc, gpointer) -> gboolean
{
auto* source = reinterpret_cast<EventSource*>(base);
struct wl_display* display = source->display;
if (source->pfd.revents & G_IO_IN)
wl_display_dispatch(display);
if (source->pfd.revents & (G_IO_ERR | G_IO_HUP))
return FALSE;
source->pfd.revents = 0;
return TRUE;
},
nullptr, // finalize
nullptr, // closure_callback
nullptr, // closure_marshall
};
const struct wl_registry_listener g_registryListener = {
// global
[](void* data, struct wl_registry* registry, uint32_t name, const char* interface, uint32_t)
{
auto& interfaces = *static_cast<WaylandDisplay::Interfaces*>(data);
if (!std::strcmp(interface, "wl_compositor"))
interfaces.compositor = static_cast<struct wl_compositor*>(wl_registry_bind(registry, name, &wl_compositor_interface, 1));
if (!std::strcmp(interface, "wl_data_device_manager"))
interfaces.data_device_manager = static_cast<struct wl_data_device_manager*>(wl_registry_bind(registry, name, &wl_data_device_manager_interface, 2));
if (!std::strcmp(interface, "wl_drm"))
interfaces.drm = static_cast<struct wl_drm*>(wl_registry_bind(registry, name, &wl_drm_interface, 2));
if (!std::strcmp(interface, "wl_seat"))
interfaces.seat = static_cast<struct wl_seat*>(wl_registry_bind(registry, name, &wl_seat_interface, 4));
if (!std::strcmp(interface, "xdg_shell"))
interfaces.xdg = static_cast<struct xdg_shell*>(wl_registry_bind(registry, name, &xdg_shell_interface, 1));
if (!std::strcmp(interface, "ivi_application"))
interfaces.ivi_application = static_cast<struct ivi_application*>(wl_registry_bind(registry, name, &ivi_application_interface, 1));
},
// global_remove
[](void*, struct wl_registry*, uint32_t) { },
};
static const struct xdg_shell_listener g_xdgShellListener = {
// ping
[](void*, struct xdg_shell* shell, uint32_t serial)
{
xdg_shell_pong(shell, serial);
},
};
static const struct wl_pointer_listener g_pointerListener = {
// enter
[](void* data, struct wl_pointer*, uint32_t serial, struct wl_surface* surface, wl_fixed_t, wl_fixed_t)
{
auto& seatData = *static_cast<WaylandDisplay::SeatData*>(data);
seatData.serial = serial;
auto it = seatData.inputClients.find(surface);
if (it != seatData.inputClients.end())
seatData.pointer.target = *it;
},
// leave
[](void* data, struct wl_pointer*, uint32_t serial, struct wl_surface* surface)
{
auto& seatData = *static_cast<WaylandDisplay::SeatData*>(data);
seatData.serial = serial;
auto it = seatData.inputClients.find(surface);
if (it != seatData.inputClients.end() && seatData.pointer.target.first == it->first)
seatData.pointer.target = { };
},
// motion
[](void* data, struct wl_pointer*, uint32_t time, wl_fixed_t fixedX, wl_fixed_t fixedY)
{
auto x = wl_fixed_to_int(fixedX);
auto y = wl_fixed_to_int(fixedY);
auto& pointer = static_cast<WaylandDisplay::SeatData*>(data)->pointer;
pointer.coords = { x, y };
if (pointer.target.first)
pointer.target.second->handlePointerEvent({ Input::PointerEvent::Motion, time, x, y, 0, 0 });
},
// button
[](void* data, struct wl_pointer*, uint32_t serial, uint32_t time, uint32_t button, uint32_t state)
{
static_cast<WaylandDisplay::SeatData*>(data)->serial = serial;
if (button >= BTN_MOUSE)
button = button - BTN_MOUSE + 1;
else
button = 0;
auto& pointer = static_cast<WaylandDisplay::SeatData*>(data)->pointer;
auto& coords = pointer.coords;
if (pointer.target.first)
pointer.target.second->handlePointerEvent(
{ Input::PointerEvent::Button, time, coords.first, coords.second, button, state });
},
// axis
[](void* data, struct wl_pointer*, uint32_t time, uint32_t axis, wl_fixed_t value)
{
auto& pointer = static_cast<WaylandDisplay::SeatData*>(data)->pointer;
auto& coords = pointer.coords;
if (pointer.target.first)
pointer.target.second->handleAxisEvent(
{ Input::AxisEvent::Motion, time, coords.first, coords.second, axis, -wl_fixed_to_int(value) });
},
};
static void
handleKeyEvent(WaylandDisplay::SeatData& seatData, uint32_t key, uint32_t state, uint32_t time)
{
auto& xkb = seatData.xkb;
uint32_t keysym = xkb_state_key_get_one_sym(xkb.state, key);
uint32_t unicode = xkb_state_key_get_utf32(xkb.state, key);
if (state == WL_KEYBOARD_KEY_STATE_PRESSED
&& xkb_compose_state_feed(xkb.composeState, keysym) == XKB_COMPOSE_FEED_ACCEPTED
&& xkb_compose_state_get_status(xkb.composeState) == XKB_COMPOSE_COMPOSED)
{
keysym = xkb_compose_state_get_one_sym(xkb.composeState);
unicode = xkb_keysym_to_utf32(keysym);
}
if (seatData.keyboard.target.first)
seatData.keyboard.target.second->handleKeyboardEvent({ time, keysym, unicode, !!state, xkb.modifiers });
}
static gboolean
repeatRateTimeout(void* data)
{
auto& seatData = *static_cast<WaylandDisplay::SeatData*>(data);
handleKeyEvent(seatData, seatData.repeatData.key, seatData.repeatData.state, seatData.repeatData.time);
return G_SOURCE_CONTINUE;
}
static gboolean
repeatDelayTimeout(void* data)
{
auto& seatData = *static_cast<WaylandDisplay::SeatData*>(data);
handleKeyEvent(seatData, seatData.repeatData.key, seatData.repeatData.state, seatData.repeatData.time);
seatData.repeatData.eventSource = g_timeout_add(seatData.repeatInfo.rate, static_cast<GSourceFunc>(repeatRateTimeout), data);
return G_SOURCE_REMOVE;
}
static const struct wl_keyboard_listener g_keyboardListener = {
// keymap
[](void* data, struct wl_keyboard*, uint32_t format, int fd, uint32_t size)
{
if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) {
close(fd);
return;
}
void* mapping = mmap(nullptr, size, PROT_READ, MAP_SHARED, fd, 0);
if (mapping == MAP_FAILED) {
close(fd);
return;
}
auto& xkb = static_cast<WaylandDisplay::SeatData*>(data)->xkb;
xkb.keymap = xkb_keymap_new_from_string(xkb.context, static_cast<char*>(mapping),
XKB_KEYMAP_FORMAT_TEXT_V1, XKB_KEYMAP_COMPILE_NO_FLAGS);
munmap(mapping, size);
close(fd);
if (!xkb.keymap)
return;
xkb.state = xkb_state_new(xkb.keymap);
if (!xkb.state)
return;
xkb.indexes.control = xkb_keymap_mod_get_index(xkb.keymap, XKB_MOD_NAME_CTRL);
xkb.indexes.alt = xkb_keymap_mod_get_index(xkb.keymap, XKB_MOD_NAME_ALT);
xkb.indexes.shift = xkb_keymap_mod_get_index(xkb.keymap, XKB_MOD_NAME_SHIFT);
},
// enter
[](void* data, struct wl_keyboard*, uint32_t serial, struct wl_surface* surface, struct wl_array*)
{
auto& seatData = *static_cast<WaylandDisplay::SeatData*>(data);
seatData.serial = serial;
auto it = seatData.inputClients.find(surface);
if (it != seatData.inputClients.end())
seatData.keyboard.target = *it;
},
// leave
[](void* data, struct wl_keyboard*, uint32_t serial, struct wl_surface* surface)
{
auto& seatData = *static_cast<WaylandDisplay::SeatData*>(data);
seatData.serial = serial;
auto it = seatData.inputClients.find(surface);
if (it != seatData.inputClients.end() && seatData.keyboard.target.first == it->first)
seatData.keyboard.target = { };
},
// key
[](void* data, struct wl_keyboard*, uint32_t serial, uint32_t time, uint32_t key, uint32_t state)
{
// IDK.
key += 8;
auto& seatData = *static_cast<WaylandDisplay::SeatData*>(data);
seatData.serial = serial;
handleKeyEvent(seatData, key, state, time);
if (!seatData.repeatInfo.rate)
return;
if (state == WL_KEYBOARD_KEY_STATE_RELEASED
&& seatData.repeatData.key == key) {
if (seatData.repeatData.eventSource)
g_source_remove(seatData.repeatData.eventSource);
seatData.repeatData = { 0, 0, 0, 0 };
} else if (state == WL_KEYBOARD_KEY_STATE_PRESSED
&& xkb_keymap_key_repeats(seatData.xkb.keymap, key)) {
if (seatData.repeatData.eventSource)
g_source_remove(seatData.repeatData.eventSource);
seatData.repeatData = { key, time, state, g_timeout_add(seatData.repeatInfo.delay, static_cast<GSourceFunc>(repeatDelayTimeout), data) };
}
},
// modifiers
[](void* data, struct wl_keyboard*, uint32_t serial, uint32_t depressedMods, uint32_t latchedMods, uint32_t lockedMods, uint32_t group)
{
static_cast<WaylandDisplay::SeatData*>(data)->serial = serial;
auto& xkb = static_cast<WaylandDisplay::SeatData*>(data)->xkb;
xkb_state_update_mask(xkb.state, depressedMods, latchedMods, lockedMods, 0, 0, group);
auto& modifiers = xkb.modifiers;
modifiers = 0;
auto component = static_cast<xkb_state_component>(XKB_STATE_MODS_DEPRESSED | XKB_STATE_MODS_LATCHED);
if (xkb_state_mod_index_is_active(xkb.state, xkb.indexes.control, component))
modifiers |= Input::KeyboardEvent::Control;
if (xkb_state_mod_index_is_active(xkb.state, xkb.indexes.alt, component))
modifiers |= Input::KeyboardEvent::Alt;
if (xkb_state_mod_index_is_active(xkb.state, xkb.indexes.shift, component))
modifiers |= Input::KeyboardEvent::Shift;
},
// repeat_info
[](void* data, struct wl_keyboard*, int32_t rate, int32_t delay)
{
auto& repeatInfo = static_cast<WaylandDisplay::SeatData*>(data)->repeatInfo;
repeatInfo = { rate, delay };
// A rate of zero disables any repeating.
if (!rate) {
auto& repeatData = static_cast<WaylandDisplay::SeatData*>(data)->repeatData;
if (repeatData.eventSource) {
g_source_remove(repeatData.eventSource);
repeatData = { 0, 0, 0, 0 };
}
}
},
};
static const struct wl_touch_listener g_touchListener = {
// down
[](void* data, struct wl_touch*, uint32_t serial, uint32_t time, struct wl_surface* surface, int32_t id, wl_fixed_t x, wl_fixed_t y)
{
auto& seatData = *static_cast<WaylandDisplay::SeatData*>(data);
seatData.serial = serial;
int32_t arraySize = std::tuple_size<decltype(seatData.touch.targets)>::value;
if (id < 0 || id >= arraySize)
return;
auto& target = seatData.touch.targets[id];
assert(!target.first && !target.second);
auto it = seatData.inputClients.find(surface);
if (it == seatData.inputClients.end())
return;
target = { surface, it->second };
auto& touchPoints = seatData.touch.touchPoints;
touchPoints[id] = { Input::TouchEvent::Down, time, id, wl_fixed_to_int(x), wl_fixed_to_int(y) };
target.second->handleTouchEvent({ touchPoints, Input::TouchEvent::Down, id, time });
},
// up
[](void* data, struct wl_touch*, uint32_t serial, uint32_t time, int32_t id)
{
auto& seatData = *static_cast<WaylandDisplay::SeatData*>(data);
seatData.serial = serial;
int32_t arraySize = std::tuple_size<decltype(seatData.touch.targets)>::value;
if (id < 0 || id >= arraySize)
return;
auto& target = seatData.touch.targets[id];
assert(target.first && target.second);
auto& touchPoints = seatData.touch.touchPoints;
auto& point = touchPoints[id];
point = { Input::TouchEvent::Up, time, id, point.x, point.y };
target.second->handleTouchEvent({ touchPoints, Input::TouchEvent::Up, id, time });
point = { Input::TouchEvent::Null, 0, 0, 0, 0 };
target = { nullptr, nullptr };
},
// motion
[](void* data, struct wl_touch*, uint32_t time, int32_t id, wl_fixed_t x, wl_fixed_t y)
{
auto& seatData = *static_cast<WaylandDisplay::SeatData*>(data);
int32_t arraySize = std::tuple_size<decltype(seatData.touch.targets)>::value;
if (id < 0 || id >= arraySize)
return;
auto& target = seatData.touch.targets[id];
assert(target.first && target.second);
auto& touchPoints = seatData.touch.touchPoints;
touchPoints[id] = { Input::TouchEvent::Motion, time, id, wl_fixed_to_int(x), wl_fixed_to_int(y) };
target.second->handleTouchEvent({ touchPoints, Input::TouchEvent::Motion, id, time });
},
// frame
[](void*, struct wl_touch*)
{
// FIXME: Dispatching events via frame() would avoid dispatching events
// for every single event that's encapsulated in a frame with multiple
// other events.
},
// cancel
[](void*, struct wl_touch*) { },
};
static const struct wl_seat_listener g_seatListener = {
// capabilities
[](void* data, struct wl_seat* seat, uint32_t capabilities)
{
auto& seatData = *static_cast<WaylandDisplay::SeatData*>(data);
// WL_SEAT_CAPABILITY_POINTER
const bool hasPointerCap = capabilities & WL_SEAT_CAPABILITY_POINTER;
if (hasPointerCap && !seatData.pointer.object) {
seatData.pointer.object = wl_seat_get_pointer(seat);
wl_pointer_add_listener(seatData.pointer.object, &g_pointerListener, &seatData);
}
if (!hasPointerCap && seatData.pointer.object) {
wl_pointer_destroy(seatData.pointer.object);
seatData.pointer.object = nullptr;
}
// WL_SEAT_CAPABILITY_KEYBOARD
const bool hasKeyboardCap = capabilities & WL_SEAT_CAPABILITY_KEYBOARD;
if (hasKeyboardCap && !seatData.keyboard.object) {
seatData.keyboard.object = wl_seat_get_keyboard(seat);
wl_keyboard_add_listener(seatData.keyboard.object, &g_keyboardListener, &seatData);
}
if (!hasKeyboardCap && seatData.keyboard.object) {
wl_keyboard_destroy(seatData.keyboard.object);
seatData.keyboard.object = nullptr;
}
// WL_SEAT_CAPABILITY_TOUCH
const bool hasTouchCap = capabilities & WL_SEAT_CAPABILITY_TOUCH;
if (hasTouchCap && !seatData.touch.object) {
seatData.touch.object = wl_seat_get_touch(seat);
wl_touch_add_listener(seatData.touch.object, &g_touchListener, &seatData);
}
if (!hasTouchCap && seatData.touch.object) {
wl_touch_destroy(seatData.touch.object);
seatData.touch.object = nullptr;
}
},
// name
[](void*, struct wl_seat*, const char*) { }
};
WaylandDisplay& WaylandDisplay::singleton()
{
static WaylandDisplay display;
return display;
}
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);
}
WaylandDisplay::~WaylandDisplay()
{
if (m_eventSource)
g_source_unref(m_eventSource);
m_eventSource = nullptr;
if (m_interfaces.compositor)
wl_compositor_destroy(m_interfaces.compositor);
if (m_interfaces.data_device_manager)
wl_data_device_manager_destroy(m_interfaces.data_device_manager);
if (m_interfaces.drm)
wl_drm_destroy(m_interfaces.drm);
if (m_interfaces.seat)
wl_seat_destroy(m_interfaces.seat);
if (m_interfaces.xdg)
xdg_shell_destroy(m_interfaces.xdg);
if (m_interfaces.ivi_application)
ivi_application_destroy(m_interfaces.ivi_application);
m_interfaces = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
if (m_registry)
wl_registry_destroy(m_registry);
m_registry = nullptr;
if (m_display)
wl_display_disconnect(m_display);
m_display = nullptr;
if (m_seatData.pointer.object)
wl_pointer_destroy(m_seatData.pointer.object);
if (m_seatData.keyboard.object)
wl_keyboard_destroy(m_seatData.keyboard.object);
if (m_seatData.touch.object)
wl_touch_destroy(m_seatData.touch.object);
if (m_seatData.xkb.context)
xkb_context_unref(m_seatData.xkb.context);
if (m_seatData.xkb.keymap)
xkb_keymap_unref(m_seatData.xkb.keymap);
if (m_seatData.xkb.state)
xkb_state_unref(m_seatData.xkb.state);
if (m_seatData.xkb.composeTable)
xkb_compose_table_unref(m_seatData.xkb.composeTable);
if (m_seatData.xkb.composeState)
xkb_compose_state_unref(m_seatData.xkb.composeState);
if (m_seatData.repeatData.eventSource)
g_source_remove(m_seatData.repeatData.eventSource);
m_seatData = SeatData{ };
}
void WaylandDisplay::registerInputClient(struct wl_surface* surface, Input::Client* client)
{
#ifndef NDEBUG
auto result =
#endif
m_seatData.inputClients.insert({ surface, client });
assert(result.second);
}
void WaylandDisplay::unregisterInputClient(struct wl_surface* surface)
{
auto it = m_seatData.inputClients.find(surface);
assert(it != m_seatData.inputClients.end());
if (m_seatData.pointer.target.first == it->first)
m_seatData.pointer.target = { };
if (m_seatData.keyboard.target.first == it->first)
m_seatData.keyboard.target = { };
m_seatData.inputClients.erase(it);
}
} // namespace ViewBackend
void WL_get_events() {
wl_display_dispatch_pending(_WL_display.display);
}
int
main(int argc, char **argv)
{
struct sigaction sigint;
struct display display = { 0 };
struct window window = { 0 };
int i, ret = 0;
window.display = &display;
display.window = &window;
window.window_size.width = 250;
window.window_size.height = 250;
window.buffer_size = 32;
window.frame_sync = 1;
for (i = 1; i < argc; i++) {
if (strcmp("-f", argv[i]) == 0)
window.fullscreen = 1;
else if (strcmp("-o", argv[i]) == 0)
window.opaque = 1;
else if (strcmp("-s", argv[i]) == 0)
window.buffer_size = 16;
else if (strcmp("-b", argv[i]) == 0)
window.frame_sync = 0;
else if (strcmp("-h", argv[i]) == 0)
usage(EXIT_SUCCESS);
else
usage(EXIT_FAILURE);
}
display.display = wl_display_connect(NULL);
assert(display.display);
display.registry = wl_display_get_registry(display.display);
wl_registry_add_listener(display.registry,
®istry_listener, &display);
wl_display_dispatch(display.display);
init_egl(&display, &window);
create_surface(&window);
init_gl(&window);
display.cursor_surface =
wl_compositor_create_surface(display.compositor);
sigint.sa_handler = signal_int;
sigemptyset(&sigint.sa_mask);
sigint.sa_flags = SA_RESETHAND;
sigaction(SIGINT, &sigint, NULL);
/* The mainloop here is a little subtle. Redrawing will cause
* EGL to read events so we can just call
* wl_display_dispatch_pending() to handle any events that got
* queued up as a side effect. */
while (running && ret != -1) {
wl_display_dispatch_pending(display.display);
redraw(&window, NULL, 0);
}
fprintf(stderr, "simple-egl exiting\n");
destroy_surface(&window);
fini_egl(&display);
wl_surface_destroy(display.cursor_surface);
if (display.cursor_theme)
wl_cursor_theme_destroy(display.cursor_theme);
if (display.shell)
xdg_shell_destroy(display.shell);
if (display.compositor)
wl_compositor_destroy(display.compositor);
wl_registry_destroy(display.registry);
wl_display_flush(display.display);
wl_display_disconnect(display.display);
return 0;
}
namespace WebCore {
class EventSource {
public:
static GSourceFuncs sourceFuncs;
GSource source;
GPollFD pfd;
struct wl_display* display;
};
GSourceFuncs EventSource::sourceFuncs = {
// prepare
[](GSource* base, gint* timeout) -> gboolean
{
auto* source = reinterpret_cast<EventSource*>(base);
struct wl_display* display = source->display;
*timeout = -1;
wl_display_flush(display);
wl_display_dispatch_pending(display);
return FALSE;
},
// check
[](GSource* base) -> gboolean
{
auto* source = reinterpret_cast<EventSource*>(base);
return !!source->pfd.revents;
},
// dispatch
[](GSource* base, GSourceFunc, gpointer) -> gboolean
{
auto* source = reinterpret_cast<EventSource*>(base);
struct wl_display* display = source->display;
if (source->pfd.revents & G_IO_IN)
wl_display_dispatch(display);
if (source->pfd.revents & (G_IO_ERR | G_IO_HUP))
return FALSE;
source->pfd.revents = 0;
return TRUE;
},
nullptr, // finalize
nullptr, // closure_callback
nullptr, // closure_marshall
};
const struct wl_registry_listener PlatformDisplayWayland::m_registryListener = {
PlatformDisplayWayland::globalCallback,
PlatformDisplayWayland::globalRemoveCallback
};
void PlatformDisplayWayland::globalCallback(void* data, struct wl_registry* registry, uint32_t name, const char* interface, uint32_t)
{
auto display = static_cast<PlatformDisplayWayland*>(data);
if (!std::strcmp(interface, "wl_compositor"))
display->m_compositor = static_cast<struct wl_compositor*>(wl_registry_bind(registry, name, &wl_compositor_interface, 1));
}
void PlatformDisplayWayland::globalRemoveCallback(void*, struct wl_registry*, uint32_t)
{
// FIXME: if this can happen without the UI Process getting shut down
// we should probably destroy our cached display instance.
}
std::unique_ptr<PlatformDisplayWayland> PlatformDisplayWayland::create()
{
struct wl_display* wlDisplay = wl_display_connect(nullptr);
if (!wlDisplay) {
WTFLogAlways("PlatformDisplayWayland initialization: failed to connect to the Wayland server socket. Check your WAYLAND_DISPLAY or WAYLAND_SOCKET environment variables.");
return nullptr;
}
std::unique_ptr<PlatformDisplayWayland> display(new PlatformDisplayWayland(wlDisplay));
if (!display->isInitialized()) {
WTFLogAlways("PlatformDisplayWayland initialization: failed to complete the initialization of the display.");
return nullptr;
}
GSource* baseSource = g_source_new(&EventSource::sourceFuncs, sizeof(EventSource));
auto* source = reinterpret_cast<EventSource*>(baseSource);
source->display = display->m_display;
source->pfd.fd = wl_display_get_fd(display->m_display);
source->pfd.events = G_IO_IN | G_IO_ERR | G_IO_HUP;
source->pfd.revents = 0;
g_source_add_poll(baseSource, &source->pfd);
g_source_set_name(baseSource, "[WebKit] WaylandDisplay");
g_source_set_priority(baseSource, G_PRIORITY_HIGH + 30);
g_source_set_can_recurse(baseSource, TRUE);
g_source_attach(baseSource, g_main_context_get_thread_default());
return display;
}
PlatformDisplayWayland::PlatformDisplayWayland(struct wl_display* wlDisplay)
: m_display(wlDisplay)
, m_registry(wl_display_get_registry(m_display))
, m_eglConfigChosen(false)
{
wl_registry_add_listener(m_registry, &m_registryListener, this);
wl_display_roundtrip(m_display);
static const EGLint configAttributes[] = {
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RED_SIZE, 1,
EGL_GREEN_SIZE, 1,
EGL_BLUE_SIZE, 1,
EGL_ALPHA_SIZE, 1,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE
};
m_eglDisplay = eglGetDisplay(m_display);
PlatformDisplay::initializeEGLDisplay();
if (m_eglDisplay == EGL_NO_DISPLAY)
return;
EGLint numberOfConfigs;
if (!eglChooseConfig(m_eglDisplay, configAttributes, &m_eglConfig, 1, &numberOfConfigs) || numberOfConfigs != 1) {
g_warning("PlatformDisplayWayland initialization: failed to find the desired EGL configuration.");
return;
}
m_eglConfigChosen = true;
}
PlatformDisplayWayland::~PlatformDisplayWayland()
{
if (m_compositor)
wl_compositor_destroy(m_compositor);
if (m_registry)
wl_registry_destroy(m_registry);
if (m_display)
wl_display_disconnect(m_display);
}
std::unique_ptr<WaylandSurface> PlatformDisplayWayland::createSurface(const IntSize& size)
{
struct wl_surface* wlSurface = wl_compositor_create_surface(m_compositor);
// We keep the minimum size at 1x1px since Mesa returns null values in wl_egl_window_create() for zero width or height.
EGLNativeWindowType nativeWindow = wl_egl_window_create(wlSurface, std::max(1, size.width()), std::max(1, size.height()));
return std::make_unique<WaylandSurface>(wlSurface, nativeWindow);
}
std::unique_ptr<GLContextEGL> PlatformDisplayWayland::createOffscreenContext(GLContext* sharingContext)
{
class OffscreenContextData : public GLContext::Data {
public:
virtual ~OffscreenContextData()
{
wl_egl_window_destroy(nativeWindow);
wl_surface_destroy(surface);
}
struct wl_surface* surface;
EGLNativeWindowType nativeWindow;
};
auto contextData = std::make_unique<OffscreenContextData>();
contextData->surface = wl_compositor_create_surface(m_compositor);
contextData->nativeWindow = wl_egl_window_create(contextData->surface, 1, 1);
auto nativeWindow = contextData->nativeWindow;
return GLContextEGL::createWindowContext(nativeWindow, nullptr, WTF::move(contextData));
}
} // namespace WebCore
int DispatchPending(){
return wl_display_dispatch_pending(cobj);
}
void MockClient::flushDisplay()
{
wl_display_dispatch_pending(display);
wl_display_flush(display);
}
