static void
set_fullscreen(struct window *window, int fullscreen)
{
struct wl_callback *callback;
window->fullscreen = fullscreen;
window->configured = 0;
if (fullscreen) {
wl_shell_surface_set_fullscreen(window->shell_surface,
WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT,
0, NULL);
callback = wl_display_sync(window->display->display);
wl_callback_add_listener(callback,
&configure_callback_listener,
window);
} else {
wl_shell_surface_set_toplevel(window->shell_surface);
handle_configure(window, window->shell_surface, 0,
window->window_size.width,
window->window_size.height);
window->configured = 1;
}
}
int _glfwPlatformCreateWindow(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig,
const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig)
{
if (!_glfwCreateContext(window, ctxconfig, fbconfig))
return GL_FALSE;
if (!createSurface(window, wndconfig))
return GL_FALSE;
if (wndconfig->monitor)
{
wl_shell_surface_set_fullscreen(
window->wl.shell_surface,
WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT,
0,
wndconfig->monitor->wl.output);
}
else
{
wl_shell_surface_set_toplevel(window->wl.shell_surface);
}
return GL_TRUE;
}
static gboolean
create_surface (GstGLWindowWaylandEGL * window_egl)
{
window_egl->window.surface =
wl_compositor_create_surface (window_egl->display.compositor);
window_egl->window.shell_surface =
wl_shell_get_shell_surface (window_egl->display.shell,
window_egl->window.surface);
wl_shell_surface_add_listener (window_egl->window.shell_surface,
&shell_surface_listener, window_egl);
if (window_egl->window.window_width <= 0)
window_egl->window.window_width = 320;
if (window_egl->window.window_height <= 0)
window_egl->window.window_height = 240;
window_egl->window.native =
wl_egl_window_create (window_egl->window.surface,
window_egl->window.window_width, window_egl->window.window_height);
wl_shell_surface_set_title (window_egl->window.shell_surface,
"OpenGL Renderer");
wl_shell_surface_set_toplevel (window_egl->window.shell_surface);
return TRUE;
}
GstWlWindow *
gst_wl_window_new_toplevel (GstWlDisplay * display, const GstVideoInfo * info)
{
GstWlWindow *window;
gint width;
window = gst_wl_window_new_internal (display);
/* go toplevel */
window->shell_surface = wl_shell_get_shell_surface (display->shell,
window->area_surface);
if (window->shell_surface) {
wl_shell_surface_add_listener (window->shell_surface,
&shell_surface_listener, window);
wl_shell_surface_set_toplevel (window->shell_surface);
} else {
GST_ERROR ("Unable to get wl_shell_surface");
g_object_unref (window);
return NULL;
}
/* set the initial size to be the same as the reported video size */
width =
gst_util_uint64_scale_int_round (info->width, info->par_n, info->par_d);
gst_wl_window_set_render_rectangle (window, 0, 0, width, info->height);
return window;
}
static struct window *
create_window(struct display *display, int width, int height)
{
struct window *window;
window = malloc(sizeof *window);
window->buffer = create_shm_buffer(display,
width, height,
WL_SHM_FORMAT_XRGB8888,
&window->shm_data);
if (!window->buffer) {
free(window);
return NULL;
}
window->callback = NULL;
window->display = display;
window->width = width;
window->height = height;
window->surface = wl_compositor_create_surface(display->compositor);
window->shell_surface = wl_shell_get_shell_surface(display->shell,
window->surface);
if (window->shell_surface)
wl_shell_surface_add_listener(window->shell_surface,
&shell_surface_listener, window);
wl_shell_surface_set_toplevel(window->shell_surface);
return window;
}
static void
create_window (GstWaylandSink * sink, struct display *display, int width,
int height)
{
struct window *window;
if (sink->window)
return;
g_mutex_lock (&sink->wayland_lock);
window = malloc (sizeof *window);
window->display = display;
window->width = width;
window->height = height;
window->redraw_pending = FALSE;
window->surface = wl_compositor_create_surface (display->compositor);
window->shell_surface = wl_shell_get_shell_surface (display->shell,
window->surface);
g_return_if_fail (window->shell_surface);
wl_shell_surface_add_listener (window->shell_surface,
&shell_surface_listener, window);
wl_shell_surface_set_toplevel (window->shell_surface);
wl_shell_surface_set_fullscreen (window->shell_surface,
WL_SHELL_SURFACE_FULLSCREEN_METHOD_SCALE, 0, NULL);
sink->window = window;
g_mutex_unlock (&sink->wayland_lock);
}
void WaylandCore::createWindow( int width, int height, const char* title )
{
if( mDisplay == NULL || mCompositor == NULL ) {
return;
}
mWidth = width;
mHeight = height;
static wl_shell_surface_listener shell_surf_listeners = {
shell_surface_handler_ping,
shell_surface_handler_configure,
shell_surface_handler_popup_done,
};
wl_surface* surface = wl_compositor_create_surface( mCompositor );
wl_shell_surface* shell_surface = wl_shell_get_shell_surface( mShell, surface );
wl_shell_surface_set_toplevel( shell_surface );
wl_shell_surface_set_title( shell_surface, title );
wl_shell_surface_add_listener( shell_surface, &shell_surf_listeners, this );
mShellSurface = shell_surface;
mSurface.surface = surface;
mEglWindow = wl_egl_window_create( surface, mWidth, mHeight );
mSurface.eglSurface = eglCreateWindowSurface( mEglDisplay, mEglConfig, mEglWindow, NULL );
if( !eglMakeCurrent( mEglDisplay, mSurface.eglSurface, mSurface.eglSurface, mEglContext ) ) {
fprintf( stderr, "MakeCurrent failed.\n" );
}
}
GstWlWindow *
gst_wl_window_new_toplevel (GstWlDisplay * display, GstVideoInfo * video_info)
{
GstWlWindow *window;
window = gst_wl_window_new_internal (display,
wl_compositor_create_surface (display->compositor));
gst_wl_window_set_video_info (window, video_info);
gst_wl_window_set_render_rectangle (window, 0, 0, window->video_width,
window->video_height);
window->shell_surface = wl_shell_get_shell_surface (display->shell,
window->surface);
if (window->shell_surface) {
wl_shell_surface_add_listener (window->shell_surface,
&shell_surface_listener, window);
wl_shell_surface_set_toplevel (window->shell_surface);
} else {
GST_ERROR ("Unable to get wl_shell_surface");
g_object_unref (window);
return NULL;
}
return window;
}
static gboolean
gst_mfx_window_wayland_set_fullscreen (GstMfxWindow * window,
gboolean fullscreen)
{
GstMfxWindowWaylandPrivate *const priv =
GST_MFX_WINDOW_WAYLAND_GET_PRIVATE (window);
if (!priv->is_shown) {
priv->fullscreen_on_show = fullscreen;
return TRUE;
}
if (!fullscreen)
wl_shell_surface_set_toplevel (priv->shell_surface);
else {
#ifdef USE_WESTON_4_0
if (priv->wp_viewport)
wp_viewport_set_destination (priv->wp_viewport,
window->width, window->height);
#else
wl_shell_surface_set_fullscreen (priv->shell_surface,
WL_SHELL_SURFACE_FULLSCREEN_METHOD_SCALE, 0, NULL);
#endif
}
return TRUE;
}
int main(int argc, char **argv)
{
get_server_references();
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);
wl_shell_surface_set_toplevel(shell_surface);
// create_opaque_region();
init_egl();
create_window();
init_gl();
while (1) {
draw();
if (eglSwapBuffers(egl_display, egl_surface)) {
fprintf(stderr, "Swapped buffers\n");
} else {
fprintf(stderr, "Swapped buffers failed\n");
}
}
wl_display_disconnect(display);
printf("disconnected from display\n");
exit(0);
}
struct window *window_setup(struct registry *registry, uint32_t width, uint32_t height, bool shell_surface) {
struct window *window = malloc(sizeof(struct window));
memset(window, 0, sizeof(struct window));
window->width = width;
window->height = height;
window->registry = registry;
window->surface = wl_compositor_create_surface(registry->compositor);
if (shell_surface) {
window->shell_surface = wl_shell_get_shell_surface(registry->shell, window->surface);
wl_shell_surface_add_listener(window->shell_surface, &surface_listener, window);
wl_shell_surface_set_toplevel(window->shell_surface);
}
if (registry->pointer) {
wl_pointer_add_listener(registry->pointer, &pointer_listener, window);
}
window->cursor.cursor_theme = wl_cursor_theme_load("default", 32, registry->shm); // TODO: let you customize this
window->cursor.cursor = wl_cursor_theme_get_cursor(window->cursor.cursor_theme, "left_ptr");
window->cursor.surface = wl_compositor_create_surface(registry->compositor);
struct wl_cursor_image *image = window->cursor.cursor->images[0];
struct wl_buffer *cursor_buf = wl_cursor_image_get_buffer(image);
wl_surface_attach(window->cursor.surface, cursor_buf, 0, 0);
wl_surface_damage(window->cursor.surface, 0, 0, image->width, image->height);
wl_surface_commit(window->cursor.surface);
return window;
}
void WaylandWindow::init()
{
// mClient = WaylandClient::getInstance();
// mSurface = AndroidRuntime::getWaylandClient()->surface();//wl_compositor_create_surface(mClient->getCompositor());
mSurface = wl_compositor_create_surface(WaylandClient::getInstance().getCompositor());
// mShellSurface = AndroidRuntime::getWaylandClient()->shellSurface();// wl_shell_get_shell_surface(mClient->getShell(), mSurface);
mShellSurface = wl_shell_get_shell_surface(WaylandClient::getInstance().getShell(), mSurface);
if (mShellSurface) {
wl_shell_surface_add_listener(mShellSurface, &mShellSurfaceListener, this);
wl_shell_surface_set_toplevel(mShellSurface);
} else {
ALOGW("wl_shell_get_shell_surface FAILED \n");
return;
}
wl_surface_set_user_data(mSurface, this);
wl_shell_surface_set_title(mShellSurface, "android");
wl_surface_commit(mSurface);
mNative = wl_egl_window_create(mSurface, mWidth, mHeight);
if (mNative == NULL) {
ALOGW("wl_egl_window_create FAILED \n");
return;
} else {
ALOGW("wl_egl_window_create succeded, resulting in %p \n", mNative);
}
}
static struct window *
create_window(struct display *display, int width, int height)
{
struct window *window;
window = calloc(1, sizeof *window);
if (!window)
return NULL;
window->callback = NULL;
window->display = display;
window->width = width;
window->height = height;
window->surface = wl_compositor_create_surface(display->compositor);
window->shell_surface = wl_shell_get_shell_surface(display->shell,
window->surface);
if (window->shell_surface)
wl_shell_surface_add_listener(window->shell_surface,
&shell_surface_listener, window);
wl_shell_surface_set_title(window->shell_surface, "simple-shm");
wl_shell_surface_set_toplevel(window->shell_surface);
return window;
}
struct wl_shell_surface *hello_create_surface(void)
{
struct wl_surface *surface;
struct wl_shell_surface *shell_surface;
surface = wl_compositor_create_surface(compositor);
if (surface == NULL)
return NULL;
shell_surface = wl_shell_get_shell_surface(shell, surface);
if (shell_surface == NULL) {
wl_surface_destroy(surface);
return NULL;
}
wl_shell_surface_add_listener(shell_surface,
&shell_surface_listener, 0);
wl_shell_surface_set_toplevel(shell_surface);
wl_shell_surface_set_user_data(shell_surface, surface);
wl_surface_set_user_data(surface, NULL);
return shell_surface;
}
static void
_cogl_winsys_onscreen_set_visibility (CoglOnscreen *onscreen,
CoglBool visibility)
{
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenWayland *wayland_onscreen = egl_onscreen->platform;
/* The first time the onscreen is shown we will set it to toplevel
* so that it will appear on the screen. If the surface is foreign
* then we won't have the shell surface and we'll just let the
* application deal with setting the surface type. */
if (visibility &&
wayland_onscreen->wayland_shell_surface &&
!wayland_onscreen->shell_surface_type_set)
{
wl_shell_surface_set_toplevel (wayland_onscreen->wayland_shell_surface);
wayland_onscreen->shell_surface_type_set = TRUE;
_cogl_onscreen_queue_full_dirty (onscreen);
}
/* FIXME: We should also do something here to hide the surface when
* visilibity == FALSE. It sounds like there are currently ongoing
* discussions about adding support for hiding surfaces in the
* Wayland protocol so we might as well wait until then to add that
* here. */
}
wlfWindow* wlf_CreateDesktopWindow(wlfContext* wlfc, char* name, int width, int height, BOOL decorations)
{
wlfWindow* window;
window = (wlfWindow*) calloc(1, sizeof(wlfWindow));
if (window)
{
window->width = width;
window->height = height;
window->fullscreen = FALSE;
window->buffers[0].busy = FALSE;
window->buffers[1].busy = FALSE;
window->callback = NULL;
window->display = wlfc->display;
window->surface = wl_compositor_create_surface(window->display->compositor);
window->shell_surface = wl_shell_get_shell_surface(window->display->shell, window->surface);
wl_shell_surface_add_listener(window->shell_surface, &wl_shell_surface_listener, window);
wl_shell_surface_set_toplevel(window->shell_surface);
wlf_ResizeDesktopWindow(wlfc, window, width, height);
wl_surface_damage(window->surface, 0, 0, window->width, window->height);
}
wlf_SetWindowText(wlfc, window, name);
return window;
}
static GLFWbool createShellSurface(_GLFWwindow* window)
{
window->wl.shellSurface = wl_shell_get_shell_surface(_glfw.wl.shell,
window->wl.surface);
if (!window->wl.shellSurface)
return GLFW_FALSE;
wl_shell_surface_add_listener(window->wl.shellSurface,
&shellSurfaceListener,
window);
if (window->wl.title)
wl_shell_surface_set_title(window->wl.shellSurface, window->wl.title);
if (window->monitor)
{
wl_shell_surface_set_fullscreen(
window->wl.shellSurface,
WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT,
0,
window->monitor->wl.output);
}
else if (window->wl.maximized)
{
wl_shell_surface_set_maximized(window->wl.shellSurface, NULL);
}
else
{
wl_shell_surface_set_toplevel(window->wl.shellSurface);
}
wl_surface_commit(window->wl.surface);
return GLFW_TRUE;
}
static void
SetFullscreen(_THIS, SDL_Window * window, struct wl_output *output)
{
const SDL_VideoData *viddata = (const SDL_VideoData *) _this->driverdata;
SDL_WindowData *wind = window->driverdata;
if (viddata->shell.xdg) {
if (output) {
xdg_toplevel_set_fullscreen(wind->shell_surface.xdg.roleobj.toplevel, output);
} else {
xdg_toplevel_unset_fullscreen(wind->shell_surface.xdg.roleobj.toplevel);
}
} else if (viddata->shell.zxdg) {
if (output) {
zxdg_toplevel_v6_set_fullscreen(wind->shell_surface.zxdg.roleobj.toplevel, output);
} else {
zxdg_toplevel_v6_unset_fullscreen(wind->shell_surface.zxdg.roleobj.toplevel);
}
} else {
if (output) {
wl_shell_surface_set_fullscreen(wind->shell_surface.wl,
WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT,
0, output);
} else {
wl_shell_surface_set_toplevel(wind->shell_surface.wl);
}
}
WAYLAND_wl_display_flush( ((SDL_VideoData*)_this->driverdata)->display );
}
void XdevLWindowWayland::show() {
if(m_fullScreen) {
wl_shell_surface_set_fullscreen(m_shellSurface, WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT, 0, nullptr);
} else {
wl_shell_surface_set_toplevel(m_shellSurface);
}
wl_display_flush(display);
}
void XdevLWindowWayland::setFullscreen(xdl_bool state) {
m_fullScreen = state;
if(state) {
wl_shell_surface_set_fullscreen(m_shellSurface, WL_SHELL_SURFACE_FULLSCREEN_METHOD_SCALE, 0, nullptr);
} else {
wl_shell_surface_set_toplevel(m_shellSurface);
}
wl_display_flush(display);
}
void
Wayland_RestoreWindow(_THIS, SDL_Window * window)
{
SDL_WindowData *wind = window->driverdata;
wl_shell_surface_set_toplevel(wind->shell_surface);
WAYLAND_wl_display_flush( ((SDL_VideoData*)_this->driverdata)->display );
}
static int Control(vout_window_t *wnd, int cmd, va_list ap)
{
vout_window_sys_t *sys = wnd->sys;
struct wl_display *display = wnd->display.wl;
switch (cmd)
{
case VOUT_WINDOW_SET_STATE:
return VLC_EGENERIC;
case VOUT_WINDOW_SET_SIZE:
{
unsigned width = va_arg (ap, unsigned);
unsigned height = va_arg (ap, unsigned);
vlc_mutex_lock(&sys->lock);
sys->top_width = width;
sys->top_height = height;
if (!sys->fullscreen)
vout_window_ReportSize(wnd, width, height);
vlc_mutex_unlock(&sys->lock);
break;
}
case VOUT_WINDOW_SET_FULLSCREEN:
{
bool fs = va_arg(ap, int);
if (fs && sys->output != NULL)
{
wl_shell_surface_set_fullscreen(sys->shell_surface, 1, 0,
sys->output);
vlc_mutex_lock(&sys->lock);
sys->fullscreen = true;
vout_window_ReportSize(wnd, sys->fs_width, sys->fs_height);
vlc_mutex_unlock(&sys->lock);
}
else
{
wl_shell_surface_set_toplevel(sys->shell_surface);
vlc_mutex_lock(&sys->lock);
sys->fullscreen = false;
vout_window_ReportSize(wnd, sys->top_width, sys->top_height);
vlc_mutex_unlock(&sys->lock);
}
break;
}
default:
msg_Err(wnd, "request %d not implemented", cmd);
return VLC_EGENERIC;
}
wl_display_flush(display);
return VLC_SUCCESS;
}
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);
}
static gboolean
_cogl_winsys_egl_onscreen_init (CoglOnscreen *onscreen,
EGLConfig egl_config,
GError **error)
{
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenWayland *wayland_onscreen;
CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
CoglContext *context = framebuffer->context;
CoglRenderer *renderer = context->display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererWayland *wayland_renderer = egl_renderer->platform;
wayland_onscreen = g_slice_new0 (CoglOnscreenWayland);
egl_onscreen->platform = wayland_onscreen;
wayland_onscreen->wayland_surface =
wl_compositor_create_surface (wayland_renderer->wayland_compositor);
if (!wayland_onscreen->wayland_surface)
{
g_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_CREATE_ONSCREEN,
"Error while creating wayland surface for CoglOnscreen");
return FALSE;
}
wayland_onscreen->wayland_shell_surface =
wl_shell_get_shell_surface (wayland_renderer->wayland_shell,
wayland_onscreen->wayland_surface);
wayland_onscreen->wayland_egl_native_window =
wl_egl_window_create (wayland_onscreen->wayland_surface,
cogl_framebuffer_get_width (framebuffer),
cogl_framebuffer_get_height (framebuffer));
if (!wayland_onscreen->wayland_egl_native_window)
{
g_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_CREATE_ONSCREEN,
"Error while creating wayland egl native window "
"for CoglOnscreen");
return FALSE;
}
egl_onscreen->egl_surface =
eglCreateWindowSurface (egl_renderer->edpy,
egl_config,
(EGLNativeWindowType)
wayland_onscreen->wayland_egl_native_window,
NULL);
wl_shell_surface_set_toplevel (wayland_onscreen->wayland_shell_surface);
return TRUE;
}
void
gst_wl_window_ensure_fullscreen (GstWlWindow * window, gboolean fullscreen)
{
if (!window)
return;
if (fullscreen)
wl_shell_surface_set_fullscreen (window->shell_surface,
WL_SHELL_SURFACE_FULLSCREEN_METHOD_SCALE, 0, NULL);
else
wl_shell_surface_set_toplevel (window->shell_surface);
}
static gboolean
gst_vaapi_window_wayland_create (GstVaapiWindow * window,
guint * width, guint * height)
{
GstVaapiWindowWaylandPrivate *const priv =
GST_VAAPI_WINDOW_WAYLAND_GET_PRIVATE (window);
GstVaapiDisplayWaylandPrivate *const priv_display =
GST_VAAPI_DISPLAY_WAYLAND_GET_PRIVATE (GST_VAAPI_OBJECT_DISPLAY (window));
GST_DEBUG ("create window, size %ux%u", *width, *height);
g_return_val_if_fail (priv_display->compositor != NULL, FALSE);
g_return_val_if_fail (priv_display->shell != NULL, FALSE);
GST_VAAPI_OBJECT_LOCK_DISPLAY (window);
priv->event_queue = wl_display_create_queue (priv_display->wl_display);
GST_VAAPI_OBJECT_UNLOCK_DISPLAY (window);
if (!priv->event_queue)
return FALSE;
GST_VAAPI_OBJECT_LOCK_DISPLAY (window);
priv->surface = wl_compositor_create_surface (priv_display->compositor);
GST_VAAPI_OBJECT_UNLOCK_DISPLAY (window);
if (!priv->surface)
return FALSE;
wl_proxy_set_queue ((struct wl_proxy *) priv->surface, priv->event_queue);
GST_VAAPI_OBJECT_LOCK_DISPLAY (window);
priv->shell_surface =
wl_shell_get_shell_surface (priv_display->shell, priv->surface);
GST_VAAPI_OBJECT_UNLOCK_DISPLAY (window);
if (!priv->shell_surface)
return FALSE;
wl_proxy_set_queue ((struct wl_proxy *) priv->shell_surface,
priv->event_queue);
wl_shell_surface_add_listener (priv->shell_surface,
&shell_surface_listener, priv);
wl_shell_surface_set_toplevel (priv->shell_surface);
priv->poll = gst_poll_new (TRUE);
gst_poll_fd_init (&priv->pollfd);
if (priv->fullscreen_on_show)
gst_vaapi_window_wayland_set_fullscreen (window, TRUE);
priv->surface_format = GST_VIDEO_FORMAT_ENCODED;
priv->use_vpp = GST_VAAPI_DISPLAY_HAS_VPP (GST_VAAPI_OBJECT_DISPLAY (window));
priv->is_shown = TRUE;
return TRUE;
}
void InputEventsWestonTest::SetUp()
{
WestonTest::SetUp();
clientLibrary.Load();
eglLibrary.Load();
xkbCommonLibrary.Load();
xkbContext.reset(CXKBKeymap::CreateXKBContext(xkbCommonLibrary),
boost::bind(&IDllXKBCommon::xkb_context_unref,
&xkbCommonLibrary, _1));
keymap.reset(new CXKBKeymap(
xkbCommonLibrary,
CXKBKeymap::CreateXKBKeymapFromNames(xkbCommonLibrary,
xkbContext.get(),
"evdev",
"pc105",
"us",
"",
"")));
display.reset(new xw::Display(clientLibrary));
queue.reset(CreateEventQueue());
registry.reset(new xw::Registry(clientLibrary,
display->GetWlDisplay(),
*this));
loop.reset(new xwe::Loop(listener, *queue));
/* Wait for the seat, shell, compositor to appear */
WaitForSynchronize();
ASSERT_TRUE(input.get() != NULL);
ASSERT_TRUE(compositor.get() != NULL);
ASSERT_TRUE(shell.get() != NULL);
ASSERT_TRUE(xbmcWayland.get() != NULL);
/* Wait for input devices to appear etc */
WaitForSynchronize();
surface.reset(new xw::Surface(clientLibrary,
compositor->CreateSurface()));
shellSurface.reset(new xw::ShellSurface(clientLibrary,
shell->CreateShellSurface(
surface->GetWlSurface())));
openGLSurface.reset(new xw::OpenGLSurface(eglLibrary,
surface->GetWlSurface(),
SurfaceWidth,
SurfaceHeight));
wl_shell_surface_set_toplevel(shellSurface->GetWlShellSurface());
surface->Commit();
}
void Wayland_ShowWindow(_THIS, SDL_Window *window)
{
SDL_WindowData *wind = window->driverdata;
if (window->flags & SDL_WINDOW_FULLSCREEN)
wl_shell_surface_set_fullscreen(wind->shell_surface,
WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT,
0, NULL);
else
wl_shell_surface_set_toplevel(wind->shell_surface);
WAYLAND_wl_display_flush( ((SDL_VideoData*)_this->driverdata)->display );
}
void
Wayland_RestoreWindow(_THIS, SDL_Window * window)
{
SDL_WindowData *wind = window->driverdata;
const SDL_VideoData *viddata = (const SDL_VideoData *) _this->driverdata;
if (viddata->shell.xdg) {
} else if (viddata->shell.zxdg) {
} else {
wl_shell_surface_set_toplevel(wind->shell_surface.wl);
}
WAYLAND_wl_display_flush( ((SDL_VideoData*)_this->driverdata)->display );
}
void
Wayland_SetWindowFullscreen(_THIS, SDL_Window * window,
SDL_VideoDisplay * _display, SDL_bool fullscreen)
{
SDL_WindowData *wind = window->driverdata;
if (fullscreen)
wl_shell_surface_set_fullscreen(wind->shell_surface,
WL_SHELL_SURFACE_FULLSCREEN_METHOD_SCALE,
0, NULL);
else
wl_shell_surface_set_toplevel(wind->shell_surface);
WAYLAND_wl_display_flush( ((SDL_VideoData*)_this->driverdata)->display );
}
