static void exit_touch_input(void)
{
if (!installed)
return;
memset(&touch_input_state, 0, sizeof(touch_input_state));
_al_event_source_free(&touch_input.es);
_al_event_source_free(&touch_input.mouse_emulation_es);
_al_win_exit_touch_input_api();
installed = false;
}
static void wgl_destroy_display(ALLEGRO_DISPLAY *disp)
{
ALLEGRO_SYSTEM_WIN *system = (ALLEGRO_SYSTEM_WIN *)al_get_system_driver();
ALLEGRO_DISPLAY_WGL *wgl_disp = (ALLEGRO_DISPLAY_WGL *)disp;
ALLEGRO_DISPLAY *old_disp = al_get_current_display();
if (old_disp != disp)
_al_set_current_display_only(disp);
if (system->mouse_grab_display == disp)
system->mouse_grab_display = NULL;
destroy_display_internals(wgl_disp);
_al_event_source_free(&disp->es);
_al_vector_find_and_delete(&system->system.displays, &disp);
_al_vector_free(&disp->bitmaps);
al_free(disp->ogl_extras);
if (old_disp != disp)
_al_set_current_display_only(old_disp);
al_free(disp->vertex_cache);
al_free(wgl_disp);
}
/* xmouse_exit:
* Shut down the mouse driver.
*/
static void xmouse_exit(void)
{
if (!xmouse_installed)
return;
xmouse_installed = false;
_al_event_source_free(&the_mouse.parent.es);
}
static void sdl_destroy_display_locked(ALLEGRO_DISPLAY *d)
{
ALLEGRO_DISPLAY_SDL *sdl = (void *)d;
ALLEGRO_SYSTEM *system = al_get_system_driver();
_al_event_source_free(&d->es);
_al_vector_find_and_delete(&system->displays, &d);
SDL_DestroyWindow(sdl->window);
al_free(sdl);
}
/* exit_keyboard:
* Shut down the keyboard driver.
*/
static void exit_keyboard(void)
{
_al_event_source_free(&the_keyboard.es);
/* This may help catch bugs in the user program, since the pointer
* we return to the user is always the same.
*/
memset(&the_keyboard, 0, sizeof the_keyboard);
installed = false;
}
static void xdpy_destroy_display(ALLEGRO_DISPLAY *d)
{
ALLEGRO_SYSTEM_XGLX *s = (ALLEGRO_SYSTEM_XGLX *)al_get_system_driver();
ALLEGRO_DISPLAY_XGLX *glx = (ALLEGRO_DISPLAY_XGLX *)d;
ALLEGRO_OGL_EXTRAS *ogl = d->ogl_extras;
bool is_last;
ALLEGRO_DEBUG("destroying display.\n");
/* If we're the last display, convert all bitmaps to display independent
* (memory) bitmaps. Otherwise, pass all bitmaps to any other living
* display. We assume all displays are compatible.)
*/
is_last = (s->system.displays._size == 1);
if (is_last)
convert_display_bitmaps_to_memory_bitmap(d);
else
transfer_display_bitmaps_to_any_other_display(s, d);
_al_ogl_unmanage_extensions(d);
ALLEGRO_DEBUG("unmanaged extensions.\n");
_al_mutex_lock(&s->lock);
_al_vector_find_and_delete(&s->system.displays, &d);
if (ogl->backbuffer) {
_al_ogl_destroy_backbuffer(ogl->backbuffer);
ogl->backbuffer = NULL;
ALLEGRO_DEBUG("destroy backbuffer.\n");
}
if (glx->overridable_vt) {
glx->overridable_vt->destroy_display_hook(d, is_last);
}
if (s->mouse_grab_display == d) {
s->mouse_grab_display = NULL;
}
_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");
}
/* ljoy_release_joystick: [primary thread]
*
* Close the device for a joystick then free the joystick structure.
*/
static void ljoy_release_joystick(ALLEGRO_JOYSTICK *joy_)
{
ALLEGRO_JOYSTICK_LINUX *joy = (ALLEGRO_JOYSTICK_LINUX *) joy_;
int i;
_al_unix_stop_watching_fd(joy->fd);
_al_event_source_free(&joy->parent.es);
close(joy->fd);
for (i = 0; i < joy->parent.info.num_sticks; i++)
_AL_FREE((void *)joy->parent.info.stick[i].name);
for (i = 0; i < joy->parent.info.num_buttons; i++)
_AL_FREE((void *)joy->parent.info.button[i].name);
_AL_FREE(joy);
}
static void gp2xwiz_destroy_display_fb(ALLEGRO_DISPLAY *d)
{
ALLEGRO_SYSTEM_GP2XWIZ *s = (void *)al_get_system_driver();
ALLEGRO_DISPLAY_GP2XWIZ_FB *wiz_disp = (void *)d;
_al_vector_find_and_delete(&s->system.displays, &d);
/* All bitmaps are memory bitmaps, no need to do anything */
_al_vector_free(&d->bitmaps);
_al_event_source_free(&d->es);
wiz_disp->backbuffer->memory = wiz_disp->screen_mem;
al_destroy_bitmap(wiz_disp->backbuffer);
al_free(d->vertex_cache);
al_free(d);
set_gfx_mode = false;
}
/* lkeybd_exit_keyboard: [primary thread]
* Shut down the keyboard driver.
*/
static void lkeybd_exit_keyboard(void)
{
_al_unix_stop_watching_fd(the_keyboard.fd);
_al_event_source_free(&the_keyboard.parent.es);
/* Restore terminal attrs, keyboard mode, and reset the LED mode. */
tcsetattr(the_keyboard.fd, TCSANOW, &the_keyboard.startup_termio);
ioctl(the_keyboard.fd, KDSKBMODE, the_keyboard.startup_kbmode);
ioctl(the_keyboard.fd, KDSETLED, 8);
close(the_keyboard.fd);
//__al_linux_leave_console();
/* This may help catch bugs in the user program, since the pointer
* we return to the user is always the same.
*/
memset(&the_keyboard, 0, sizeof the_keyboard);
}
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;
}
}
/* Function: al_destroy_user_event_source
*/
void al_destroy_user_event_source(ALLEGRO_EVENT_SOURCE *src)
{
if (src) {
_al_event_source_free(src);
}
}
static void android_exit_keyboard(void)
{
_al_event_source_free(&the_keyboard.es);
}
/* xkeybd_exit_keyboard:
* Shut down the keyboard driver.
*/
static void xkeybd_exit_keyboard(void)
{
x_keyboard_exit();
_al_event_source_free(&the_keyboard.parent.es);
}
static void iphone_exit_keyboard(void)
{
_al_event_source_free(&the_keyboard.es);
}
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");
}
