diff --git a/cogl/Makefile.am b/cogl/Makefile.am index 51353e37c..703bedd82 100644 --- a/cogl/Makefile.am +++ b/cogl/Makefile.am @@ -452,14 +452,6 @@ endif if SUPPORT_WAYLAND_EGL_SERVER cogl_experimental_h += cogl-wayland-server.h endif -if SUPPORT_EGL_PLATFORM_WAYLAND -cogl_experimental_h += \ - cogl-wayland-renderer.h \ - cogl-wayland-client.h -cogl_sources_c += \ - winsys/cogl-winsys-egl-wayland.c \ - winsys/cogl-winsys-egl-wayland-private.h -endif if SUPPORT_EGL_PLATFORM_KMS cogl_experimental_h += \ cogl-kms-renderer.h \ diff --git a/cogl/cogl-onscreen-private.h b/cogl/cogl-onscreen-private.h index f982d206e..0a67832ac 100644 --- a/cogl/cogl-onscreen-private.h +++ b/cogl/cogl-onscreen-private.h @@ -65,10 +65,6 @@ struct _CoglOnscreen void *foreign_update_mask_data; #endif -#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT - struct wl_surface *foreign_surface; -#endif - CoglBool swap_throttled; CoglList frame_closures; diff --git a/cogl/cogl-onscreen.h b/cogl/cogl-onscreen.h index 7f9fa16aa..6a55c4c1d 100644 --- a/cogl/cogl-onscreen.h +++ b/cogl/cogl-onscreen.h @@ -166,73 +166,6 @@ uint32_t cogl_x11_onscreen_get_visual_xid (CoglOnscreen *onscreen); #endif /* COGL_HAS_X11 */ -#if defined (COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT) -struct wl_surface * -cogl_wayland_onscreen_get_surface (CoglOnscreen *onscreen); -struct wl_shell_surface * -cogl_wayland_onscreen_get_shell_surface (CoglOnscreen *onscreen); - -/** - * cogl_wayland_onscreen_set_foreign_surface: - * @onscreen: An unallocated framebuffer. - * @surface A Wayland surface to associate with the @onscreen. - * - * Allows you to explicitly notify Cogl of an existing Wayland surface to use, - * which prevents Cogl from allocating a surface and shell surface for the - * @onscreen. An allocated surface will not be destroyed when the @onscreen is - * freed. - * - * This function must be called before @onscreen is allocated. - * - * Since: 1.16 - * Stability: unstable - */ -void -cogl_wayland_onscreen_set_foreign_surface (CoglOnscreen *onscreen, - struct wl_surface *surface); - -/** - * cogl_wayland_onscreen_resize: - * @onscreen: A #CoglOnscreen framebuffer - * @width: The desired width of the framebuffer - * @height: The desired height of the framebuffer - * @offset_x: A relative x offset for the new framebuffer - * @offset_y: A relative y offset for the new framebuffer - * - * Resizes the backbuffer of the given @onscreen framebuffer to the - * given size. Since a buffer is usually conceptually scaled with a - * center point the @offset_x and @offset_y arguments allow the newly - * allocated buffer to be positioned relative to the old buffer size. - * - * For example a buffer that is being resized by moving the bottom right - * corner, and the top left corner is remaining static would use x and y - * offsets of (0, 0) since the top-left of the new buffer should have the same - * position as the old buffer. If the center of the old buffer is being zoomed - * into then all the corners of the new buffer move out from the center and the x - * and y offsets would be (-half_x_size_increase, -half_y_size_increase) where - * x/y_size_increase is how many pixels bigger the buffer is on the x and y - * axis. - * - * Note that if some drawing commands have been applied to the - * framebuffer since the last swap buffers then the resize will be - * queued and will only take effect in the next swap buffers. - * - * If multiple calls to cogl_wayland_onscreen_resize() get queued - * before the next swap buffers request then the relative x and y - * offsets accumulate instead of being replaced. The @width and - * @height values superseed the old values. - * - * Since: 1.10 - * Stability: unstable - */ -void -cogl_wayland_onscreen_resize (CoglOnscreen *onscreen, - int width, - int height, - int offset_x, - int offset_y); -#endif /* COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT */ - /** * cogl_onscreen_set_swap_throttled: * @onscreen: A #CoglOnscreen framebuffer diff --git a/cogl/cogl-renderer-private.h b/cogl/cogl-renderer-private.h index 8e8e336dd..f22696874 100644 --- a/cogl/cogl-renderer-private.h +++ b/cogl/cogl-renderer-private.h @@ -44,11 +44,6 @@ #include #endif -#if defined (COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT) -#include -#endif - - struct _CoglRenderer { CoglObject _parent; @@ -80,11 +75,6 @@ struct _CoglRenderer GModule *libgl_module; #endif -#if defined (COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT) - struct wl_display *foreign_wayland_display; - CoglBool wayland_enable_event_dispatch; -#endif - #if defined (COGL_HAS_EGL_PLATFORM_KMS_SUPPORT) int kms_fd; #endif diff --git a/cogl/cogl-renderer.c b/cogl/cogl-renderer.c index 5bb1eafde..1d3eba53f 100644 --- a/cogl/cogl-renderer.c +++ b/cogl/cogl-renderer.c @@ -54,9 +54,6 @@ #ifdef COGL_HAS_EGL_PLATFORM_XLIB_SUPPORT #include "cogl-winsys-egl-x11-private.h" #endif -#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT -#include "cogl-winsys-egl-wayland-private.h" -#endif #ifdef COGL_HAS_EGL_PLATFORM_KMS_SUPPORT #include "cogl-winsys-egl-kms-private.h" #endif @@ -171,9 +168,6 @@ static CoglWinsysVtableGetter _cogl_winsys_vtable_getters[] = #ifdef COGL_HAS_EGL_PLATFORM_XLIB_SUPPORT _cogl_winsys_egl_xlib_get_vtable, #endif -#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT - _cogl_winsys_egl_wayland_get_vtable, -#endif #ifdef COGL_HAS_EGL_PLATFORM_KMS_SUPPORT _cogl_winsys_egl_kms_get_vtable, #endif @@ -252,10 +246,6 @@ cogl_renderer_new (void) renderer->xlib_enable_event_retrieval = TRUE; #endif -#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT - renderer->wayland_enable_event_dispatch = TRUE; -#endif - #ifdef COGL_HAS_EGL_PLATFORM_KMS_SUPPORT renderer->kms_fd = -1; #endif diff --git a/cogl/cogl-renderer.h b/cogl/cogl-renderer.h index c31664ab3..20c79068c 100644 --- a/cogl/cogl-renderer.h +++ b/cogl/cogl-renderer.h @@ -161,7 +161,6 @@ cogl_renderer_new (void); * @COGL_WINSYS_ID_STUB: Use the no-op stub backend * @COGL_WINSYS_ID_GLX: Use the GLX window system binding API * @COGL_WINSYS_ID_EGL_XLIB: Use EGL with the X window system via XLib - * @COGL_WINSYS_ID_EGL_WAYLAND: Use EGL with the Wayland window system * @COGL_WINSYS_ID_EGL_KMS: Use EGL with the KMS platform * * Identifies specific window system backends that Cogl supports. @@ -175,7 +174,6 @@ typedef enum COGL_WINSYS_ID_STUB, COGL_WINSYS_ID_GLX, COGL_WINSYS_ID_EGL_XLIB, - COGL_WINSYS_ID_EGL_WAYLAND, COGL_WINSYS_ID_EGL_KMS, } CoglWinsysID; diff --git a/cogl/cogl-wayland-client.h b/cogl/cogl-wayland-client.h deleted file mode 100644 index bac3f709a..000000000 --- a/cogl/cogl-wayland-client.h +++ /dev/null @@ -1,64 +0,0 @@ -/* - * Cogl - * - * A Low Level GPU Graphics and Utilities API - * - * Copyright (C) 2012 Intel Corporation. - * - * Permission is hereby granted, free of charge, to any person - * obtaining a copy of this software and associated documentation - * files (the "Software"), to deal in the Software without - * restriction, including without limitation the rights to use, copy, - * modify, merge, publish, distribute, sublicense, and/or sell copies - * of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be - * included in all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS - * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN - * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN - * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - * - */ - -#ifndef __COGL_WAYLAND_CLIENT_H -#define __COGL_WAYLAND_CLIENT_H - -/* NB: this is a top-level header that can be included directly but we - * want to be careful not to define __COGL_H_INSIDE__ when this is - * included internally while building Cogl itself since - * __COGL_H_INSIDE__ is used in headers to guard public vs private api - * definitions - */ -#ifndef COGL_COMPILATION - -/* Note: When building Cogl .gir we explicitly define - * __COGL_H_INSIDE__ */ -#ifndef __COGL_H_INSIDE__ -#define __COGL_H_INSIDE__ -#define __COGL_MUST_UNDEF_COGL_H_INSIDE__ -#endif -#endif /* COGL_COMPILATION */ - -#include - -/* The gobject introspection scanner seems to parse public headers in - * isolation which means we need to be extra careful about how we - * define and undefine __COGL_H_INSIDE__ used to detect when internal - * headers are incorrectly included by developers. In the gobject - * introspection case we have to manually define __COGL_H_INSIDE__ as - * a commandline argument for the scanner which means we must be - * careful not to undefine it in a header... - */ -#ifdef __COGL_MUST_UNDEF_COGL_H_INSIDE__ -#undef __COGL_H_INSIDE__ -#undef __COGL_MUST_UNDEF_COGL_H_INSIDE__ -#endif - -#endif /* __COGL_WAYLAND_CLIENT_H */ diff --git a/cogl/cogl-wayland-renderer.h b/cogl/cogl-wayland-renderer.h deleted file mode 100644 index ea0a20b47..000000000 --- a/cogl/cogl-wayland-renderer.h +++ /dev/null @@ -1,105 +0,0 @@ -/* - * Cogl - * - * A Low Level GPU Graphics and Utilities API - * - * Copyright (C) 2011 Intel Corporation. - * - * Permission is hereby granted, free of charge, to any person - * obtaining a copy of this software and associated documentation - * files (the "Software"), to deal in the Software without - * restriction, including without limitation the rights to use, copy, - * modify, merge, publish, distribute, sublicense, and/or sell copies - * of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be - * included in all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS - * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN - * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN - * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - */ - -#if !defined(__COGL_H_INSIDE__) && !defined(COGL_COMPILATION) -#error "Only can be included directly." -#endif - -#ifndef __COGL_WAYLAND_RENDERER_H__ -#define __COGL_WAYLAND_RENDERER_H__ - -#include -#include - -#include - -COGL_BEGIN_DECLS - -/** - * cogl_wayland_renderer_set_foreign_display: - * @renderer: A #CoglRenderer - * @display: A Wayland display - * - * Allows you to explicitly control what Wayland display you want Cogl - * to work with instead of leaving Cogl to automatically connect to a - * wayland compositor. - * - * Since: 1.8 - * Stability: unstable - */ -void -cogl_wayland_renderer_set_foreign_display (CoglRenderer *renderer, - struct wl_display *display); - -/** - * cogl_wayland_renderer_set_event_dispatch_enabled: - * @renderer: A #CoglRenderer - * @enable: The new value - * - * Sets whether Cogl should handle calling wl_display_dispatch() and - * wl_display_flush() as part of its main loop integration via - * cogl_poll_renderer_get_info() and cogl_poll_renderer_dispatch(). - * The default value is %TRUE. When it is enabled the application can - * register listeners for Wayland interfaces and the callbacks will be - * invoked during cogl_poll_renderer_dispatch(). If the application - * wants to integrate with its own code that is already handling - * reading from the Wayland display socket, it should disable this to - * avoid having competing code read from the socket. - * - * Since: 1.16 - * Stability: unstable - */ -void -cogl_wayland_renderer_set_event_dispatch_enabled (CoglRenderer *renderer, - CoglBool enable); - -/** - * cogl_wayland_renderer_get_display: - * @renderer: A #CoglRenderer - * - * Retrieves the Wayland display that Cogl is using. If a foreign - * display has been specified using - * cogl_wayland_renderer_set_foreign_display() then that display will - * be returned. If no foreign display has been specified then the - * display that Cogl creates internally will be returned unless the - * renderer has not yet been connected (either implicitly or explicitly by - * calling cogl_renderer_connect()) in which case %NULL is returned. - * - * Returns: The wayland display currently associated with @renderer, - * or %NULL if the renderer hasn't yet been connected and no - * foreign display has been specified. - * - * Since: 1.8 - * Stability: unstable - */ -struct wl_display * -cogl_wayland_renderer_get_display (CoglRenderer *renderer); - -COGL_END_DECLS - -#endif /* __COGL_WAYLAND_RENDERER_H__ */ diff --git a/cogl/cogl.symbols b/cogl/cogl.symbols index 1926dee60..ad4240777 100644 --- a/cogl/cogl.symbols +++ b/cogl/cogl.symbols @@ -1023,18 +1023,7 @@ cogl_winsys_feature_get_type #ifdef COGL_HAS_WAYLAND_EGL_SERVER_SUPPORT cogl_wayland_display_set_compositor_display -#endif -#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT -cogl_wayland_onscreen_get_shell_surface -cogl_wayland_onscreen_get_surface -#endif -#ifdef COGL_HAS_WAYLAND_EGL_SERVER_SUPPORT cogl_wayland_onscreen_resize -#endif -#ifdef COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT -cogl_wayland_onscreen_set_foreign_surface -#endif -#ifdef COGL_HAS_WAYLAND_EGL_SERVER_SUPPORT cogl_wayland_renderer_get_display cogl_wayland_renderer_set_event_dispatch_enabled cogl_wayland_renderer_set_foreign_display diff --git a/cogl/winsys/cogl-winsys-egl-wayland-private.h b/cogl/winsys/cogl-winsys-egl-wayland-private.h deleted file mode 100644 index 55012c80a..000000000 --- a/cogl/winsys/cogl-winsys-egl-wayland-private.h +++ /dev/null @@ -1,39 +0,0 @@ -/* - * Cogl - * - * A Low Level GPU Graphics and Utilities API - * - * Copyright (C) 2011 Intel Corporation. - * - * Permission is hereby granted, free of charge, to any person - * obtaining a copy of this software and associated documentation - * files (the "Software"), to deal in the Software without - * restriction, including without limitation the rights to use, copy, - * modify, merge, publish, distribute, sublicense, and/or sell copies - * of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be - * included in all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS - * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN - * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN - * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - * - * - */ - -#ifndef __COGL_WINSYS_EGL_WAYLAND_PRIVATE_H -#define __COGL_WINSYS_EGL_WAYLAND_PRIVATE_H - -#include "cogl-winsys-private.h" - -const CoglWinsysVtable * -_cogl_winsys_egl_wayland_get_vtable (void); - -#endif /* __COGL_WINSYS_EGL_WAYLAND_PRIVATE_H */ diff --git a/cogl/winsys/cogl-winsys-egl-wayland.c b/cogl/winsys/cogl-winsys-egl-wayland.c deleted file mode 100644 index 2e220528e..000000000 --- a/cogl/winsys/cogl-winsys-egl-wayland.c +++ /dev/null @@ -1,853 +0,0 @@ -/* - * Cogl - * - * A Low Level GPU Graphics and Utilities API - * - * Copyright (C) 2011 Intel Corporation. - * - * Permission is hereby granted, free of charge, to any person - * obtaining a copy of this software and associated documentation - * files (the "Software"), to deal in the Software without - * restriction, including without limitation the rights to use, copy, - * modify, merge, publish, distribute, sublicense, and/or sell copies - * of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be - * included in all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS - * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN - * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN - * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - * - * - * Authors: - * Robert Bragg - * Neil Roberts - */ - -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -#include -#include -#include -#include - -#include "cogl-winsys-egl-wayland-private.h" -#include "cogl-winsys-egl-private.h" -#include "cogl-renderer-private.h" -#include "cogl-onscreen-private.h" -#include "cogl-wayland-renderer.h" -#include "cogl-error-private.h" -#include "cogl-poll-private.h" -#include "cogl-frame-info-private.h" - -static const CoglWinsysEGLVtable _cogl_winsys_egl_vtable; - -static const CoglWinsysVtable *parent_vtable; - -typedef struct _CoglRendererWayland -{ - struct wl_display *wayland_display; - struct wl_compositor *wayland_compositor; - struct wl_shell *wayland_shell; - struct wl_registry *wayland_registry; - int fd; -} CoglRendererWayland; - -typedef struct _CoglDisplayWayland -{ - struct wl_surface *dummy_wayland_surface; - struct wl_egl_window *dummy_wayland_egl_native_window; -} CoglDisplayWayland; - -typedef struct _CoglOnscreenWayland -{ - struct wl_egl_window *wayland_egl_native_window; - struct wl_surface *wayland_surface; - struct wl_shell_surface *wayland_shell_surface; - - /* Resizing a wayland framebuffer doesn't take affect - * until the next swap buffers request, so we have to - * track the resize geometry until then... */ - int pending_width; - int pending_height; - int pending_dx; - int pending_dy; - CoglBool has_pending; - - CoglBool shell_surface_type_set; - - CoglList frame_callbacks; -} CoglOnscreenWayland; - -typedef struct -{ - CoglList link; - CoglFrameInfo *frame_info; - struct wl_callback *callback; - CoglOnscreen *onscreen; -} FrameCallbackData; - -static void -registry_handle_global_cb (void *data, - struct wl_registry *registry, - uint32_t id, - const char *interface, - uint32_t version) -{ - CoglRendererEGL *egl_renderer = (CoglRendererEGL *)data; - CoglRendererWayland *wayland_renderer = egl_renderer->platform; - - if (strcmp (interface, "wl_compositor") == 0) - wayland_renderer->wayland_compositor = - wl_registry_bind (registry, id, &wl_compositor_interface, 1); - else if (strcmp(interface, "wl_shell") == 0) - wayland_renderer->wayland_shell = - wl_registry_bind (registry, id, &wl_shell_interface, 1); -} - -static void -registry_handle_global_remove_cb (void *data, - struct wl_registry *registry, - uint32_t name) -{ - /* Nothing to do for now */ -} - -static void -_cogl_winsys_renderer_disconnect (CoglRenderer *renderer) -{ - CoglRendererEGL *egl_renderer = renderer->winsys; - CoglRendererWayland *wayland_renderer = egl_renderer->platform; - - if (egl_renderer->edpy) - eglTerminate (egl_renderer->edpy); - - if (wayland_renderer->wayland_display) - { - _cogl_poll_renderer_remove_fd (renderer, wayland_renderer->fd); - - if (renderer->foreign_wayland_display == NULL) - wl_display_disconnect (wayland_renderer->wayland_display); - } - - g_slice_free (CoglRendererWayland, egl_renderer->platform); - g_slice_free (CoglRendererEGL, egl_renderer); -} - -static const struct wl_registry_listener registry_listener = { - registry_handle_global_cb, - registry_handle_global_remove_cb -}; - -static int64_t -prepare_wayland_display_events (void *user_data) -{ - CoglRenderer *renderer = user_data; - CoglRendererEGL *egl_renderer = renderer->winsys; - CoglRendererWayland *wayland_renderer = egl_renderer->platform; - int flush_ret; - - flush_ret = wl_display_flush (wayland_renderer->wayland_display); - - if (flush_ret == -1) - { - /* If the socket buffer became full then we need to wake up the - * main loop once it is writable again */ - if (errno == EAGAIN) - { - _cogl_poll_renderer_modify_fd (renderer, - wayland_renderer->fd, - COGL_POLL_FD_EVENT_IN | - COGL_POLL_FD_EVENT_OUT); - } - else if (errno != EINTR) - { - /* If the flush failed for some other reason then it's - * likely that it's going to consistently fail so we'll stop - * waiting on the file descriptor instead of making the - * application take up 100% CPU. FIXME: it would be nice if - * there was some way to report this to the application so - * that it can quit or recover */ - _cogl_poll_renderer_remove_fd (renderer, wayland_renderer->fd); - } - } - - /* Calling this here is a bit dodgy because Cogl usually tries to - * say that it won't do any event processing until - * cogl_poll_renderer_dispatch is called. However Wayland doesn't - * seem to provide any way to query whether the event queue is empty - * and we would need to do that in order to force the main loop to - * wake up to call it from dispatch. */ - wl_display_dispatch_pending (wayland_renderer->wayland_display); - - return -1; -} - -static void -dispatch_wayland_display_events (void *user_data, int revents) -{ - CoglRenderer *renderer = user_data; - CoglRendererEGL *egl_renderer = renderer->winsys; - CoglRendererWayland *wayland_renderer = egl_renderer->platform; - - if ((revents & COGL_POLL_FD_EVENT_IN)) - { - if (wl_display_dispatch (wayland_renderer->wayland_display) == -1 && - errno != EAGAIN && - errno != EINTR) - goto socket_error; - } - - if ((revents & COGL_POLL_FD_EVENT_OUT)) - { - int ret = wl_display_flush (wayland_renderer->wayland_display); - - if (ret == -1) - { - if (errno != EAGAIN && errno != EINTR) - goto socket_error; - } - else - { - /* There is no more data to write so we don't need to wake - * up when the write buffer is emptied anymore */ - _cogl_poll_renderer_modify_fd (renderer, - wayland_renderer->fd, - COGL_POLL_FD_EVENT_IN); - } - } - - return; - - socket_error: - /* If there was an error on the wayland socket then it's likely that - * it's going to consistently fail so we'll stop waiting on the file - * descriptor instead of making the application take up 100% CPU. - * FIXME: it would be nice if there was some way to report this to - * the application so that it can quit or recover */ - _cogl_poll_renderer_remove_fd (renderer, wayland_renderer->fd); -} - -static CoglBool -_cogl_winsys_renderer_connect (CoglRenderer *renderer, - CoglError **error) -{ - CoglRendererEGL *egl_renderer; - CoglRendererWayland *wayland_renderer; - - renderer->winsys = g_slice_new0 (CoglRendererEGL); - egl_renderer = renderer->winsys; - wayland_renderer = g_slice_new0 (CoglRendererWayland); - egl_renderer->platform = wayland_renderer; - - egl_renderer->platform_vtable = &_cogl_winsys_egl_vtable; - - if (renderer->foreign_wayland_display) - { - wayland_renderer->wayland_display = renderer->foreign_wayland_display; - } - else - { - wayland_renderer->wayland_display = wl_display_connect (NULL); - if (!wayland_renderer->wayland_display) - { - _cogl_set_error (error, COGL_WINSYS_ERROR, - COGL_WINSYS_ERROR_INIT, - "Failed to connect wayland display"); - goto error; - } - } - - wayland_renderer->wayland_registry = - wl_display_get_registry (wayland_renderer->wayland_display); - - wl_registry_add_listener (wayland_renderer->wayland_registry, - ®istry_listener, - egl_renderer); - - /* - * Ensure that that we've received the messages setting up the - * compostor and shell object. - */ - wl_display_roundtrip (wayland_renderer->wayland_display); - if (!wayland_renderer->wayland_compositor || !wayland_renderer->wayland_shell) - { - _cogl_set_error (error, - COGL_WINSYS_ERROR, - COGL_WINSYS_ERROR_INIT, - "Unable to find wl_compositor or wl_shell"); - goto error; - } - - egl_renderer->edpy = - eglGetDisplay ((EGLNativeDisplayType) wayland_renderer->wayland_display); - - if (!_cogl_winsys_egl_renderer_connect_common (renderer, error)) - goto error; - - wayland_renderer->fd = wl_display_get_fd (wayland_renderer->wayland_display); - - if (renderer->wayland_enable_event_dispatch) - _cogl_poll_renderer_add_fd (renderer, - wayland_renderer->fd, - COGL_POLL_FD_EVENT_IN, - prepare_wayland_display_events, - dispatch_wayland_display_events, - renderer); - - return TRUE; - -error: - _cogl_winsys_renderer_disconnect (renderer); - return FALSE; -} - -static CoglBool -_cogl_winsys_egl_display_setup (CoglDisplay *display, - CoglError **error) -{ - CoglDisplayEGL *egl_display = display->winsys; - CoglDisplayWayland *wayland_display; - - wayland_display = g_slice_new0 (CoglDisplayWayland); - egl_display->platform = wayland_display; - - return TRUE; -} - -static void -_cogl_winsys_egl_display_destroy (CoglDisplay *display) -{ - CoglDisplayEGL *egl_display = display->winsys; - - g_slice_free (CoglDisplayWayland, egl_display->platform); -} - -static CoglBool -make_dummy_surface (CoglDisplay *display, - CoglError **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->dummy_wayland_surface = - wl_compositor_create_surface (wayland_renderer->wayland_compositor); - if (!wayland_display->dummy_wayland_surface) - { - error_message= "Failed to create a dummy wayland surface"; - goto fail; - } - - wayland_display->dummy_wayland_egl_native_window = - wl_egl_window_create (wayland_display->dummy_wayland_surface, - 1, - 1); - if (!wayland_display->dummy_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->dummy_wayland_egl_native_window, - NULL); - if (egl_display->dummy_surface == EGL_NO_SURFACE) - { - error_message= "Unable to create dummy window surface"; - goto fail; - } - - return TRUE; - - fail: - _cogl_set_error (error, COGL_WINSYS_ERROR, - COGL_WINSYS_ERROR_CREATE_CONTEXT, - "%s", error_message); - - return FALSE; -} - -static CoglBool -_cogl_winsys_egl_context_created (CoglDisplay *display, - CoglError **error) -{ - CoglRenderer *renderer = display->renderer; - CoglRendererEGL *egl_renderer = renderer->winsys; - CoglDisplayEGL *egl_display = display->winsys; - - if ((egl_renderer->private_features & - COGL_EGL_WINSYS_FEATURE_SURFACELESS_CONTEXT) == 0 && - !make_dummy_surface(display, error)) - return FALSE; - - if (!_cogl_winsys_egl_make_current (display, - egl_display->dummy_surface, - egl_display->dummy_surface, - egl_display->egl_context)) - { - _cogl_set_error (error, - COGL_WINSYS_ERROR, - COGL_WINSYS_ERROR_CREATE_CONTEXT, - "%s", - "Unable to eglMakeCurrent with dummy surface"); - } - - return TRUE; -} - -static void -_cogl_winsys_egl_cleanup_context (CoglDisplay *display) -{ - CoglRenderer *renderer = display->renderer; - CoglRendererEGL *egl_renderer = renderer->winsys; - CoglDisplayEGL *egl_display = display->winsys; - CoglDisplayWayland *wayland_display = egl_display->platform; - - if (egl_display->dummy_surface != EGL_NO_SURFACE) - { - eglDestroySurface (egl_renderer->edpy, egl_display->dummy_surface); - egl_display->dummy_surface = EGL_NO_SURFACE; - } - - if (wayland_display->dummy_wayland_egl_native_window) - { - wl_egl_window_destroy (wayland_display->dummy_wayland_egl_native_window); - wayland_display->dummy_wayland_egl_native_window = NULL; - } - - if (wayland_display->dummy_wayland_surface) - { - wl_surface_destroy (wayland_display->dummy_wayland_surface); - wayland_display->dummy_wayland_surface = NULL; - } -} - -static CoglBool -_cogl_winsys_egl_context_init (CoglContext *context, - CoglError **error) -{ - context->feature_flags |= COGL_FEATURE_ONSCREEN_MULTIPLE; - COGL_FLAGS_SET (context->features, - COGL_FEATURE_ID_ONSCREEN_MULTIPLE, TRUE); - COGL_FLAGS_SET (context->winsys_features, - COGL_WINSYS_FEATURE_MULTIPLE_ONSCREEN, - TRUE); - COGL_FLAGS_SET (context->winsys_features, - COGL_WINSYS_FEATURE_SYNC_AND_COMPLETE_EVENT, - TRUE); - - /* We'll manually handle queueing dirty events when the surface is - * first shown or when it is resized. Note that this is slightly - * different from the emulated behaviour that CoglFramebuffer would - * provide if we didn't set this flag because we want to emit the - * event on show instead of on allocation. The Wayland protocol - * delays setting the surface type until the next buffer is attached - * so attaching a buffer before setting the type would not cause - * anything to be displayed */ - COGL_FLAGS_SET (context->private_features, - COGL_PRIVATE_FEATURE_DIRTY_EVENTS, - TRUE); - - return TRUE; -} - -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; -} - -static void -free_frame_callback_data (FrameCallbackData *callback_data) -{ - cogl_object_unref (callback_data->frame_info); - wl_callback_destroy (callback_data->callback); - _cogl_list_remove (&callback_data->link); - g_slice_free (FrameCallbackData, callback_data); -} - -static void -_cogl_winsys_egl_onscreen_deinit (CoglOnscreen *onscreen) -{ - CoglOnscreenEGL *egl_onscreen = onscreen->winsys; - CoglOnscreenWayland *wayland_onscreen = egl_onscreen->platform; - FrameCallbackData *frame_callback_data, *tmp; - - _cogl_list_for_each_safe (frame_callback_data, - tmp, - &wayland_onscreen->frame_callbacks, - link) - free_frame_callback_data (frame_callback_data); - - if (wayland_onscreen->wayland_egl_native_window) - { - wl_egl_window_destroy (wayland_onscreen->wayland_egl_native_window); - wayland_onscreen->wayland_egl_native_window = NULL; - } - - if (!onscreen->foreign_surface) - { - /* NB: The wayland protocol docs explicitly state that - * "wl_shell_surface_destroy() must be called before destroying - * the wl_surface object." ... */ - if (wayland_onscreen->wayland_shell_surface) - { - wl_shell_surface_destroy (wayland_onscreen->wayland_shell_surface); - wayland_onscreen->wayland_shell_surface = NULL; - } - - if (wayland_onscreen->wayland_surface) - { - wl_surface_destroy (wayland_onscreen->wayland_surface); - wayland_onscreen->wayland_surface = NULL; - } - } - - g_slice_free (CoglOnscreenWayland, wayland_onscreen); -} - -static void -flush_pending_resize (CoglOnscreen *onscreen) -{ - CoglOnscreenEGL *egl_onscreen = onscreen->winsys; - CoglOnscreenWayland *wayland_onscreen = egl_onscreen->platform; - - if (wayland_onscreen->has_pending) - { - wl_egl_window_resize (wayland_onscreen->wayland_egl_native_window, - wayland_onscreen->pending_width, - wayland_onscreen->pending_height, - wayland_onscreen->pending_dx, - wayland_onscreen->pending_dy); - - _cogl_framebuffer_winsys_update_size (COGL_FRAMEBUFFER (onscreen), - wayland_onscreen->pending_width, - wayland_onscreen->pending_height); - - _cogl_onscreen_queue_full_dirty (onscreen); - - wayland_onscreen->pending_dx = 0; - wayland_onscreen->pending_dy = 0; - wayland_onscreen->has_pending = FALSE; - } -} - -static void -frame_cb (void *data, - struct wl_callback *callback, - uint32_t time) -{ - FrameCallbackData *callback_data = data; - CoglFrameInfo *info = callback_data->frame_info; - CoglOnscreen *onscreen = callback_data->onscreen; - - g_assert (callback_data->callback == callback); - - _cogl_onscreen_queue_event (onscreen, COGL_FRAME_EVENT_SYNC, info); - _cogl_onscreen_queue_event (onscreen, COGL_FRAME_EVENT_COMPLETE, info); - - free_frame_callback_data (callback_data); -} - -static const struct wl_callback_listener -frame_listener = -{ - frame_cb -}; - -static void -_cogl_winsys_onscreen_swap_buffers_with_damage (CoglOnscreen *onscreen, - const int *rectangles, - int n_rectangles) -{ - CoglOnscreenEGL *egl_onscreen = onscreen->winsys; - CoglOnscreenWayland *wayland_onscreen = egl_onscreen->platform; - FrameCallbackData *frame_callback_data = g_slice_new (FrameCallbackData); - - flush_pending_resize (onscreen); - - /* Before calling the winsys function, - * cogl_onscreen_swap_buffers_with_damage() will have pushed the - * frame info object onto the end of the pending frames. We can grab - * it out of the queue now because we don't care about the order and - * we will just directly queue the event corresponding to the exact - * frame that Wayland reports as completed. This will steal the - * reference */ - frame_callback_data->frame_info = - g_queue_pop_tail (&onscreen->pending_frame_infos); - frame_callback_data->onscreen = onscreen; - - frame_callback_data->callback = - wl_surface_frame (wayland_onscreen->wayland_surface); - wl_callback_add_listener (frame_callback_data->callback, - &frame_listener, - frame_callback_data); - - _cogl_list_insert (&wayland_onscreen->frame_callbacks, - &frame_callback_data->link); - - parent_vtable->onscreen_swap_buffers_with_damage (onscreen, - rectangles, - n_rectangles); -} - -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. */ -} - -void -cogl_wayland_renderer_set_foreign_display (CoglRenderer *renderer, - struct wl_display *display) -{ - _COGL_RETURN_IF_FAIL (cogl_is_renderer (renderer)); - - /* NB: Renderers are considered immutable once connected */ - _COGL_RETURN_IF_FAIL (!renderer->connected); - - renderer->foreign_wayland_display = display; -} - -void -cogl_wayland_renderer_set_event_dispatch_enabled (CoglRenderer *renderer, - CoglBool enable) -{ - _COGL_RETURN_IF_FAIL (cogl_is_renderer (renderer)); - /* NB: Renderers are considered immutable once connected */ - _COGL_RETURN_IF_FAIL (!renderer->connected); - - renderer->wayland_enable_event_dispatch = enable; -} - -struct wl_display * -cogl_wayland_renderer_get_display (CoglRenderer *renderer) -{ - _COGL_RETURN_VAL_IF_FAIL (cogl_is_renderer (renderer), NULL); - - if (renderer->foreign_wayland_display) - return renderer->foreign_wayland_display; - else if (renderer->connected) - { - CoglRendererEGL *egl_renderer = renderer->winsys; - CoglRendererWayland *wayland_renderer = egl_renderer->platform; - return wayland_renderer->wayland_display; - } - else - return NULL; -} - -struct wl_surface * -cogl_wayland_onscreen_get_surface (CoglOnscreen *onscreen) -{ - CoglOnscreenEGL *egl_onscreen; - CoglOnscreenWayland *wayland_onscreen; - - cogl_framebuffer_allocate (COGL_FRAMEBUFFER (onscreen), NULL); - - egl_onscreen = onscreen->winsys; - wayland_onscreen = egl_onscreen->platform; - - return wayland_onscreen->wayland_surface; -} - -struct wl_shell_surface * -cogl_wayland_onscreen_get_shell_surface (CoglOnscreen *onscreen) -{ - CoglOnscreenEGL *egl_onscreen; - CoglOnscreenWayland *wayland_onscreen; - - cogl_framebuffer_allocate (COGL_FRAMEBUFFER (onscreen), NULL); - - egl_onscreen = onscreen->winsys; - wayland_onscreen = egl_onscreen->platform; - - return wayland_onscreen->wayland_shell_surface; -} - -void -cogl_wayland_onscreen_set_foreign_surface (CoglOnscreen *onscreen, - struct wl_surface *surface) -{ - CoglFramebuffer *fb; - - fb = COGL_FRAMEBUFFER (onscreen); - _COGL_RETURN_IF_FAIL (!fb->allocated); - - onscreen->foreign_surface = surface; -} - -void -cogl_wayland_onscreen_resize (CoglOnscreen *onscreen, - int width, - int height, - int offset_x, - int offset_y) -{ - CoglFramebuffer *fb; - - fb = COGL_FRAMEBUFFER (onscreen); - if (fb->allocated) - { - CoglOnscreenEGL *egl_onscreen = onscreen->winsys; - CoglOnscreenWayland *wayland_onscreen = egl_onscreen->platform; - - if (cogl_framebuffer_get_width (fb) != width || - cogl_framebuffer_get_height (fb) != height || - offset_x || - offset_y) - { - wayland_onscreen->pending_width = width; - wayland_onscreen->pending_height = height; - wayland_onscreen->pending_dx += offset_x; - wayland_onscreen->pending_dy += offset_y; - wayland_onscreen->has_pending = TRUE; - - /* If nothing has been drawn to the framebuffer since the - * last swap then wl_egl_window_resize will take effect - * immediately. Otherwise it might not take effect until the - * next swap, depending on the version of Mesa. To keep - * consistent behaviour we'll delay the resize until the - * next swap unless we're sure nothing has been drawn */ - if (!fb->mid_scene) - flush_pending_resize (onscreen); - } - } - else - _cogl_framebuffer_winsys_update_size (fb, width, height); -} - -static const CoglWinsysEGLVtable -_cogl_winsys_egl_vtable = - { - .display_setup = _cogl_winsys_egl_display_setup, - .display_destroy = _cogl_winsys_egl_display_destroy, - .context_created = _cogl_winsys_egl_context_created, - .cleanup_context = _cogl_winsys_egl_cleanup_context, - .context_init = _cogl_winsys_egl_context_init, - .onscreen_init = _cogl_winsys_egl_onscreen_init, - .onscreen_deinit = _cogl_winsys_egl_onscreen_deinit - }; - -const CoglWinsysVtable * -_cogl_winsys_egl_wayland_get_vtable (void) -{ - static CoglBool vtable_inited = FALSE; - static CoglWinsysVtable vtable; - - if (!vtable_inited) - { - /* The EGL_WAYLAND winsys is a subclass of the EGL winsys so we - start by copying its vtable */ - - parent_vtable = _cogl_winsys_egl_get_vtable (); - vtable = *parent_vtable; - - vtable.id = COGL_WINSYS_ID_EGL_WAYLAND; - vtable.name = "EGL_WAYLAND"; - - vtable.renderer_connect = _cogl_winsys_renderer_connect; - vtable.renderer_disconnect = _cogl_winsys_renderer_disconnect; - - vtable.onscreen_swap_buffers_with_damage = - _cogl_winsys_onscreen_swap_buffers_with_damage; - - vtable.onscreen_set_visibility = - _cogl_winsys_onscreen_set_visibility; - - vtable_inited = TRUE; - } - - return &vtable; -} diff --git a/configure.ac b/configure.ac index f8beabbf5..7b12cc1d4 100644 --- a/configure.ac +++ b/configure.ac @@ -95,7 +95,6 @@ m4_define([xfixes_req_version], [3]) m4_define([xcomposite_req_version], [0.4]) m4_define([xrandr_req_version], [1.2]) m4_define([cairo_req_version], [1.10]) -m4_define([wayland_req_version], [1.0.0]) m4_define([wayland_server_req_version], [1.1.90]) m4_define([mirclient_req_version], [0.9.0]) @@ -109,7 +108,6 @@ AC_SUBST([XFIXES_REQ_VERSION], [xfixes_req_version]) AC_SUBST([GTK_DOC_REQ_VERSION], [gtk_doc_req_version]) AC_SUBST([GI_REQ_VERSION], [gi_req_version]) AC_SUBST([UPROF_REQ_VERSION], [uprof_req_version]) -AC_SUBST([WAYLAND_REQ_VERSION], [wayland_req_version]) AC_SUBST([WAYLAND_SERVER_REQ_VERSION], [wayland_server_req_version]) # Save this value here, since automake will set cflags later and we @@ -840,29 +838,6 @@ AM_CONDITIONAL(SUPPORT_GLX, [test "x$SUPPORT_GLX" = "xyes"]) EGL_PLATFORM_COUNT=0 -AC_ARG_ENABLE( - [wayland-egl-platform], - [AC_HELP_STRING([--enable-wayland-egl-platform=@<:@no/yes@:>@], [Enable support for the Wayland egl platform @<:@default=no@:>@])], - [], - enable_wayland_egl_platform=no -) -AS_IF([test "x$enable_wayland_egl_platform" = "xyes"], - [ - EGL_PLATFORM_COUNT=$((EGL_PLATFORM_COUNT+1)) - NEED_EGL=yes - EGL_PLATFORMS="$EGL_PLATFORMS wayland" - - PKG_CHECK_MODULES(WAYLAND_CLIENT, - [wayland-egl >= wayland_req_version wayland-client >= wayland_req_version]) - COGL_PKG_REQUIRES="$COGL_PKG_REQUIRES wayland-egl >= wayland_req_version" - COGL_PKG_REQUIRES="$COGL_PKG_REQUIRES wayland-client >= wayland_req_version" - - COGL_DEFINES_SYMBOLS="$COGL_DEFINES_SYMBOLS COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT" - ]) -AM_CONDITIONAL(SUPPORT_EGL_PLATFORM_WAYLAND, - [test "x$enable_wayland_egl_platform" = "xyes"]) - - AC_ARG_ENABLE( [kms-egl-platform], [AC_HELP_STRING([--enable-kms-egl-platform=@<:@no/yes@:>@], [Enable support for the KMS egl platform @<:@default=no@:>@])], diff --git a/examples/cogl-info.c b/examples/cogl-info.c index faa326661..5d9482436 100644 --- a/examples/cogl-info.c +++ b/examples/cogl-info.c @@ -137,8 +137,6 @@ get_winsys_name_for_id (CoglWinsysID winsys_id) return "GLX"; case COGL_WINSYS_ID_EGL_XLIB: return "EGL + Xlib platform"; - case COGL_WINSYS_ID_EGL_WAYLAND: - return "EGL + Wayland platform"; case COGL_WINSYS_ID_EGL_KMS: return "EGL + KMS platform"; }