/**
* Called via eglMakeCurrent(), drv->API.MakeCurrent().
*/
static EGLBoolean
xdri_eglMakeCurrent(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *d,
_EGLSurface *r, _EGLContext *context)
{
struct xdri_egl_context *xdri_ctx = lookup_context(context);
struct xdri_egl_surface *draw = lookup_surface(d);
struct xdri_egl_surface *read = lookup_surface(r);
if (!_eglMakeCurrent(drv, dpy, d, r, context))
return EGL_FALSE;
/* the symbol is defined in libGL.so */
_glapi_check_multithread();
if (xdri_ctx) {
if (!xdri_ctx->driContext->bindContext(xdri_ctx->driContext,
draw->driDrawable,
read->driDrawable)) {
return EGL_FALSE;
}
}
else {
_EGLContext *old = _eglGetCurrentContext();
if (old) {
xdri_ctx = lookup_context(old);
xdri_ctx->driContext->unbindContext(xdri_ctx->driContext);
}
}
return EGL_TRUE;
}
static EGLBoolean
xdri_eglSwapBuffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *draw)
{
struct xdri_egl_display *xdri_dpy = lookup_display(dpy);
struct xdri_egl_surface *xdri_surf = lookup_surface(draw);
xdri_dpy->psc->driScreen->swapBuffers(xdri_surf->driDrawable);
return EGL_TRUE;
}
static EGLBoolean
xdri_eglDestroySurface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface)
{
struct xdri_egl_surface *xdri_surf = lookup_surface(surface);
if (!_eglIsSurfaceBound(&xdri_surf->Base)) {
xdri_surf->driDrawable->destroyDrawable(xdri_surf->driDrawable);
free(xdri_surf);
}
return EGL_TRUE;
}
/**
* Called via eglMakeCurrent(), drv->API.MakeCurrent().
*/
static EGLBoolean
xlib_eglMakeCurrent(_EGLDriver *drv, EGLDisplay dpy,
EGLSurface draw, EGLSurface read, EGLContext ctx)
{
struct xlib_egl_context *context = lookup_context(ctx);
struct xlib_egl_surface *draw_surf = lookup_surface(draw);
struct xlib_egl_surface *read_surf = lookup_surface(read);
if (!_eglMakeCurrent(drv, dpy, draw, read, context))
return EGL_FALSE;
st_make_current((context ? context->Context : NULL),
(draw_surf ? draw_surf->Framebuffer : NULL),
(read_surf ? read_surf->Framebuffer : NULL));
if (draw_surf)
check_and_update_buffer_size(draw_surf);
if (read_surf && read_surf != draw_surf)
check_and_update_buffer_size(draw_surf);
return EGL_TRUE;
}
static EGLBoolean
xlib_eglDestroySurface(_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
{
struct xlib_egl_surface *surf = lookup_surface(surface);
if (surf) {
_eglHashRemove(_eglGlobal.Surfaces, (EGLuint) surface);
if (surf->Base.IsBound) {
surf->Base.DeletePending = EGL_TRUE;
}
else {
XFreeGC(surf->Dpy, surf->Gc);
st_unreference_framebuffer(&surf->Framebuffer);
free(surf);
}
return EGL_TRUE;
}
else {
_eglError(EGL_BAD_SURFACE, "eglDestroySurface");
return EGL_FALSE;
}
}
static EGLBoolean
xlib_eglSwapBuffers(_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw)
{
/* error checking step: */
if (!_eglSwapBuffers(drv, dpy, draw))
return EGL_FALSE;
{
struct xlib_egl_surface *xsurf = lookup_surface(draw);
struct pipe_winsys *pws = xsurf->winsys;
struct pipe_surface *psurf =
st_get_framebuffer_surface(xsurf->Framebuffer, ST_SURFACE_BACK_LEFT);
st_notify_swapbuffers(xsurf->Framebuffer);
display_surface(pws, psurf, xsurf);
check_and_update_buffer_size(xsurf);
}
return EGL_TRUE;
}
