static void convert_display_bitmaps_to_memory_bitmap(ALLEGRO_DISPLAY *d)
{
ALLEGRO_DEBUG("converting display bitmaps to memory bitmaps.\n");
while (d->bitmaps._size > 0) {
ALLEGRO_BITMAP **bptr = _al_vector_ref_back(&d->bitmaps);
ALLEGRO_BITMAP *b = *bptr;
_al_convert_to_memory_bitmap(b);
}
}
static void destroy_display_internals(ALLEGRO_DISPLAY_WGL *wgl_disp)
{
ALLEGRO_DISPLAY *disp = (ALLEGRO_DISPLAY *)wgl_disp;
ALLEGRO_DISPLAY_WIN *win_disp = (ALLEGRO_DISPLAY_WIN *)wgl_disp;
/* We need to convert all our bitmaps to display independent (memory)
* bitmaps because WGL driver doesn't support sharing of resources. */
while (disp->bitmaps._size > 0) {
ALLEGRO_BITMAP **bptr = _al_vector_ref_back(&disp->bitmaps);
ALLEGRO_BITMAP *bmp = *bptr;
_al_convert_to_memory_bitmap(bmp);
}
if (disp->ogl_extras->backbuffer)
_al_ogl_destroy_backbuffer(disp->ogl_extras->backbuffer);
disp->ogl_extras->backbuffer = NULL;
_al_ogl_unmanage_extensions(disp);
PostMessage(win_disp->window, _al_win_msg_suicide, (WPARAM)win_disp, 0);
while (!win_disp->thread_ended)
al_rest(0.001);
if (wgl_disp->glrc) {
wglDeleteContext(wgl_disp->glrc);
wgl_disp->glrc = NULL;
}
if (wgl_disp->dc) {
ReleaseDC(win_disp->window, wgl_disp->dc);
wgl_disp->dc = NULL;
}
if (disp->flags & ALLEGRO_FULLSCREEN && !_wgl_do_not_change_display_mode) {
ChangeDisplaySettings(NULL, 0);
}
if (win_disp->window) {
DestroyWindow(win_disp->window);
win_disp->window = NULL;
}
}
static void destroy_display_internals(ALLEGRO_DISPLAY_WGL *wgl_disp)
{
ALLEGRO_DISPLAY *disp = (ALLEGRO_DISPLAY *)wgl_disp;
ALLEGRO_DISPLAY_WIN *win_disp = (ALLEGRO_DISPLAY_WIN *)wgl_disp;
/* We need to convert all our bitmaps to display independent (memory)
* bitmaps because WGL driver doesn't support sharing of resources. */
while (disp->bitmaps._size > 0) {
ALLEGRO_BITMAP **bptr = _al_vector_ref_back(&disp->bitmaps);
ALLEGRO_BITMAP *bmp = *bptr;
_al_convert_to_memory_bitmap(bmp);
}
if (disp->ogl_extras->backbuffer)
_al_ogl_destroy_backbuffer(disp->ogl_extras->backbuffer);
disp->ogl_extras->backbuffer = NULL;
_al_ogl_unmanage_extensions(disp);
PostMessage(win_disp->window, _al_win_msg_suicide, (WPARAM)win_disp, 0);
while (!win_disp->thread_ended)
al_rest(0.001);
}
static void raspberrypi_destroy_display(ALLEGRO_DISPLAY *d)
{
ALLEGRO_DISPLAY_RASPBERRYPI *pidisplay = (ALLEGRO_DISPLAY_RASPBERRYPI *)d;
hide_cursor(pidisplay);
delete_cursor_data(pidisplay);
_al_set_current_display_only(d);
while (d->bitmaps._size > 0) {
ALLEGRO_BITMAP **bptr = (ALLEGRO_BITMAP **)_al_vector_ref_back(&d->bitmaps);
ALLEGRO_BITMAP *b = *bptr;
_al_convert_to_memory_bitmap(b);
}
_al_event_source_free(&d->es);
ALLEGRO_SYSTEM_RASPBERRYPI *system = (void *)al_get_system_driver();
_al_vector_find_and_delete(&system->system.displays, &d);
eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
eglDestroySurface(egl_display, egl_window);
eglDestroyContext(egl_display, egl_context);
eglTerminate(egl_display);
if (getenv("DISPLAY")) {
_al_mutex_lock(&system->lock);
XUnmapWindow(system->x11display, pidisplay->window);
XDestroyWindow(system->x11display, pidisplay->window);
_al_mutex_unlock(&system->lock);
}
if (system->mouse_grab_display == d) {
system->mouse_grab_display = NULL;
}
}
static void xdpy_destroy_display(ALLEGRO_DISPLAY *d)
{
ALLEGRO_SYSTEM_XGLX *s = (void *)al_get_system_driver();
ALLEGRO_DISPLAY_XGLX *glx = (void *)d;
ALLEGRO_OGL_EXTRAS *ogl = d->ogl_extras;
ALLEGRO_DEBUG("destroy display.\n");
/* If we're the last display, convert all bitmpas to display independent
* (memory) bitmaps. */
if (s->system.displays._size == 1) {
while (d->bitmaps._size > 0) {
ALLEGRO_BITMAP **bptr = _al_vector_ref_back(&d->bitmaps);
ALLEGRO_BITMAP *b = *bptr;
_al_convert_to_memory_bitmap(b);
}
}
else {
/* Pass all bitmaps to any other living display. (We assume all displays
* are compatible.) */
size_t i;
ALLEGRO_DISPLAY **living = NULL;
ASSERT(s->system.displays._size > 1);
for (i = 0; i < s->system.displays._size; i++) {
living = _al_vector_ref(&s->system.displays, i);
if (*living != d)
break;
}
for (i = 0; i < d->bitmaps._size; i++) {
ALLEGRO_BITMAP **add = _al_vector_alloc_back(&(*living)->bitmaps);
ALLEGRO_BITMAP **ref = _al_vector_ref(&d->bitmaps, i);
*add = *ref;
(*add)->display = *living;
}
}
_al_xglx_unuse_adapter(s, glx->adapter);
_al_ogl_unmanage_extensions(d);
ALLEGRO_DEBUG("unmanaged extensions.\n");
_al_mutex_lock(&s->lock);
_al_vector_find_and_delete(&s->system.displays, &d);
XDestroyWindow(s->x11display, glx->window);
if (s->mouse_grab_display == d) {
s->mouse_grab_display = NULL;
}
ALLEGRO_DEBUG("destroy window.\n");
if (d->flags & ALLEGRO_FULLSCREEN) {
size_t i;
ALLEGRO_DISPLAY **living = NULL;
bool last_fullscreen = true;
/* If any other fullscreen display is still active on the same adapter,
* we must not touch the video mode.
*/
for (i = 0; i < s->system.displays._size; i++) {
living = _al_vector_ref(&s->system.displays, i);
ALLEGRO_DISPLAY_XGLX *living_glx = (void*)*living;
if (*living == d) continue;
/* check for fullscreen displays on the same adapter */
if (living_glx->adapter == glx->adapter &&
al_get_display_flags(*living) & ALLEGRO_FULLSCREEN)
{
last_fullscreen = false;
}
}
if (last_fullscreen) {
ALLEGRO_DEBUG("restore modes.\n");
_al_xglx_restore_video_mode(s, glx->adapter);
}
else {
ALLEGRO_DEBUG("*not* restoring modes.\n");
}
}
if (ogl->backbuffer) {
_al_ogl_destroy_backbuffer(ogl->backbuffer);
ogl->backbuffer = NULL;
ALLEGRO_DEBUG("destroy backbuffer.\n");
}
if (glx->context) {
glXDestroyContext(s->gfxdisplay, glx->context);
glx->context = NULL;
ALLEGRO_DEBUG("destroy context.\n");
}
/* XXX quick pre-release hack */
/* In multi-window programs these result in a double-free bugs. */
#if 0
if (glx->fbc) {
al_free(glx->fbc);
glx->fbc = NULL;
XFree(glx->xvinfo);
glx->xvinfo = NULL;
}
else if (glx->xvinfo) {
al_free(glx->xvinfo);
glx->xvinfo = NULL;
}
#endif
_al_cond_destroy(&glx->mapped);
_al_vector_free(&d->bitmaps);
_al_event_source_free(&d->es);
al_free(d->ogl_extras);
al_free(d->vertex_cache);
al_free(d);
_al_mutex_unlock(&s->lock);
ALLEGRO_DEBUG("destroy display finished.\n");
}
