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;
}
static void
clutter_backend_wayland_load_cursor (ClutterBackendWayland *backend_wayland)
{
struct wl_cursor *cursor;
backend_wayland->cursor_theme =
wl_cursor_theme_load (NULL, /* default */
32,
backend_wayland->wayland_shm);
cursor = wl_cursor_theme_get_cursor (backend_wayland->cursor_theme,
"left_ptr");
backend_wayland->cursor_buffer =
wl_cursor_image_get_buffer (cursor->images[0]);
if (backend_wayland->cursor_buffer)
{
backend_wayland->cursor_x = cursor->images[0]->hotspot_x;
backend_wayland->cursor_y = cursor->images[0]->hotspot_y;
}
backend_wayland->cursor_surface =
wl_compositor_create_surface (backend_wayland->wayland_compositor);
}
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);
}
}
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);
}
void create_surface(struct display *display)
{
EGLBoolean ret;
display->surface = wl_compositor_create_surface(display->compositor);
display->shell_surface = wl_shell_get_shell_surface(display->shell,
display->surface);
wl_shell_surface_add_listener(display->shell_surface,
&shell_surface_listener, display);
display->native = wl_egl_window_create(display->surface, 1, 1);
display->egl_surface =
eglCreateWindowSurface((EGLDisplay) display->egl.dpy, display->egl.conf, (EGLNativeWindowType) display->native, NULL);
wl_shell_surface_set_title(display->shell_surface, "projection");
ret = eglMakeCurrent(display->egl.dpy, display->egl_surface,
display->egl_surface, display->egl.ctx);
assert(ret == EGL_TRUE);
struct wl_callback *callback;
display->configured = 0;
wl_shell_surface_set_fullscreen(display->shell_surface,
WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT, 0, NULL);
callback = wl_display_sync(display->display);
wl_callback_add_listener(callback, &configure_callback_listener, display);
}
bool WaylandEGLContext::attach (GtkWidget *widget)
{
GdkWindow *window = gtk_widget_get_window (widget);
if (!GDK_IS_WAYLAND_WINDOW (window))
return false;
gdk_window = window;
gdk_window_get_geometry (gdk_window, &x, &y, &width, &height);
display = gdk_wayland_display_get_wl_display (gdk_window_get_display (gdk_window));
parent = gdk_wayland_window_get_wl_surface (gdk_window);
registry = wl_display_get_registry (display);
wl_registry_add_listener (registry, &wl_registry_listener, this);
wl_display_roundtrip (display);
if (!compositor || !subcompositor)
return false;
child = wl_compositor_create_surface (compositor);
region = wl_compositor_create_region (compositor);
subsurface = wl_subcompositor_get_subsurface (subcompositor, child, parent);
wl_surface_set_input_region (child, region);
wl_subsurface_set_desync (subsurface);
wl_subsurface_set_position (subsurface, x, y);
return true;
}
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;
}
static GLFWbool createSurface(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig)
{
window->wl.surface = wl_compositor_create_surface(_glfw.wl.compositor);
if (!window->wl.surface)
return GLFW_FALSE;
wl_surface_set_user_data(window->wl.surface, window);
window->wl.native = wl_egl_window_create(window->wl.surface,
wndconfig->width,
wndconfig->height);
if (!window->wl.native)
return GLFW_FALSE;
window->wl.shell_surface = wl_shell_get_shell_surface(_glfw.wl.shell,
window->wl.surface);
if (!window->wl.shell_surface)
return GLFW_FALSE;
wl_shell_surface_add_listener(window->wl.shell_surface,
&shellSurfaceListener,
window);
window->wl.width = wndconfig->width;
window->wl.height = wndconfig->height;
return GLFW_TRUE;
}
TestBase::TestBase()
: wlDisplay(NULL)
, wlRegistry(NULL)
{
wlDisplay = wl_display_connect(NULL);
if (!wlDisplay)
{
throw std::runtime_error("could not connect to wayland display");
}
wlRegistry = wl_display_get_registry(wlDisplay);
static const struct wl_registry_listener registry_listener = {
registry_listener_callback,
NULL
};
wl_registry_add_listener(wlRegistry, ®istry_listener, &wlCompositor);
if (wl_display_roundtrip(wlDisplay) == -1 || wl_display_roundtrip(wlDisplay) == -1)
{
throw std::runtime_error("wl_display error");
}
wlSurfaces.reserve(10);
for (int i = 0; i < wlSurfaces.capacity(); ++i)
{
wlSurfaces.push_back(wl_compositor_create_surface(wlCompositor));
}
}
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 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 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;
}
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;
}
static void
create_surface(struct window *window)
{
struct display *display = window->display;
EGLBoolean ret;
window->surface = wl_compositor_create_surface(display->compositor);
window->shell_surface = wl_shell_get_shell_surface(display->shell,
window->surface);
wl_shell_surface_add_listener(window->shell_surface,
&shell_surface_listener, window);
window->native =
wl_egl_window_create(window->surface,
window->window_size.width,
window->window_size.height);
window->egl_surface =
eglCreateWindowSurface(display->egl.dpy,
display->egl.conf,
window->native, NULL);
wl_shell_surface_set_title(window->shell_surface, "simple-egl");
ret = eglMakeCurrent(window->display->egl.dpy, window->egl_surface,
window->egl_surface, window->display->egl.ctx);
assert(ret == EGL_TRUE);
toggle_fullscreen(window, window->fullscreen);
}
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);
}
static EventdNdSurface *
_eventd_nd_wl_surface_new(EventdNdBackendContext *context, EventdNdNotification *notification, gint width, gint height)
{
EventdNdSurface *self;
self = g_new0(EventdNdSurface, 1);
self->context = context;
self->notification = notification;
self->width = width;
self->height = height;
self->surface = wl_compositor_create_surface(context->compositor);
wl_surface_set_user_data(self->surface, self);
if ( ! _eventd_nd_wl_create_buffer(self) )
{
wl_surface_destroy(self->surface);
g_free(self);
return NULL;
}
self->ww_notification = zww_notification_area_v1_create_notification(context->notification_area, self->surface);
return self;
}
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" );
}
}
struct window *
window_create(struct display *display, const char *title,
int32_t width, int32_t height)
{
struct window *window;
window = malloc(sizeof *window);
if (window == NULL)
return NULL;
memset(window, 0, sizeof *window);
window->display = display;
window->title = strdup(title);
window->surface = wl_compositor_create_surface(display->compositor);
window->allocation.x = 0;
window->allocation.y = 0;
window->allocation.width = width;
window->allocation.height = height;
window->saved_allocation = window->allocation;
window->margin = 16;
window->decoration = 1;
if (display->drm)
window->buffer_type = WINDOW_BUFFER_TYPE_DRM;
else
window->buffer_type = WINDOW_BUFFER_TYPE_SHM;
wl_surface_set_user_data(window->surface, window);
wl_list_insert(display->window_list.prev, &window->link);
return window;
}
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;
}
void hello_set_cursor_from_pool(struct wl_shm_pool *pool,
unsigned width, unsigned height,
int32_t hot_spot_x, int32_t hot_spot_y)
{
struct pointer_data *data;
data = malloc(sizeof(struct pointer_data));
if (data == NULL)
goto error;
data->hot_spot_x = hot_spot_x;
data->hot_spot_y = hot_spot_y;
data->surface = wl_compositor_create_surface(compositor);
if (data->surface == NULL)
goto cleanup_alloc;
data->buffer = hello_create_buffer(pool, width, height);
if (data->buffer == NULL)
goto cleanup_surface;
wl_pointer_set_user_data(pointer, data);
return;
cleanup_surface:
wl_surface_destroy(data->surface);
cleanup_alloc:
free(data);
error:
perror("Unable to allocate cursor");
}
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);
}
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;
}
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 GLFWbool createSurface(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig)
{
window->wl.surface = wl_compositor_create_surface(_glfw.wl.compositor);
if (!window->wl.surface)
return GLFW_FALSE;
wl_surface_add_listener(window->wl.surface,
&surfaceListener,
window);
wl_surface_set_user_data(window->wl.surface, window);
window->wl.native = wl_egl_window_create(window->wl.surface,
wndconfig->width,
wndconfig->height);
if (!window->wl.native)
return GLFW_FALSE;
window->wl.width = wndconfig->width;
window->wl.height = wndconfig->height;
window->wl.scale = 1;
if (!window->wl.transparent)
setOpaqueRegion(window);
return GLFW_TRUE;
}
static void
create_surface(struct window *window)
{
struct display *display = window->display;
EGLBoolean ret;
window->surface = wl_compositor_create_surface(display->compositor);
window->xdg_surface = xdg_shell_get_xdg_surface(display->shell,
window->surface);
xdg_surface_add_listener(window->xdg_surface,
&xdg_surface_listener, window);
window->native =
wl_egl_window_create(window->surface,
window->window_size.width,
window->window_size.height);
window->egl_surface =
eglCreateWindowSurface(display->egl.dpy,
display->egl.conf,
window->native, NULL);
xdg_surface_set_title(window->xdg_surface, "simple-egl");
ret = eglMakeCurrent(window->display->egl.dpy, window->egl_surface,
window->egl_surface, window->display->egl.ctx);
assert(ret == EGL_TRUE);
if (!window->frame_sync)
eglSwapInterval(display->egl.dpy, 0);
xdg_surface_request_change_state(window->xdg_surface,
XDG_SURFACE_STATE_FULLSCREEN,
window->fullscreen, 0);
}
struct window *window_setup(struct registry *registry, uint32_t width, uint32_t height,
int32_t scale, bool shell_surface) {
struct window *window = malloc(sizeof(struct window));
memset(window, 0, sizeof(struct window));
window->width = width;
window->height = height;
window->scale = scale;
window->registry = registry;
window->font = "monospace 10";
window->surface = wl_compositor_create_surface(registry->compositor);
if (shell_surface) {
window_make_shell(window);
}
if (registry->pointer) {
wl_pointer_add_listener(registry->pointer, &pointer_listener, window);
}
get_next_buffer(window);
if (registry->pointer) {
char *cursor_theme = getenv("SWAY_CURSOR_THEME");
if (!cursor_theme) {
cursor_theme = "default";
}
char *cursor_size = getenv("SWAY_CURSOR_SIZE");
if (!cursor_size) {
cursor_size = "16";
}
sway_log(L_DEBUG, "Cursor scale: %d", scale);
window->cursor.cursor_theme = wl_cursor_theme_load(cursor_theme,
atoi(cursor_size) * scale, registry->shm);
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_set_buffer_scale(window->cursor.surface, scale);
wl_surface_damage(window->cursor.surface, 0, 0,
image->width, image->height);
wl_surface_commit(window->cursor.surface);
}
return window;
}
static CoglBool
_cogl_winsys_egl_onscreen_init (CoglOnscreen *onscreen,
EGLConfig egl_config,
CoglError **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;
_cogl_list_init (&wayland_onscreen->frame_callbacks);
if (onscreen->foreign_surface)
wayland_onscreen->wayland_surface = onscreen->foreign_surface;
else
wayland_onscreen->wayland_surface =
wl_compositor_create_surface (wayland_renderer->wayland_compositor);
if (!wayland_onscreen->wayland_surface)
{
_cogl_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_CREATE_ONSCREEN,
"Error while creating wayland surface for CoglOnscreen");
return FALSE;
}
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)
{
_cogl_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);
if (!onscreen->foreign_surface)
wayland_onscreen->wayland_shell_surface =
wl_shell_get_shell_surface (wayland_renderer->wayland_shell,
wayland_onscreen->wayland_surface);
return TRUE;
}
int _glfwPlatformInit(void)
{
_glfw.wl.display = wl_display_connect(NULL);
if (!_glfw.wl.display)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Failed to connect to display");
return GLFW_FALSE;
}
_glfw.wl.registry = wl_display_get_registry(_glfw.wl.display);
wl_registry_add_listener(_glfw.wl.registry, ®istryListener, NULL);
_glfw.wl.monitors = calloc(4, sizeof(_GLFWmonitor*));
_glfw.wl.monitorsSize = 4;
_glfw.wl.xkb.context = xkb_context_new(0);
if (!_glfw.wl.xkb.context)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Failed to initialize xkb context");
return GLFW_FALSE;
}
// Sync so we got all registry objects
wl_display_roundtrip(_glfw.wl.display);
// Sync so we got all initial output events
wl_display_roundtrip(_glfw.wl.display);
if (!_glfwInitContextAPI())
return GLFW_FALSE;
_glfwInitTimer();
_glfwInitJoysticks();
if (_glfw.wl.pointer && _glfw.wl.shm)
{
_glfw.wl.cursorTheme = wl_cursor_theme_load(NULL, 32, _glfw.wl.shm);
if (!_glfw.wl.cursorTheme)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Unable to load default cursor theme\n");
return GLFW_FALSE;
}
_glfw.wl.defaultCursor =
wl_cursor_theme_get_cursor(_glfw.wl.cursorTheme, "left_ptr");
if (!_glfw.wl.defaultCursor)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Unable to load default left pointer\n");
return GLFW_FALSE;
}
_glfw.wl.cursorSurface =
wl_compositor_create_surface(_glfw.wl.compositor);
}
return GLFW_TRUE;
}
static GstWlWindow *
gst_wl_window_new_internal (GstWlDisplay * display, GMutex * render_lock)
{
GstWlWindow *window;
struct wl_region *region;
window = g_object_new (GST_TYPE_WL_WINDOW, NULL);
window->display = g_object_ref (display);
window->render_lock = render_lock;
window->area_surface = wl_compositor_create_surface (display->compositor);
window->video_surface = wl_compositor_create_surface (display->compositor);
window->area_surface_wrapper = wl_proxy_create_wrapper (window->area_surface);
window->video_surface_wrapper =
wl_proxy_create_wrapper (window->video_surface);
wl_proxy_set_queue ((struct wl_proxy *) window->area_surface_wrapper,
display->queue);
wl_proxy_set_queue ((struct wl_proxy *) window->video_surface_wrapper,
display->queue);
/* embed video_surface in area_surface */
window->video_subsurface =
wl_subcompositor_get_subsurface (display->subcompositor,
window->video_surface, window->area_surface);
wl_subsurface_set_desync (window->video_subsurface);
if (display->viewporter) {
window->area_viewport = wp_viewporter_get_viewport (display->viewporter,
window->area_surface);
window->video_viewport = wp_viewporter_get_viewport (display->viewporter,
window->video_surface);
}
/* do not accept input */
region = wl_compositor_create_region (display->compositor);
wl_surface_set_input_region (window->area_surface, region);
wl_region_destroy (region);
region = wl_compositor_create_region (display->compositor);
wl_surface_set_input_region (window->video_surface, region);
wl_region_destroy (region);
return window;
}
static gboolean
_cogl_winsys_egl_context_created (CoglDisplay *display,
GError **error)
{
CoglRenderer *renderer = display->renderer;
CoglRendererEGL *egl_renderer = renderer->winsys;
CoglRendererWayland *wayland_renderer = egl_renderer->platform;
CoglDisplayEGL *egl_display = display->winsys;
CoglDisplayWayland *wayland_display = egl_display->platform;
const char *error_message;
wayland_display->wayland_surface =
wl_compositor_create_surface (wayland_renderer->wayland_compositor);
if (!wayland_display->wayland_surface)
{
error_message= "Failed to create a dummy wayland surface";
goto fail;
}
wayland_display->wayland_egl_native_window =
wl_egl_window_create (wayland_display->wayland_surface,
1,
1);
if (!wayland_display->wayland_egl_native_window)
{
error_message= "Failed to create a dummy wayland native egl surface";
goto fail;
}
egl_display->dummy_surface =
eglCreateWindowSurface (egl_renderer->edpy,
egl_display->egl_config,
(EGLNativeWindowType)
wayland_display->wayland_egl_native_window,
NULL);
if (egl_display->dummy_surface == EGL_NO_SURFACE)
{
error_message= "Unable to eglMakeCurrent with dummy surface";
goto fail;
}
if (!eglMakeCurrent (egl_renderer->edpy,
egl_display->dummy_surface,
egl_display->dummy_surface,
egl_display->egl_context))
{
error_message = "Unable to eglMakeCurrent with dummy surface";
goto fail;
}
return TRUE;
fail:
g_set_error (error, COGL_WINSYS_ERROR,
COGL_WINSYS_ERROR_CREATE_CONTEXT,
"%s", error_message);
return FALSE;
}
