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;
}
}
NativeStateWayland::~NativeStateWayland()
{
if (window_) {
if (window_->shell_surface)
wl_shell_surface_destroy(window_->shell_surface);
if (window_->opaque_reqion)
wl_region_destroy(window_->opaque_reqion);
if (window_->surface)
wl_surface_destroy(window_->surface);
if (window_->native)
wl_egl_window_destroy(window_->native);
delete window_;
}
if (display_) {
if (display_->shell)
wl_shell_destroy(display_->shell);
for (OutputsVector::iterator it = display_->outputs.begin();
it != display_->outputs.end(); ++it) {
wl_output_destroy((*it)->output);
delete *it;
}
if (display_->compositor)
wl_compositor_destroy(display_->compositor);
if (display_->registry)
wl_registry_destroy(display_->registry);
if (display_->display) {
wl_display_flush(display_->display);
wl_display_disconnect(display_->display);
}
delete display_;
}
}
std::unique_ptr<GLContextEGL> GLContextEGL::createWaylandContext(PlatformDisplay& platformDisplay, EGLContext sharingContext)
{
EGLDisplay display = platformDisplay.eglDisplay();
EGLConfig config;
if (!getEGLConfig(display, &config, WindowSurface))
return nullptr;
EGLContext context = eglCreateContext(display, config, sharingContext, gContextAttributes);
if (context == EGL_NO_CONTEXT)
return nullptr;
WlUniquePtr<struct wl_surface> wlSurface(downcast<PlatformDisplayWayland>(platformDisplay).createSurface());
if (!wlSurface) {
eglDestroyContext(display, context);
return nullptr;
}
EGLNativeWindowType window = wl_egl_window_create(wlSurface.get(), 1, 1);
EGLSurface surface = eglCreateWindowSurface(display, config, window, 0);
if (surface == EGL_NO_SURFACE) {
eglDestroyContext(display, context);
wl_egl_window_destroy(window);
return nullptr;
}
return std::unique_ptr<GLContextEGL>(new GLContextEGL(platformDisplay, context, surface, WTFMove(wlSurface), window));
}
static void gfx_ctx_wl_destroy_resources(gfx_ctx_wayland_data_t *wl)
{
if (!wl)
return;
switch (wl_api)
{
case GFX_CTX_OPENGL_API:
case GFX_CTX_OPENGL_ES_API:
case GFX_CTX_OPENVG_API:
#ifdef HAVE_EGL
egl_destroy(&wl->egl);
if (wl->win)
wl_egl_window_destroy(wl->win);
#endif
break;
case GFX_CTX_VULKAN_API:
#ifdef HAVE_VULKAN
vulkan_context_destroy(&wl->vk, wl->surface);
if (wl->fd >= 0)
close(wl->fd);
#endif
break;
case GFX_CTX_NONE:
default:
break;
}
if (wl->shell)
wl_shell_destroy(wl->shell);
if (wl->compositor)
wl_compositor_destroy(wl->compositor);
if (wl->registry)
wl_registry_destroy(wl->registry);
if (wl->shell_surf)
wl_shell_surface_destroy(wl->shell_surf);
if (wl->surface)
wl_surface_destroy(wl->surface);
if (wl->dpy)
{
wl_display_flush(wl->dpy);
wl_display_disconnect(wl->dpy);
}
#ifdef HAVE_EGL
wl->win = NULL;
#endif
wl->shell = NULL;
wl->compositor = NULL;
wl->registry = NULL;
wl->dpy = NULL;
wl->shell_surf = NULL;
wl->surface = NULL;
wl->width = 0;
wl->height = 0;
}
void cWaylandInterface::DestroyWindow(void)
{
wl_egl_window_destroy(GLWin.wl_egl_native);
wl_shell_surface_destroy(GLWin.wl_shell_surface);
wl_surface_destroy(GLWin.wl_surface);
}
static void delete_window (struct window *window) {
eglDestroySurface (egl_display, window->egl_surface);
wl_egl_window_destroy (window->egl_window);
wl_shell_surface_destroy (window->shell_surface);
wl_surface_destroy (window->surface);
eglDestroyContext (egl_display, window->egl_context);
}
WaylandSurface::~WaylandSurface()
{
// The surface couldn't have been created in the first place if WaylandDisplay wasn't properly initialized.
ASSERT(WaylandDisplay::instance());
eglMakeCurrent(WaylandDisplay::instance()->eglDisplay(), EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
wl_egl_window_destroy(m_nativeWindow);
wl_surface_destroy(m_wlSurface);
}
xdl_int XdevLWindowWayland::shutdown() {
if(m_egl.m_eglWindow != nullptr) {
wl_egl_window_destroy(m_egl.m_eglWindow);
m_egl.m_eglWindow = nullptr;
}
return ERR_OK;
}
void destroySubWindow(EGLNativeDisplayType dis,EGLNativeWindowType win){
/* krnlyng hmm */
#ifndef X11
//wl_surface_destroy(win);
wl_egl_window_destroy((struct wl_egl_window*)win);
#else
XDestroyWindow(dis, win);
#endif
}
void GLESV2API::Destroy() {
if (nullptr != p_->egl_surface) {
_ASSERT(nullptr != p_->wl_egl_window);
Display *display = Application::GetInstance()->GetDisplay();
eglDestroySurface(Display::Proxy::egl_display(display), p_->egl_surface);
wl_egl_window_destroy(p_->wl_egl_window);
p_->wl_egl_window = nullptr;
p_->egl_surface = nullptr;
}
}
void
WindowEGLImpl::DestroySurface()
{
eglMakeCurrent(m_egl.dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
eglDestroySurface(m_egl.dpy, m_eglSurface);
wl_egl_window_destroy(m_native);
if (m_callback)
wl_callback_destroy(m_callback);
}
static void
destroy_surface(struct window *window)
{
wl_egl_window_destroy(window->native);
wl_shell_surface_destroy(window->shell_surface);
wl_surface_destroy(window->surface);
if (window->callback)
wl_callback_destroy(window->callback);
}
QWaylandEglWindow::~QWaylandEglWindow()
{
if (m_eglSurface) {
eglDestroySurface(m_eglIntegration->eglDisplay(), m_eglSurface);
m_eglSurface = 0;
}
wl_egl_window_destroy(m_waylandEglWindow);
delete m_contentFBO;
}
static void
wayland_output_destroy(struct weston_output *output_base)
{
struct wayland_output *output = (struct wayland_output *) output_base;
gl_renderer_output_destroy(output_base);
wl_egl_window_destroy(output->parent.egl_window);
free(output);
return;
}
static void
triangle_destroy(struct triangle *tri)
{
if (tri->egl_surface)
eglDestroySurface(tri->egl->dpy, tri->egl_surface);
if (tri->egl_window)
wl_egl_window_destroy(tri->egl_window);
widget_destroy(tri->widget);
free(tri);
}
EglWaylandBackend::~EglWaylandBackend()
{
cleanupGL();
checkGLError("Cleanup");
doneCurrent();
eglDestroyContext(m_display, m_context);
eglDestroySurface(m_display, m_surface);
eglTerminate(m_display);
eglReleaseThread();
if (m_overlay) {
wl_egl_window_destroy(m_overlay);
}
}
/*
* Closes a window, destroying the frame and OpenGL context
*/
void fgPlatformCloseWindow( SFG_Window* window )
{
fghPlatformCloseWindowEGL(window);
if ( window->Window.pContext.egl_window )
wl_egl_window_destroy( window->Window.pContext.egl_window );
if ( window->Window.pContext.shsurface )
wl_shell_surface_destroy( window->Window.pContext.shsurface );
if ( window->Window.pContext.surface )
wl_surface_destroy( window->Window.pContext.surface );
if ( window->Window.pContext.cursor_surface )
wl_surface_destroy( window->Window.pContext.cursor_surface );
}
void _glfwPlatformDestroyWindow(_GLFWwindow* window)
{
if (window->wl.native)
wl_egl_window_destroy(window->wl.native);
_glfwDestroyContext(window);
if (window->wl.shell_surface)
wl_shell_surface_destroy(window->wl.shell_surface);
if (window->wl.surface)
wl_surface_destroy(window->wl.surface);
}
static int
evgl_eng_native_window_destroy(void *data, void *win)
{
Render_Engine *re;
if (!(re = (Render_Engine *)data)) return 0;
if (!win) return 0;
wl_egl_window_destroy((struct wl_egl_window *)win);
win = NULL;
return 1;
}
static void releaseGlContext_wayland(MPGLContext *ctx)
{
GL *gl = ctx->gl;
struct egl_context * egl_ctx = ctx->priv;
gl->Finish();
eglMakeCurrent(egl_ctx->egl.dpy, NULL, NULL, EGL_NO_CONTEXT);
eglDestroyContext(egl_ctx->egl.dpy, egl_ctx->egl.ctx);
eglTerminate(egl_ctx->egl.dpy);
eglReleaseThread();
wl_egl_window_destroy(egl_ctx->egl_window);
egl_ctx->egl.ctx = NULL;
}
void destroy_surface(struct display *display)
{
/* Required, otherwise segfault in egl_dri2.c: dri2_make_current()
* on eglReleaseThread(). */
eglMakeCurrent(display->egl.dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
eglDestroySurface(display->egl.dpy, display->egl_surface);
wl_egl_window_destroy(display->native);
wl_surface_destroy(display->surface);
if (display->callback)
wl_callback_destroy(display->callback);
}
static void releaseGlContext_wayland(MPGLContext *ctx)
{
GL *gl = ctx->gl;
struct vo_wayland_state *wl = ctx->vo->wayland;
gl->Finish();
eglReleaseThread();
wl_egl_window_destroy(wl->egl_context.egl_window);
eglDestroySurface(wl->egl_context.egl.dpy, wl->egl_context.egl_surface);
eglMakeCurrent(wl->egl_context.egl.dpy, NULL, NULL, EGL_NO_CONTEXT);
eglDestroyContext(wl->egl_context.egl.dpy, wl->egl_context.egl.ctx);
eglTerminate(wl->egl_context.egl.dpy);
wl->egl_context.egl.ctx = NULL;
}
Window::~Window()
{
unmap();
if (m_eglSurface != EGL_NO_SURFACE) {
eglDestroySurface(m_integration->eglDisplay(), m_eglSurface);
}
#if HAVE_WAYLAND_EGL
if (m_eglWaylandWindow) {
wl_egl_window_destroy(m_eglWaylandWindow);
}
#endif
delete m_shellSurface;
delete m_surface;
}
static void waylandgl_uninit(MPGLContext *ctx)
{
struct vo_wayland_state *wl = ctx->vo->wayland;
if (wl->egl_context.egl.ctx) {
eglReleaseThread();
wl_egl_window_destroy(wl->egl_context.egl_window);
eglDestroySurface(wl->egl_context.egl.dpy, wl->egl_context.egl_surface);
eglMakeCurrent(wl->egl_context.egl.dpy, NULL, NULL, EGL_NO_CONTEXT);
eglDestroyContext(wl->egl_context.egl.dpy, wl->egl_context.egl.ctx);
}
eglTerminate(wl->egl_context.egl.dpy);
wl->egl_context.egl.ctx = NULL;
vo_wayland_uninit(ctx->vo);
}
void QWaylandEglWindow::newSurfaceCreated()
{
if (mWaylandEglWindow) {
wl_egl_window_destroy(mWaylandEglWindow);
}
wl_visual *visual = QWaylandScreen::waylandScreenFromWidget(widget())->visual();
QSize size = geometry().size();
if (!size.isValid())
size = QSize(0,0);
mWaylandEglWindow = wl_egl_window_create(mSurface,size.width(),size.height(),visual);
if (mGLContext) {
EGLNativeWindowType window(reinterpret_cast<EGLNativeWindowType>(mWaylandEglWindow));
EGLSurface surface = eglCreateWindowSurface(mEglIntegration->eglDisplay(),mGLContext->eglConfig(),window,NULL);
mGLContext->setEglSurface(surface);
}
}
GHOST_WindowWayland::~GHOST_WindowWayland()
{
EGLDisplay display = m_system->getEglDisplay();
if (m_egl_context != EGL_NO_CONTEXT) {
context_make_current(EGL_NO_SURFACE);
EGL_CHK(eglDestroyContext(display, m_egl_context));
}
if (m_egl_surface != EGL_NO_SURFACE)
EGL_CHK(eglDestroySurface(display, m_egl_surface));
if (m_window)
wl_egl_window_destroy(m_window);
wl::destroy(m_shell_surface);
wl::destroy(m_surface);
}
static void
nested_client_destroy(struct nested_client *client)
{
eglMakeCurrent(client->egl_display,
EGL_NO_SURFACE, EGL_NO_SURFACE,
EGL_NO_CONTEXT);
wl_egl_window_destroy(client->native);
wl_surface_destroy(client->surface);
if (client->compositor)
wl_compositor_destroy(client->compositor);
wl_registry_destroy(client->registry);
wl_display_flush(client->display);
wl_display_disconnect(client->display);
}
WaylandEGLContext::~WaylandEGLContext ()
{
if (subsurface)
wl_subsurface_destroy (subsurface);
if (region)
wl_region_destroy (region);
if (child)
wl_surface_destroy (child);
if (egl_context)
eglDestroyContext (egl_display, egl_context);
if (egl_surface)
eglDestroySurface (egl_display, egl_surface);
if (egl_window)
wl_egl_window_destroy (egl_window);
}
static void
destroy_surfaces (GstGLWindowWaylandEGL * window_egl)
{
if (window_egl->window.subsurface) {
wl_subsurface_destroy (window_egl->window.subsurface);
window_egl->window.subsurface = NULL;
}
if (window_egl->window.shell_surface) {
wl_shell_surface_destroy (window_egl->window.shell_surface);
window_egl->window.shell_surface = NULL;
}
if (window_egl->window.surface) {
wl_surface_destroy (window_egl->window.surface);
window_egl->window.surface = NULL;
}
if (window_egl->window.native) {
wl_egl_window_destroy (window_egl->window.native);
window_egl->window.native = NULL;
}
}
static void
_cogl_winsys_egl_onscreen_deinit (CoglOnscreen *onscreen)
{
CoglOnscreenEGL *egl_onscreen = onscreen->winsys;
CoglOnscreenWayland *wayland_onscreen = egl_onscreen->platform;
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 (wayland_onscreen->wayland_surface)
{
wl_surface_destroy (wayland_onscreen->wayland_surface);
wayland_onscreen->wayland_surface = NULL;
}
g_slice_free (CoglOnscreenWayland, wayland_onscreen);
}