int main(int argc, char **argv) {
display = wl_display_connect(NULL);
if (display == NULL) {
fprintf(stderr, "Can't connect to display\n");
exit(1);
}
printf("connected to display\n");
struct wl_registry *registry = wl_display_get_registry(display);
wl_registry_add_listener(registry, ®istry_listener, NULL);
wl_display_dispatch(display);
wl_display_roundtrip(display);
if (compositor == NULL) {
fprintf(stderr, "Can't find compositor\n");
exit(1);
} else {
fprintf(stderr, "Found compositor\n");
}
surface = wl_compositor_create_surface(compositor);
if (surface == NULL) {
fprintf(stderr, "Can't create surface\n");
exit(1);
} else {
fprintf(stderr, "Created surface\n");
}
shell_surface = wl_shell_get_shell_surface(shell, surface);
if (shell_surface == NULL) {
fprintf(stderr, "Can't create shell surface\n");
exit(1);
} else {
fprintf(stderr, "Created shell surface\n");
}
wl_shell_surface_set_toplevel(shell_surface);
wl_shell_surface_add_listener(shell_surface,
&shell_surface_listener, NULL);
create_window();
paint_pixels();
while (wl_display_dispatch(display) != -1) {
;
}
wl_display_disconnect(display);
printf("disconnected from display\n");
exit(0);
}
int main(int argc, char *argv[])
{
struct display *display;
char buf[256], *p;
int ret, fd;
display = malloc(sizeof *display);
assert(display);
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);
wl_display_dispatch(display->display);
fd = 0;
p = getenv("TEST_SOCKET");
if (p)
fd = strtol(p, NULL, 0);
while (1) {
ret = read(fd, buf, sizeof buf);
if (ret == -1) {
fprintf(stderr, "test-client: read error: fd %d, %m\n",
fd);
return -1;
}
fprintf(stderr, "test-client: got %.*s\n", ret - 1, buf);
if (strncmp(buf, "bye\n", ret) == 0) {
return 0;
} else if (strncmp(buf, "create-surface\n", ret) == 0) {
create_surface(fd, display);
} else if (strncmp(buf, "send-state\n", ret) == 0) {
send_state(fd, display);
} else if (strncmp(buf, "send-button-state\n", ret) == 0) {
send_button_state(fd, display);
} else if (strncmp(buf, "send-keyboard-state\n", ret) == 0) {
send_keyboard_state(fd, display);
} else {
fprintf(stderr, "test-client: unknown command %.*s\n",
ret, buf);
return -1;
}
}
assert(0);
}
xdl_int initWayland() {
//
// Connect to the Wayland server.
//
display = wl_display_connect(nullptr);
if(display == nullptr) {
std::cerr << "## XdevLWindowWayland::wl_display_connect failed" << std::endl;
return xdl::ERR_ERROR;
}
// We get the registry for the window which holds extension
// of the wayland server.
m_registry = wl_display_get_registry(display);
if(m_registry == nullptr) {
std::cerr << "## XdevLWindowWayland::wl_display_get_registry failed" << std::endl;
return ERR_ERROR;
}
// Now we tell the registry that we want to listen to events.
wl_registry_add_listener(m_registry, ®istry_listener, nullptr);
wl_display_dispatch(display);
return ERR_OK;
}
int
main(int argc, char **argv)
{
struct sigaction sigint;
struct display *display;
struct window *window;
int ret = 0;
display = create_display();
window = create_window(display, 250, 250);
if (!window)
return 1;
sigint.sa_handler = signal_int;
sigemptyset(&sigint.sa_mask);
sigint.sa_flags = SA_RESETHAND;
sigaction(SIGINT, &sigint, NULL);
/* Initialise damage to full surface, so the padding gets painted */
wl_surface_damage(window->surface, 0, 0,
window->width, window->height);
redraw(window, NULL, 0);
while (running && ret != -1)
ret = wl_display_dispatch(display->display);
fprintf(stderr, "simple-dmabuf exiting\n");
destroy_window(window);
destroy_display(display);
return 0;
}
WaylandEventQueue::WaylandEventQueue(IOLoop &_io_loop, EventQueue &_queue)
:io_loop(_io_loop), queue(_queue),
display(wl_display_connect(nullptr))
{
if (display == nullptr) {
fprintf(stderr, "wl_display_connect() failed\n");
exit(EXIT_FAILURE);
}
auto registry = wl_display_get_registry(display);
wl_registry_add_listener(registry, ®istry_listener, this);
wl_display_dispatch(display);
wl_display_roundtrip(display);
if (compositor == nullptr) {
fprintf(stderr, "No Wayland compositor found\n");
exit(EXIT_FAILURE);
}
if (seat == nullptr) {
fprintf(stderr, "No Wayland seat found\n");
exit(EXIT_FAILURE);
}
if (shell == nullptr) {
fprintf(stderr, "No Wayland shell found\n");
exit(EXIT_FAILURE);
}
io_loop.Add(FileDescriptor(wl_display_get_fd(display)), io_loop.READ, *this);
}
int main(int argc, char **argv)
{
Helper helper;
helper.display = wl_display_connect(nullptr);
helper.registry = wl_display_get_registry(helper.display);
static const wl_registry_listener registryListener = {
wrapInterface(&Helper::global),
wrapInterface(&Helper::globalRemove)
};
wl_registry_add_listener(helper.registry, ®istryListener, &helper);
wl_display_roundtrip(helper.display);
if (!helper.helper) {
qWarning("No orbital_authorizer_helper interface.");
exit(1);
}
int ret = 0;
while (ret != -1)
ret = wl_display_dispatch(helper.display);
return 0;
}
static int createWLContext()
{
t_ilm_bool result = ILM_TRUE;
g_wlContextStruct.wlDisplay = wl_display_connect(NULL);
if (NULL == g_wlContextStruct.wlDisplay)
{
printf("Error: wl_display_connect() failed.\n");
}
g_wlContextStruct.wlRegistry = wl_display_get_registry(g_wlContextStruct.wlDisplay);
wl_registry_add_listener(g_wlContextStruct.wlRegistry, ®istry_listener, &g_wlContextStruct);
wl_display_dispatch(g_wlContextStruct.wlDisplay);
wl_display_roundtrip(g_wlContextStruct.wlDisplay);
g_wlContextStruct.wlSurface = wl_compositor_create_surface(g_wlContextStruct.wlCompositor);
if (NULL == g_wlContextStruct.wlSurface)
{
printf("Error: wl_compositor_create_surface failed.\n");
destroyWLContext();
}
createShmBuffer();
return result;
}
bool cWaylandInterface::Initialize(void *config)
{
if (!GLWin.wl_display) {
printf("Error: couldn't open wayland display\n");
return false;
}
GLWin.pointer.wl_pointer = nullptr;
GLWin.keyboard.wl_keyboard = nullptr;
GLWin.keyboard.xkb.context = xkb_context_new((xkb_context_flags) 0);
if (GLWin.keyboard.xkb.context == nullptr) {
fprintf(stderr, "Failed to create XKB context\n");
return nullptr;
}
GLWin.wl_registry = wl_display_get_registry(GLWin.wl_display);
wl_registry_add_listener(GLWin.wl_registry,
®istry_listener, nullptr);
while (!GLWin.wl_compositor)
wl_display_dispatch(GLWin.wl_display);
GLWin.wl_cursor_surface =
wl_compositor_create_surface(GLWin.wl_compositor);
return true;
}
void wl_dispatch_events() {
wl_display_flush(registry->display);
if (wl_display_dispatch(registry->display) == -1) {
sway_log(L_ERROR, "failed to run wl_display_dispatch");
exit(1);
}
}
static int
get_registry_objects()
{
struct wl_registry *registry = wl_display_get_registry(g_wl_display);
wl_registry_add_listener(registry, ®istry_listener, NULL);
wl_display_dispatch(g_wl_display);
wl_display_roundtrip(g_wl_display);
if (!g_wl_compositor) {
p_log("Failed to get a proxy compositor (wl_compositor) object.\n");
return (-1);
}
if (!g_wl_shm) {
p_log("Failed to get a proxy shared memory (wl_shm) object.\n");
return (-1);
}
if (!g_wl_shell) {
p_log("Failed to get a proxy shell (wl_shell) object.\n");
}
return (0);
}
GdkDisplay *
_gdk_wayland_display_open (const gchar *display_name)
{
struct wl_display *wl_display;
GdkDisplay *display;
GdkWaylandDisplay *display_wayland;
GDK_NOTE (MISC, g_message ("opening display %s", display_name ? display_name : ""));
/* If this variable is unset then wayland initialisation will surely
* fail, logging a fatal error in the process. Save ourselves from
* that.
*/
if (g_getenv ("XDG_RUNTIME_DIR") == NULL)
return NULL;
wl_log_set_handler_client (log_handler);
wl_display = wl_display_connect (display_name);
if (!wl_display)
return NULL;
display = g_object_new (GDK_TYPE_WAYLAND_DISPLAY, NULL);
display->device_manager = _gdk_wayland_device_manager_new (display);
display_wayland = GDK_WAYLAND_DISPLAY (display);
display_wayland->wl_display = wl_display;
display_wayland->screen = _gdk_wayland_screen_new (display);
display_wayland->event_source = _gdk_wayland_display_event_source_new (display);
display_wayland->known_globals =
g_hash_table_new_full (NULL, NULL, NULL, g_free);
_gdk_wayland_display_init_cursors (display_wayland);
_gdk_wayland_display_prepare_cursor_themes (display_wayland);
display_wayland->wl_registry = wl_display_get_registry (display_wayland->wl_display);
wl_registry_add_listener (display_wayland->wl_registry, ®istry_listener, display_wayland);
_gdk_wayland_display_async_roundtrip (display_wayland);
/* Wait for initializing to complete. This means waiting for all
* asynchrounous roundtrips that were triggered during initial roundtrip. */
while (g_list_length (display_wayland->async_roundtrips) > 0)
{
if (wl_display_dispatch (display_wayland->wl_display) < 0)
{
g_object_unref (display);
return NULL;
}
}
gdk_input_init (display);
display_wayland->selection = gdk_wayland_selection_new ();
g_signal_emit_by_name (display, "opened");
return display;
}
void
frame_callback_wait(struct client *client, int *done)
{
while (!*done) {
assert(wl_display_dispatch(client->wl_display) >= 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);
}
}
int
main(int argc, char **argv)
{
struct sigaction sigint;
struct display *display;
struct window *window;
int ret = 0;
display = create_display();
window = create_window(display, 250, 250);
if (!window)
return 1;
sigint.sa_handler = signal_int;
sigemptyset(&sigint.sa_mask);
sigint.sa_flags = SA_RESETHAND;
sigaction(SIGINT, &sigint, NULL);
/* Here we retrieve the linux-dmabuf objects, or error */
wl_display_roundtrip(display->display);
if (!running)
return 1;
redraw(window, NULL, 0);
while (running && ret != -1)
ret = wl_display_dispatch(display->display);
fprintf(stderr, "simple-dmabuf exiting\n");
destroy_window(window);
destroy_display(display);
return 0;
}
int
main(int argc, char **argv)
{
struct nested_client *client;
int ret = 0;
if (getenv("WAYLAND_SOCKET") == NULL) {
fprintf(stderr, "must be run by nested, don't run standalone\n");
return -1;
}
// printf ("client: program started\n");
client = nested_client_create(400, 300);
while (ret != -1) {
ret = wl_display_dispatch(client->display);
}
nested_client_destroy(client);
// printf ("client: program finished\n");
return 0;
}
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);
}
}
}
}
void* display_dispatch_thread(void* p)
{
int ret = 0;
while (ret != -1) {
ret = wl_display_dispatch(window->p_wl_display);
}
return 0;
}
void QWaylandEventThread::readWaylandEvents()
{
if (wl_display_dispatch(m_display) < 0) {
checkError();
m_readNotifier->setEnabled(false);
emit fatalError();
return;
}
emit newEventsRead();
}
struct client *
client_create(int x, int y, int width, int height)
{
struct client *client;
struct surface *surface;
wl_log_set_handler_client(log_handler);
/* connect to display */
client = xzalloc(sizeof *client);
client->wl_display = wl_display_connect(NULL);
assert(client->wl_display);
wl_list_init(&client->global_list);
/* setup registry so we can bind to interfaces */
client->wl_registry = wl_display_get_registry(client->wl_display);
wl_registry_add_listener(client->wl_registry, ®istry_listener, client);
/* trigger global listener */
wl_display_dispatch(client->wl_display);
wl_display_roundtrip(client->wl_display);
/* must have WL_SHM_FORMAT_ARGB32 */
assert(client->has_argb);
/* must have wl_test interface */
assert(client->test);
/* must have an output */
assert(client->output);
/* initialize the client surface */
surface = xzalloc(sizeof *surface);
surface->wl_surface =
wl_compositor_create_surface(client->wl_compositor);
assert(surface->wl_surface);
wl_surface_add_listener(surface->wl_surface, &surface_listener,
surface);
client->surface = surface;
wl_surface_set_user_data(surface->wl_surface, surface);
surface->width = width;
surface->height = height;
surface->wl_buffer = create_shm_buffer(client, width, height,
&surface->data);
memset(surface->data, 64, width * height * 4);
move_client(client, x, y);
return client;
}
int main(int argc, char **argv) {
init_log(L_INFO);
surfaces = create_list();
registry = registry_poll();
if (argc < 4) {
sway_abort("Do not run this program manually. See man 5 sway and look for output options.");
}
if (!registry->desktop_shell) {
sway_abort("swaybg requires the compositor to support the desktop-shell extension.");
}
int desired_output = atoi(argv[1]);
sway_log(L_INFO, "Using output %d of %d", desired_output, registry->outputs->length);
int i;
struct output_state *output = registry->outputs->items[desired_output];
struct window *window = window_setup(registry, 100, 100, false);
if (!window) {
sway_abort("Failed to create surfaces.");
}
window->width = output->width;
window->height = output->height;
desktop_shell_set_background(registry->desktop_shell, output->output, window->surface);
list_add(surfaces, window);
char *scaling_mode = argv[3];
cairo_surface_t *image = cairo_image_surface_create_from_png(argv[2]);
double width = cairo_image_surface_get_width(image);
double height = cairo_image_surface_get_height(image);
for (i = 0; i < surfaces->length; ++i) {
struct window *window = surfaces->items[i];
if (window_prerender(window) && window->cairo) {
cairo_scale(window->cairo, window->width / width, window->height / height);
cairo_set_source_surface(window->cairo, image, 0, 0);
cairo_paint(window->cairo);
window_render(window);
}
}
while (wl_display_dispatch(registry->display) != -1);
for (i = 0; i < surfaces->length; ++i) {
struct window *window = surfaces->items[i];
window_teardown(window);
}
list_free(surfaces);
registry_teardown(registry);
return 0;
}
int
main(int argc, char **argv)
{
struct touch *touch;
int ret = 0;
touch = touch_create(600, 500);
while (ret != -1)
ret = wl_display_dispatch(touch->display);
return 0;
}
void WaylandCore::waitEvents() {
if( mDisplay == NULL || mRegistry == NULL ) {
mShouldClose = true;
return;
}
int ret = wl_display_dispatch(mDisplay);
if( ret == -1 ) {
mShouldClose = true;
return;
}
return;
}
static void Wayland_MainLoop()
{
// Wait for display to be initialized
while (!GLWin.wl_display)
usleep(20000);
GLWin.running = 1;
while (GLWin.running)
wl_display_dispatch(GLWin.wl_display);
if (GLWin.wl_display)
wl_display_disconnect(GLWin.wl_display);
}
int main(void)
{
struct sigaction sigint;
struct my_display *display;
struct my_window *window;
/* Connect to the display */
printf("Connecting to display\n");
display = create_display();
printf("Connected!\n");
/* Create a window */
printf("Creating a window\n");
window = create_window(display, MIN_WIDTH, MIN_HEIGHT);
if (!window)
return 1;
printf("Window created\n");
/* Set up singal handler. So SIGINT allows us to cleanly die. */
sigint.sa_handler = signal_int;
sigemptyset(&sigint.sa_mask);
sigint.sa_flags = SA_RESETHAND;
sigaction(SIGINT, &sigint, NULL);
printf("Initialising buffers\n");
/* Initialize */
wl_surface_damage(window->surface, 0, 0, window->width, window->height);
/* Draw first screen which allocates buffer(s). */
draw(window, NULL, 0);
printf("Starting loop\n");
/* Main loop */
while (running) {
if (wl_display_dispatch(display->display) == -1) {
running = 0;
}
}
printf("Loop exited\n");
/* Destroy the display */
printf("Destroying window\n");
destroy_window(window); window = NULL;
printf("Disconnecting display\n");
destroy_display(display); display = NULL;
printf("Done\n");
return 0;
}
static struct touch *
touch_create(int width, int height)
{
struct touch *touch;
touch = malloc(sizeof *touch);
if (touch == NULL) {
fprintf(stderr, "out of memory\n");
exit(1);
}
touch->display = wl_display_connect(NULL);
assert(touch->display);
touch->has_argb = 0;
touch->registry = wl_display_get_registry(touch->display);
wl_registry_add_listener(touch->registry, ®istry_listener, touch);
wl_display_dispatch(touch->display);
wl_display_roundtrip(touch->display);
if (!touch->has_argb) {
fprintf(stderr, "WL_SHM_FORMAT_ARGB32 not available\n");
exit(1);
}
touch->width = width;
touch->height = height;
touch->surface = wl_compositor_create_surface(touch->compositor);
touch->shell_surface = wl_shell_get_shell_surface(touch->shell,
touch->surface);
create_shm_buffer(touch);
if (touch->shell_surface) {
wl_shell_surface_add_listener(touch->shell_surface,
&shell_surface_listener, touch);
wl_shell_surface_set_toplevel(touch->shell_surface);
}
wl_surface_set_user_data(touch->surface, touch);
wl_shell_surface_set_title(touch->shell_surface, "simple-touch");
memset(touch->data, 64, width * height * 4);
wl_surface_attach(touch->surface, touch->buffer, 0, 0);
wl_surface_damage(touch->surface, 0, 0, width, height);
wl_surface_commit(touch->surface);
return touch;
}
void
_gdk_wayland_display_queue_events (GdkDisplay *display)
{
GdkWaylandDisplay *display_wayland;
GdkWaylandEventSource *source;
display_wayland = GDK_WAYLAND_DISPLAY (display);
source = (GdkWaylandEventSource *) display_wayland->event_source;
if (source->pfd.revents & G_IO_IN)
{
wl_display_dispatch(display_wayland->wl_display);
source->pfd.revents = 0;
}
if (source->pfd.revents & (G_IO_ERR | G_IO_HUP))
g_error ("Lost connection to wayland compositor");
}
static int
client_main(void)
{
struct client_test client;
client_test_create(&client, "fullscreen", 320, 320);
surface_create(&client);
shell_surface_create(&client);
client_test_roundtrip(&client);
client_test_roundtrip(&client);
struct output *o;
assert((o = chck_iter_pool_get(&client.outputs, 0)));
wl_shell_surface_set_fullscreen(client.view.ssurface, 0, 0, o->output);
wl_surface_commit(client.view.surface);
while (wl_display_dispatch(client.display) != -1);
return client_test_end(&client);
}
int
main(int argc, char **argv)
{
int i, ret = 0, cursor_count = argc - 3;
struct sigaction sigint;
struct cursor_viewer *viewer;
struct cursor_surface **cursors;
if (argc < 4) {
printf("Usage: %s CURSOR_THEME SIZE CURSOR_NAMES...\n", argv[0]);
exit(EXIT_FAILURE);
}
sigint.sa_handler = signal_int;
sigemptyset(&sigint.sa_mask);
sigint.sa_flags = SA_RESETHAND;
sigaction(SIGINT, &sigint, NULL);
viewer = cursor_viewer_create();
viewer->cursor_theme =
wl_cursor_theme_load(argv[1], atoi(argv[2]), viewer->shm);
if (!viewer->cursor_theme)
die("Failed to load default cursor theme\n");
cursors = calloc(1, sizeof (struct cursor_surface *) * cursor_count);
for (i = 3; i < argc; ++i) {
struct cursor_surface *cursor =
cursor_viewer_show_cursor(viewer, argv[i]);
cursors[i - 3] = cursor;
}
while (running && ret != -1)
ret = wl_display_dispatch(viewer->display);
for (i = 0; i < cursor_count; ++i)
cursor_surface_destroy(cursors[i]);
free(cursors);
cursor_viewer_destroy(viewer);
exit(EXIT_SUCCESS);
}
bool
WLContext::InitWLContext(const struct wl_pointer_listener* wlPointerListener,
const struct wl_keyboard_listener* wlKeyboardListener,
const struct wl_touch_listener* wlTouchListener)
{
m_wlPointerListener = const_cast<wl_pointer_listener*>(wlPointerListener);
m_wlKeyboardListener = const_cast<wl_keyboard_listener*>(wlKeyboardListener);
m_wlTouchListener = const_cast<wl_touch_listener*>(wlTouchListener);
m_wlDisplay = wl_display_connect(NULL);
m_wlRegistry = wl_display_get_registry(m_wlDisplay);
wl_registry_add_listener(m_wlRegistry, ®istryListener, this);
wl_display_dispatch(m_wlDisplay);
wl_display_roundtrip(m_wlDisplay);
return true;
}
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;
}
