void
release_gasket(ModeInfo * mi)
{
if (gasket != NULL)
{
int screen;
for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++)
{
gasketstruct *gp = &gasket[screen];
if (gp->colors != NULL) {
XFree((caddr_t) gp->colors);
gp->colors = (XColor *) NULL;
}
if (gp->glx_context)
{
/* Display lists MUST be freed while their glXContext is current. */
glXMakeCurrent(MI_DISPLAY(mi), gp->window, *(gp->glx_context));
if (glIsList(gp->gasket1)) glDeleteLists(gp->gasket1, 1);
}
}
free(gasket);
gasket = (gasketstruct *) NULL;
}
FreeAllGL(mi);
}
ENTRYPOINT void
release_planet (ModeInfo * mi)
{
if (planets != NULL) {
int screen;
for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) {
planetstruct *gp = &planets[screen];
if (gp->glx_context) {
/* Display lists MUST be freed while their glXContext is current. */
/* but this gets a BadMatch error. -jwz */
/*glXMakeCurrent(MI_DISPLAY(mi), gp->window, *(gp->glx_context));*/
if (glIsList(gp->platelist))
glDeleteLists(gp->platelist, 1);
if (glIsList(gp->starlist))
glDeleteLists(gp->starlist, 1);
}
}
(void) free((void *) planets);
planets = NULL;
}
FreeAllGL(mi);
}
ENTRYPOINT void
release_gasket(ModeInfo * mi)
{
if (gasket != NULL)
{
int screen;
for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++)
{
gasketstruct *gp = &gasket[screen];
if (gp->glx_context)
{
/* Display lists MUST be freed while their glXContext is current. */
glXMakeCurrent(MI_DISPLAY(mi), gp->window, *(gp->glx_context));
if (glIsList(gp->gasket0)) glDeleteLists(gp->gasket0, 1);
if (glIsList(gp->gasket1)) glDeleteLists(gp->gasket1, 1);
if (glIsList(gp->gasket2)) glDeleteLists(gp->gasket2, 1);
if (glIsList(gp->gasket3)) glDeleteLists(gp->gasket3, 1);
}
}
(void) free((void *) gasket);
gasket = NULL;
}
FreeAllGL(mi);
}
ENTRYPOINT void release_screenflip(ModeInfo *mi)
{
if (screenflip != NULL) {
(void) free((void *) screenflip);
screenflip = NULL;
}
FreeAllGL(mi);
}
ENTRYPOINT void release_antmaze(ModeInfo * mi)
{
if(antmaze) {
free((void *) antmaze);
antmaze = (antmazestruct *) NULL;
}
FreeAllGL(mi);
}
/* cleanup code */
ENTRYPOINT void release_gflux(ModeInfo * mi)
{
if (gfluxes != NULL) {
free((void *) gfluxes);
gfluxes = NULL;
}
FreeAllGL(mi);
}
/** bust it */
ENTRYPOINT void release_chess(ModeInfo *mi)
{
if(qs)
free((void *) qs);
qs = 0;
FreeAllGL(mi);
}
ENTRYPOINT void release_queens(ModeInfo *mi)
{
if(qss)
free((void *) qss);
qss = 0;
FreeAllGL(mi);
}
ENTRYPOINT void release_antinspect(ModeInfo * mi)
{
if(antinspect) {
free((void *) antinspect);
antinspect = (antinspectstruct *) NULL;
}
FreeAllGL(mi);
}
ENTRYPOINT void
release_morph3d(ModeInfo * mi)
{
if (morph3d != NULL) {
(void) free((void *) morph3d);
morph3d = (morph3dstruct *) NULL;
}
FreeAllGL(mi);
}
ENTRYPOINT void release_bang (ModeInfo * mi)
{
if (bang)
{
free((void *) bang);
bang = (bangstruct *) NULL;
}
FreeAllGL(mi);
}
ENTRYPOINT void
release_superquadrics(ModeInfo * mi)
{
if (superquadrics != NULL) {
(void) free((void *) superquadrics);
superquadrics = NULL;
}
FreeAllGL(mi);
}
ENTRYPOINT void
release_moebius (ModeInfo * mi)
{
if (moebius != NULL) {
(void) free((void *) moebius);
moebius = (moebiusstruct *) NULL;
}
FreeAllGL(mi);
}
void
release_morph3d(ModeInfo * mi)
{
if (morph3d != NULL) {
free(morph3d);
morph3d = (morph3dstruct *) NULL;
}
FreeAllGL(mi);
}
/* cleanup routine */
ENTRYPOINT void release_providence(ModeInfo * mi)
{
if(providence) {
free((void *) providence);
providence = (providencestruct *) NULL;
}
FreeAllGL(mi);
}
/* cleanup routine */
ENTRYPOINT void release_antspotlight(ModeInfo * mi)
{
if(antspotlight) {
free((void *) antspotlight);
antspotlight = (antspotlightstruct *) NULL;
}
FreeAllGL(mi);
}
ENTRYPOINT void
release_pipes (ModeInfo * mi)
{
if (pipes != NULL) {
int screen;
for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) {
pipesstruct *pp = &pipes[screen];
if (pp->glx_context) {
/* Display lists MUST be freed while their glXContext is current. */
glXMakeCurrent(MI_DISPLAY(mi), pp->window, *(pp->glx_context));
if (pp->valve)
glDeleteLists(pp->valve, 1);
if (pp->bolts)
glDeleteLists(pp->bolts, 1);
if (pp->betweenbolts)
glDeleteLists(pp->betweenbolts, 1);
if (pp->elbowbolts)
glDeleteLists(pp->elbowbolts, 1);
if (pp->elbowcoins)
glDeleteLists(pp->elbowcoins, 1);
if (pp->guagehead)
glDeleteLists(pp->guagehead, 1);
if (pp->guageface)
glDeleteLists(pp->guageface, 1);
if (pp->guagedial)
glDeleteLists(pp->guagedial, 1);
if (pp->guageconnector)
glDeleteLists(pp->guageconnector, 1);
if (pp->teapot)
glDeleteLists(pp->teapot, 1);
if (pp->dlists)
{
int i;
for (i = 0; i < pp->dlist_count; i++)
glDeleteLists (pp->dlists[i], 1);
free (pp->dlists);
free (pp->poly_counts);
}
}
}
(void) free((void *) pipes);
pipes = NULL;
}
FreeAllGL(mi);
}
/* all sorts of nice cleanup code should go here! */
ENTRYPOINT void release_pulsar(ModeInfo * mi)
{
int screen;
if (Pulsar != NULL) {
for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) {
pulsarstruct *gp = &Pulsar[screen];
free(gp->quads);
}
(void) free((void *) Pulsar);
Pulsar = NULL;
}
FreeAllGL(mi);
}
/* all sorts of nice cleanup code should go here! */
ENTRYPOINT void release_atunnel(ModeInfo * mi)
{
int screen;
if (Atunnel != NULL) {
for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) {
atunnelstruct *sa = &Atunnel[screen];
FreeTunnel(sa->ts);
}
(void) free((void *) Atunnel);
Atunnel = NULL;
}
FreeAllGL(mi);
}
void
release_molecule(ModeInfo * mi)
{
if (mcs != NULL) {
int screen;
for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) {
molecule_configuration *mc = &mcs[screen];
#if 0
int i;
for (i = 0; i < mc->nmolecules; i++) {
molecule *m = &mc->molecules[i];
if (m->atoms) {
free(m->atoms);
m->atoms = (molecule_atom *) NULL;
}
if (m->bonds) {
free(m->bonds);
m->bonds = (molecule_bond *) NULL;
}
if (m->label) {
free(m->label);
m->label = (char *) NULL;
}
}
if (mc->molecules) {
free(mc->molecules);
mc->molecules = (molecule *) NULL;
}
#endif
if (mc->glx_context) {
/* Display lists MUST be freed while their glXContext is current. */
#ifdef WIN32
wglMakeCurrent(hdc, mc->glx_context);
#else
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(mc->glx_context));
#endif
/* Free font stuff */
free_fonts (mi);
}
}
free(mcs);
mcs = (molecule_configuration *) NULL;
}
FreeAllGL(mi);
}
ENTRYPOINT void release_commander(ModeInfo *mi)
{
if (commander != NULL) {
int screen;
for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) {
commander_conf *cp = &commander[screen];
if (cp->glx_context) {
cp->glx_context = NULL;
}
}
free((void *)commander);
commander = NULL;
}
FreeAllGL(mi);
}
ENTRYPOINT void
release_bubble3d(ModeInfo * mi)
{
if (contexts) {
int screen;
for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) {
struct context *c = &contexts[screen];
if (c->draw_context)
glb_draw_end(c->draw_context);
}
free (contexts);
contexts = 0;
}
FreeAllGL(mi);
}
ENTRYPOINT void
release_stonerview (ModeInfo *mi)
{
if (bps) {
int screen;
for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) {
stonerview_configuration *bp = &bps[screen];
if (bp->st)
win_release (bp->st);
}
free (bps);
bps = 0;
}
FreeAllGL(mi);
}
ENTRYPOINT void release_cube21(ModeInfo *mi)
{
if (cube21 != NULL) {
int screen;
for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) {
cube21_conf *cp = &cube21[screen];
if (cp->glx_context) {
cp->glx_context = NULL;
}
}
free((void *)cube21);
cube21 = NULL;
}
FreeAllGL(mi);
}
ENTRYPOINT void
release_stairs (ModeInfo * mi)
{
if (stairs != NULL) {
int i;
for (i = 0; i < MI_NUM_SCREENS(mi); i++) {
stairsstruct *sp = &stairs[i];
if (glIsList(sp->objects)) {
glDeleteLists(sp->objects, 1);
}
}
free(stairs);
stairs = NULL;
}
FreeAllGL(mi);
}
ENTRYPOINT void
release_sws (ModeInfo *mi)
{
if (scs) {
int screen;
for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) {
sws_configuration *sc = &scs[screen];
if (sc->tc)
textclient_close (sc->tc);
/* #### there's more to free here */
}
free (scs);
scs = 0;
}
FreeAllGL(mi);
}
void release_fire(ModeInfo * mi)
{
if (fire != NULL) {
int screen;
for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++)
free_fire(&fire[screen]);
free(fire);
fire = (firestruct *) NULL;
}
if (mode_font != None)
{
/* only free-ed when there are no more screens used */
XFreeFont(MI_DISPLAY(mi), mode_font);
mode_font = None;
}
FreeAllGL(mi);
}
ENTRYPOINT void release_hypertorus(ModeInfo *mi)
{
if (hyper != NULL)
{
int screen;
for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++)
{
hypertorusstruct *hp = &hyper[screen];
if (hp->glx_context)
hp->glx_context = (GLXContext *)NULL;
}
(void) free((void *)hyper);
hyper = (hypertorusstruct *)NULL;
}
FreeAllGL(mi);
}
ENTRYPOINT void
release_cage (ModeInfo * mi)
{
if (cage != NULL) {
int screen;
for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) {
cagestruct *cp = &cage[screen];
if (cp->glx_context) {
cp->glx_context = (GLXContext *) NULL;
}
}
(void) free((void *) cage);
cage = (cagestruct *) NULL;
}
FreeAllGL(mi);
}
ENTRYPOINT void release_blocktube (ModeInfo *mi)
{
if (lps) {
int screen;
for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) {
blocktube_configuration *lp = &lps[screen];
# if defined ( I_HAVE_XPM )
if (lp->envTexture)
glDeleteTextures(1, &lp->envTexture);
if (lp->texti)
XDestroyImage(lp->texti);
# endif
}
free (lps);
lps = 0;
}
FreeAllGL(mi);
}
