static void
gst_gl_window_wayland_egl_close (GstGLWindow * window)
{
GstGLWindowWaylandEGL *window_egl;
window_egl = GST_GL_WINDOW_WAYLAND_EGL (window);
destroy_surface (window_egl);
if (window_egl->display.cursor_surface)
wl_surface_destroy (window_egl->display.cursor_surface);
if (window_egl->display.cursor_theme)
wl_cursor_theme_destroy (window_egl->display.cursor_theme);
if (window_egl->display.shell)
wl_shell_destroy (window_egl->display.shell);
if (window_egl->display.compositor)
wl_compositor_destroy (window_egl->display.compositor);
if (window_egl->display.display) {
wl_display_flush (window_egl->display.display);
wl_display_disconnect (window_egl->display.display);
}
}
NativeStateWayland::~NativeStateWayland()
{
if (window_) {
if (window_->shell_surface)
wl_shell_surface_destroy(window_->shell_surface);
if (window_->opaque_reqion)
wl_region_destroy(window_->opaque_reqion);
if (window_->surface)
wl_surface_destroy(window_->surface);
if (window_->native)
wl_egl_window_destroy(window_->native);
delete window_;
}
if (display_) {
if (display_->shell)
wl_shell_destroy(display_->shell);
for (OutputsVector::iterator it = display_->outputs.begin();
it != display_->outputs.end(); ++it) {
wl_output_destroy((*it)->output);
delete *it;
}
if (display_->compositor)
wl_compositor_destroy(display_->compositor);
if (display_->registry)
wl_registry_destroy(display_->registry);
if (display_->display) {
wl_display_flush(display_->display);
wl_display_disconnect(display_->display);
}
delete display_;
}
}
static void gfx_ctx_wl_destroy_resources(gfx_ctx_wayland_data_t *wl)
{
if (!wl)
return;
switch (wl_api)
{
case GFX_CTX_OPENGL_API:
case GFX_CTX_OPENGL_ES_API:
case GFX_CTX_OPENVG_API:
#ifdef HAVE_EGL
egl_destroy(&wl->egl);
if (wl->win)
wl_egl_window_destroy(wl->win);
#endif
break;
case GFX_CTX_VULKAN_API:
#ifdef HAVE_VULKAN
vulkan_context_destroy(&wl->vk, wl->surface);
if (wl->fd >= 0)
close(wl->fd);
#endif
break;
case GFX_CTX_NONE:
default:
break;
}
if (wl->shell)
wl_shell_destroy(wl->shell);
if (wl->compositor)
wl_compositor_destroy(wl->compositor);
if (wl->registry)
wl_registry_destroy(wl->registry);
if (wl->shell_surf)
wl_shell_surface_destroy(wl->shell_surf);
if (wl->surface)
wl_surface_destroy(wl->surface);
if (wl->dpy)
{
wl_display_flush(wl->dpy);
wl_display_disconnect(wl->dpy);
}
#ifdef HAVE_EGL
wl->win = NULL;
#endif
wl->shell = NULL;
wl->compositor = NULL;
wl->registry = NULL;
wl->dpy = NULL;
wl->shell_surf = NULL;
wl->surface = NULL;
wl->width = 0;
wl->height = 0;
}
static void
gst_wl_display_finalize (GObject * gobject)
{
GstWlDisplay *self = GST_WL_DISPLAY (gobject);
gst_poll_set_flushing (self->wl_fd_poll, TRUE);
if (self->thread)
g_thread_join (self->thread);
/* to avoid buffers being unregistered from another thread
* at the same time, take their ownership */
g_mutex_lock (&self->buffers_mutex);
self->shutting_down = TRUE;
g_hash_table_foreach (self->buffers, (GHFunc) g_object_ref, NULL);
g_mutex_unlock (&self->buffers_mutex);
g_hash_table_foreach (self->buffers,
(GHFunc) gst_wl_buffer_force_release_and_unref, NULL);
g_hash_table_remove_all (self->buffers);
g_array_unref (self->shm_formats);
g_array_unref (self->dmabuf_formats);
gst_poll_free (self->wl_fd_poll);
g_hash_table_unref (self->buffers);
g_mutex_clear (&self->buffers_mutex);
if (self->viewporter)
wp_viewporter_destroy (self->viewporter);
if (self->shm)
wl_shm_destroy (self->shm);
if (self->dmabuf)
zwp_linux_dmabuf_v1_destroy (self->dmabuf);
if (self->shell)
wl_shell_destroy (self->shell);
if (self->compositor)
wl_compositor_destroy (self->compositor);
if (self->subcompositor)
wl_subcompositor_destroy (self->subcompositor);
if (self->registry)
wl_registry_destroy (self->registry);
if (self->queue)
wl_event_queue_destroy (self->queue);
if (self->own_display) {
wl_display_flush (self->display);
wl_display_disconnect (self->display);
}
G_OBJECT_CLASS (gst_wl_display_parent_class)->finalize (gobject);
}
void hello_cleanup_wayland(void)
{
wl_pointer_destroy(pointer);
wl_seat_destroy(seat);
wl_shell_destroy(shell);
wl_shm_destroy(shm);
wl_compositor_destroy(compositor);
wl_display_disconnect(display);
}
void
Wayland_VideoQuit(_THIS)
{
SDL_VideoData *data = _this->driverdata;
int i;
Wayland_FiniMouse ();
for (i = 0; i < _this->num_displays; ++i) {
SDL_VideoDisplay *display = &_this->displays[i];
wl_output_destroy(display->driverdata);
display->driverdata = NULL;
}
Wayland_display_destroy_input(data);
Wayland_display_destroy_pointer_constraints(data);
Wayland_display_destroy_relative_pointer_manager(data);
if (data->xkb_context) {
WAYLAND_xkb_context_unref(data->xkb_context);
data->xkb_context = NULL;
}
#ifdef SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH
if (data->windowmanager)
qt_windowmanager_destroy(data->windowmanager);
if (data->surface_extension)
qt_surface_extension_destroy(data->surface_extension);
Wayland_touch_destroy(data);
#endif /* SDL_VIDEO_DRIVER_WAYLAND_QT_TOUCH */
if (data->shm)
wl_shm_destroy(data->shm);
if (data->cursor_theme)
WAYLAND_wl_cursor_theme_destroy(data->cursor_theme);
if (data->shell)
wl_shell_destroy(data->shell);
if (data->compositor)
wl_compositor_destroy(data->compositor);
if (data->registry)
wl_registry_destroy(data->registry);
if (data->display) {
WAYLAND_wl_display_flush(data->display);
WAYLAND_wl_display_disconnect(data->display);
}
SDL_free(data->classname);
free(data);
_this->driverdata = NULL;
}
void fgPlatformCloseDisplay ( void )
{
wl_cursor_theme_destroy( fgDisplay.pDisplay.cursor_theme );
wl_shm_destroy( fgDisplay.pDisplay.shm );
wl_seat_destroy( fgDisplay.pDisplay.seat );
wl_shell_destroy( fgDisplay.pDisplay.shell );
wl_compositor_destroy( fgDisplay.pDisplay.compositor );
wl_registry_destroy( fgDisplay.pDisplay.registry );
wl_display_disconnect( fgDisplay.pDisplay.display );
}
int
main(int argc, char **argv)
{
struct sigaction sigint;
struct display display = { 0 };
struct window window = { 0 };
window.display = &display;
window.geometry.width = 250;
window.geometry.height = 250;
display.display = wl_display_connect(NULL);
assert(display.display);
wl_display_add_global_listener(display.display,
display_handle_global, &display);
wl_display_get_fd(display.display, event_mask_update, &display);
wl_display_iterate(display.display, WL_DISPLAY_READABLE);
init_egl(&display);
create_surface(&window);
init_gl(&window);
sigint.sa_handler = signal_int;
sigemptyset(&sigint.sa_mask);
sigint.sa_flags = SA_RESETHAND;
sigaction(SIGINT, &sigint, NULL);
redraw(&window, NULL, 0);
while (running)
wl_display_iterate(display.display, display.mask);
fprintf(stderr, "simple-egl exiting\n");
destroy_surface(&window);
fini_egl(&display);
if (display.shell)
wl_shell_destroy(display.shell);
if (display.compositor)
wl_compositor_destroy(display.compositor);
wl_display_flush(display.display);
wl_display_disconnect(display.display);
return 0;
}
static void
destroy_display (struct display *display)
{
if (display->shm)
wl_shm_destroy (display->shm);
if (display->shell)
wl_shell_destroy (display->shell);
if (display->compositor)
wl_compositor_destroy (display->compositor);
wl_display_flush (display->display);
wl_display_disconnect (display->display);
free (display);
}
static void
cursor_viewer_destroy(struct cursor_viewer *viewer)
{
if (viewer->cursor_theme)
wl_cursor_theme_destroy(viewer->cursor_theme);
if (viewer->shell)
wl_shell_destroy(viewer->shell);
if (viewer->compositor)
wl_compositor_destroy(viewer->compositor);
if (viewer->shm)
wl_shm_destroy(viewer->shm);
if (viewer->registry)
wl_registry_destroy(viewer->registry);
if (viewer->display)
wl_display_disconnect(viewer->display);
free(viewer);
}
/**
* Destroys a Wayland shell surface.
*/
static void Close(vout_window_t *wnd)
{
vout_window_sys_t *sys = wnd->sys;
vlc_cancel(sys->thread);
vlc_join(sys->thread, NULL);
wl_shell_surface_destroy(sys->shell_surface);
wl_surface_destroy(wnd->handle.wl);
wl_shell_destroy(sys->shell);
if (sys->output != NULL)
wl_output_destroy(sys->output);
wl_compositor_destroy(sys->compositor);
wl_display_disconnect(wnd->display.wl);
vlc_mutex_destroy(&sys->lock);
free(sys);
}
void wlf_DestroyDisplay(wlfContext* wlfc, wlfDisplay* display)
{
if (display == NULL)
return;
if (wlfc->display == display)
wlfc->display = NULL;
if (display->seat)
wl_seat_destroy(display->seat);
if (display->shm)
wl_shm_destroy(display->shm);
if (display->shell)
wl_shell_destroy(display->shell);
if (display->compositor)
wl_compositor_destroy(display->compositor);
if (display->registry)
wl_registry_destroy(display->registry);
wl_display_disconnect(display->display);
free(display);
}
static void
gst_wl_display_finalize (GObject * gobject)
{
GstWlDisplay *self = GST_WL_DISPLAY (gobject);
gst_poll_set_flushing (self->wl_fd_poll, TRUE);
if (self->thread)
g_thread_join (self->thread);
g_array_unref (self->formats);
gst_poll_free (self->wl_fd_poll);
if (self->shm)
wl_shm_destroy (self->shm);
if (self->shell)
wl_shell_destroy (self->shell);
if (self->compositor)
wl_compositor_destroy (self->compositor);
if (self->subcompositor)
wl_subcompositor_destroy (self->subcompositor);
if (self->registry)
wl_registry_destroy (self->registry);
if (self->queue)
wl_event_queue_destroy (self->queue);
if (self->own_display) {
wl_display_flush (self->display);
wl_display_disconnect (self->display);
}
G_OBJECT_CLASS (gst_wl_display_parent_class)->finalize (gobject);
}
void _glfwPlatformTerminate(void)
{
_glfwTerminateEGL();
_glfwTerminateJoysticksLinux();
_glfwTerminateThreadLocalStoragePOSIX();
xkb_keymap_unref(_glfw.wl.xkb.keymap);
xkb_state_unref(_glfw.wl.xkb.state);
xkb_context_unref(_glfw.wl.xkb.context);
if (_glfw.wl.cursorTheme)
wl_cursor_theme_destroy(_glfw.wl.cursorTheme);
if (_glfw.wl.cursorSurface)
wl_surface_destroy(_glfw.wl.cursorSurface);
if (_glfw.wl.compositor)
wl_compositor_destroy(_glfw.wl.compositor);
if (_glfw.wl.shm)
wl_shm_destroy(_glfw.wl.shm);
if (_glfw.wl.shell)
wl_shell_destroy(_glfw.wl.shell);
if (_glfw.wl.pointer)
wl_pointer_destroy(_glfw.wl.pointer);
if (_glfw.wl.keyboard)
wl_keyboard_destroy(_glfw.wl.keyboard);
if (_glfw.wl.seat)
wl_seat_destroy(_glfw.wl.seat);
if (_glfw.wl.relativePointerManager)
zwp_relative_pointer_manager_v1_destroy(_glfw.wl.relativePointerManager);
if (_glfw.wl.pointerConstraints)
zwp_pointer_constraints_v1_destroy(_glfw.wl.pointerConstraints);
if (_glfw.wl.registry)
wl_registry_destroy(_glfw.wl.registry);
if (_glfw.wl.display)
{
wl_display_flush(_glfw.wl.display);
wl_display_disconnect(_glfw.wl.display);
}
}
void shutdownWayland() {
if(m_sharedMemory) {
wl_shm_destroy(m_sharedMemory);
}
if(m_shell) {
wl_shell_destroy(m_shell);
}
if(m_compositor) {
wl_compositor_destroy(m_compositor);
}
if(m_registry) {
wl_registry_destroy(m_registry);
}
if(display != nullptr) {
wl_display_disconnect(display);
display = nullptr;
}
}
static void gfx_ctx_wl_destroy_resources(gfx_ctx_wayland_data_t *wl)
{
if (!wl)
return;
egl_destroy(wl);
if (wl->win)
wl_egl_window_destroy(wl->win);
if (wl->shell)
wl_shell_destroy(wl->shell);
if (wl->compositor)
wl_compositor_destroy(wl->compositor);
if (wl->registry)
wl_registry_destroy(wl->registry);
if (wl->shell_surf)
wl_shell_surface_destroy(wl->shell_surf);
if (wl->surface)
wl_surface_destroy(wl->surface);
if (wl->dpy)
{
wl_display_flush(wl->dpy);
wl_display_disconnect(wl->dpy);
}
wl->win = NULL;
wl->shell = NULL;
wl->compositor = NULL;
wl->registry = NULL;
wl->dpy = NULL;
wl->shell_surf = NULL;
wl->surface = NULL;
wl->width = 0;
wl->height = 0;
}
void registry_teardown(struct registry *registry) {
if (registry->pointer) {
wl_pointer_destroy(registry->pointer);
}
if (registry->seat) {
wl_seat_destroy(registry->seat);
}
if (registry->shell) {
wl_shell_destroy(registry->shell);
}
if (registry->shm) {
wl_shm_destroy(registry->shm);
}
if (registry->compositor) {
wl_compositor_destroy(registry->compositor);
}
if (registry->display) {
wl_display_disconnect(registry->display);
}
if (registry->outputs) {
free_flat_list(registry->outputs);
}
free(registry);
}
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;
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("-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.opaque);
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);
while (running && ret != -1)
ret = wl_display_dispatch(display.display);
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)
wl_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;
}
int wlfreerdp_run(freerdp* instance)
{
int i;
int fds;
int max_fds;
int rcount;
int wcount;
void* rfds[32];
void* wfds[32];
fd_set rfds_set;
fd_set wfds_set;
ZeroMemory(rfds, sizeof(rfds));
ZeroMemory(wfds, sizeof(wfds));
freerdp_connect(instance);
while (1)
{
rcount = 0;
wcount = 0;
if (freerdp_get_fds(instance, rfds, &rcount, wfds, &wcount) != TRUE)
{
printf("Failed to get FreeRDP file descriptor");
break;
}
if (freerdp_channels_get_fds(instance->context->channels, instance, rfds, &rcount, wfds, &wcount) != TRUE)
{
printf("Failed to get FreeRDP file descriptor");
break;
}
max_fds = 0;
FD_ZERO(&rfds_set);
FD_ZERO(&wfds_set);
for (i = 0; i < rcount; i++)
{
fds = (int)(long)(rfds[i]);
if (fds > max_fds)
max_fds = fds;
FD_SET(fds, &rfds_set);
}
if (max_fds == 0)
break;
if (select(max_fds + 1, &rfds_set, &wfds_set, NULL, NULL) == -1)
{
if (!((errno == EAGAIN) ||
(errno == EWOULDBLOCK) ||
(errno == EINPROGRESS) ||
(errno == EINTR)))
{
printf("wlfreerdp_run: select failed\n");
break;
}
}
if (freerdp_check_fds(instance) != TRUE)
{
printf("Failed to check FreeRDP file descriptor\n");
break;
}
if (freerdp_channels_check_fds(instance->context->channels, instance) != TRUE)
{
printf("Failed to check channel manager file descriptor\n");
break;
}
}
struct display* display;
struct window* window;
struct wl_context* context;
context = (struct wl_context*) instance->context;
display = context->display;
window = context->window;
free(window->buffers[0].shm_data);
free(window->buffers[1].shm_data);
free(window->data);
wl_buffer_destroy(window->buffers[0].buffer);
wl_buffer_destroy(window->buffers[1].buffer);
wl_shell_surface_destroy(window->shell_surface);
wl_surface_destroy(window->surface);
wl_shm_destroy(display->shm);
wl_shell_destroy(display->shell);
wl_compositor_destroy(display->compositor);
wl_registry_destroy(display->registry);
wl_display_disconnect(display->display);
freerdp_channels_close(instance->context->channels, instance);
freerdp_channels_free(instance->context->channels);
freerdp_free(instance);
return 0;
}
void _glfwPlatformTerminate(void)
{
_glfwTerminateJoysticksLinux();
_glfwTerminateEGL();
if (_glfw.wl.egl.handle)
{
_glfw_dlclose(_glfw.wl.egl.handle);
_glfw.wl.egl.handle = NULL;
}
#ifdef HAVE_XKBCOMMON_COMPOSE_H
if (_glfw.wl.xkb.composeState)
xkb_compose_state_unref(_glfw.wl.xkb.composeState);
#endif
if (_glfw.wl.xkb.keymap)
xkb_keymap_unref(_glfw.wl.xkb.keymap);
if (_glfw.wl.xkb.state)
xkb_state_unref(_glfw.wl.xkb.state);
if (_glfw.wl.xkb.context)
xkb_context_unref(_glfw.wl.xkb.context);
if (_glfw.wl.xkb.handle)
{
_glfw_dlclose(_glfw.wl.xkb.handle);
_glfw.wl.xkb.handle = NULL;
}
if (_glfw.wl.cursorTheme)
wl_cursor_theme_destroy(_glfw.wl.cursorTheme);
if (_glfw.wl.cursor.handle)
{
_glfw_dlclose(_glfw.wl.cursor.handle);
_glfw.wl.cursor.handle = NULL;
}
if (_glfw.wl.cursorSurface)
wl_surface_destroy(_glfw.wl.cursorSurface);
if (_glfw.wl.subcompositor)
wl_subcompositor_destroy(_glfw.wl.subcompositor);
if (_glfw.wl.compositor)
wl_compositor_destroy(_glfw.wl.compositor);
if (_glfw.wl.shm)
wl_shm_destroy(_glfw.wl.shm);
if (_glfw.wl.shell)
wl_shell_destroy(_glfw.wl.shell);
if (_glfw.wl.viewporter)
wp_viewporter_destroy(_glfw.wl.viewporter);
if (_glfw.wl.wmBase)
xdg_wm_base_destroy(_glfw.wl.wmBase);
if (_glfw.wl.pointer)
wl_pointer_destroy(_glfw.wl.pointer);
if (_glfw.wl.keyboard)
wl_keyboard_destroy(_glfw.wl.keyboard);
if (_glfw.wl.seat)
wl_seat_destroy(_glfw.wl.seat);
if (_glfw.wl.relativePointerManager)
zwp_relative_pointer_manager_v1_destroy(_glfw.wl.relativePointerManager);
if (_glfw.wl.pointerConstraints)
zwp_pointer_constraints_v1_destroy(_glfw.wl.pointerConstraints);
if (_glfw.wl.idleInhibitManager)
zwp_idle_inhibit_manager_v1_destroy(_glfw.wl.idleInhibitManager);
if (_glfw.wl.registry)
wl_registry_destroy(_glfw.wl.registry);
if (_glfw.wl.display)
{
wl_display_flush(_glfw.wl.display);
wl_display_disconnect(_glfw.wl.display);
}
}
/**
* Creates a Wayland shell surface.
*/
static int Open(vout_window_t *wnd, const vout_window_cfg_t *cfg)
{
if (cfg->type != VOUT_WINDOW_TYPE_INVALID
&& cfg->type != VOUT_WINDOW_TYPE_WAYLAND)
return VLC_EGENERIC;
vout_window_sys_t *sys = malloc(sizeof (*sys));
if (unlikely(sys == NULL))
return VLC_ENOMEM;
sys->compositor = NULL;
sys->output = NULL;
sys->shell = NULL;
sys->shell_surface = NULL;
sys->top_width = cfg->width;
sys->top_height = cfg->height;
sys->fs_width = cfg->width;
sys->fs_height = cfg->height;
sys->fullscreen = false;
vlc_mutex_init(&sys->lock);
wnd->sys = sys;
/* Connect to the display server */
char *dpy_name = var_InheritString(wnd, "wl-display");
struct wl_display *display = wl_display_connect(dpy_name);
free(dpy_name);
if (display == NULL)
{
vlc_mutex_destroy(&sys->lock);
free(sys);
return VLC_EGENERIC;
}
/* Find the interesting singleton(s) */
struct wl_registry *registry = wl_display_get_registry(display);
if (registry == NULL)
goto error;
wl_registry_add_listener(registry, ®istry_cbs, wnd);
wl_display_roundtrip(display);
wl_registry_destroy(registry);
if (sys->compositor == NULL || sys->shell == NULL)
goto error;
if (sys->output != NULL)
wl_output_add_listener(sys->output, &output_cbs, wnd);
/* Create a surface */
struct wl_surface *surface = wl_compositor_create_surface(sys->compositor);
if (surface == NULL)
goto error;
struct wl_shell_surface *shell_surface =
wl_shell_get_shell_surface(sys->shell, surface);
if (shell_surface == NULL)
goto error;
sys->shell_surface = shell_surface;
wl_shell_surface_add_listener(shell_surface, &shell_surface_cbs, wnd);
wl_shell_surface_set_class(shell_surface, PACKAGE_NAME);
wl_shell_surface_set_toplevel(shell_surface);
char *title = var_InheritString(wnd, "video-title");
wl_shell_surface_set_title(shell_surface, title ? title
: _("VLC media player"));
free(title);
//if (var_InheritBool (wnd, "keyboard-events"))
// do_something();
wl_display_flush(display);
wnd->type = VOUT_WINDOW_TYPE_WAYLAND;
wnd->handle.wl = surface;
wnd->display.wl = display;
wnd->control = Control;
if (vlc_clone (&sys->thread, Thread, wnd, VLC_THREAD_PRIORITY_LOW))
goto error;
vout_window_ReportSize(wnd, cfg->width, cfg->height);
return VLC_SUCCESS;
error:
if (sys->shell_surface != NULL)
wl_shell_surface_destroy(sys->shell_surface);
if (sys->shell != NULL)
wl_shell_destroy(sys->shell);
if (sys->output != NULL)
wl_output_destroy(sys->output);
if (sys->compositor != NULL)
wl_compositor_destroy(sys->compositor);
wl_display_disconnect(display);
vlc_mutex_destroy(&sys->lock);
free(sys);
return VLC_EGENERIC;
}
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("--compile-binary-shader", argv[i]) == 0)
g_CompileBinary = 1;
else if (strcmp("--use-binary-shader", argv[i]) == 0)
g_UseBinary = 1;
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);
while (!window.configured)
wl_display_dispatch(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)
wl_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;
}
/*virtual*/ Shell::~Shell()
{
wl_shell_destroy(*this);
}