/* Function: al_destroy_cond
*/
void al_destroy_cond(ALLEGRO_COND *cond)
{
if (cond) {
_al_cond_destroy(&cond->cond);
al_free(cond);
}
}
static void xdpy_destroy_display_hook_default(ALLEGRO_DISPLAY *d, bool is_last)
{
ALLEGRO_SYSTEM_XGLX *s = (ALLEGRO_SYSTEM_XGLX *)al_get_system_driver();
ALLEGRO_DISPLAY_XGLX *glx = (ALLEGRO_DISPLAY_XGLX *)d;
(void)is_last;
if (glx->context) {
glXDestroyContext(s->gfxdisplay, glx->context);
glx->context = NULL;
ALLEGRO_DEBUG("destroy context.\n");
}
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;
}
if ((glx->glxwindow) && (glx->glxwindow != glx->window)) {
glXDestroyWindow(s->x11display, glx->glxwindow);
glx->glxwindow = 0;
ALLEGRO_DEBUG("destroy glx window\n");
}
_al_cond_destroy(&glx->mapped);
_al_cond_destroy(&glx->selectioned);
ALLEGRO_DEBUG("destroy window.\n");
XDestroyWindow(s->x11display, glx->window);
_al_xglx_unuse_adapter(s, glx->adapter);
if (d->flags & ALLEGRO_FULLSCREEN) {
restore_mode_if_last_fullscreen_display(s, glx);
}
}
/* Function: al_join_thread
*/
void al_join_thread(ALLEGRO_THREAD *thread, void **ret_value)
{
ASSERT(thread);
/* If al_join_thread() is called soon after al_start_thread(), the thread
* function may not yet have noticed the STARTING state and executed the
* user's thread function. Hence we must wait until the thread enters the
* STARTED state.
*/
while (thread->thread_state == THREAD_STATE_STARTING) {
al_rest(0.001);
}
switch (thread->thread_state) {
case THREAD_STATE_CREATED: /* fall through */
case THREAD_STATE_STARTED:
_al_mutex_lock(&thread->mutex);
thread->thread_state = THREAD_STATE_JOINING;
_al_cond_broadcast(&thread->cond);
_al_mutex_unlock(&thread->mutex);
_al_cond_destroy(&thread->cond);
_al_mutex_destroy(&thread->mutex);
_al_thread_join(&thread->thread);
thread->thread_state = THREAD_STATE_JOINED;
break;
case THREAD_STATE_STARTING:
ASSERT(thread->thread_state != THREAD_STATE_STARTING);
break;
case THREAD_STATE_JOINING:
ASSERT(thread->thread_state != THREAD_STATE_JOINING);
break;
case THREAD_STATE_JOINED:
ASSERT(thread->thread_state != THREAD_STATE_JOINED);
break;
case THREAD_STATE_DESTROYED:
ASSERT(thread->thread_state != THREAD_STATE_DESTROYED);
break;
case THREAD_STATE_DETACHED:
ASSERT(thread->thread_state != THREAD_STATE_DETACHED);
break;
}
if (ret_value) {
*ret_value = thread->retval;
}
}
/* Function: al_destroy_event_queue
*/
void al_destroy_event_queue(ALLEGRO_EVENT_QUEUE *queue)
{
ASSERT(queue);
_al_unregister_destructor(_al_dtor_list, queue);
/* Unregister any event sources registered with this queue. */
while (_al_vector_is_nonempty(&queue->sources)) {
ALLEGRO_EVENT_SOURCE **slot = _al_vector_ref_back(&queue->sources);
al_unregister_event_source(queue, *slot);
}
ASSERT(_al_vector_is_empty(&queue->sources));
_al_vector_free(&queue->sources);
ASSERT(queue->events_head == queue->events_tail);
_al_vector_free(&queue->events);
_al_cond_destroy(&queue->cond);
_al_mutex_destroy(&queue->mutex);
al_free(queue);
}
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");
}
