/*ScianSpaces.c
  Space objects
  Eric Pepke
  April 6, 1990
*/

#include "Scian.h"
#include "ScianTypes.h"
#include "ScianColors.h"
#include "ScianLists.h"
#include "ScianArrays.h"
#include "ScianLights.h"
#include "ScianSpaces.h"
#include "ScianEvents.h"
#include "ScianDraw.h"
#include "ScianWindows.h"
#include "ScianObjWindows.h"
#include "ScianVisWindows.h"
#include "ScianVisObjects.h"
#include "ScianScripts.h"
#include "ScianIcons.h"
#include "ScianIDs.h"
#include "ScianControls.h"
#include "ScianButtons.h"
#include "ScianTextBoxes.h"
#include "ScianTitleBoxes.h"
#include "ScianPerspec.h"
#include "ScianErrors.h"
#include "ScianTimers.h"
#include "ScianDialogs.h"
#include "ScianSliders.h"
#include "ScianTextBoxes.h"
#include "ScianStyle.h"
#include "ScianComplexControls.h"
#include "ScianMethods.h"
#include "ScianPick.h"
#include "ScianPreferences.h"
#include "ScianFiles.h"

#define NEWCLOCK

Bool phsco = false;			/*True iff phscologram is on*/
Bool drawingTransparent = false;	/*True iff drawing only transparent*/

static void StartSpace(ObjPtr, int, int, int, int, int, int);

typedef struct
    {
	unsigned char alpha;
	unsigned char blue;
	unsigned char green;
	unsigned char red;
    } Pixel;

Pixel imageBuffer[SCRWIDTH * SCRHEIGHT];

#define PLAYCLOCK (0.1)			/*Rate for clock play*/
#define FASTCLOCK (0.2)			/*Rate for clock fast*/

#define ROTLIGHTS			/*Rotate lights with object*/

#define DSPCLOCKWIDTH	97
#define DSPCLOCKHEIGHT	48
#define DSPCLOCKLEFT	55
#define DSPCLOCKTOP	70
#define DSPCLOCKTLEFT	10
#define DSPCLOCKTRIGHT	10
#define DSPCLOCKTTOP	23

#define ASPECT		(((float) (right - left)) / ((float) (top - bottom))) * (phsco ? 0.61 : 1.0)
#define MINROT		3		/*Minimum number of pixels to move to rotate*/
#define SQUARE(x)	((x) * (x))
#define AIRSPEEDFACTOR	0.02		/*Airspeed of eye per throttle stop*/
#define MAXROLL		(M_PI / 10.0)	/*Pi/10 of roll max*/
#define MAXDPITCH	0.1		/*Maximum delta percentage pitch*/
#define ROLLYAWFACTOR	1.0		/*Roll into yaw per unit time*/
#define ROLLDSPFACTOR	(900.0 / M_PI)
#define STARSIZE	0.05		/*Size of a star*/
#define MOVEFACTOR	0.35		/*Move per D unit * distance*/

Matrix tempMatrix;			/*Temporary matrix*/

ObjPtr curSpace = 0;			/*Current space*/
real curSpacePerspec[4];		/*Current perspective stuff*/
ObjPtr curSpaceLights;			/*Lights in the current space*/
Matrix viewerCoordsMatrix;		/*Transformation matrix for viewer coords*/
Matrix viewerUnrotMatrix;		/*Transformation matrix for unrotated viewer coords*/

ObjPtr spaceClass = 0;			/*Class of a 3-D space*/
extern ObjPtr visClass;			/*Class of all visualization objects*/
extern ObjPtr iconClass;		/*Class of icons*/
real spaceTime = 0.0;			/*Time for current space.  Cute name, huh?*/
ObjPtr spacePanelClass;			/*Invisible panel over a space*/
ObjPtr spaceBackPanelClass;		/*Colored panel behind a space*/
ObjPtr controllerClass;			/*Class for space controllers (clocks, lights, etc.)*/
ObjPtr clockClass;			/*Class of clocks*/
ObjPtr observerClass;			/*Class of observers*/
ObjPtr rendererClass;			/*Class of renderers*/
Bool oneObserver = false;
Bool oneRenderer = false;
Bool oneClock = false;
Bool oneLights = false;			/*True iff to make only one controller*/

Coord starPoints[][3] =			/*Points of a star*/
	{
	    {1.0, STARSIZE, 0.0},
	    {1.0, 0.0, STARSIZE},
	    {1.0, -STARSIZE, 0.0},
	    {1.0, 0.0, -STARSIZE}
	};


void DrawSpaceContents(ObjPtr, int, int, int, int, int);

static float f(x)
float x;
/*Performs the increasing monotonic function required for the virtual trackball
  of click radius ratio x.  Yeah, right.*/
{
    if (x <= 0.0)
    {
	return 0.0;
    }
    else if (x >= 1.0)
    {
	return M_PI_2;
    }
    else
    {
	return M_PI_2 * x;
    }
}

Bool GetListExtent(list, bounds)
ObjPtr list;
real bounds[];
/*Puts the extent of the objects (or the objects they represent) in list 
  into bounds.  Returns true iff it's nonzero*/
{
    ThingListPtr runner;

    /*Make bounds ludicrous*/
    bounds[0] = bounds[2] = bounds[4] = 1e12;
    bounds[1] = bounds[3] = bounds[5] = -1e12;

    runner = LISTOF(list);
    if (!runner)
    {
	return false;
    }
    while (runner)
    {
	ObjPtr repObj;
	repObj = runner -> thing;
	if (IsObject(repObj))
	{
	    FuncTyp boundsMethod;

	    boundsMethod = GetMethodSurely("GetListExtent", repObj, GETBOUNDS);
	    if (boundsMethod)
	    {
		real localBounds[6];
		(*boundsMethod)(repObj, localBounds);
		if (localBounds[0] < bounds[0]) bounds[0] = localBounds[0];
		if (localBounds[1] > bounds[1]) bounds[1] = localBounds[1];
		if (localBounds[2] < bounds[2]) bounds[2] = localBounds[2];
		if (localBounds[3] > bounds[3]) bounds[3] = localBounds[3];
		if (localBounds[4] < bounds[4]) bounds[4] = localBounds[4];
		if (localBounds[5] > bounds[5]) bounds[5] = localBounds[5];
	    }
	}
	runner = runner -> next;
    }
    return true;
}

#define NUDGESIZE	400		/*Size of one nudge*/
#define MAXNNUDGES	3		/*Maximum number of nudges*/
long zMin = 0 + NUDGESIZE * MAXNNUDGES;
long zMax = 0x7fffff - NUDGESIZE * MAXNNUDGES;
long curZMin, curZMax;

void NudgeCloser()
/*Nudges objects to be drawn closer*/
{
    curZMax -= NUDGESIZE;
    curZMin -= NUDGESIZE;
    lsetdepth(curZMin, curZMax);
}

void NudgeFarther()
/*Nudges objects to be drawn farther*/
{
    curZMax += NUDGESIZE;
    curZMin += NUDGESIZE;
    lsetdepth(curZMin, curZMax);
}

static void StartSpace(space, left, right, bottom, top, action, whichView)
ObjPtr space;
int left, right, bottom, top;
int action;
int whichView;
/*Start a drawing, rotation, or press in a space.  Action is the action
  that is being performed*/
{
    real eyePosn[3];		/*Coords of the eye*/
    real focusPoint[3];		/*Coords of the focus point*/
    real roll;
    ObjPtr object;
    ObjPtr psStuff;
    ObjPtr boundsArray;
    real bounds[4];
    real bigBounds[6];		/*Bounds of the objects*/
    Coord center[3];		/*The center of the data set*/
    ObjPtr contents;
    float scaleFactor;		/*Factor to scale*/
    ObjPtr xformMatrix;		/*The rotation matrix*/
    ObjPtr shearMatrix;		/*The shear matrix*/
    real maxSize;		/*Maximum size of the objects this draw*/
    ObjPtr observer;		/*Observer of the space*/
    ObjPtr clock;		/*The clock*/
    real eyeOffset;
    real eyeDir[3];

    MyPushMatrix();

    if (whichView == VIEW_XLEFT)
    {
	left = (left + right) / 2 + 1;
    }
    else if (whichView == VIEW_XRIGHT)
    {
	right = (left + right) / 2;
    }

    switch (whichView)
    {
	case VIEW_XLEFT:
	case VIEW_RCLEFT:
	    eyeOffset = -0.2;
	    break;
	case VIEW_XRIGHT:
	case VIEW_RCRIGHT:
	    eyeOffset = 0.2;
	    break;
	default:
	    eyeOffset = 0.0;
    }

    /*Set a new viewport to the current area*/
    pushviewport();
    viewport(left, right, bottom, top);
    InitClipRect();

#if 0
    observers = GetListVar("StartSpace", space, OBSERVERS);
    if (!observers || !LISTOF(observers)) return;
    observer = LISTOF(observers) -> thing;
#else
    observer = GetObjectVar("StartSpace", space, OBSERVER);
#endif
    if (!observer) return;

    curSpacePerspec[0] = INITEYEDIST;
    psStuff = GetFixedArrayVar("StartSpace", observer, PERSPECSTUFF, 1, 4L);
    if (psStuff)
    {
	Array2CArray(curSpacePerspec, psStuff);
    }

    /*Get information about the eye*/
    object = GetFixedArrayVar("StartSpace", observer, LOCATION, 1, 3L);
    if (object)
    {
	Array2CArray(eyePosn, object);
    }
    else
    {
	eyePosn[0] = 0.0;
	eyePosn[1] = 0.0;
	eyePosn[2] = curSpacePerspec[0];
    }
    object = GetFixedArrayVar("StartSpace", observer, FOCUSPOINT, 1, 3L);
    if (object)
    {
	Array2CArray(focusPoint, object);
    }
    else
    {
	focusPoint[0] = 0.0;
	focusPoint[1] = 0.0;
	focusPoint[2] = 0.0;
    }

    object = GetRealVar("StartSpace", observer, ROLL);
    if (object)
    {
	roll = GetReal(object);
    }
    else
    {
	roll = 0.0;
    }

    if (whichView == VIEW_XLEFT || whichView == VIEW_XRIGHT ||
	rgbp && (whichView == VIEW_RCLEFT || whichView == VIEW_RCRIGHT))
    {
	real temp;
	/*Have to slide eyePosn and focusPoint over somewhat*/
	eyeDir[0] = focusPoint[0] - eyePosn[0];
	eyeDir[1] = focusPoint[1] - eyePosn[1];
	eyeDir[2] = focusPoint[2] - eyePosn[2];
	NORMALIZE(eyeDir);

	/*Make 90 degree rotation in plane*/
	temp = eyeDir[0];
	eyeDir[0] = eyeDir[2];
	eyeDir[2] = -temp;
	eyeDir[1] = 0.0;
	NORMALIZE(eyeDir);

	/*Twist by roll*/
	temp = rcos(roll);
	eyeDir[0] *= temp;
	eyeDir[2] *= temp;
	eyeDir[1] *= rsin(roll);

	/*Offset*/
	eyeDir[0] *= eyeOffset;
	eyeDir[1] *= eyeOffset;
	eyeDir[2] *= eyeOffset;

	eyePosn[0] -= eyeDir[0];
	eyePosn[1] -= eyeDir[1];
	eyePosn[2] -= eyeDir[2];
/*
	focusPoint[0] -= eyeDir[0];
	focusPoint[1] -= eyeDir[1];
	focusPoint[2] -= eyeDir[2];
*/
    }

    /*Get information about the clock*/
    clock = GetObjectVar("StartSpace", space, CLOCK);
    if (clock)
    {
	ObjPtr time;
	time = GetVar(clock, TIME);
	if (time)
	{
	    spaceTime = GetReal(time);
	}
	else
	{
	    spaceTime = 0.0;
	}
    }
    else
    {
	spaceTime = 0.0;
    }

    /*Set the current space*/
    curSpace = space;
    RegisterInSpace(true);

    shearMatrix = (ObjPtr) GetVar(space, SHEAR);
    if (observer)
    {
	xformMatrix = (ObjPtr) GetMatrixVar("StartSpace", observer, XFORM);
    }
    curSpaceLights = GetVar(space, LIGHTS);
    /*Set up the lights*/
    if (action == DRAWSPACE)
    {
	shademodel(GOURAUD);
#ifdef GL4D
	mmode(MPROJECTION);
	loadmatrix(Identity);
#endif
	ortho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
	lookat(0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0);

#ifdef GL4D
	mmode(MVIEWING);
	loadmatrix(Identity);
#endif

	/*Shear the light sources*/
	if (shearMatrix && IsMatrix(shearMatrix))
	{
	    multmatrix(MATRIXOF(shearMatrix));
	}

#ifdef ROTLIGHTS
	/*Rotate the light sources*/
	if (xformMatrix && IsMatrix(xformMatrix))
	{
	    multmatrix(MATRIXOF(xformMatrix));
	}
#endif

#ifdef GL4D
	if (curSpaceLights)
	{
	    StartLights(space, curSpaceLights);
	}
#endif
    }

    if (action == PICKSPACE)
    {
	StartPick(space);
    }
#ifdef GL4D
    mmode(MPROJECTION);
#endif
    if (whichView == VIEW_ORTHO)
    {
	/*Plain old orthographic projection.*/
	ortho(-ASPECT * curSpacePerspec[1], ASPECT * curSpacePerspec[1],
	      -curSpacePerspec[1], curSpacePerspec[1], curSpacePerspec[2], curSpacePerspec[3]);
    }
    else
    {
	/*Exciting perspective projection!!!*/
	perspective((long) (curSpacePerspec[1] * 10.0), ASPECT, curSpacePerspec[2], curSpacePerspec[3]);
    }
    lookat(eyePosn[0], eyePosn[1], eyePosn[2],
	focusPoint[0], focusPoint[1], focusPoint[2], 
	-(Angle) (roll * ROLLDSPFACTOR));

#ifdef GL4D
    mmode(MVIEWING);
    loadmatrix(Identity);
#endif

    if (action == DRAWSPACE || action == PICKSPACE)
    {
	/*Draw the background of the space*/
	if (action == DRAWSPACE)
	{
	    zbuffer(TRUE);
	    zclear();
	    curZMin = zMin + NUDGESIZE * MAXNNUDGES;
	    curZMax = zMax - NUDGESIZE * MAXNNUDGES;
	    lsetdepth(curZMin, curZMax);
	}

	if (rgbp && whichView == VIEW_RCLEFT)
	{
	    RGBwritemask(0, 0xFF, 0xFF);
	}
	else if (rgbp && whichView == VIEW_RCRIGHT)
	{
	    RGBwritemask(0xFF, 0, 0);
	}

	/*Shear the objects*/
	if (shearMatrix && IsMatrix(shearMatrix))
	{
	    multmatrix(MATRIXOF(shearMatrix));
	}

	/*Draw stuff in focus centered space coordinates*/
	if (action == DRAWSPACE)
	{
	    Matrix justRot;
	    int i;
	    real radius;

	    radius = SPACESPHERESIZE * curSpacePerspec[0] * rsin(curSpacePerspec[1] * M_PI / 180.0);

	    MATCOPY(justRot, MATRIXOF(xformMatrix));
	    for (i = 0; i < 3; ++i)
	    {
		    justRot[3][i] = justRot[i][3] = 0.0;
	    }

	    pushmatrix();
	    translate(focusPoint[0], focusPoint[1], focusPoint[2]);
	    getmatrix(viewerUnrotMatrix);
	    multmatrix(justRot);

	    getmatrix(viewerCoordsMatrix);
	    if (GetPredicate(curSpace, ROTATING) && GetPrefTruth(PREF_ROTGUIDES))
	    {
		DrawWFSphere(0.0, 0.0, 0.0,
			radius, UIGRAY50);
		DrawSpaceLine(0.0 - radius, 0.0, 0.0, 0.0 + radius, 0.0, 0.0, UIGRAY50);
		DrawSpaceLine(0.0, 0.0 - radius, 0.0, 0.0, 0.0 + radius, 0.0, UIGRAY50);
		DrawSpaceLine(0.0, 0.0, 0.0 - radius, 0.0, 0.0, 0.0 + radius, UIGRAY50);
	    }
	    else if (GetPredicate(curSpace, MOVING) && GetPrefTruth(PREF_MOVEGUIDES))
	    {
		real x, y;
		for (x = -10.0; x <= 10.0; x += 2.0)
		{
		    for (y = -10.0; y <= 10.0; y += 2.0)
		    {
			DrawSpaceLine(x, y, -10.0, x, y, 10.0, UIGRAY50);
			DrawSpaceLine(x, -10.0, y, x, 10.0, y, UIGRAY50);
			DrawSpaceLine(-10.0, x, y, 10.0, x, y, UIGRAY50);
		    }
		}
	    }
	    popmatrix();
	}

	/*Rotate the objects*/
	multmatrix(MATRIXOF(xformMatrix));

	/*Determine the size of the objects within*/ 
	contents = GetVar(space, CONTENTS);
	GetListExtent(contents, bigBounds);

	/*Get their center*/
	center[0] = (bigBounds[1] + bigBounds[0]) / 2.0;
	center[1] = (bigBounds[3] + bigBounds[2]) / 2.0;
	center[2] = (bigBounds[5] + bigBounds[4]) / 2.0;

	/*Scale to a reasonable scaling factor for the data*/
	maxSize = ABS(bigBounds[1] - bigBounds[0]);
	if (ABS(bigBounds[3] - bigBounds[2]) > maxSize)
	{
	    maxSize = ABS(bigBounds[3] - bigBounds[2]);
	}
	if (ABS(bigBounds[5] - bigBounds[4]) > maxSize)
	{
	    maxSize = ABS(bigBounds[5] - bigBounds[4]);
	}
	scaleFactor = 1.6 / maxSize;
	scale(scaleFactor, scaleFactor, scaleFactor);

	/*Translate to be centered around object's center*/
	translate(-center[0], -center[1], -center[2]);
    }
}

static void StopSpace(action)
int action;
/*Stops drawing, rotating, or pressing in a space*/
{
    if (action == PICKSPACE)
    {
	StopPick(curSpace);
    }

    if (action == DRAWSPACE)
    {
	real radius;

	radius = SPACESPHERESIZE * curSpacePerspec[0] * rsin(curSpacePerspec[1] * M_PI / 180.0);

	/*Draw the lights*/
	loadmatrix(viewerCoordsMatrix);
	if (curSpaceLights)
	{
	    DrawLights(curSpace, curSpaceLights, action, radius);
	    StopLights(curSpace);
	}
	if (rgbp)
	{
	   RGBwritemask(0xFF, 0xFF, 0xFF);
	}
    }
    ResetClipRect();
    popviewport();
#ifdef GL4D
    mmode(MSINGLE);
    loadmatrix(Identity);
#endif

    EndRegister();
    MyPopMatrix();

    zbuffer(FALSE);
    curSpace = NULLOBJ;
}

Bool ChangeFocus(observer)
ObjPtr observer;
/*Changes the focus of observer according to roll, pitch, yaw*/
{
    ObjPtr tempObj;
    real eyePosn[3];
    real pitch, yaw, roll;
    real perspecStuff[4];

    tempObj = GetFixedArrayVar("ChangeFocus", observer, LOCATION, 1, 3L);
    if (!tempObj)
    {
	return false;
    }
    Array2CArray(eyePosn, tempObj);

    tempObj = GetRealVar("ChangeFocus", observer, PITCH);
    if (!tempObj)
    {
	return false;
    }
    pitch = GetReal(tempObj);

    tempObj = GetRealVar("ChangeFocus", observer, YAW);
    if (!tempObj)
    {
	return false;
    }
    yaw = GetReal(tempObj);

    tempObj = GetRealVar("ChangeFocus", observer, ROLL);
    if (!tempObj)
    {
	return false;
    }
    roll = GetReal(tempObj);

    /*Get perspective stuff for scaling movement and eyeball distance*/
    tempObj = GetFixedArrayVar("ChangeFocus", observer, PERSPECSTUFF, 1, 4L);
    if (tempObj)
    {
	Array2CArray(perspecStuff, tempObj);
    }
    else
    {
	perspecStuff[0] = INITEYEDIST;
    }

    /*Change focus point to be from new eye position*/
    eyePosn[0] += rsin(yaw) * perspecStuff[0];
    eyePosn[1] += rsin(pitch) * perspecStuff[0];
    eyePosn[2] += rcos(yaw) * perspecStuff[0];
    tempObj = NewRealArray(1, 3L);
    CArray2Array(tempObj, eyePosn);
    SetVar(observer, FOCUSPOINT, tempObj);

    ResolveController(observer);
    return true;
}

ObjPtr WakeObserver(observer, lateness)
ObjPtr observer;
double lateness;
/*Wakes an observer and makes it continue rotation*/
{
    ObjPtr var;
    real axis[3];
    Matrix rotDelta;		/*Delta rotation matrix*/
    real phi;
    Bool wakeAgain = false;	/*True iff wake again*/

    DoNotDisturb(observer, MARKTIME);

    var = GetVar(observer, ROTSPEED);
    if (var && 0.0 != (phi = GetReal(var)))
    {
	/*Turn phi from speed to amount*/
	phi *= lateness;

	var = GetFixedArrayVar("WakeObserver", observer, ROTAXIS, 1, 3L);
	if (var)
	{
	    Array2CArray(axis, var);

	    RotateObserver(observer, axis, phi, false);
	}

	wakeAgain = true;
    }
    else if (GetPredicate(observer, FLYING))
    {
	real focusPoint[3];
	ObjPtr var;
	real eyePosn[3];
	real roll, yaw, dPitch, pitch;
	float dTime;
	real perspecStuff[4];
	real airspeed;

	dTime = lateness;

	var = GetFixedArrayVar("DrawSpace", observer, FOCUSPOINT, 1, 3L);
	if (var)
	{
	    Array2CArray(focusPoint, var);
	}
	else
	{
	    focusPoint[0] = 0.0;
	    focusPoint[1] = 0.0;
	    focusPoint[2] = 0.0;
	}

	/*Move eye according to airspeed*/
	var = GetVar(observer, AIRSPEED);
	if (var && IsReal(var))
	{
	    airspeed = GetReal(var);
	}
	else
	{
	    airspeed = 0.0;
	}
	
	var = GetVar(observer, LOCATION);
	if (var && IsArray(var) && RANK(var) == 1 && 
	    DIMS(var)[0] == 3)
	{
	    Array2CArray(eyePosn, var);
	}
	else
	{
	    eyePosn[0] = 0.0;
	    eyePosn[1] = 0.0;
	    eyePosn[2] = INITEYEDIST;
	    var = NewRealArray(1, (long) 3);
	    SetVar(observer, LOCATION, var);
	}
	
	/*Update eye position based on airspeed*/
	    var = GetVar(observer, ROLL);
	    if (var && IsReal(var))
	    {
		roll = GetReal(var);
	    }
	    else
	    {
		roll = 0.0;
		var = NewReal(roll);
		SetVar(observer, ROLL, var);
	    }

	    /*Get dPitch*/
	    var = GetVar(observer, DPITCH);
	    if (var && IsReal(var))
	    {
		dPitch = GetReal(var);
	    }
	    else
	    {
		dPitch = 0.0;
		var = NewReal(dPitch);
		SetVar(observer, DPITCH, var);
	    }

	    /*Get pitch*/
	    var = GetVar(observer, PITCH);
	    if (var && IsReal(var))
	    {
		pitch = GetReal(var);
	    }
	    else
	    {
		pitch = 0.0;
		var = NewReal(pitch);
		SetVar(observer, PITCH, var);
	    }
	
	    /*Change the pitch based on dpitch, asymptotic to up and down*/
	    if (dPitch > 0.0)
	    {
		pitch = pitch + (M_PI_2 - pitch) * dPitch * dTime;
	    }
	    else
	    {
		pitch = pitch + (pitch + M_PI_2) * dPitch * dTime;
	    }
	    SetVar(observer, PITCH, NewReal(pitch));

	    /*Get yaw*/
	    var = GetRealVar("DrawSpace", observer, YAW);
	    if (var && IsReal(var))
	    {
		yaw = GetReal(var);
	    }
	    else
	    {
		yaw = M_PI;
		var = NewReal(yaw);
		SetVar(observer, YAW, var);
	    }
	
	    /*Change yaw based on roll*/
	    yaw -= roll * ROLLYAWFACTOR * dTime;
	    SetVar(observer, YAW, NewReal(yaw));

	    /*Move eye*/
	    eyePosn[2] += rcos(yaw) * airspeed * dTime;
	    eyePosn[1] += rsin(pitch) * airspeed * dTime;
	    eyePosn[0] += rsin(yaw) * airspeed * dTime; 

	    var = NewRealArray(1, 3L);
	    CArray2Array(var, eyePosn);
	    SetVar(observer, LOCATION, var);
	
	    /*Recalculate focuspoint*/
	    ChangeFocus(observer);
	    ResolveController(observer);
	wakeAgain = true;
    }
    if (wakeAgain)
    {
	WakeMe(observer, MARKTIME, Clock() + 0.001);
    }
    return ObjTrue;
}

#ifdef PROTO
void SetRotationMotor(real rotSpeed, real ax, real ay, real az)
#else
void SetRotationMotor(rotSpeed, ax, ay, az)
real rotSpeed, ax, ay, az;
#endif
/*Sets a rotation motor at rotSpeed around axis ax, ay, az*/
{
    ObjPtr var;
    real axis[3];
    char logLine[256];
    ObjPtr space, observer;

    if (!selWinInfo)
    {
	return;
    }

    space = FindSpace(selWinInfo);
    if (!space)
    {
	return;
    }

    observer = GetObjectVar("SetRotationMotor", space, OBSERVER);
    if (!observer)
    {
	return;
    }

    var = NewRealArray(1, 3L);
    axis[0] = ax;
    axis[1] = ay;
    axis[2] = az;
    CArray2Array(var, axis);

    SetVar(observer, ROTAXIS, var);
    SetVar(observer, ROTSPEED, NewReal(rotSpeed));

    if (logging)
    {
	sprintf(logLine, "set rotation %g [%g %g %g]\n",
		rotSpeed * 180.0 / M_PI, ax, ay, az);
	Log(logLine);
    }

    if (rotSpeed > 0.0)
    {
	DoNotDisturb(observer, MARKTIME);
	WakeMe(observer, MARKTIME, Clock());
    }
}

static ObjPtr RotateSpace(object, x, y, flags)
ObjPtr object;
int x, y;
int flags;
/*Does a rotate in a space beginning at x and y.  Returns
  true iff the rotate really was in the panel.*/
{
    int left, right, bottom, top;

    Get2DIntBounds(object, &left, &right, &bottom, &top);

    if (x >= left && x <= right && y >= bottom && y <= top)
    {
	ObjPtr xformMatrix = 0;
	ObjPtr observer/*, observers*/;
	ObjPtr lights;
	ThingListPtr runner;

	if (TOOL(flags) == T_HELP)
	{
	    ContextHelp(object);
	    return ObjTrue;
	}

	/*Hey!  It really was a click in the space!*/
	StartSpace(object, left, right, bottom, top, ROTSPACE, VIEW_CENTER);

	/*See if there are any lights to rotate*/
	lights = GetVar(object, LIGHTS);
	if (lights)
	{
	    runner = LISTOF(lights);
	    while (runner)
	    {
		if (IsLightSelected(runner -> thing, GetVar(object, CORRAL)))
		{
		    break;
		}
		runner = runner -> next;
	    }
	}
	/*If none selected, say there are none*/
	if (!runner)
	{
	    lights = NULLOBJ;
	}

	/*Get the rotation matrix*/
#if 0
	observers = GetListVar("RotateSpace", object, OBSERVERS);
	if (!observers || !LISTOF(observers)) return ObjFalse;
	observer = LISTOF(observers) -> thing;
#else
	observer = GetObjectVar("RotateSpace", object, OBSERVER);
#endif

	if (observer)
	{
	    xformMatrix = (ObjPtr) GetMatrixVar("RotateSpace", observer, XFORM);
	}
	if (xformMatrix && IsMatrix(xformMatrix))
	{
	    Bool motorOn = false;	/*True iff motor on*/
	    float rotSpeed = 0.0;	/*Rotation speed*/
	    float ax, ay, az;		/*Three components of axis of rotation*/
	    real axis[3];
	    if (flags & F_DOUBLECLICK)
	    {
		if (lights)
		{
		    /*Double-click.  Snap lights to their closest values*/

		    runner = LISTOF(lights);
		    while (runner)
		    {
			if (IsLightSelected(runner -> thing, GetVar(object, CORRAL)))
			{
			    /*Rotate the light*/
			    ObjPtr var;
			    int i;
			    float biggest;
			    int ibiggest;
			    real location[3];
	    
			    var = GetFixedArrayVar("RotateSpace", runner -> thing, LOCATION, 1, 3L);
			    if (var)
			    {
				Array2CArray(location, var);
				biggest = 0.0;
				ibiggest = 0;
				for (i = 0; i < 3; ++i)
				{
				    if (ABS(location[i]) > biggest)
				    {
					ibiggest = i;
					biggest = ABS(location[i]);
				    }
				}
				location[ibiggest] =
				    location[ibiggest] > 0.0 ? 1.0 : -1.0;
				for (i = 0; i < 3; ++i)
				{
				    if (i != ibiggest)
				    {
					location[i] = 0.0;
				    }
				}
				var = NewRealArray(1, 3L);
				CArray2Array(var, location);
				SetVar(runner -> thing, LOCATION, var);
				ResolveController(runner -> thing);
			    }
			}
			runner = runner -> next;
		    }
		}
		else
		{
		/*It was a double click.  Align the rotation matrix to the
		  nearest orthogonal unit vector*/
		Matrix newRot;		/*New rotation matrix*/
		Bool jSet[3];		/*True iff this j has been set nonzero*/
		int i, j;		/*Counters within the matrix*/
		float biggest;		/*The biggest xform coefficient so far*/
		int jbiggest;		/*The j of biggest*/

		MATCOPY(newRot, MATRIXOF(xformMatrix));
		for (j = 0; j < 3; ++j)
		{
		    jSet[j] = false;
		}
		for (i = 0; i < 3; ++i)
		{
		    biggest = -1.0;
		    jbiggest = -1;

		    for (j = 0; j < 3; ++j)
		    {
			if ((ABS(newRot[i][j]) > biggest) && (!jSet[j]))
			{
			    biggest = ABS(newRot[i][j]);
			    jbiggest = j;
			}
		    }
		    if (jbiggest == -1)
		    {
			StopSpace(ROTSPACE);
			return ObjTrue;
		    }
		    else
		    {
			jSet[jbiggest] = 1;
			for (j = 0; j < 3; ++j)
			{
			    if (j == jbiggest)
			    {
				if (newRot[i][j] < 0.0) newRot[i][j] = -1.0;
				else newRot[i][j] = 1.0;
			    }
			    else newRot[i][j] = 0.0;
			}
		    }
		}
		MATCOPY(MATRIXOF(xformMatrix), newRot);
		ResolveController(observer);
		}
		ImInvalid(object);
	    }
	    else
	    {
		/*It's a click and drag.  Do the trackball stuff.*/
		float Ox, Oy;		/*Center of virtual trackball*/
		float r;		/*Radius of virtual trackball*/
		float omega;		/*Ratio of the click radius to the trackball radius*/
		float theta;		/*Angle to the click radius*/
		float tao;		/*Angle from the click radius to the direction*/
		float phi;		/*Amount the trackball is pushed*/
		int newX, newY;		/*New X and Y values*/
		Bool firstRun = true;	/*The first run*/
		float lastTime = 0.0;   /*The last time*/
		float cumPhi = 0.0;	/*Cumulative phi*/
		float curTime = 0.0;	/*The current time*/

		SetVar(object, ROTATING, ObjTrue);
		DrawMe(object);

		/*Calculate origin and radius of trackball*/
		Ox = (left + right) / 2;
		Oy = (top + bottom) / 2;
		r = 0.4 * (float) (top - bottom);

		x -= Ox;		/*Offset x and y around trackball*/
		y -= Oy;

		while (Mouse(&newX, &newY))
		{
		    newX -= Ox;		/*Offset the new x and y*/
		    newY -= Oy;
		
		    if (ABS(newX - x) >= MINROT || ABS(newY - y) >= MINROT)
		    {
			/*Now we have a differential*/
			float dr;		/*Click axis distance*/
			float sw, cw;		/*Sin and cosine of omega*/
			float st, ct;		/*Sin and cosine of theta*/
			float sp, cp;		/*Sin and cosine of phi*/
			float a1x, a1y, a1z;	/*Temporary values for axis of rotation*/
			float a2x, a2y, a2z;	/*Temporary values for axis of rotation*/
			float t;		/*1-cos phi*/
			Matrix rotDelta;	/*Change in rotation*/
			ObjPtr dRotMatrix;	/*Delta rotation matrix*/

			dr = fsqrt(SQUARE((float) x) +
				   SQUARE((float) y));
			omega = f(dr / r);

			/*Calculate theta*/
			theta = fatan2((float) (y), (float) (x));

			/*Calculate tao as offset from theta*/
			tao = fatan2((float) (newY - y), (float) (newX - x)) - theta;

			/*Calculate phi simplistically*/
			phi = fsqrt(SQUARE((float) (newX - x)) +
				    SQUARE((float) (newY - y))) / r;

			/*Calculate sin and cos of the angles for speed*/
			sw = fsin(omega);
			cw = fcos(omega);
			st = fsin(theta);
			ct = fcos(theta);
			sp = fsin(phi);
			cp = fcos(phi);
			t = 1.0 - cp;

			/*Calculate the axis of rotation*/
			/*First the motion from origin component*/
			a1x = -fsin(tao);
			a1y = fcos(tao);
			a1z = 0.0;

			/*Now multiply in the "on x-axis" component*/
			a2x = a1x * cw + a1z * sw;
			a2y = a1y;
			a2z = a1x * -sw + a1z * cw;
			/*Now multiply in the from the x-axis component*/
			ax = a2x * ct + a2y * -st;
			ay = a2x * st + a2y * ct;
			az = a2z;

			/*Calculate the phi and delta time*/
			if (firstRun)
			{
			    firstRun = false;
			    cumPhi = 0.0;
			    lastTime = Clock();
			}
			else
			{
			    curTime = Clock();
			    cumPhi += phi;
			    if (curTime > lastTime + MINROTTIME)
			    {
				motorOn = true;
				rotSpeed = cumPhi / (curTime - lastTime);
				lastTime = curTime;
			    }
			}

			axis[0] = ax;
			axis[1] = ay;
			axis[2] = az;

			/*Now that there's a new delta, save it and redraw*/
			if (lights)
			{
			    RotateLights(lights, axis, phi, flags & F_SHIFTDOWN ? true : false, observer, object);
			}
			else
			{
			    RotateObserver(observer, axis, phi, flags & F_SHIFTDOWN ? true : false);
			}

			x = newX;
			y = newY;
			ResolveController(observer);
			DrawMe(object);
		    }
		    else
		    {
			firstRun = true;
			motorOn = false;
		    }
		}
		SetVar(object, ROTATING, false);
	    }
	    StopSpace(ROTSPACE);

	    if (logging)
	    {
		char cmd[256];
		char *s;
		Bool rotLights;
		ThingListPtr runner;

		/*See if it's lights that were rotated*/
		rotLights = false;
		if (lights)
		{
		    runner = LISTOF(lights);

		    while (runner)
		    {
			if (IsLightSelected(runner -> thing, GetVar(object, CORRAL)))
			{
			    /*Rotated light*/
		
			    ObjPtr var;
			    real location[3];
				
			    rotLights = true;
			    var = GetFixedArrayVar("RotateSpace", runner -> thing, LOCATION, 1, 3L);
			    if (var)
			    {
				Array2CArray(location, var);
				sprintf(cmd, "set location ");
				s = cmd;
				while (*s) ++s;
				MakeObjectName(s, runner -> thing);
				while (*s) ++s;
				sprintf(s, " [%g %g %g]\n",
					location[0],
					location[1],
					location[2]);
				Log(cmd);
			    }
			}
			runner = runner -> next;
		    }
		}
		else
		{
		    /*No lights rotated*/
		    xformMatrix = (ObjPtr) GetMatrixVar("RotateSpace", observer, XFORM);
		    MatrixToText(tempStr, MATRIXOF(xformMatrix));
	 	    sprintf(cmd, "rotate to %s\n", tempStr);
		    Log(cmd);
		}
	    }

	    if (!lights && GetPrefTruth(PREF_ROTINERTIA))
	    {
		if (motorOn)
		{
	            SetRotationMotor((real) rotSpeed, axis[0], axis[1], axis[2]);
		}
		else
		{
	            SetRotationMotor((real) 0.0, axis[0], axis[1], axis[2]);
		}
	    }

	    return ObjTrue;
	}
	else
	{
	    return ObjFalse;
	}
    }
    else
    {
	return ObjFalse;
    }
}

static ObjPtr PressSpace(object, x, y, flags)
ObjPtr object;
int x, y;
int flags;
/*Does a press in a space beginning at x and y.  Returns
  true iff the press really was in the space.*/
{
    int left, right, bottom, top;
    ObjPtr lights, corral;
    ThingListPtr runner;

    if (TOOL(flags) == T_ROTATE)
    {
	return RotateSpace(object, x, y, flags);
    }

    Get2DIntBounds(object, &left, &right, &bottom, &top);

    if (x >= left && x <= right && y >= bottom && y <= top)
    {
	/*It's a click in the space*/
	int d;
	int newX, newY;
	ObjPtr observer/*, observers*/;
	ObjPtr pickedObjects;
	ObjPtr lights, objects;
	ThingListPtr runner;
	ObjPtr xformMatrix;
	ObjPtr tempObj;
	real eyePosn[3];
	real moveVector[3];
	real pitch, yaw, roll;
	real uMove, vMove;
	real uMoveP, vMoveP, wMoveP;
	real sr, cr;
	real sp, cp;
	real sy, cy;
	real perspecStuff[4];
	real sf;

	d = top - bottom;

	if (TOOL(flags) == T_HELP)
	{
	    ContextHelp(object);
	    return ObjTrue;
	}

	corral = GetVar(object, CORRAL);
	lights = GetVar(object, LIGHTS);
	if (lights && corral)
	{
	    runner = LISTOF(lights);
	    while (runner)
	    {
		if (IsLightSelected(runner -> thing, corral))
		{
		    return ObjTrue;
		}
		runner = runner -> next;
	    }
	}
#if 0
	observers = GetListVar("PressSpace", object, OBSERVERS);
	if (!observers || !LISTOF(observers)) return ObjFalse;
	observer = LISTOF(observers) -> thing;
#else
	observer = GetObjectVar("PressSpace", object, OBSERVER);
#endif
	if (!observer) return ObjFalse;

	SetRotationMotor(0.0, 0.0, 0.0, 1.0);
	MakeMeCurrent(NULLOBJ);

	xformMatrix = (ObjPtr) GetMatrixVar("PressSpace", observer, XFORM);
	if (!xformMatrix)
	{
	    return ObjFalse;
	}
#if 0
Don't pick for now
	/*See if this press picks anything*/
	StartSpace(object, left, right, bottom, top, PICKSPACE, VIEW_CENTER);

	StopSpace(PICKSPACE);

	/*Deselect all objects if shift not down*/
	if (0 == (flags & F_SHIFTDOWN))
	{
	    /*First lights*/
	    objects = GetVar(object, LIGHTS);
	    if (objects)
	    {
		runner = LISTOF(objects);
		while (runner)
		{
		    FuncTyp method;
		    method = GetMethod(runner -> thing, SELECT);
		    if (method)
		    {
			(*method)(runner -> thing, false);
		    }
		    runner = runner -> next;
		}
	    }
	}

	if (pickedObjects = PickedObjects())
	{
	    /*Some objects were picked*/
	    /*Now select all the picked objects*/
	    runner = LISTOF(pickedObjects);
	    while (runner)
	    {
		/*Select or deselect the object*/
		if (GetPredicate(runner -> thing, SELECTED))
	        {
		    /*Already selected.  Only deselect if shift down*/
		    if (flags & F_SHIFTDOWN)
		    {
			FuncTyp method;
			method = GetMethod(runner -> thing, SELECT);
			if (method)
			{
			    (*method)(runner -> thing, false);
			}
		    }
		}
		else
		{
		    FuncTyp method;
		    method = GetMethod(runner -> thing, SELECT);
		    if (method)
		    {
			(*method)(runner -> thing, true);
		    }
		}
		runner = runner -> next;
	    }
	}
#endif
	StartSpace(object, left, right, bottom, top, MOVESPACE, VIEW_CENTER);

	SetVar(object, MOVING, ObjTrue);
	DrawMe(object);

	/*Get info about the space*/
	tempObj = GetFixedArrayVar("PressSpace", observer, LOCATION, 1, 3L);
	if (!tempObj)
	{
	    return ObjFalse;
	}
	Array2CArray(eyePosn, tempObj);

	tempObj = GetRealVar("PressSpace", observer, PITCH);
	if (!tempObj)
	{
	    return ObjFalse;
	}
	pitch = GetReal(tempObj);

	tempObj = GetRealVar("PressSpace", observer, YAW);
	if (!tempObj)
	{
	    return ObjFalse;
	}
	yaw = GetReal(tempObj);

	tempObj = GetRealVar("PressSpace", observer, ROLL);
	if (!tempObj)
	{
	    return ObjFalse;
	}
	roll = GetReal(tempObj);

	/*Get perspective stuff for scaling movement and eyeball distance*/
	tempObj = GetFixedArrayVar("PressSpace", observer, PERSPECSTUFF, 1, 4L);
	if (tempObj)
	{
	    Array2CArray(perspecStuff, tempObj);
	}
	else
	{
	    perspecStuff[0] = INITEYEDIST;
	}

	if (flags & F_DOUBLECLICK)
	{
	
	}
	/*Press the contents of the space*/
	else while (Mouse(&newX, &newY))
	{
	    if (newX != x && newY != y)
	    {
		real focusPoint[3];

		/*Get raw uMove and vMove*/
		sf = perspecStuff[0] * MOVEFACTOR;
		uMove = sf * ((float) (x - newX)) / (float) d;
		vMove = sf * ((float) (y - newY)) / (float) d;

		/*Transform by roll*/
		sr = sin((double) roll);
		cr = cos((double) roll);
		uMoveP = uMove * cr + vMove * sr;
		vMoveP = uMove * -sr + vMove * cr;

		sp = sin((double) pitch);
		cp = cos((double) pitch);
		sy = sin((double) yaw);
		cy = cos((double) yaw);

		/*Produce a motion vector*/
		moveVector[0] = uMoveP * -cy + vMoveP * (sy * -sp);
		moveVector[1] = vMoveP * cp;;
		moveVector[2] = uMoveP * sy + uMoveP * (sy * sp);

		if (flags & F_SHIFTDOWN)
		{
		    int k, best = 0;
		    float curDot, maxDot = 0.0;
		    float rr;

		    /*Constrain the axis to the nearest ortho axis*/
		    for (k = 0; k < 3; ++k)
		    {
			curDot =
			    moveVector[0] * MATRIXOF(xformMatrix)[k][0] +
			    moveVector[1] * MATRIXOF(xformMatrix)[k][1] +
			    moveVector[2] * MATRIXOF(xformMatrix)[k][2];

			if (ABS(curDot) > ABS(maxDot))
			{
			    /*It's a better choice*/
			    maxDot = curDot;
			    best = k;
			}
		    }

		    /*Now we have a best match*/
		    moveVector[0] = maxDot * MATRIXOF(xformMatrix)[best][0];
		    moveVector[1] = maxDot * MATRIXOF(xformMatrix)[best][1];
		    moveVector[2] = maxDot * MATRIXOF(xformMatrix)[best][2];
		}

		eyePosn[0] += moveVector[0];
		eyePosn[1] += moveVector[1];
		eyePosn[2] += moveVector[2];

		/*Put eyePosn back*/
		tempObj = NewRealArray(1, 3L);
		CArray2Array(tempObj, eyePosn);
		SetVar(observer, LOCATION, tempObj);

		/*Change focus point*/
		focusPoint[0] = eyePosn[0] + rsin(yaw) * perspecStuff[0];
		focusPoint[1] = eyePosn[1] + rsin(pitch) * perspecStuff[0];
		focusPoint[2] = eyePosn[2] + rcos(yaw) * perspecStuff[0];
		tempObj = NewRealArray(1, 3L);
		CArray2Array(tempObj, focusPoint);
		SetVar(observer, FOCUSPOINT, tempObj);

		x = newX;
		y = newY;

		ResolveController(observer);
		DrawMe(object);
	    }
	}
	SetVar(object, MOVING, ObjFalse);
	ImInvalid(object);

	StopSpace(MOVESPACE);
	if (logging)
	{
	    ObjPtr eyeStuff;
	    real eyePosn[3];

	    eyeStuff = GetFixedArrayVar("PressSpace", observer, LOCATION, 1, 3L);
	    if (eyeStuff)
	    {
		Array2CArray(eyePosn, eyeStuff);
		sprintf(tempStr, "eyeposn [%g %g %g]\n",
			eyePosn[0], eyePosn[1], eyePosn[2]);
		Log(tempStr);
	    }
	}
	return ObjTrue;
    }
    else
    {
	return ObjFalse;
    }
}

int dsn = 0;

void DrawSpaceContents(space, left, right, bottom, top, viewType)
ObjPtr space;
int left, right, bottom, top;
int viewType;
{
    ObjPtr contents;
    Bool anyTransparent;		/*True iff any objects are transparent*/
    ThingListPtr drawList;		/*List of objects to draw*/
    ObjPtr frontPanel;

    frontPanel = GetVar(space, FRONTPANEL);
    if (frontPanel && GetVar(frontPanel, BACKGROUND))
    {
	/*Front panel has a background.  Don't need to draw space*/
	return;
    }

    /*Set a new viewport to the current area*/
    StartSpace(space, left, right, bottom, top, DRAWSPACE, viewType);

    /*Draw the contents of the space*/
    contents = GetVar(space, CONTENTS);

    /*First draw opaque objects*/
    anyTransparent = false;
    drawList = LISTOF(contents);
    while (drawList)
    {
	if (IsObject(drawList -> thing))
	{
	    if (GetPredicate(drawList -> thing, ISTRANSPARENT))
	    {
		anyTransparent = true;
	    }
	    DrawObject(drawList -> thing);
	}
	else if (IsList(drawList -> thing))
	{
	    DrawList(drawList -> thing);
	}
	drawList = drawList -> next;
    }

    if (anyTransparent && rgbp)
    {
	zwritemask(0);
	blendfunction(BF_SA, BF_MSC);
/***DEBUG
	blendfunction(BF_SA, BF_MSA);
*/
	drawingTransparent = true;
	drawList = LISTOF(contents);
	while (drawList)
	{
	    if (IsObject(drawList -> thing))
	    {
		DrawObject(drawList -> thing);
	    }
	    else if (IsList(drawList -> thing))
	    {
		DrawList(drawList -> thing);
	    }
	    drawList = drawList -> next;
	}
	blendfunction(BF_ONE, BF_ZERO);
	zwritemask(0xffffffff);
	drawingTransparent = false;
    }

    StopSpace(DRAWSPACE);
}

#ifdef PROTO
Bool RotateObserver(ObjPtr observer, real axis[3], real phi, Bool constrain)
#else
Bool RotateObserver(observer, axis, phi, constrain)
ObjPtr observer;
real axis[3];
real phi;
Bool constrain;
#endif
/*Rotates an observer by rotDelta*/
{
    ObjPtr xformMatrix;
    ObjPtr var;
    real focusPoint[3];
    Matrix rotDelta;
    float t;
    float sp, cp;		/*Sin and cosine of phi*/

    sp = rsin(phi);
    cp = rcos(phi);
    t = 1.0 - cp;

    /*Now that there's a new delta, rotate and redraw*/
    xformMatrix = GetMatrixVar("RotateObserver", observer, XFORM);
    if (!xformMatrix)
    {
	return false;
    }

    if (constrain)
    {
	int k, best;
	float curDot, maxDot = 0.0;
	float rr;

	/*Constrain the axis to the nearest ortho axis*/
	for (k = 0; k < 3; ++k)
	{
	    curDot =
		axis[0] * MATRIXOF(xformMatrix)[k][0] +
		axis[1] * MATRIXOF(xformMatrix)[k][1] +
		axis[2] * MATRIXOF(xformMatrix)[k][2];

	    if (ABS(curDot) > ABS(maxDot))
	    {
		/*It's a better choice*/
		maxDot = curDot;
		best = k;
	    }
	}

	/*Now we have a best match*/
	axis[0] = MATRIXOF(xformMatrix)[best][0];
	axis[1] = MATRIXOF(xformMatrix)[best][1];
	axis[2] = MATRIXOF(xformMatrix)[best][2];
	if (maxDot < 0.0)
	{
	    axis[0] = -axis[0];
	    axis[1] = -axis[1];
	    axis[2] = -axis[2];
	}

	/*Normalize the axis*/
	rr = 1.0 / sqrt(axis[0] * axis[0] + axis[1] * axis[1] + axis[2] * axis[2]);
	axis[0] *= rr;
	axis[1] *= rr;
	axis[2] *= rr;
    }

    /*Now make the change rotation matrix by rows from top to bottom*/
    rotDelta[0][0] = t * SQUARE(axis[0]) + cp;
    rotDelta[0][1] = t * axis[0] * axis[1] + sp * axis[2];
    rotDelta[0][2] = t * axis[0] * axis[2] - sp * axis[1];
    rotDelta[0][3] = 0.0;

    rotDelta[1][0] = t * axis[0] * axis[1] - sp * axis[2];
    rotDelta[1][1] = t * SQUARE(axis[1]) + cp;
    rotDelta[1][2] = t * axis[1] * axis[2] + sp * axis[0];
    rotDelta[1][3] = 0.0;

    rotDelta[2][0] = t * axis[0] * axis[2] + sp * axis[1];
    rotDelta[2][1] = t * axis[1] * axis[2] - sp * axis[0];
    rotDelta[2][2] = t * SQUARE(axis[2]) + cp;
    rotDelta[2][3] = 0.0;

    rotDelta[3][0] = 0.0;
    rotDelta[3][1] = 0.0;
    rotDelta[3][2] = 0.0;
    rotDelta[3][3] = 1.0;

    var = GetFixedArrayVar("RotateObserver", observer, FOCUSPOINT, 1, 3L);
    if (var)
    {
	Array2CArray(focusPoint, var);
    }
    else
    {
	focusPoint[0] = 0.0;
	focusPoint[1] = 0.0;
	focusPoint[2] = 0.0;
    }

    pushmatrix();
		    
    loadmatrix(Identity);
    translate(focusPoint[0], focusPoint[1], focusPoint[2]);
    multmatrix(rotDelta);
    translate(-focusPoint[0], -focusPoint[1], -focusPoint[2]);

    multmatrix(MATRIXOF(xformMatrix));
    xformMatrix = NewMatrix();
    getmatrix(MATRIXOF(xformMatrix));
    popmatrix();
    SetVar(observer, XFORM, xformMatrix);
    ResolveController(observer);
    return true;
}

#ifdef PROTO
Bool RotateLights(ObjPtr lights, real startAxis[3], real phi, Bool constrain, ObjPtr observer, ObjPtr space)
#else
Bool RotateLights(lights, axis, phi, constrain, observer, space)
ObjPtr lights;
real startAxis[3];
real phi;
Bool constrain;
ObjPtr observer;
ObjPtr space;
#endif
/*Rotates lights by rotDelta wrt observer within space*/
{
    ObjPtr xformMatrix;
    Matrix rotFixed;
    ThingListPtr runner;
    Matrix rotDelta;
    real axis[3];
    float t;
    float sp, cp;		/*Sin and cosine of phi*/

    xformMatrix = GetMatrixVar("RotateObserver", observer, XFORM);
    if (!xformMatrix)
    {
	return false;
    }

    MATCOPY(rotFixed, MATRIXOF(xformMatrix));

    runner = LISTOF(lights);
    while (runner)
    {
	if (IsLightSelected(runner -> thing, GetVar(space, CORRAL)))
	{
	    /*Rotate the light*/
	    ObjPtr var;
	    real location[3];
	    real newLoc[3];
	    float tv[3];

	    axis[0] = startAxis[0];
	    axis[1] = startAxis[1];
	    axis[2] = startAxis[2];

	    var = GetFixedArrayVar("DrawSpace", runner -> thing, LOCATION, 1, 3L);
	    if (!var)
	    {
		return false;
	    }
	    Array2CArray(location, var);

		/*Test elevation*/
		tv[0] = location[1];
		tv[1] = -location[0];
		tv[2] = 0.0;


	    /*Prerotate by rotFixed*/
	    newLoc[0] = rotFixed[0][0] * location[0] +
			rotFixed[1][0] * location[1] +
			rotFixed[2][0] * location[2];
	    newLoc[1] = rotFixed[0][1] * location[0] +
			rotFixed[1][1] * location[1] +
			rotFixed[2][1] * location[2];
	    newLoc[2] = rotFixed[0][2] * location[0] +
			rotFixed[1][2] * location[1] +
			rotFixed[2][2] * location[2];
	    location[0] = newLoc[0];
	    location[1] = newLoc[1];
	    location[2] = newLoc[2];
    
	    if (constrain)
	    {
		float dot1, dot2;
		float rr;

		/*Constrain the axis to the azimuth or elevation*/

		/*Test azimuth*/
		dot1 = axis[0] * rotFixed[2][0] +
		       axis[1] * rotFixed[2][1] +
		       axis[2] * rotFixed[2][2];

		/*Test elevation*/
	    newLoc[0] = rotFixed[0][0] * tv[0] +
			rotFixed[1][0] * tv[1] +
			rotFixed[2][0] * tv[2];
	    newLoc[1] = rotFixed[0][1] * tv[0] +
			rotFixed[1][1] * tv[1] +
			rotFixed[2][1] * tv[2];
	    newLoc[2] = rotFixed[0][2] * tv[0] +
			rotFixed[1][2] * tv[1] +
			rotFixed[2][2] * tv[2];
		tv[0] = newLoc[0];
		tv[1] = newLoc[1];
		tv[2] = newLoc[2];
		rr = sqrt(tv[0] * tv[0] + tv[1] * tv[1] + tv[2] * tv[2]);
		if (rr > 0.0)
		{
		    rr = 1.0 / rr;
		    tv[0] *= rr;
		    tv[1] *= rr;
		    tv[2] *= rr;
		}
		else
		{
		    tv[0] = 1.0;
		    tv[1] = 0.0;
		    tv[2] = 0.0;
		}

		dot2 = axis[0] * tv[0] +
		       axis[1] * tv[1] +
		       axis[2] * tv[2];

		if (ABS(dot1) > ABS(dot2))
		{
		    /*Azimuth is better*/
		    axis[0] = rotFixed[2][0];
		    axis[1] = rotFixed[2][1];
		    axis[2] = rotFixed[2][2];
		    if (dot1 < 0.0)
		    {
			axis[0] = -axis[0];
			axis[1] = -axis[1];
			axis[2] = -axis[2];
		    }
		}
	        else
		{
		    axis[0] = tv[0];
		    axis[1] = tv[1];
		    axis[2] = tv[2];
		    /*Elevation is better*/
		    if (dot2 < 0.0)
		    {
			axis[0] = -axis[0];
			axis[1] = -axis[1];
			axis[2] = -axis[2];
		    }
		}
	    }

	    sp = rsin(phi);
	    cp = rcos(phi);
	    t = 1.0 - cp;

	    /*Now make the change rotation matrix by rows from top to bottom*/
	    rotDelta[0][0] = t * SQUARE(axis[0]) + cp;
	    rotDelta[0][1] = t * axis[0] * axis[1] + sp * axis[2];
	    rotDelta[0][2] = t * axis[0] * axis[2] - sp * axis[1];
	    rotDelta[0][3] = 0.0;

	    rotDelta[1][0] = t * axis[0] * axis[1] - sp * axis[2];
	    rotDelta[1][1] = t * SQUARE(axis[1]) + cp;
	    rotDelta[1][2] = t * axis[1] * axis[2] + sp * axis[0];
	    rotDelta[1][3] = 0.0;

	    rotDelta[2][0] = t * axis[0] * axis[2] + sp * axis[1];
	    rotDelta[2][1] = t * axis[1] * axis[2] - sp * axis[0];
	    rotDelta[2][2] = t * SQUARE(axis[2]) + cp;
	    rotDelta[2][3] = 0.0;

	    rotDelta[3][0] = 0.0;
	    rotDelta[3][1] = 0.0;
	    rotDelta[3][2] = 0.0;
	    rotDelta[3][3] = 1.0;

		/*Rotate this location by rotDelta*/
		newLoc[0] = rotDelta[0][0] * location[0] +
			    rotDelta[1][0] * location[1] +
			    rotDelta[2][0] * location[2];
		newLoc[1] = rotDelta[0][1] * location[0] +
			    rotDelta[1][1] * location[1] +
			    rotDelta[2][1] * location[2];
		newLoc[2] = rotDelta[0][2] * location[0] +
			    rotDelta[1][2] * location[1] +
			    rotDelta[2][2] * location[2];
		location[0] = newLoc[0];
		location[1] = newLoc[1];
		location[2] = newLoc[2];
    
		/*Unrotate by rotFixed*/
		newLoc[0] = rotFixed[0][0] * location[0] + 
			    rotFixed[0][1] * location[1] +
			    rotFixed[0][2] * location[2];
		newLoc[1] = rotFixed[1][0] * location[0] +
			    rotFixed[1][1] * location[1] +
			    rotFixed[1][2] * location[2];
		newLoc[2] = rotFixed[2][0] * location[0] +
			    rotFixed[2][1] * location[1] +
			    rotFixed[2][2] * location[2];

		NORM3(newLoc);
		var = NewRealArray(1, 3L);
		CArray2Array(var, newLoc);
		SetVar(runner -> thing, LOCATION, var);
		ResolveController(runner -> thing);
	}
	runner = runner -> next;
    }
}

ObjPtr DrawSpace(object)
ObjPtr object;
/*Draws a space and everything it contains*/
{
    int left, right, bottom, top;
    ObjPtr eyePosnObj;			/*Eyeposition object*/
    ObjPtr tempObj;			/*Temporary object*/
    ObjPtr dRotMatrix;
    ObjPtr observer, observers;		/*Observer of the space*/
    ObjPtr panel;			/*Front and back panel*/
    ObjPtr renderer;			/*Current renderer*/
    ObjPtr var;				/*A random variable*/
    int renderType, filterType;		/*Types of renderers and filters*/
    int viewType;			/*Type of view*/

    renderer = GetObjectVar("DrawSpace", object, RENDERER);
    if (!renderer) return ObjFalse;

    /*Get render type*/
    var = GetIntVar("DrawSpace", renderer, RENDERTYPE);
    if (var)
    {
	renderType = GetInt(var);
    }
    else
    {
	renderType = RT_HARDWARE;
    }
    if (renderType == RT_NONE)
    {
	/*Don't render*/
	return ObjTrue;
    }

    /*Get filter type*/
    var = GetIntVar("DrawSpace", renderer, FILTERTYPE);
    if (var)
    {
	filterType = GetInt(var);
    }
    else
    {
	filterType = FT_NONE;
    }

    Get2DIntBounds(object, &left, &right, &bottom, &top);

    /*Update the rotation matrix and fly through*/
#if 0
    observers = GetListVar("DrawSpace", object, OBSERVERS);
    if (!observers || !LISTOF(observers)) return ObjFalse;
    observer = LISTOF(observers) -> thing;
#else
    observer = GetObjectVar("DrawSpace", object, OBSERVER);
#endif

    var = GetVar(observer, VIEWTYPE);
    if (var)
    {
	viewType = GetInt(var);
    }
    else
    {
	viewType = VT_PERSPECTIVE;
    }
    switch(viewType)
    {
	case VT_PERSPECTIVE:
	    DrawSpaceContents(object, left, right, bottom, top, VIEW_CENTER);
	    break;
	case VT_ORTHOGRAPHIC:
	    DrawSpaceContents(object, left, right, bottom, top, VIEW_ORTHO);
	    break;
	case VT_CROSSEYED:
	    DrawSpaceContents(object, left, right, bottom, top, VIEW_XLEFT);
	    DrawSpaceContents(object, left, right, bottom, top, VIEW_XRIGHT);
	    break;
	case VT_REDCYAN:
	    if (rgbp)
	    {
		DrawSpaceContents(object, left, right, bottom, top, VIEW_RCLEFT);
		DrawSpaceContents(object, left, right, bottom, top, VIEW_RCRIGHT);
	    }
	    else
	    {
		DrawSpaceContents(object, left, right, bottom, top, VIEW_CENTER);
	    }
	    break;
    }

/*Filter space if need be*/
    if (rgbp && drawingQuality == DQ_FULL && filterType == FT_SHRINK)
    {
	/*Shrink the pixels in the window*/
	int s, d;
	register int y, x;
	int xdd, ydd;
	int xSize, ySize;

	if (right - left > SCRWIDTH) right = left + SCRWIDTH;
	if (top - bottom > SCRHEIGHT) top = bottom + SCRHEIGHT;

	if ((right - left) & 1) --right;
	if ((top - bottom) & 1) --top;
	xdd = (right - left) / 2;
	ydd = (top - bottom) / 2;
	xSize = (right - left);
	ySize = (top - bottom);

	lrectread(left, bottom, right, top, (unsigned int *) imageBuffer);

	s = 0;
	d = 0;
	for (y = 0; y <= ydd; ++y)
	{
	    for (x = 0; x <= xdd; ++x)
	    {
		imageBuffer[d] . red =
			(imageBuffer[s] . red +
			 imageBuffer[s + 1] . red +
			 imageBuffer[s + xSize] . red +
			 imageBuffer[s + xSize + 1] . red) / 4;
		imageBuffer[d] . green =
			(imageBuffer[s] . green +
			 imageBuffer[s + 1] . green +
			 imageBuffer[s + xSize] . green +
			 imageBuffer[s + xSize + 1] . green) / 4;
		imageBuffer[d] . blue =
			(imageBuffer[s] . blue +
			 imageBuffer[s + 1] . blue +
			 imageBuffer[s + xSize] . blue +
			 imageBuffer[s + xSize + 1] . blue) / 4;
		imageBuffer[d] . alpha =
			(imageBuffer[s] . alpha +
			 imageBuffer[s + 1] . alpha +
			 imageBuffer[s + xSize] . alpha +
			 imageBuffer[s + xSize + 1] . alpha) / 4;
		s += 2;
		++d;
	    }
	    s += xSize;
	}
	cpack(0);
	clear();
	lrectwrite(left, bottom, left + xdd, bottom + ydd, (unsigned int *) imageBuffer);
    }
    if (rgbp && drawingQuality == DQ_FULL && filterType == FT_4AVERAGE)
    {
	/*Average the pixels in the window*/
	int s;
	register int y, x;
	int xSize, ySize;

	if (right - left > SCRWIDTH) right = left + SCRWIDTH;
	if (top - bottom > SCRHEIGHT) top = bottom + SCRHEIGHT;

	xSize = (right - left);
	ySize = (top - bottom);

	lrectread(left, bottom, right, top, (unsigned int *) imageBuffer);

	s = 0;
	for (y = 0; y <= ySize - 1; ++y)
	{
	    for (x = 0; x <= xSize - 1; ++x)
	    {
		imageBuffer[s] . red =
			(imageBuffer[s] . red +
			 imageBuffer[s + 1] . red +
			 imageBuffer[s + xSize] . red +
			 imageBuffer[s + xSize + 1] . red) / 4;
		imageBuffer[s] . green =
			(imageBuffer[s] . green +
			 imageBuffer[s + 1] . green +
			 imageBuffer[s + xSize] . green +
			 imageBuffer[s + xSize + 1] . green) / 4;
		imageBuffer[s] . blue =
			(imageBuffer[s] . blue +
			 imageBuffer[s + 1] . blue +
			 imageBuffer[s + xSize] . blue +
			 imageBuffer[s + xSize + 1] . blue) / 4;
		imageBuffer[s] . alpha = 255;
		++s;
	    }
	    ++s;
	}
	lrectwrite(left, bottom, right, top, (unsigned int *) imageBuffer);
    }

    return ObjTrue;
}

static ObjPtr KeyDownSpace(object, key)
ObjPtr object;
short key;
/*Does a keydown in a space.  Returns
  true iff the press really was in the space.*/
{
    ObjPtr retVal;

    return ObjFalse;
}

ObjPtr ShowIconControls(object)
ObjPtr object;
/*Shows the controls for an icon*/
{
    DoTask(DoShowControls);
    return ObjTrue;
}

static void DoFileInVisAlert()
{
    WinInfoPtr errWindow;
    errWindow = AlertUser(UIRED, (WinInfoPtr) 0, "Files cannot be visualized directly.  First open the files and then visualize the datasets they contain.", 0, 0, "");
    SetVar((ObjPtr) errWindow, HELPSTRING,
	NewString("SciAn must first read data files into datasets before the data can \
be visualized.  First open the file, then select the \
datasets you want to visualize within the Datasets window and visualize them."));
}

static void DoCannotVisError()
/*Whines at the user that it cannot visualize an object*/
{
    WinInfoPtr errWindow;
    errWindow = AlertUser(UIRED, (WinInfoPtr) 0, "Some objects could not be visualized.", 0, 0, "");
    SetVar((ObjPtr) errWindow, HELPSTRING,
	NewString("Some of the objects which you have tried to visualize could not \
be visualized, either because they are of the wrong type for visualization or \
because they need to be modified before they can be visualized."));
}

Bool AddObjToSpace(object, space, corral, loc, visType)
ObjPtr object;
ObjPtr space;
ObjPtr corral;
ObjPtr loc;
ObjPtr visType;
/*Adds object or a representation of it to space.
  If the class of object is
    iconClass    Finds a preferred visualization for REPOBJ and adds it
    visClass     Adds it directly
    fileClass	 Whines
    otherwise    Finds a preferred visualization and adds it

  loc is a location to put the new icon, or NULLOBJ
  visType is the preferred visualization, or NULLOBJ to get the preferred
*/
{
    ObjPtr repObj, icon, defaultIcon;
    ObjPtr name;
    ObjPtr contents;
    ObjPtr clock;
    FuncTyp AddControls;
    FuncTyp method;
    ObjPtr parents;

    if (InClass(object, iconClass))
    {
	/*It's an icon; got to find a REPOBJ*/
	object = GetVar(object, REPOBJ);
	if (!object)
	{
	    return false;
	}
    }
    if (InClass(object, fileClass))
    {
	/*It's a file.  Whine*/
	DoUniqueTask(DoFileInVisAlert);
	return false;
    }
    if (InClass(object, visClass) && visType)
    {
	/*Go down to dataset level if visObject*/
	repObj = GetVar(object, MAINDATASET);
	if (!repObj)
	{
	    repObj = GetVar(object, REPOBJ);
	}
	object = repObj;
    }
    if (!InClass(object, visClass))
    {
	/*It's not a visualization yet.  Gotta find one*/

	repObj = object;
	object = NewVis(repObj, visType);
	if (!object)
	{
	    DoUniqueTask(DoCannotVisError);
	    return false;
	}
	if (globalEventFlags & F_OPTIONDOWN)
	{
	    SetVar(object, HIDDEN, ObjTrue);
	}
    }
    else
    {
	repObj = GetVar(object, MAINDATASET);
	if (!repObj)
	{
	    repObj = GetVar(object, REPOBJ);
	}
    }

    /*If object is a template, make a new copy*/
    if (GetPredicate(object, TEMPLATEP))
    {
	FuncTyp method;
	method = GetMethodSurely("AddObjToSpace", object, CLONE);
	if (method)
	{
	    object = (*method)(object);
	}
    }

    contents = GetVar(space, CONTENTS);
    PrefixList(contents, object);
    parents = GetListVar("AddObjToSpace", object, PARENTS);
    if (parents)
    {
	PrefixList(parents, space);
    }
    else
    {
	SetVar(object, PARENT, space);
    }
    ImInvalid(object);
    SetVar(object, SPACE, space);

    /*Make an icon that represents the field and put it in the corral*/
    icon = NewVisIcon(object);
    if (icon)
    {
	SetVar(icon, ICONLOC, loc);	
	SetVar(icon, SPACE, space);
	if (globalEventFlags & F_OPTIONDOWN)
	{
	    SetVar(icon, ICONGREYED, ObjTrue);
	}
	DropIconInCorral(corral, icon);
    }

    /*Reinitialize the clock in the space*/
    clock = GetVar(space, CLOCK);
    if (clock)
    {
	ReinitController(clock);
    }

    return true;
}

Bool DeleteControllerFromSpace(controller, space, corral)
ObjPtr controller, space, corral;
/*Deletes a controller from a space and its icon from the corral*/
{
    ObjPtr spaces;
    ObjPtr contents;
    ThingListPtr list;

    spaces = GetListVar("DeleteControllerFromSpace", controller, SPACES);
    if (!spaces) return false;

    /*Remove the space reference from the controller*/
    if (0 == DeleteFromList(spaces, space)) return false;
    
    /*Remove the controller's icon from the corral*/
    contents = GetListVar("DeleteControllerFromSpace", corral, CONTENTS);
    list = LISTOF(contents);
    while (list)
    {
	ObjPtr foundController;
	foundController = GetVar(list -> thing, REPOBJ);
	if (foundController == controller)
	{
	    DeleteFromList(contents, list -> thing);
	    ImInvalid(corral);
	    break;
	}
	list = list -> next;
    }

    return true;
}

static ObjPtr BindClockToSpace(clock, space)
ObjPtr clock, space;
/*Makes space know about clock*/
{
    SetVar(space, CLOCK, clock);
    return ObjTrue;
}

static ObjPtr BindObserverToSpace(observer, space)
ObjPtr observer, space;
/*Makes space know about observer*/
{
#if 0
    ObjPtr observersList;

    observersList = GetVar(space, OBSERVERS);
    if (!observersList)
    {
	observersList = NewList();
	SetVar(space, OBSERVERS, observersList);
    }
    PostfixList(observersList, observer);
#else
    SetVar(space, OBSERVER, observer);
#endif
    return ObjTrue;
}

static ObjPtr BindRendererToSpace(renderer, space)
ObjPtr renderer, space;
/*Makes space know about renderer*/
{
    SetVar(space, RENDERER, renderer);
    return ObjTrue;
}

Bool AddControllerToSpace(controller, space, corral, loc)
ObjPtr controller;
ObjPtr space;
ObjPtr corral;
ObjPtr loc;
/*Adds a space controller to space at loc and puts its icon in corral.
*/
{
    ObjPtr repObj, icon, iconY;
    ObjPtr contents, spaces;
    ThingListPtr list;
    ObjPtr controllerClass;
    ObjPtr defaultIcon;
    ObjPtr name;
    FuncTyp method;

    controllerClass = GetVar(controller, CONTROLLERCLASS);
    if (controllerClass)
    {
	/*First see if there is already a controller there*/
	contents = GetListVar("AddControllerToSpace", corral, CONTENTS);
	if (!contents) return;
	list = LISTOF(contents);
	while (list)
	{
	    ObjPtr foundController;
	    foundController = GetVar(list -> thing, REPOBJ);
	    if (InClass(foundController, controllerClass))
	    {
		if (foundController == controller)
		{
		    /*This is really the same controller.  Just move the icon*/
		    if (loc)
		    {
			SetVar(list -> thing, ICONLOC, loc);
			ImInvalid(list -> thing);
		    }
		    return true;
		}
		else
		{
		    /*It's a new controller.  Delete the old one and fall through*/
		    DeleteControllerFromSpace(foundController, space, corral);
		    break;
		}
	    }
	    list = list -> next;
	}
    }
    /*Make an icon that represents the new controller and put it in the corral*/
    name = GetStringVar("AddControllerToSpace", controller, NAME);
    defaultIcon = GetObjectVar("AddControllerToSpace", controller, DEFAULTICON);
    if (defaultIcon)
    {
	icon = NewObject(defaultIcon, 0);
	SetVar(icon, NAME, name ? name : NewString("Controller"));
	SetVar(icon, ICONGREYED, GetVar(controller, HIDDEN));
    }
    else
    {
	icon = NewIcon(0, 0, ICONQUESTION,
		   name ? GetString(name) : "Controller");
	SetVar(icon, HELPSTRING, 
	    NewString("This icon represents a controller.  For some reason, \
the default icon could not be found, so the icon appears as a question mark.  \
Please report this as a bug in SciAn."));
    }
    SetMethod(icon, DOUBLECLICK, GetMethod(controller, DOUBLECLICK));
    SetVar(icon, SPACE, space);
    SetVar(icon, REPOBJ, controller);
    method = GetMethod(controller, BINDTOSPACE);
    if (method)
    {
	(*method)(controller, space);
    }
    SetVar(icon, ICONLOC, loc);
    DropIconInCorral(corral, icon);

    /*Make the controller know about this space*/
    spaces = GetListVar("AddControllerToSpace", controller, SPACES);
    if (!spaces) return;
    PrefixList(spaces, space);

    ResolveController(controller);

    return true;
}

ObjPtr NewSpace(left, right, bottom, top)
int left, right, bottom, top;
/*Makes a new Space with bounds left, right, bottom, top*/
{
    ObjPtr xformMatrix;	/*The rotation matrix of the space, I to start*/
    ObjPtr retVal;

    retVal = NewObject(spaceClass, 0);
	
    Set2DIntBounds(retVal, left, right, bottom, top);
    SetVar(retVal, CONTENTS, NewList());

    return retVal;
}

#ifdef PROTO
void PrintClock(char *s, char *f, real t)
#else
void PrintClock(s, f, t)
char *s;
char *f;
real t;
#endif
/*Prints t in seconds to a string s using format f*/
{
    while (*f)
    {
	if (*f == '%')
	{
	    /*Format string*/
	    ++f;
	    if (*f == '%')
	    {
		/*Just print out a %*/
		*s++ = *f++;
	    }
	    else
	    {
		char *temp;	/*Pointer into tempStr to assemble*/
		real n;		/*Number to print*/
		long i;		/*Temporary integer*/
		/*It's a real format.  Start assembling*/

		temp = tempStr;
		*temp++ = '%';

		/*Skip over flag(s)*/
		while (*f == '-' || *f == '+' || *f == ' ' || *f == '#')
		{
		    *temp++ = *f++;
		}

		/*Skip over first number*/
		while (*f >= '0' && *f <= '9')
		{
		    *temp++ = *f++;
		}

		/*Skip over second number*/
		if (*f == '.')
		{
		    *temp++ = *f++;
		    while (*f >= '0' && *f <= '9')
		    {
			*temp++ = *f++;
		    }
		}

		/*Now see what the format is*/
		switch (*f)
		{
		    case 'h':
			/*Hours, [1,12]*/
			n = t / 3600.0;
			i = n / 12.0;
			n = n - i * 12;
			if (n < 1.00) n += 12.00;
			break;
		    case 'H':
			/*Hours, [0,24)*/
			n = t / 3600.0;
			i = n / 24.0;
			i = n - i * 24;
			n = i;
			break;
		    case 'M':
			/*Unrestricted minutes*/
			n = t / 60.0;
			break;
		    case 'm':
			/*Minutes, 0 to 59*/
			n = t / 60.0;
			i = n / 60.0;
			i = n - i * 60;
			n = i;
			break;
		    case 's':
			/*Seconds, 0 to 59*/
			i = t / 60.0;
			i = t - i * 60;
			n = i;
			break;
		    case 'S':
			/*Unrestricted seconds*/
		    case 't':
		    case 'T':
			/*Just a timestep*/
			n = t;
			break;
		    case 'd':
		    case 'D':
		    case 'i':
		    case 'I':
			/*Integral seconds*/
			i = t;
			n = i;
			break;
		    default:
			strcpy(s, "Bad format: ");
			while (*s) ++s;
			*s++ = *f++;
			*s = 0;
			goto dontsprintf;
		}
		++f;

		/*Ready to print*/
		*temp++ = 'f';
		*temp = 0;
		sprintf(s, tempStr, n);
dontsprintf:
		while (*s)
		{
		    ++s;
		}
	    }
	}
	else
	{
	    *s++ = *f++;
	}
    }
    *s = 0;
}

static ObjPtr TouchSpaceClock(clock, space)
ObjPtr clock, space;
/*Touches a space with a clock.  Returns ObjTrue if it had an effect,
  ObjFalse otherwise.*/
{
    real time;
    ObjPtr timeObj;
    ObjPtr timeBounds;
    Bool clockHasTime;
    Bool boundsChanged;
    ObjPtr objTime;
    real tb[2];
    ObjPtr displayClock;
    ObjPtr format;
    ObjPtr contents;
    ObjPtr repObj;		/*The repobj of a vis object, ie, main dataset*/
    ObjPtr data;		/*The DATA ARRAY of the main dataset*/
    char s[256];
    ThingListPtr runner;

    timeObj = GetVar(clock, TIME);
    if (timeObj)
    {
	time = GetReal(timeObj);
    }
    else
    {
	time = 0.0;
    }

    format = GetVar(clock, FORMAT);
    if (format)
    {
	PrintClock(s, GetString(format), time);
    }
    else
    {
        sprintf(s, "%#.2f", time);
    }

    /*See if there's a display clock in the space*/
    displayClock = GetVar(space, DISPLAYCLOCK);
    if (displayClock)
    {
	/*Yes, display it*/
	SetTextBox(displayClock, s);
    }

    /*Go through all the objects in the space expanding the time bounds*/
    timeBounds = GetVar(clock, TIMEBOUNDS);
    clockHasTime = timeBounds ? true : false;
    contents = GetListVar("TouchSpaceClock", space, CONTENTS);
    if (!contents)
    {
	return ObjTrue;
    }

    boundsChanged = false;
    runner = LISTOF(contents);
    while (runner)
    {
	ChangeVar(runner -> thing, TIME, timeObj);
	repObj = GetVar(runner -> thing, MAINDATASET);
	if (!repObj) repObj = GetObjectVar("TouchSpaceClock", runner -> thing, REPOBJ);
	if (repObj)
	{
	    data = GetVar(repObj, DATA);
	    if (data)
	    {
		ObjPtr objTime;
		real otb[2];
		MakeVar(data, TIMEBOUNDS);
		objTime = GetVar(data, TIMEBOUNDS);
		if (objTime)
		{
		    ObjPtr lastTimeStep;
		    real lts;

		    lastTimeStep = GetRealVar("TouchSpaceClock", data, LASTTIMESTEP);
		    if (lastTimeStep)
		    {
			lts = GetReal(lastTimeStep);
		    }
		    else
		    {
			lts = 0.0;
		    }
	
		    Array2CArray(otb, objTime);
		    if (clockHasTime)
		    {
			if (boundsChanged)
			{
			    if (otb[0] < tb[0])
			    {
				tb[0] = otb[0];
			    }
			}
			else
			{
			    tb[0] = otb[0];
			    boundsChanged = true;
			}
			if (boundsChanged)
			{
			    if (otb[1] > tb[1] + lts)
			    {
				tb[1] = otb[1] + lts;
			    }
			}
			else
			{
			    tb[1] = otb[1] + lts;
			    boundsChanged = true;
			}
		    }
		    else
		    {
			tb[0] = otb[0];
			tb[1] = otb[1] + lts;
			clockHasTime = true;
			boundsChanged = true;
		    }
		}
	    }
	}
	runner = runner -> next;
    }
    if (boundsChanged)
    {
	timeBounds = NewRealArray(1, 2L);
	CArray2Array(timeBounds, tb);
	SetVar(clock, TIMEBOUNDS, timeBounds);
    }
    return ObjTrue;
}

ObjPtr RegisterTime(clock)
ObjPtr clock;
/*Registers time or timebounds changes in clock*/
{
    ObjPtr time;
    WinInfoPtr dialog;

    time = GetVar(clock, TIME);
	/*Now change the slider*/
	dialog = DialogExists((WinInfoPtr) clock, NewString("Clock"));

	if (dialog)
	{
	    ObjPtr control;

	    control = GetVar((ObjPtr) dialog, TIMECONTROL);
	    if (control)
	    {
		ObjPtr value;
		value = GetVar(control, VALUE);
		if (time && !Equal(value, time))
		{
		    FuncTyp method;
		    method = GetMethod(control, CHANGEDVALUE);
		    SetMethod(control, CHANGEDVALUE, (FuncTyp) 0);
		    SetValue(control, time);
		    AutoScroll(control);
		    SetMethod(control, CHANGEDVALUE, method);
		}
	    }
	}

    SetVar(clock, TIMEREGISTERED, ObjTrue);
    return ObjTrue;
}

ObjPtr ResolveClock(clock)
ObjPtr clock;
/*Resolves a clock after all the spaces have ben touched*/
{
    MakeVar(clock, TIMEREGISTERED);
    return ObjTrue;
}

static ObjPtr TouchSpaceObserver(observer, space)
ObjPtr observer, space;
/*Touches a space with an observer.  Returns ObjTrue if it had an effect,
  ObjFalse otherwise.*/
{
#if 0
    ObjPtr observers;
    if ((observers = GetListVar("TouchSpaceObserver", space, OBSERVERS)) &&
	LISTOF(observers) -> thing == observer)
    {
	return ObjTrue;
    }
    else
    {
	return ObjFalse;
    }
#else
    return ObjTrue;
#endif
}

static ObjPtr TouchSpaceRenderer(renderer, space)
ObjPtr renderer, space;
/*Touches a space with an renderer.  Returns ObjTrue if it had an effect,
  ObjFalse otherwise.*/
{
    ObjPtr renderers;
    if (GetVar(space, RENDERER) == renderer)
    {
	return ObjTrue;
    }
    else
    {
	return ObjFalse;
    }
}

void ResolveController(controller)
ObjPtr controller;
/*Resolves all the space references from controller*/
{
    ObjPtr spaces;
    ThingListPtr list;
    FuncTyp method;	

    spaces = GetListVar("ResolveController", controller, SPACES);
    if (!spaces) return;
    list = LISTOF(spaces);
    while (list)
    {
	method = GetMethod(controller, TOUCHSPACE);
	if (method)
	{
	    if (IsTrue((*method)(controller, list -> thing)))
	    {
		ImInvalid(list -> thing);
	    }
	}
	method = GetMethod(controller, TOUCHPANEL);
	if (method)
	{
	    if (IsTrue((*method)(controller, GetVar(list -> thing, PANEL))))
	    {
		ImInvalid(GetVar(list -> thing, PANEL));
	    }
	}
        list = list -> next;
    }

    /*Let the controller know if it's been resolved*/
    method = GetMethod(controller, RESOLVE);
    if (method)
    {
	(*method)(controller);
    }
}

void ReinitController(controller)
ObjPtr controller;
/*Reinitializes a controller by sending it a REINIT message and then resolving
  it*/
{
    FuncTyp method;
    method = GetMethod(controller, REINIT);
    if (method)
    {
	(*method)(controller);
    }
    ResolveController(controller);
}

static void DoClockAlert()
{
    WinInfoPtr errWindow;
    errWindow = AlertUser(UIRED, (WinInfoPtr) 0, "A clock cannot be displayed in a space it doesn't control.", 0, 0, "");
    SetVar((ObjPtr) errWindow, HELPSTRING,
	NewString("You have just tried to drag a clock into a space that it does not control.  \
In order for a clock to be displayed in a space, it must control that space.  \
You can make a clock control a space by dragging it into the icon corral of \
the visualization window which contains the space."));
}

static ObjPtr DeleteClockReadout(readout)
ObjPtr readout;
/*Deletes a clock readout from a space*/
{
    ObjPtr space;
    space = GetObjectVar("DeleteClockReadout", readout, SPACE);
    if (!space)
    {
	return ObjFalse;
    }
    SetVar(space, DISPLAYCLOCK, NULLOBJ);
    return ObjTrue;
}

void AddClockToSpacePanel(clock, panel, space, x, y)
ObjPtr clock, panel, space;
int x, y;
/*Adds clock to panel.  If there is already a clock there, just move it and
  update the clock*/
{
    ObjPtr clockThere;

    if (GetVar(space, CLOCK) != clock)
    {
	DoTask(DoClockAlert);
	return;
    }

    clockThere = GetVar(space, DISPLAYCLOCK);
    if (clockThere)
    {
	/*There's already a clock there, just move and update*/
	int w, h;
	int l, r, b, t;
	
	Get2DIntBounds(clockThere, &l, &r, &b, &t);
	w = r - l;
	h = t - b;
	Set2DIntBounds(clockThere, x - w / 2, x + (w + 1) / 2,
			y - (h + 1) / 2, y + h / 2);
	ImInvalid(clockThere);
    }
    else
    {
	clockThere = NewTextBox(x - DSPCLOCKWIDTH / 2, x + DSPCLOCKWIDTH / 2, 
			y - DSPCLOCKHEIGHT / 2, y + DSPCLOCKHEIGHT / 2,
			/*WITH_BG + EDITABLE*/ ADJUSTABLE, "Space Clock", "1:37");
	PrefixList(GetVar(panel, CONTENTS), clockThere);
	SetMethod(clockThere, DELETEICON, DeleteClockReadout);
	SetVar(clockThere, SPACE, space);
	SetVar(clockThere, HELPSTRING, NewString("This text box displays the time \
given by the clock in this space.  The display format is controlled by the Format \
text box in the clock control panel.\n"));
	SetVar(clockThere, PARENT, panel);
	SetTextAlign(clockThere, RIGHTALIGN);
	SetTextFont(clockThere, "Helvetica-Bold");
	SetTextSize(clockThere, 18);
	SetTextColor(clockThere, NewInt(UIGRAY75));
	SetVar(clockThere, STICKINESS, NewInt(FLOATINGLEFT + FLOATINGRIGHT + FLOATINGTOP + FLOATINGBOTTOM));
	MakeMeCurrent(clockThere);
    }
    SetVar(clockThere, REPOBJ, clock);
    SetVar(space, DISPLAYCLOCK, clockThere);

    /*Resolve the clock references*/
    ResolveController(clock);
}

int pdspSerialNum = 0;

static ObjPtr DeletePaletteDisplay(display)
ObjPtr display;
/*Deletes display*/
{
    return ObjTrue;
}

void AddPaletteToSpacePanel(palette, panel, space, x, y)
ObjPtr palette, panel, space;
int x, y;
/*Adds palette to panel.*/
{
    ObjPtr paletteDisplay;

    sprintf(tempStr, "Palette Display %d", ++pdspSerialNum); 
    paletteDisplay = NewPaletteDisplay(x - DSPPALETTEWIDTH / 2, x + DSPPALETTEWIDTH / 2, 
			y - DSPPALETTEHEIGHT / 2, y + DSPPALETTEHEIGHT / 2,
			tempStr, palette);
    PrefixList(GetVar(panel, CONTENTS), paletteDisplay);
    SetVar(paletteDisplay, PARENT, panel);
    SetMethod(paletteDisplay, DELETEICON, DeletePaletteDisplay);
    SetVar(paletteDisplay, STICKINESS, NewInt(FLOATINGLEFT + FLOATINGRIGHT + FLOATINGTOP + FLOATINGBOTTOM));
    MakeMeCurrent(paletteDisplay);
    SetTextFont(paletteDisplay, ANNOTFONT);
    SetTextSize(paletteDisplay, ANNOTFONTSIZE);
}
static ObjPtr DropInSpacePanel(panel, dropObj, x, y)
ObjPtr panel, dropObj;
int x, y;
/*Drops object in a panel beginning at x and y.  Returns
  true iff the drop really was in the panel.*/
{
    int left, right, bottom, top;

    Get2DIntBounds(panel, &left, &right, &bottom, &top);

    if (x >= left && x <= right && y >= bottom && y <= top)
    {
	/*Hey!  It really was a drop in the panel*/
	ObjPtr contents;
	ObjPtr firstIcon;
	ThingListPtr restIcons;
	ThingListPtr runner;
	ObjPtr repObj;
	ObjPtr space;
	ObjPtr iconLoc;
	real loc[2];
	int xDisp, yDisp;

	if (IsList(dropObj))
	{
	    restIcons = LISTOF(dropObj);
	    firstIcon = restIcons -> thing;
	    restIcons = restIcons -> next;
	}
	else if (InClass(dropObj, iconClass))
	{
	    firstIcon = dropObj;
	    restIcons = 0;
	}
	else
	{
	    ReportError("DropInSpacePanel", "An object other than an icon was dropped");
	    return ObjFalse;
	}

	space = GetObjectVar("DropInSpacePanel", panel, SPACE);
	if (!space) return;

	iconLoc = GetFixedArrayVar("DropInSpacePanel", firstIcon, ICONLOC, 1, 2L);
	if (!iconLoc)
	{
	    return ObjFalse;
	}
	Array2CArray(loc, iconLoc);

    	/*Setup the new viewport*/
	StartPanel(left, right, bottom, top);

        x -= left;
        y -= bottom;

	xDisp = x - loc[0];
	yDisp = y - loc[1];

	/*Drop first icon*/
	repObj = GetVar(firstIcon, REPOBJ);
	if (InClass(repObj, clockClass))
	{
	    AddClockToSpacePanel(repObj, panel, space, x, y);
	}
	else if (IsPalette(repObj))
	{
	    AddPaletteToSpacePanel(repObj, panel, space, x, y);
	}
	else
	{
	    AddObjToSpace(repObj, space, GetVar(space, CORRAL), NULLOBJ, NULLOBJ);
	}

	/*Drop remaining icons*/
	runner = restIcons;
	while (runner)
	{
	    repObj = GetVar(runner -> thing, REPOBJ);
	    if (InClass(repObj, clockClass))
	    {
		iconLoc = GetFixedArrayVar("DropInSpacePanel", runner -> thing, ICONLOC, 1, 2L);
		if (!iconLoc) break;
		Array2CArray(loc, iconLoc);
		loc[0] += xDisp;
		loc[1] += yDisp;

		AddClockToSpacePanel(repObj, panel, space, (int) loc[0], (int) loc[1]);
	    }
	    else if (IsPalette(repObj))
	    {
		iconLoc = GetFixedArrayVar("DropInSpacePanel", runner -> thing, ICONLOC, 1, 2L);
		if (!iconLoc) break;
		Array2CArray(loc, iconLoc);
		loc[0] += xDisp;
		loc[1] += yDisp;
		AddPaletteToSpacePanel(repObj, panel, space, (int) loc[0], (int) loc[1]);
	    }
	    else
	    {
		AddObjToSpace(repObj, space, GetVar(space, CORRAL), NULLOBJ, NULLOBJ);
	    }
	    runner = runner -> next;
	}

	StopPanel();
	return ObjTrue;
    }
    else
    {
	return ObjFalse;
    }
}

#ifdef PROTO
void SetClock(ObjPtr clock, real time)
#else
void SetClock(clock, time)
ObjPtr clock;
real time;
#endif
/*Sets clock to time*/
{
    SetVar(clock, TIME, NewReal(time));
    ResolveController(clock);
}

static ObjPtr MarkClockTime(clock, lateness)
ObjPtr clock;
double lateness;
/*Marks time in a clock after a delay of lateness*/
{
    ObjPtr curTime;
    ObjPtr dTime;
    ObjPtr timeBounds;
    real deltaTime;
    real time;
    real tb[2];
    ObjPtr name;
    ObjPtr whichDialog;
    WinInfoPtr dialog;
    ObjPtr spaces;
    ThingListPtr list;
    Bool wrap;

    InhibitLogging(true);

    dTime = GetVar(clock, DTIME);
    if (!dTime || !IsReal(dTime))
    {
	return ObjTrue;
    }
    deltaTime = GetReal(dTime);

    wrap = GetPredicate(clock, CYCLECLOCK);

    /*Another wakeup call*/
    DoNotDisturb(clock, MARKTIME);
    WakeMe(clock, MARKTIME, Clock());

    if (lateness <= 0.0)
    {
	return ObjTrue;
    }

    curTime = GetVar(clock, TIME);
    if (curTime)
    {
	time = GetReal(curTime);
    }
    else
    {
	time = 0.0;
    }

    /*Increment the time by the elapsed time*/
    time += deltaTime * lateness;

    /*Check against time bounds*/
    timeBounds = GetVar(clock, TIMEBOUNDS);
    if (timeBounds && IsArray(timeBounds) && RANK(timeBounds) == 1 &&
    DIMS(timeBounds)[0] == 2)
    {
	Array2CArray(tb, timeBounds);
    }
    else
    {
	tb[0] = 0.0;
	tb[1] = 1.0;
    }
    if (deltaTime > 0.0 && time > tb[1])
    {
	if (wrap) time = tb[0];
	else time = tb[1];
    }
    else if (deltaTime < 0.0 && time < tb[0])
    {
	if (wrap) time = tb[1];
	else time = tb[0];
    }

    /*Now change the clock*/
    SetClock(clock, time);

    InhibitLogging(false);

    return ObjTrue;
}

static ObjPtr ChangeTime(object)
ObjPtr object;
/*Changed value for a control time*/
{
    real time;
    ObjPtr val;
    ObjPtr repObj;
    ObjPtr spaces;
    ThingListPtr list;

    repObj = GetObjectVar("ChangeTime", object, REPOBJ);
    if (!repObj)
    {
	return ObjFalse;
    }

    val = GetValue(object);
    if (val)
    {
	time = GetReal(val);
    }
    else
    {
	time = 0.0;
    }

    SetClock(repObj, time);

    spaces = GetListVar("ChangeTime", repObj, SPACES);
    if (!spaces) return ObjFalse;
    list = LISTOF(spaces);
    while (list)
    {
	DrawMe(list -> thing);
	list = list -> next;
    }
    return ObjTrue;
}

#ifdef PROTO
void GetSliderRange(ObjPtr slider, real *loValue, real *hiValue)
#else
void GetSliderRange(slider, loValue, hiValue)
ObjPtr slider;
real *loValue, *hiValue;
#endif
/*Returns the range of slider into loValue and hiValue*/
{
    ObjPtr var;
    var = GetRealVar("GetSliderRange", slider, LOVALUE);
    if (var) *loValue = GetReal(var);
    var = GetRealVar("GetSliderRange", slider, HIVALUE);
    if (var) *hiValue = GetReal(var);
}

static void ClockSliderToRadio(radioGroup, slider)
ObjPtr radioGroup, slider;
/*Sets the value of the radio group based on the value of the dtime slider*/
{
    real loValue, hiValue;
    FuncTyp method;
    ObjPtr var;
    real value;

    /*Temporarily save changedvalue method*/
    method = GetMethod(radioGroup, CHANGEDVALUE);
    SetMethod(radioGroup, CHANGEDVALUE, (FuncTyp) 0);
    
    GetSliderRange(slider, &loValue, &hiValue);
    var = GetValue(slider);
    if (var) value = GetReal(var); else value = 0.0;
    if (value == 0.0)
    {
	/*Stop*/
	SetValue(radioGroup, NewInt(0));
    }
    else if (value >= (hiValue - loValue) * (FASTCLOCK + PLAYCLOCK) * 0.5)
    {
	/*Fast Forward*/
	SetValue(radioGroup, NewInt(3));
    }
    else if (value <= (loValue - hiValue) * (FASTCLOCK + PLAYCLOCK) * 0.5)
    {
	/*Fast Reverse*/
	SetValue(radioGroup, NewInt(4));
    }
    else if (value > 0.0)
    {
	/*Play*/
	SetValue(radioGroup, NewInt(1));
    }
    else
    {
	/*Reverse*/
	SetValue(radioGroup, NewInt(2));
    }

    /*Put changedvalue method back*/
    SetMethod(radioGroup, CHANGEDVALUE, method);
}

static ObjPtr ChangeDeltaTime(object)
ObjPtr object;
/*Changed value for a slider delta time*/
{
    real deltaTime;
    ObjPtr val;
    ObjPtr repObj;
    ObjPtr speedControl;

    repObj = GetObjectVar("ChangeDeltaTime", object, REPOBJ);
    if (!repObj)
    {
	return ObjFalse;
    }

    val = GetVar(object, VALUE);
    if (val)
    {
	deltaTime = GetReal(val);
    }
    else
    {
	deltaTime = 0.0;
    }

    SetVar(repObj, DTIME, NewReal(deltaTime));
    speedControl = GetObjectVar("ChangeDeltaTime", object, SPEEDCONTROL);
    if (speedControl)
    {
	ClockSliderToRadio(speedControl, object);
    }
    DoNotDisturb(repObj, MARKTIME);
    if (deltaTime != 0.0)
    {
	WakeMe(repObj, MARKTIME, Clock());
    }
    return ObjTrue;
}

static ObjPtr ChangeCycleClock(checkBox)
ObjPtr checkBox;
/*Sets the CYCLECLOCK in the checkBoxes repobj to the value of checkBox*/
{
    ObjPtr repObj, value;
    repObj = GetObjectVar("ChangeCycleClock", checkBox, REPOBJ);
    if (!repObj) return ObjFalse;
    value = GetValue(checkBox);
    if (!IsInt(value) && !IsReal(value)) return ObjFalse;
    SetVar(repObj, CYCLECLOCK, GetInt(value) ? ObjTrue : ObjFalse);
    return ObjTrue;
} 

static ObjPtr ChangeClockSpeed(radioGroup)
ObjPtr radioGroup;
/*Changes the speed of a clock according to a newly pressed button*/
{
    ObjPtr slider;
    real loValue, hiValue;
    ObjPtr var;
    int value;
    FuncTyp method;

    var = GetValue(radioGroup);
    if (var) value = GetInt(var); else value = 0;
    
    slider = GetObjectVar("ChangeClockSpeed", radioGroup, REPOBJ);
    if (!slider) return ObjFalse;
    GetSliderRange(slider, &loValue, &hiValue);

    /*Temporarily save my changedvalue method*/
    method = GetMethod(radioGroup, CHANGEDVALUE);
    SetMethod(radioGroup, CHANGEDVALUE, (FuncTyp) 0);

    switch (value)
    {
	case 0:		/*Stop*/
	    SetValue(slider, NewReal(0.0));
	    break;
	case 1:		/*Play*/
	    SetValue(slider, NewReal((hiValue - loValue) * PLAYCLOCK));
	    break;
	case 2:		/*Reverse*/
	    SetValue(slider, NewReal((loValue - hiValue) * PLAYCLOCK));
	    break;
	case 3:		/*Fast Forward*/
	    SetValue(slider, NewReal((hiValue - loValue) * FASTCLOCK));
	    break;
	case 4:		/*Fast Reverse*/
	    SetValue(slider, NewReal((loValue - hiValue) * FASTCLOCK));
	    break;
    }

    SetMethod(radioGroup, CHANGEDVALUE, method);

    return ObjTrue;
}

ObjPtr ChangeClockFormat(textBox)
ObjPtr textBox;
/*Changes a clock's FORMAT according to textBox*/
{
    ObjPtr repObj;
    repObj = GetObjectVar("ChangeClockFormat", textBox, REPOBJ);
    if (!repObj) return ObjFalse;
    SetVar(repObj, FORMAT, GetValue(textBox));
    ResolveController(repObj);
    return ObjTrue;
}

ObjPtr ShowClockControls(clock, ownerWindow, windowName)
ObjPtr clock;
ObjPtr ownerWindow, windowName;
/*Makes a new clock window to control clock.  Ignores ownerWindow and windowName*/
{
    WinInfoPtr clockWindow;
    ObjPtr name;
    ObjPtr var;
    ObjPtr panel;
    ObjPtr contents;
    ObjPtr button, checkBox;
    int left;
    ObjPtr format;
    WinInfoPtr dialogExists;
    ObjPtr whichDialog;

    if (!clock) return NULLOBJ;

    name = GetVar(clock, NAME);

    whichDialog = NewString("Clock");
    dialogExists = DialogExists((WinInfoPtr) clock, whichDialog);
    if (name)
    {
	strncpy(tempStr, GetString(name), TEMPSTRSIZE);
	tempStr[TEMPSTRSIZE] = 0;
    }
    else
    {
	strcpy(tempStr, "Clock");
    }
    clockWindow = GetDialog((WinInfoPtr) clock, whichDialog, tempStr, 
	CLWINWIDTH, CLWINHEIGHT, CLWINWIDTH, CLWINHEIGHT, WINDBUF + WINFIXEDSIZE);

    if (!dialogExists)
    {
	SetVar((ObjPtr) clockWindow, REPOBJ, clock);

	/*Put in a help string*/
	SetVar((ObjPtr) clockWindow, HELPSTRING,
	    NewString("This window shows controls for a clock.  Using these \
controls, you can change the time displayed in all the spaces a clock controls \
or set time to advance forward or backward at a certain rate."));

	/*Add in a panel*/
	panel = NewPanel(greyPanelClass, 0, CLWINWIDTH, 0, CLWINHEIGHT);
	if (!panel)
	{
	    return ObjFalse;
	}
	contents = GetVar((ObjPtr) clockWindow, CONTENTS);
	PrefixList(contents, panel);
	SetVar(panel, PARENT, (ObjPtr) clockWindow);

	contents = GetListVar("ShowClockControls", panel, CONTENTS);
	if (contents)
	{
	    ObjPtr slider, button, checkBox, radioGroup, control;
	    ObjPtr timeBounds;
	    ObjPtr time;
	    ObjPtr textBox;
	    real tb[2], tbt[2];
	    real bigStep, littleStep, anchor;
	    real dt, mdt;
	    int left, right, top;

	    left = MAJORBORDER;
	    right = CLWINWIDTH - MAJORBORDER;
	    top = CLWINHEIGHT - MAJORBORDER;

	    time = GetVar(clock, TIME);

	    /*Add a time control*/
	    control = NewTimeControl(left, right, top - CLTCHEIGHT, top, "Time Control");
	    PrefixList(contents, control);
	    SetVar(control, PARENT, panel);
	    SetVar(control, REPOBJ, clock);
	    SetVar((ObjPtr) clockWindow, TIMECONTROL, control);
	    if (time)
	    {
		SetValue(control, time);
	    }

	    SetMethod(control, CHANGEDVALUE, ChangeTime);

	    ReinitController(clock);

	    top -= CLTCHEIGHT + MAJORBORDER;

	    timeBounds = GetVar(clock, TIMEBOUNDS);
	    if (timeBounds && IsArray(timeBounds) && RANK(timeBounds) == 1 &&
	        DIMS(timeBounds)[0] == 2)
	    {
		Array2CArray(tb, timeBounds);
	    }
	    else
	    {
		tb[0] = 0.0;
		tb[1] = 1.0;
	    }

	    tbt[0] = tb[0]; tbt[1] = tb[1];
	    ChooseGoodSliderParams(&(tbt[0]), &(tbt[1]), &bigStep, &littleStep, &anchor);

	    /*Create the format text box*/
	    textBox = NewTextBox(left, left + 70, 
				top - EDITBOXHEIGHT + (EDITBOXHEIGHT - TEXTBOXHEIGHT) / 2,
				top - (EDITBOXHEIGHT - TEXTBOXHEIGHT) / 2, 
				PLAIN, "Format:", "Format:");
	    PrefixList(contents, textBox);
	    SetVar(textBox, PARENT, panel);
	    
	    /*Create the format editable text box*/
	    format = GetVar(clock, FORMAT);
	    textBox = NewTextBox(left + 70, right - 70, 
				top - EDITBOXHEIGHT,
				top, 
				DEFERCHANGE + EDITABLE + WITH_PIT + ONE_LINE, "Format",
				format ? GetString(format) : "%#.2t");
	    PrefixList(contents, textBox);
	    SetVar(textBox, PARENT, panel);
	    SetVar(textBox, REPOBJ, clock);
	    SetMethod(textBox, CHANGEDVALUE, ChangeClockFormat);

	    top -= EDITBOXHEIGHT + MAJORBORDER;

	    /*Create the time units per second slider*/
	    slider = NewSlider(left, right, 
			    top - MAJORBORDER - SLIDERWIDTH,
			    top - MAJORBORDER,
			    SCALE, "Delta Time per second");
	    PrefixList(contents, slider);
	    SetVar(slider, HELPSTRING,
		NewString("This slider controls the rate at which time flows \
in the spaces controlled by the clock.  The number on the slider specifies how \
many time units in the space will go by for every second of real time.  This rate is \
approximated as well as can be considering the time it takes to draw windows.  \
It compensates correctly when recording frame-by-frame.  This slider is connected \
to the tape recorder style buttons below it."));
	    SetVar(slider, PARENT, panel);
	    dt = (tb[1] - tb[0]) * 0.2;
	    mdt = -dt;
	    ChooseGoodSliderParams(&mdt, &dt, &bigStep, &littleStep, &anchor);
	    SetSliderRange(slider, dt, mdt, 0.0);
	    SetSliderValue(slider, 0.0);
	    SetSliderScale(slider, bigStep, littleStep, 0.0, "%g");
	    SetVar(slider, REPOBJ, clock);
	    SetMethod(slider, CHANGEDVALUE, ChangeDeltaTime);

	    /*Create the text box*/
	    textBox = NewTextBox(left, right, 
				top - MAJORBORDER - SLIDERWIDTH - TEXTBOXSEP - TEXTBOXHEIGHT,
				top - MAJORBORDER - SLIDERWIDTH - TEXTBOXSEP,
				PLAIN, "Delta time text", "Delta time per second");
	    SetVar(textBox, PARENT, panel);
 	    PrefixList(contents, textBox);
	    SetTextAlign(textBox, CENTERALIGN);

	    top -= 2 * MAJORBORDER + SLIDERWIDTH + TEXTBOXSEP + TEXTBOXHEIGHT;

	    /*Create the cycle time radio group*/
	    radioGroup = NewRadioButtonGroup("Cycle the clock");
	    SetVar(radioGroup, PARENT, panel);
	    SetVar(radioGroup, REPOBJ, clock);
	    SetMethod(radioGroup, CHANGEDVALUE, ChangeCycleClock);
	    SetVar(radioGroup, HELPSTRING,
		NewString("These radio buttons control whether the clock, when it is running forward \
or backward, stops at the endpoints in time or cycles around to the other end.\n"));
	    PrefixList(contents, radioGroup);

	    /*And buttons*/
	    button = NewRadioButton(left, (right + left) / 2,
				top - CHECKBOXHEIGHT,
				top,
				"Stop at endpoints");
	    SetVar(button, HELPSTRING,
		NewString("Click on this button to have the clock automatically stop when it reaches an endpoint."));
	    AddRadioButton(radioGroup, button);

	    button = NewRadioButton((right + left) / 2, right,
				top - CHECKBOXHEIGHT,
				top,
				"Cycle at endpoints");
	    SetVar(button, HELPSTRING,
		NewString("Click on this button to have the clock automatically cycle around it reaches an endpoint."));
	    AddRadioButton(radioGroup, button);

	    SetValue(radioGroup, NewInt(GetPredicate(clock, CYCLECLOCK)));

	    top -= MAJORBORDER + CHECKBOXHEIGHT;

	    /*Create the icon buttons*/
	    radioGroup = NewRadioButtonGroup("Speed Control");
	    SetVar(radioGroup, PARENT, panel);
	    SetVar(radioGroup, REPOBJ, slider);
	    SetVar(radioGroup, HELPSTRING,
		NewString("These radio buttons control the speed of the clock.  \
They are tied to the Delta Time Per Second slider and provide easy access to some convenient values.  \
The most useful is Stop, the button in the center with the square icon."));
	    PrefixList(contents, radioGroup); 

	    /*Stop*/
	    button = NewIconButton((left + right) / 2 - ICONBUTTONSIZE / 2,
				   (left + right) / 2 + ICONBUTTONSIZE / 2,
				   top - ICONBUTTONSIZE, top,
				   ICONSTOP, UIGREEN, "Stop");
	    SetVar(button, REPOBJ, slider);
	    SetVar(button, HELPSTRING, NewString("This button stops the clock."));
	    AddRadioButton(radioGroup, button);

	    /*Forward*/
	    button = NewIconButton((left + right) / 2 - ICONBUTTONSIZE / 2 + ICONBUTTONSIZE + MINORBORDER,
				   (left + right) / 2 + ICONBUTTONSIZE / 2 + ICONBUTTONSIZE + MINORBORDER,
				   top - ICONBUTTONSIZE, top,
				   ICONPLAY, UIGREEN, "Play");
	    SetVar(button, REPOBJ, slider);
	    SetVar(button, HELPSTRING, NewString("This button sets time moving forward at a moderate pace."));
	    AddRadioButton(radioGroup, button);

	    /*Reverse*/
	    button = NewIconButton((left + right) / 2 - ICONBUTTONSIZE / 2 - ICONBUTTONSIZE - MINORBORDER,
				   (left + right) / 2 + ICONBUTTONSIZE / 2 - ICONBUTTONSIZE - MINORBORDER,
				   top - ICONBUTTONSIZE, top,
				   ICONREV, UIGREEN, "Reverse");
	    SetVar(button, REPOBJ, slider);
	    SetVar(button, HELPSTRING, NewString("This button sets time moving backward at a moderate pace."));
	    AddRadioButton(radioGroup, button);

	    /*Fast Forward*/
	    button = NewIconButton((left + right) / 2 - ICONBUTTONSIZE / 2 + 2 * (ICONBUTTONSIZE + MINORBORDER),
				   (left + right) / 2 + ICONBUTTONSIZE / 2 + 2 * (ICONBUTTONSIZE + MINORBORDER),
				   top - ICONBUTTONSIZE, top,
				   ICONFF, UIGREEN, "Fast Forward");
	    SetVar(button, REPOBJ, slider);
	    SetVar(button, HELPSTRING, NewString("This button sets time moving forward at a quick pace."));
	    AddRadioButton(radioGroup, button);

	    /*Reverse*/
	    button = NewIconButton((left + right) / 2 - ICONBUTTONSIZE / 2 - 2 * (ICONBUTTONSIZE + MINORBORDER),
				   (left + right) / 2 + ICONBUTTONSIZE / 2 - 2 * (ICONBUTTONSIZE + MINORBORDER),
				   top - ICONBUTTONSIZE, top,
				   ICONFR, UIGREEN, "Fast Reverse");
	    SetVar(button, REPOBJ, slider);
	    SetVar(button, HELPSTRING, NewString("This button sets time moving backward at a quick pace."));
	    AddRadioButton(radioGroup, button);

	    /*Link dtime slider to this speed control*/
	    SetVar(slider, SPEEDCONTROL, radioGroup);

	    /*Set the radio group*/
	    ClockSliderToRadio(radioGroup, slider);

	    SetMethod(radioGroup, CHANGEDVALUE, ChangeClockSpeed);
	}
    }

    return (ObjPtr) clockWindow;
}

static ObjPtr ChangePerspective(object)
ObjPtr object;
/*Change value for a perspective control*/
{
    ObjPtr val;
    ObjPtr repObj;
    real oldPerspec[4];
    real newPerspec[4];

    repObj = GetObjectVar("ChangePerspective", object, REPOBJ);
    if (!repObj)
    {
	return ObjFalse;
    }

    val = GetFixedArrayVar("ChangePerspective", repObj, PERSPECSTUFF, 1, 4L);
    if (!val)
    {
	return ObjFalse;
    }
    Array2CArray(oldPerspec, val);
    val = GetFixedArrayVar("ChangePerspective", object, VALUE, 1, 4L);
    if (!val)
    {
	return ObjFalse;
    }
    Array2CArray(newPerspec, val);
    val = NewRealArray(1, 4L);
    CArray2Array(val, newPerspec);
    SetVar(repObj, PERSPECSTUFF, val);

    /*See if field distance has changed*/
    if (oldPerspec[0] != newPerspec[0])
    {
	/*If so, change LOCATION accordingly*/
	real posn[3];
	ObjPtr posnArray;
	real yaw, pitch;

	val = GetRealVar("ChangePerspective", repObj, YAW);
	yaw = GetReal(val);
	val = GetRealVar("ChangePerspective", repObj, PITCH);
	pitch = GetReal(val);
	posnArray = GetFixedArrayVar("ChangePerspective", repObj, FOCUSPOINT, 1, 3L);
	Array2CArray(posn, posnArray);
	posn[0] -= rsin(yaw) * newPerspec[0];
	posn[1] -= rsin(pitch) * newPerspec[0];
	posn[2] -= rcos(yaw) * newPerspec[0];
	posnArray = NewRealArray(1, 3L);
	CArray2Array(posnArray, posn);
	SetVar(repObj, LOCATION, posnArray);
   }

   ResolveController(repObj);
   DrawMe(object);
   return ObjTrue;
}

ObjPtr ChangeViewType(radio)
ObjPtr radio;
/*Changes the view type according to radio*/
{
    ObjPtr controller, control;
    ObjPtr var;
    int oldValue, newValue;

    controller = GetObjectVar("ChangeViewType", radio, REPOBJ);
    if (!controller)
    {
	return ObjFalse;
    }

    var = GetIntVar("ChangeViewType", controller, VIEWTYPE);
    if (!var)
    {
	return ObjFalse;
    }
    oldValue = GetInt(var);

    var = GetValue(radio);
    if (!var)
    {
	return ObjFalse;
    }
    newValue = GetInt(var);

    if (newValue == oldValue)
    {
	return ObjTrue;
    }

    control = GetObjectVar("ChangeViewType", radio, PERSPECCONTROL);
    if (!control)
    {
	return ObjFalse;
    }

    if (newValue == VT_ORTHOGRAPHIC)
    {
	MakePerspecOrtho(control, true);
	ChangedValue(control);
    }
    else if (oldValue == VT_ORTHOGRAPHIC)
    {
	MakePerspecOrtho(control, false);
	ChangedValue(control);
    }

    SetVar(controller, VIEWTYPE, NewInt(newValue));
    ResolveController(controller);
}

ObjPtr ChangeAirspeed(slider)
ObjPtr slider;
/*Changes the airspeed of an observer according to a slider*/
{
    ObjPtr controller;
    ObjPtr value;

    controller = GetObjectVar("ChangeAirspeed", slider, REPOBJ);
    if (!controller)
    {
	return ObjFalse;
    }

    value = GetRealVar("ChangeAirspeed", slider, VALUE);
    if (!value)
    {
	return ObjFalse;
    }

    SetVar(controller, AIRSPEED, value);
    ResolveController(controller);
    IdleTimers();

    return ObjTrue;
}

ObjPtr ChangeRollDpitch(control)
ObjPtr control;
/*Changes roll and dpitch based on an XY control*/
{
    ObjPtr controller;
    ObjPtr value;
    real roll, dpitch;

    controller = GetObjectVar("ChangeRollDpitch", control, REPOBJ);
    if (!controller)
    {
	return ObjFalse;
    }

    GetXYControlValue(control, &roll, &dpitch);

    SetVar(controller, ROLL, NewReal(roll));
    SetVar(controller, DPITCH, NewReal(-dpitch));
    ResolveController(controller);
    IdleTimers();

    return ObjTrue;
}

ObjPtr ChangeFlying(radio)
ObjPtr radio;
/*Changes whether an observer is flying based on radio*/
{
    ObjPtr repObj, var;
    Bool flying;
    repObj = GetObjectVar("ChangeFlying", radio, REPOBJ);
    if (!repObj)
    {
	return ObjFalse;
    }
    var = GetValue(radio);
    if (!var)
    {
	return ObjFalse;
    }
    flying = GetInt(var) ? true : false;
    if (flying)
    {
    	WakeMe(repObj, MARKTIME, Clock() + 0.001);
    }

    SetVar(repObj, FLYING, flying ? ObjTrue : ObjFalse);
    ResolveController(repObj);
    return ObjTrue;
}

ObjPtr ResetPosition(button)
ObjPtr button;
/*Resets an observer's position*/
{
    ObjPtr observer, var;
    real perspecStuff[4];
    real eyePosn[3];
    Matrix justRot;
    int i;

    observer = GetObjectVar("ResetPosition", button, REPOBJ);
    if (!observer)
    {
	return ObjFalse;
    }

    perspecStuff[0] = INITEYEDIST;
    var = GetFixedArrayVar("StartSpace", observer, PERSPECSTUFF, 1, 4L);
    if (var)
    {
	Array2CArray(perspecStuff, var);
    }

    /*Change the eye position*/
    eyePosn[0] = 0.0;
    eyePosn[1] = 0.0;
    eyePosn[2] = perspecStuff[0];
    var = NewRealArray(1, 3L);
    CArray2Array(var, eyePosn);
    SetVar(observer, LOCATION, var);
    /*Fix roll, pitch, yaw*/
    SetVar(observer, ROLL, NewReal(0.0));
    SetVar(observer, PITCH, NewReal(0.0));
    SetVar(observer, YAW, NewReal(M_PI));
    ChangeFocus(observer);

    /*Change the transformation matrix*/
    var = GetMatrixVar("ResetPosition", observer, XFORM);
    if (!var)
    {
	return NULLOBJ;
    }

    MATCOPY(justRot, MATRIXOF(var));
    for (i = 0; i < 3; ++i)
    {
	justRot[3][i] = justRot[i][3] = 0.0;
    }
    var = NewMatrix();
    MATCOPY(MATRIXOF(var), justRot);
    SetVar(observer, XFORM, var);

    ResolveController(observer);

    return ObjTrue;
}

ObjPtr ResetRotation(button)
ObjPtr button;
/*Resets an observer's rotation*/
{
    ObjPtr observer, var;
    Matrix rot;
    int i, j;

    observer = GetObjectVar("ResetPosition", button, REPOBJ);
    if (!observer)
    {
	return ObjFalse;
    }

    /*Change the transformation matrix*/
    var = GetMatrixVar("ResetPosition", observer, XFORM);
    if (!var)
    {
	return NULLOBJ;
    }

    MATCOPY(rot, MATRIXOF(var));
    for (i = 0; i < 3; ++i)
    {
	for (j = 0; j < 3; ++j)
	{
	    rot[i][j] = i == j ? 1.0 : 0.0;
	}
    }
    var = NewMatrix();
    MATCOPY(MATRIXOF(var), rot);
    SetVar(observer, XFORM, var);

    ResolveController(observer);

    return ObjTrue;
}

ObjPtr ShowObserverControls(observer, ownerWindow, windowName)
ObjPtr observer;
ObjPtr ownerWindow, windowName;
/*Makes a new observer window to control observer.  Ignores ownerWindow and windowName*/
{
    WinInfoPtr observerWindow;
    ObjPtr name;
    ObjPtr var;
    ObjPtr panel;
    ObjPtr contents;
    int left;
    WinInfoPtr dialogExists;
    ObjPtr whichDialog;

    if (!observer) return NULLOBJ;

    name = GetVar(observer, NAME);

    whichDialog = NewString("Observer");
    dialogExists = DialogExists((WinInfoPtr) observer, whichDialog);
    if (name)
    {
	strncpy(tempStr, GetString(name), TEMPSTRSIZE);
	tempStr[TEMPSTRSIZE] = 0;
    }
    else
    {
	strcpy(tempStr, "Observer");
    }
    observerWindow = GetDialog((WinInfoPtr) observer, whichDialog, tempStr, 
	OBWINWIDTH, OBWINHEIGHT, OBWINWIDTH, OBWINHEIGHT, WINDBUF);

    if (!dialogExists)
    {
	SetVar((ObjPtr) observerWindow, REPOBJ, observer);

	/*Add in a help string*/
	SetVar((ObjPtr) observerWindow, HELPSTRING,
	    NewString("This window shows controls for an observer.  The observer \
represents you, looking into the space containing visualization objects.  The controls \
allow you to change your viewing angle, focus point, and clipping planes \
and also let you fly through the visualization with a simple flight simulator."));

	/*Add in a panel*/
	panel = NewPanel(greyPanelClass, 0, OBWINWIDTH, 0, OBWINHEIGHT);
	if (!panel)
	{
	    return ObjFalse;
	}
	contents = GetVar((ObjPtr) observerWindow, CONTENTS);
	PrefixList(contents, panel);
	SetVar(panel, PARENT, (ObjPtr) observerWindow);

	contents = GetListVar("ShowObserverControls", panel, CONTENTS);
	if (contents)
	{
	    ObjPtr control;
	    ObjPtr textBox;
	    ObjPtr slider, var;
	    ObjPtr radio, button;
	    ObjPtr tempObj;
	    ObjPtr titleBox, checkBox;
	    real roll, dPitch, airspeed;
	    int left, right, bottom, top;
	    int viewType;

	    /*Bottom control group*/
	    left = MAJORBORDER;
	    right = OBWINWIDTH - MAJORBORDER;
	    bottom = MAJORBORDER;
	    top = MAJORBORDER + OBBOTTOMHEIGHT;

	    /*View type chooser*/
	    titleBox = NewTitleBox(left, right, bottom, top, "View Type");
	    SetVar(titleBox, PARENT, panel);
	    PrefixList(contents, titleBox);

	    radio = NewRadioButtonGroup("View Type Radio");
	    PrefixList(contents, radio);
	    SetVar(radio, PARENT, panel);
	    SetVar(radio, REPOBJ, observer);
	    SetVar(radio, HELPSTRING, NewString("This radio group controls \
the type of view given in all spaces controlled by this observer.  For more information \
about a given view type, use Help In Context on the button naming the view type.\n"));

	    button = NewRadioButton(left + MINORBORDER, (left + right) / 2,
				    top - TITLEBOXTOP - MINORBORDER - CHECKBOXHEIGHT,
				    top - TITLEBOXTOP - MINORBORDER, "Perspective");
	    AddRadioButton(radio, button);
	    SetVar(button, HELPSTRING, NewString("When this button is down, the standard \
perspective view is used.  Objects closer to the observer appear larger, giving a \
realistic image.\n"));

	    button = NewRadioButton(left + MINORBORDER, (left + right) / 2,
				    bottom + MINORBORDER,
				    bottom + MINORBORDER + CHECKBOXHEIGHT, "Orthographic");
	    AddRadioButton(radio, button);
	    SetVar(button, HELPSTRING, NewString("When this button is down, the \
orthograpic view is enabled.  Objects appear the same size no matter what the \
distance to the observer.  This view does not appear as realistic as the perspective \
view, but it does have the advantage that objects at different depths line up.  \
It is useful for viewing 2-D data or for comparing values in 3-D data at different \
depths.\n"));

	    button = NewRadioButton((left + right) / 2 - MINORBORDER, right - MINORBORDER,
				    top - TITLEBOXTOP - MINORBORDER - CHECKBOXHEIGHT,
				    top - TITLEBOXTOP - MINORBORDER, "Crosseyed Stereo");
	    AddRadioButton(radio, button);
	    SetVar(button, HELPSTRING, NewString("When this button is down, two \
perspective images are shown side by side for a stereo pair.  To view the stereo \
pair, cross your eyes until the images coincide.  For some people, this is very \
easy to do.  Some people have difficulty doing it.  Only try this if you personally \
find it easy, and if it becomes a strain, stop at once."));

	    button = NewRadioButton((left + right) / 2 - MINORBORDER, right - MINORBORDER,
				    bottom + MINORBORDER,
				    bottom + MINORBORDER + CHECKBOXHEIGHT, "Anaglyphic Stereo");
	    AddRadioButton(radio, button);
	    SetVar(button, HELPSTRING, NewString("When this button is down, two \
perspective images are shown, one red and one cyan, for a stereo pair.  To view the stereo \
pair, you will need to use a pair of red/cyan 3-D glasses.  Because one eye \
can see only one set of colors, subtle color variations will be washed out.  \
Also, colors which are heavily toward red or heavily toward blue will be confusing."));

	    var = GetVar(observer, VIEWTYPE);
	    if (var)
	    {
		SetValue(radio, var);
		viewType = GetInt(var);
	    }
	    else
	    {
		SetValue(radio, NewInt(viewType = VT_PERSPECTIVE));
	    }
	    SetMethod(radio, CHANGEDVALUE, ChangeViewType);

	    /*Middle control group*/
	    left = MAJORBORDER;
	    right = OBWINWIDTH - MAJORBORDER;
	    bottom = MAJORBORDER + MINORBORDER + OBBOTTOMHEIGHT;
	    top = bottom + OBMIDHEIGHT;

	    /*Add in the perspective control*/
    	    control = NewPerspecControl(
			right - PCWIDTH,
			right,
			bottom + TEXTBOXHEIGHT + TEXTBOXSEP,
			top,
			"Perspective Control");
	    PrefixList(contents, control);
	    SetVar(control, PARENT, panel);
	    SetVar(control, REPOBJ, observer);
	    if (viewType == VT_ORTHOGRAPHIC)
	    {
		MakePerspecOrtho(control, true);
	    }
	    SetValue(control, GetVar(observer, PERSPECSTUFF));
	    SetMethod(control, CHANGEDVALUE, ChangePerspective);

	    /*Link it to the radio*/
	    SetVar(radio, PERSPECCONTROL, control);

	    /*Add in the perspective text box*/
	    textBox = NewTextBox(
			right - PCWIDTH - MINORBORDER,
			right + MINORBORDER,
			bottom, bottom + TEXTBOXHEIGHT,
			PLAIN,
			"Perspective Text",
			"Perspective");
	    PrefixList(contents, textBox);
	    SetVar(textBox, PARENT, panel);
	    SetTextAlign(textBox, CENTERALIGN);

	    /*Get observer's roll and dPitch*/
	    tempObj = GetVar(observer, ROLL);
	    if (tempObj && IsReal(tempObj))
	    {
		roll = GetReal(tempObj);
	    }
	    else
	    {
		roll = 0.0;
	    }

	    tempObj = GetVar(observer, DPITCH);
	    if (tempObj && IsReal(tempObj))
	    {
		dPitch = GetReal(tempObj);
	    }
	    else
	    {
		dPitch = 0.0;
	    }

	    /*Put in the flight control*/
	    control = NewXYControl(
			left + SCALESLOP + SLIDERWIDTH + MINORBORDER,
			right - PCWIDTH - MINORBORDER,
			bottom + TEXTBOXHEIGHT + TEXTBOXSEP,
			top,
			"Flight Control");
	    PrefixList(contents, control);
	    SetVar(control, PARENT, panel);
	    SetVar(control, REPOBJ, observer);
	    SetVar(control, ALWAYSCHANGE, ObjTrue);
	    SetXYControlLimits(control, -MAXROLL, MAXROLL, -MAXDPITCH, MAXDPITCH);
	    SetXYControlValue(control, roll, dPitch);
	    SetMethod(control, CHANGEDVALUE, ChangeRollDpitch);
	    SetVar(control, HELPSTRING, NewString("This control is like the control stick of an airplane.  \
Move the indicator down to pull back on the stick and climb.  Move the indicator down to push \
forward on the stick and dive.  Move the indicator from side to side to bank and turn.  \
This will only work properly when you have set your airspeed.  Here's a hint: It's easier to fly \
if the perspective control is set to a wide angle view."));

	    /*Add in the flight control text box*/
	    textBox = NewTextBox(
			left + SCALESLOP + SLIDERWIDTH,
			right - PCWIDTH - MINORBORDER,
			bottom, bottom + TEXTBOXHEIGHT,
			PLAIN,
			"Control Text",
			"Flight Control");
	    PrefixList(contents, textBox);
	    SetVar(textBox, PARENT, panel);
	    SetTextAlign(textBox, CENTERALIGN);

	    /*Get the observer's airspeed*/
	    tempObj = GetVar(observer, AIRSPEED);
	    if (tempObj && IsReal(tempObj))
	    {
		airspeed = GetReal(tempObj);
	    }
	    else
	    {
		airspeed = 0.0;
	    }

	    /*Add in the airspeed slider*/
	    slider = NewSlider(
			left + SCALESLOP, left + SCALESLOP + SLIDERWIDTH, 
			bottom + TEXTBOXHEIGHT + TEXTBOXSEP,
			top,
			SCALE,
			"Airspeed");
	    
	    if (!slider)
	    {
		return ObjFalse;
	    }
	    PrefixList(contents, slider);
	    SetVar(slider, HELPSTRING,
		NewString("This slider controls the airspeed of the flight \
simulator.  Use the square flight control to navigate while flying."));
	    SetVar(slider, PARENT, panel);
	    SetVar(slider, REPOBJ, observer);
	    SetSliderRange(slider, 0.2, -0.2, 0.0);
	    SetSliderScale(slider, 0.1, 0.02, 0.0, "%g");
	    SetSliderValue(slider, airspeed);
	    SetMethod(slider, CHANGEDVALUE, ChangeAirspeed);

	    /*Add in the airspeed text box*/
	    textBox = NewTextBox(
			left - MINORBORDER, left + SCALESLOP + SLIDERWIDTH + MINORBORDER, 
			bottom, bottom + TEXTBOXHEIGHT,
			PLAIN,
			"Airspeed Text",
			"Airspeed");
	    PrefixList(contents, textBox);
	    SetVar(textBox, PARENT, panel);
	    SetTextAlign(textBox, CENTERALIGN);

	    /*Add the top controls*/
	    bottom = top + MINORBORDER;
	    top = bottom +  TITLEBOXTOP + 2 * MINORBORDER + CHECKBOXSPACING + 2 * CHECKBOXHEIGHT;
	    left = MAJORBORDER;
	    right = (OBWINWIDTH - MINORBORDER) / 2;
	    titleBox = NewTitleBox(left, right, bottom, top, "Flight Simulator");
	    PrefixList(contents, titleBox);
	    SetVar(titleBox, PARENT, panel);

	    radio = NewRadioButtonGroup("Flight On/Off");
	    PrefixList(contents, radio);
	    SetVar(radio, PARENT, panel);
	    SetVar(radio, HELPSTRING, NewString("This radio button group controls \
whether the flight simulator is on.  If the Anchored button is selected, the \
flight simulator is off.  If the Flying button is selected, the flight simulator \
is on, and the Airspeed slider and the Flight Control are used to fly around.\n"));

	    button = NewRadioButton(left + MINORBORDER, right - MINORBORDER,
		top - TITLEBOXTOP - MINORBORDER - CHECKBOXHEIGHT,
		top - TITLEBOXTOP - MINORBORDER, "Anchored");
	    AddRadioButton(radio, button);

	    button = NewRadioButton(left + MINORBORDER, right - MINORBORDER,
		top - TITLEBOXTOP - MINORBORDER - 2 * CHECKBOXHEIGHT - CHECKBOXSPACING,
		top - TITLEBOXTOP - MINORBORDER - CHECKBOXHEIGHT - CHECKBOXSPACING, 
		"Flying");
	    AddRadioButton(radio, button);

	    SetValue(radio, NewInt(GetPredicate(observer, FLYING) ? 1 : 0));
	    SetMethod(radio, CHANGEDVALUE, ChangeFlying);
	    SetVar(radio, REPOBJ, observer);

	    /*Add in the reset buttons*/
	    left = right + MINORBORDER;
	    right = OBWINWIDTH - MAJORBORDER;
	    button = NewButton(left, right,
			bottom + BUTTONHEIGHT + MINORBORDER,
			bottom + 2 * BUTTONHEIGHT + MINORBORDER,
			"Reset Position");
	    PrefixList(contents, button);
	    SetVar(button, PARENT, panel);
	    SetVar(button, REPOBJ, observer);
	    SetMethod(button, CHANGEDVALUE, ResetPosition);
	    SetVar(radio, HELPSTRING, NewString("This button resets the position \
of the observer to the default.  It is useful if you get lost.\n"));

	    button = NewButton(left, right,
			bottom, bottom + BUTTONHEIGHT,
			"Reset Rotation");
	    PrefixList(contents, button);
	    SetVar(button, PARENT, panel);
	    SetVar(button, REPOBJ, observer);
	    SetMethod(button, CHANGEDVALUE, ResetRotation);
	    SetVar(radio, HELPSTRING, NewString("This button resets the rotation \
of the observer to the default.  It is useful if you get lost.\n"));
	}
    }

    return (ObjPtr) observerWindow;
}

ObjPtr ChangeRenderType(control)
ObjPtr control;
/*Changes the render type based on a radio button*/
{
    ObjPtr controller;
    ObjPtr value;
    real roll, dpitch;

    controller = GetObjectVar("ChangeRenderType", control, REPOBJ);
    if (!controller)
    {
	return ObjFalse;
    }

    SetVar(controller, RENDERTYPE, GetValue(control));
    ResolveController(controller);

    return ObjTrue;
}

void RendererRGB(visWindow)
WinInfoPtr visWindow;
/*Sends a deferred message to visWindow if it has objectForRGB*/
{
    ObjPtr space;

    space = FindSpace(visWindow);
    if (space)
    {
	if (objectForRGB == GetVar(space, RENDERER))
	{
	    if (0 == (visWindow -> flags & WINRGB))
	    {
		DeferMessage((ObjPtr) visWindow, SETRGBMESSAGE);
	    }
	}
    }
}

ObjPtr ChangeFilterType(control)
ObjPtr control;
/*Changes the filter type based on a radio button*/
{
    ObjPtr controller;
    ObjPtr value;

    controller = GetObjectVar("ChangeFilterType", control, REPOBJ);
    if (!controller)
    {
	return ObjFalse;
    }

    value = GetValue(control);
    SetVar(controller, FILTERTYPE, GetValue(control));
    if (GetInt(value) != FT_NONE)
    {
	ObjPtr renderType;
	renderType = GetVar(controller, RENDERTYPE);
	if (renderType && GetInt(renderType) == 1 && hasRGB)
	{
	    objectForRGB = controller;
	    ForAllVisWindows(RendererRGB);
	}
    }
    ResolveController(controller);

    return ObjTrue;
}

ObjPtr ShowRendererControls(renderer, ownerWindow, windowName)
ObjPtr renderer;
ObjPtr ownerWindow, windowName;
/*Makes a new renderer window to control renderer.*/
{
    WinInfoPtr rendererWindow;
    ObjPtr name;
    ObjPtr var;
    ObjPtr panel;
    ObjPtr contents;
    WinInfoPtr dialogExists;
    ObjPtr whichDialog;

    if (!renderer) return NULLOBJ;

    name = GetVar(renderer, NAME);

    whichDialog = NewString("Renderer");
    dialogExists = DialogExists((WinInfoPtr) renderer, whichDialog);
    if (name)
    {
	strncpy(tempStr, GetString(name), TEMPSTRSIZE);
	tempStr[TEMPSTRSIZE] = 0;
    }
    else
    {
	strcpy(tempStr, "Renderer");
    }
    rendererWindow = GetDialog((WinInfoPtr) renderer, whichDialog, tempStr, 
	RWINWIDTH, RWINHEIGHT, RWINWIDTH, RWINHEIGHT, WINDBUF);

    if (!dialogExists)
    {
	SetVar((ObjPtr) rendererWindow, REPOBJ, renderer);
	SetVar((ObjPtr) rendererWindow, OWNERWINDOW, (ObjPtr) ownerWindow);

	/*Add controls*/
	SetVar((ObjPtr) rendererWindow, HELPSTRING,
	    NewString("This window shows controls that affect the rendering of \
the objects within the space."));

	/*Add in a panel*/
	panel = NewPanel(greyPanelClass, 0, RWINWIDTH, 0, RWINHEIGHT);
	if (!panel)
	{
	    return ObjFalse;
	}
	contents = GetVar((ObjPtr) rendererWindow, CONTENTS);
	PrefixList(contents, panel);
	SetVar(panel, PARENT, (ObjPtr) rendererWindow);

	contents = GetListVar("ShowRendererControls", panel, CONTENTS);
	if (contents)
	{
	    ObjPtr titleBox;
	    ObjPtr button;
	    ObjPtr radio;
	    ObjPtr var;
	    int left, right, top;
	    left = MAJORBORDER;
	    right = RWINWIDTH - MAJORBORDER;
	    top = RWINHEIGHT - MAJORBORDER;

	    /*Make the title box around render type*/
	    titleBox = NewTitleBox(left, right,
			top - TITLEBOXTOP - 2 * MINORBORDER - 2 * CHECKBOXHEIGHT - CHECKBOXSPACING, top, 
			"Renderer Type");
	    PrefixList(contents, titleBox);
	    SetVar(titleBox, PARENT, panel);

	    /*Make the no renderer button*/
	    radio = NewRadioButtonGroup("Renderer");
	    SetVar(radio, HELPSTRING, NewString("These radio buttons control what kind of renderer is \
used to render the objects within the space.  At present, there is only one renderer available: a hardware renderer."));

	    button = NewRadioButton(left + MINORBORDER, right - MINORBORDER,
			top - TITLEBOXTOP - MINORBORDER - CHECKBOXHEIGHT,
			top - TITLEBOXTOP - MINORBORDER,
			"None");
	    AddRadioButton(radio, button);
	    SetVar(button, HELPSTRING,
		NewString("This button causes rendering not to be done on the space.  \
This is sometimes useful as to hide all the visualization objects."));


	    /*Make the hardware renderer button*/
	    button = NewRadioButton(left + MINORBORDER, right - MINORBORDER,
			top - TITLEBOXTOP - MINORBORDER - 2 * CHECKBOXHEIGHT - CHECKBOXSPACING,
			top - TITLEBOXTOP - MINORBORDER - CHECKBOXHEIGHT - CHECKBOXSPACING,
			"Hardware");
	    AddRadioButton(radio, button);
	    SetVar(button, HELPSTRING,
		NewString("This button sets the space to use the hardware renderer.  \
At present, this is the only renderer available."));

	    PrefixList(contents, radio);
	    SetVar(radio, PARENT, panel);
	    SetVar(radio, REPOBJ, renderer);
	    var = GetVar(renderer, RENDERTYPE);
	    if (var)
	    {
		SetValue(radio, var);
	    }
	    else
	    {
		SetValue(radio, NewInt(RT_HARDWARE));
	    }
	    SetMethod(radio, CHANGEDVALUE, ChangeRenderType);

	    top -= TITLEBOXTOP + 2 * MINORBORDER + 2 * CHECKBOXHEIGHT + CHECKBOXSPACING + MAJORBORDER;

	    /*Make the title box around filter type*/
	    titleBox = NewTitleBox(left, right,
			top - TITLEBOXTOP - 2 * MINORBORDER - 3 * CHECKBOXHEIGHT - 2 * CHECKBOXSPACING, top, 
			"Image Filter");
	    PrefixList(contents, titleBox);
	    SetVar(titleBox, PARENT, panel);

	    /*Make the no filter button*/
	    radio = NewRadioButtonGroup("Filter Type");

	    SetVar(radio, HELPSTRING,
		NewString("These radio buttons select the kind of filtration that is done \
to the image of the space after it has been rendererd.  Filtration only works when the \
space is set to full color mode."));
	    button = NewRadioButton(left + MINORBORDER, right - MINORBORDER,
			top - TITLEBOXTOP - MINORBORDER - CHECKBOXHEIGHT,
			top - TITLEBOXTOP - MINORBORDER,
			"None");
	    AddRadioButton(radio, button);
	    SetVar(button, HELPSTRING,
		NewString("This button causes the image of the space to be shown \
without filtration.  This is the fastest and is recommended for interactive work."));

	    /*Make the shrink filter button*/
	    button = NewRadioButton(left + MINORBORDER, right - MINORBORDER,
			top - TITLEBOXTOP - MINORBORDER - 2 * CHECKBOXHEIGHT - CHECKBOXSPACING,
			top - TITLEBOXTOP - MINORBORDER - CHECKBOXHEIGHT - CHECKBOXSPACING,
			"2 to 1 shrink");
	    SetVar(button, HELPSTRING,
		NewString("This button causes the image of the space to be shrunk \
2 to 1 and averaged before being displayed.  This only works well when the window is \
in full color mode and the entire window is shown on the screen and is not covered by \
any other window.  It produces pretty good results with video.  Use the Double Video Screen \
item in the Window menu."));
	    AddRadioButton(radio, button);

	    /*Make the shrink filter button*/
	    button = NewRadioButton(left + MINORBORDER, right - MINORBORDER,
			top - TITLEBOXTOP - MINORBORDER - 3 * CHECKBOXHEIGHT - 2 * CHECKBOXSPACING,
			top - TITLEBOXTOP - MINORBORDER - 2 * CHECKBOXHEIGHT - 2 * CHECKBOXSPACING,
			"Four neighbor average");
	    SetVar(button, HELPSTRING,
		NewString("This button causes each pixel of image of the space to be \
averaged with its four neighbors in the horizontal and vertical directions before being displayed.  \
This only works well when the window is in full color mode and is not covered by \
other windows.  It produces pretty good results with video, \
though not as good as the shrinking filter."));
	    AddRadioButton(radio, button);

	    PrefixList(contents, radio);
	    SetVar(radio, PARENT, panel);
	    SetVar(radio, REPOBJ, renderer);
	    var = GetVar(renderer, FILTERTYPE);
	    if (var)
	    {
		SetValue(radio, var);
	    }
	    else
	    {
		SetValue(radio, NewInt(FT_NONE));
	    }
	    SetMethod(radio, CHANGEDVALUE, ChangeFilterType);
	}
    }

    return (ObjPtr) rendererWindow;
}

ObjPtr MakeClockTimeFormat(clock)
ObjPtr clock;
/*Makes a clock's TIMEFORMAT variable*/
{
    ObjPtr datasets;
    int curFormat;
    ObjPtr format;
    ObjPtr *elements;
    int k;

    MakeVar(clock, DATASETS);
    curFormat = 0;

    datasets = GetVar(clock, DATASETS);
    if (datasets)
    {
	elements = ELEMENTS(datasets);
	for (k = 0; k < DIMS(datasets)[0]; ++k)
	{
	    format = GetVar(elements[k], TIMEFORMAT);
	    if (format)
	    {
		int newFormat;
		newFormat = GetInt(format);
		curFormat |= newFormat;
	    }
	}
    }
    if (!curFormat)
    {
	curFormat = TF_SECONDS + TF_SUBSECONDS;
    }
    SetVar(clock, TIMEFORMAT, NewInt(curFormat));
    return ObjTrue;
}

ObjPtr MakeClockDatasets(clock)
ObjPtr clock;
/*Makes a clock's DATASETS variable, along with time slices*/
{
    ObjPtr list, spaces, array;
    ObjPtr *elements;
    long k;
    WinInfoPtr dialog;

    list = NewList();
    spaces = GetListVar("MakeClockDatasets", clock, SPACES);
    if (spaces)
    {
	ThingListPtr spaceRunner;
	spaceRunner = LISTOF(spaces);
	while (spaceRunner)
	{
	    ObjPtr contents;
	    contents = GetListVar("MakeClockDatasets", spaceRunner -> thing, CONTENTS);
	    if (contents)
	    {
		ThingListPtr contentsRunner;
		contentsRunner = LISTOF(contents);
		while (contentsRunner)
		{
		    PrefixDatasets(list, contentsRunner -> thing);
		    contentsRunner = contentsRunner -> next;
		}
	    }
	    spaceRunner = spaceRunner -> next;
	}
    }

    if (LISTOF(list))
    {
	/*There's something in the list*/
	Bool hasMinValue = false;
	real minValue;

	/*Convert to an array*/
	array = ListToArray(list);

	/*Remove duplicate elements*/
	array = Uniq(array);

	/*Sort the array*/
	array = SortArrayByStringVar(array, NAME);

	elements = ELEMENTS(array);
	for (k = 0; k < DIMS(array)[0]; ++k)
	{
	    ObjPtr name, timeSteps;
	    MakeVar(elements[k], NAME);
	    MakeVar(elements[k], TIMESTEPS);
	    name = GetVar(elements[k], NAME);
	    timeSteps = GetVar(elements[k], TIMESTEPS);
	    if (timeSteps)
	    {
		if (hasMinValue)
		{
		    minValue = MIN(minValue, *((real *)ELEMENTS(timeSteps)));
		}
		else
		{
		    minValue = *((real *)ELEMENTS(timeSteps));
		    hasMinValue = true;
		}
	    }
	}
	if (hasMinValue)
	{
	    if (!GetVar(clock, TIME))
	    {
		SetVar(clock, TIME, NewReal(minValue));
		ResolveController(clock);
	    }
	}
	else
	{
	    SetVar(clock, TIME, NULLOBJ);
	}
    }
    else
    {
	array = NULLOBJ;
	SetVar(clock, TIME, NULLOBJ);
    }

    /*Set the clock's datasets to datasets*/
    SetVar(clock, DATASETS, array);

	/*Now inval the control*/
	dialog = DialogExists((WinInfoPtr) clock, NewString("Clock"));

	if (dialog)
	{
	    ObjPtr control;

	    control = GetVar((ObjPtr) dialog, TIMECONTROL);
	    if (control)
	    {
		ImInvalid(control);
		MakeVar(control, DATASETS);
	    }
	}

    return ObjTrue;
}

ObjPtr commonClock = NULLOBJ;
ObjPtr commonObserver = NULLOBJ;
ObjPtr commonRenderer = NULLOBJ;

int clockNum = 0;
int observerNum = 0;
int rendererNum = 0;

ObjPtr NewClock()
/*Returns a new clock*/
{
    ObjPtr retVal;
    ObjPtr name;


    if (oneClock)
    {
	if (commonClock) return commonClock;
    }

    retVal = NewObject(clockClass, 0);
    if (oneClock)
    {
	commonClock = retVal;
    }
    name = GetVar(clockClass, NAME);
    if (name)
    {
	sprintf(tempStr, "%s %d", GetString(name), ++clockNum);
    }
    else
    {
	sprintf(tempStr, "Clock %d", ++clockNum);
    }
    name = NewString(tempStr);
    SetVar(retVal, NAME, name);
    SetVar(retVal, SPACES, NewList());
    SetVar(retVal, CYCLECLOCK, ObjTrue);
    return retVal;
}

ObjPtr NewObserver()
/*Returns a new observer*/
{
    ObjPtr retVal;
    ObjPtr name;
    real perspecStuff[4];
    ObjPtr psArray, anArray;
    real posn[3];

    if (oneObserver)
    {
	if (commonObserver) return commonObserver;
    }
    retVal = NewObject(observerClass, 0);
    if (oneObserver)
    {
	commonObserver = retVal;
    }
    name = GetVar(observerClass, NAME);
    if (name)
    {
	sprintf(tempStr, "%s %d", GetString(name), ++observerNum);
    }
    else
    {
	sprintf(tempStr, "Observer %d", ++observerNum);
    }
    name = NewString(tempStr);
    SetVar(retVal, NAME, name);
    SetVar(retVal, SPACES, NewList());
    SetVar(retVal, XFORM, NewMatrix());
    perspecStuff[0] = INITEYEDIST;
    perspecStuff[1] = INITAOV;
    perspecStuff[2] = INITNEARCLIP;
    perspecStuff[3] = INITFARCLIP;
    psArray = NewRealArray(1, 4);
    CArray2Array(psArray, perspecStuff);
    SetVar(retVal, PERSPECSTUFF, psArray);
    posn[0] = 0.0;
    posn[1] = 0.0;
    posn[2] = INITEYEDIST;
    anArray = NewRealArray(1, 3L);
    CArray2Array(anArray, posn);
    SetVar(retVal, LOCATION, anArray);
    posn[2] = 0.0;
    anArray = NewRealArray(1, 3L);
    CArray2Array(anArray, posn);
    SetVar(retVal, FOCUSPOINT, anArray);
    SetVar(retVal, FOCUSDIST, NewReal((real) INITEYEDIST));
    SetVar(retVal, ROLL, NewReal((real) 0.0));
    SetVar(retVal, YAW, NewReal((real) M_PI));
    SetVar(retVal, PITCH, NewReal((real) 0.0));

    return retVal;
}

ObjPtr NewRenderer()
/*Returns a new renderer*/
{
    ObjPtr retVal;
    ObjPtr name;

    if (oneRenderer)
    {
	if (commonRenderer) return commonRenderer;
    }
    retVal = NewObject(rendererClass, 0);
    if (oneRenderer)
    {
	commonRenderer = retVal;
    }
    name = GetVar(rendererClass, NAME);
    if (name)
    {
	sprintf(tempStr, "%s %d", GetString(name), ++rendererNum);
    }
    else
    {
	sprintf(tempStr, "Renderer %d", ++rendererNum);
    }
    name = NewString(tempStr);
    SetVar(retVal, NAME, name);
    SetVar(retVal, SPACES, NewList());
    SetVar(retVal, RENDERTYPE, NewInt(RT_HARDWARE));
    SetVar(retVal, FILTERTYPE, NewInt(RT_NONE));

    return retVal;
}

static ObjPtr CloneObserver(observer)
ObjPtr observer;
/*Clones observer*/
{
    Bool oldOneObserver;
    ObjPtr retVal;
    ObjPtr m, om;

    oldOneObserver = oneObserver;
    oneObserver = false;
    retVal = NewObserver();
    oneObserver = oldOneObserver;

    om = GetVar(observer, XFORM);
    if (om)
    {
	m = NewMatrix();
	MATCOPY(MATRIXOF(m), MATRIXOF(om));
	SetVar(retVal, XFORM, m);
    }

    CopyVar(retVal, observer, ROTAXIS);
    CopyVar(retVal, observer, ROTSPEED);	
    CopyVar(retVal, observer, PERSPECSTUFF);
    CopyVar(retVal, observer, LOCATION);
    CopyVar(retVal, observer, FOCUSPOINT);
    CopyVar(retVal, observer, FOCUSDIST);
    CopyVar(retVal, observer, ROLL);
    CopyVar(retVal, observer, YAW);
    CopyVar(retVal, observer, PITCH);
    CopyVar(retVal, observer, AIRSPEED);

    return retVal;
}

static ObjPtr CloneClock(clock)
ObjPtr clock;
{
    ObjPtr retVal;
    Bool oldOneClock;

    oldOneClock = oneClock;
    oneClock = false;
    retVal = NewClock();
    oneClock = oldOneClock;

    CopyVar(retVal, clock, CYCLECLOCK);
    CopyVar(retVal, clock, TIMESTEPS);
    CopyVar(retVal, clock, DATASETS);
    CopyVar(retVal, clock, TIME);

    return retVal;
}

static ObjPtr CloneRenderer(renderer)
ObjPtr renderer;
/*Clones renderer*/
{
    Bool oldOneRenderer;
    ObjPtr retVal;

    oldOneRenderer = oneRenderer;
    oneRenderer = false;
    retVal = NewRenderer();
    oneRenderer = oldOneRenderer;

    CopyVar(retVal, renderer, RENDERTYPE);
    CopyVar(retVal, renderer, FILTERTYPE);

    return retVal;
}

#if 0
static ObjPtr DrawExtraObserverIcon(icon, x, y)
ObjPtr icon;
int x, y;
/*Draws the extra stuff for an observer icon*/
{
    ObjPtr space, observers;
    space = GetObjectVar("DrawExtraObserverIcon", icon, SPACE);
    if (!space)
    {
	return ObjFalse;
    }
    observers = GetListVar("DrawExtraObserverIcon", space, OBSERVERS);
    if (!observers)
    {
	return ObjFalse;
    }
    if (GetVar(icon, REPOBJ) == LISTOF(observers) -> thing)
    {
	FrameUIRect(x - ICONSIZE / 2 - 4, x + ICONSIZE / 2 + 4, y - ICONSIZE / 2 - ICONSHADOW - 4, y + ICONSIZE / 2 + 4, UIREC);
	SetUIColor(UIBLACK);
    }
    return ObjTrue;
}
#endif

void InitSpaces()
/*Initializes the spaces*/
{
    ObjPtr icon;
 
    /*Create a class of spaces*/
    spaceClass = NewObject(NULLOBJ, 0);
    AddToReferenceList(spaceClass);
    SetMethod(spaceClass, DRAW, DrawSpace);
    SetVar(spaceClass, NAME, NewString("Space"));
    SetMethod(spaceClass, PRESS, PressSpace);
    SetMethod(spaceClass, KEYDOWN, KeyDownSpace);
    SetVar(spaceClass, XSTRETCH, NewInt(1));
    SetVar(spaceClass, YSTRETCH, NewInt(1));
    SetVar(spaceClass, TYPESTRING, NewString("space"));
    SetVar(spaceClass, HELPSTRING,
	NewString("A space provides a 3-dimensional world for visualization \
objects.  Objects are automatically scaled and translated to appear near the \
center by default.  Any number of visualization objects can exist within a space. \
Spaces are controlled by controllers, such as observers and lights.\n\
-\n\
Click and drag within the space using the left \
mouse button to move all the objects within the space.  Hold down the Shift \
key while dragging to contrain motion to an orthogonal axis of the space.  \
If Space Motion Guides is selected in the Preferences window, you will see the \
objects as embedded within a gray lattice showing the orthogonal axes.\n\
-\n\
Click and drag within the space ucing the center mouse button to rotate \
the entire space around the focus point of the observer at the center of the \
space.  The space can be rotated around any axis.  Hold down the Shift key \
to constrain to rotation around an orthogonal axis of the space.  Double-click \
to snap the space to the nearest straight-on orientation.  \
If Space Rotation Guides is selected in the Preferences window, you will see the \
virtual trackball that you are rotation as a wire frame sphere.  If Rotation Inertia \
is selected in the Preferences window, the space will continue to rotate if you \
give it a spin and let go while moving the mouse.\n\
-\n\
Both motion and rotation will affect other spaces controlled by the same observer."));
    lmdef(DEFMATERIAL, 1, 0, NULL);

    /*Initialize a space panel*/
    spacePanelClass = NewObject(panelClass, 0);
    AddToReferenceList(spacePanelClass);
    SetMethod(spacePanelClass, DROPOBJECTS, DropInSpacePanel);

    /*Initialize a space back panel*/
    spaceBackPanelClass = NewObject(spacePanelClass, 0);
    AddToReferenceList(spaceBackPanelClass);
    SetVar(spaceBackPanelClass, BACKGROUND, NewInt(UIBLACK));

    /*Create class of space controllers*/
    controllerClass = NewObject(NULLOBJ, 0);
    AddToReferenceList(controllerClass);

    /*Create class of clocks*/
    clockClass = NewObject(controllerClass, 0);
    AddToReferenceList(clockClass);
    SetMethod(clockClass, MARKTIME, MarkClockTime);
    SetMethod(clockClass, CLONE, CloneClock);
    SetMethod(clockClass, BINDTOSPACE, BindClockToSpace);
    SetMethod(clockClass, TOUCHSPACE, TouchSpaceClock);
    SetMethod(clockClass, NEWCTLWINDOW, ShowClockControls);
    SetMethod(clockClass, DOUBLECLICK, ShowIconControls);
    SetMethod(clockClass, RESOLVE, ResolveClock);
    SetMethod(clockClass, REINIT, MakeClockDatasets);
    SetVar(clockClass, CONTROLLERCLASS, clockClass);
    SetVar(clockClass, DEFAULTICON, icon = NewIcon(0, 0, ICONCLOCK, "Clock"));
    SetVar(icon, HELPSTRING,
	NewString("This icon represents a clock.  The clock controls the current \
time displayed within a space and the rate at which time goes forward or backward.  \
You can see controls for this clock by selecting it and choosing the Show Controls \
item in the Object menu.\n\
\n\
You can drag this icon into the icon corral of another visualization window to have \
it control the other space as well.  \
A space can only be controlled by one clock at a time.  If you drag another \
clock icon into this space, this clock will be replaced.\n\
\n\
You can place a time display in the image of the space itself by dragging this \
icon into the space itself."));
    SetVar(clockClass, NAME, NewString("Clock"));
    DeclareDependency(clockClass, TIMEREGISTERED, TIMEBOUNDS);
    SetMethod(clockClass, TIMEREGISTERED, RegisterTime);
    DeclareDependency(clockClass, TIMEFORMAT, DATASETS);
    SetMethod(clockClass, TIMEFORMAT, MakeClockTimeFormat);

    /*Create class of observers*/
    observerClass = NewObject(controllerClass, 0);
    AddToReferenceList(observerClass);
    SetMethod(observerClass, BINDTOSPACE, BindObserverToSpace);
    SetMethod(observerClass, TOUCHSPACE, TouchSpaceObserver);
    SetMethod(observerClass, NEWCTLWINDOW, ShowObserverControls);
    SetMethod(observerClass, DOUBLECLICK, ShowIconControls);
    SetVar(observerClass, VIEWTYPE, NewInt(VT_PERSPECTIVE));
    SetMethod(observerClass, MARKTIME, WakeObserver);
    icon = NewIcon(0, 0, ICONOBSERVER, "Observer");
    SetVar(icon, HELPSTRING, 
	NewString("This icon represents an observer.  The observer represents \
you looking into the 3-dimensional space.  You can change attributes such as the \
viewing angle and near and far clipping planes in the control panel, which you \
can show by selecting the icon and choosing the Show Controls \
item in the Object menu.\n\
\n\
You can drag this icon into the icon corral of another visualization window to have \
it control the other space as well.  When an observer controls more than one \
space, the view of the objects in the spaces are tied together.  This is very \
useful for viewing several similar datasets from the same viewpoint at once.  \
A space can only be controlled by one observer at a time.  If you drag another \
observer icon into this space, this observer will be replaced."));
#if 0
    SetMethod(icon, ICONEXTRADRAW, DrawExtraObserverIcon);
#endif
    SetVar(observerClass, DEFAULTICON, icon);
    SetVar(observerClass, CONTROLLERCLASS, observerClass);
    SetVar(observerClass, NAME, NewString("Observer"));
    SetMethod(observerClass, CLONE, CloneObserver);

    /*Create class of renderers*/
    rendererClass = NewObject(controllerClass, 0);
    AddToReferenceList(rendererClass);
    SetMethod(rendererClass, BINDTOSPACE, BindRendererToSpace);
    SetMethod(rendererClass, TOUCHSPACE, TouchSpaceRenderer);
    SetMethod(rendererClass, NEWCTLWINDOW, ShowRendererControls);
    SetMethod(rendererClass, DOUBLECLICK, ShowIconControls);
    SetVar(rendererClass, CONTROLLERCLASS, rendererClass);
    icon = NewIcon(0, 0, ICONRENDERER, "Renderer");
    SetVar(icon, HELPSTRING,
	NewString("This icon represents a renderer.  The controls the process \
of rendering, or producing an image from the visualization objects in the space.  \
You can show controls for the renderer by selecting the icon and choosing the Show Controls \
item in the Object menu.\n\
\n\
You can drag this icon into the icon corral of another visualization window to have \
it control the other space as well.  \
A space can only be controlled by one renderer at a time.  If you drag another \
renderer icon into this space, this renderer will be replaced."));
    SetVar(rendererClass, DEFAULTICON, icon);
    SetVar(rendererClass, NAME, NewString("Renderer"));
    SetMethod(rendererClass, CLONE, CloneRenderer);

    InitLights();
}

void KillSpaces()
/*Kills the spaces*/
{
    KillLights();
    DeleteThing(rendererClass);
    DeleteThing(observerClass);
    DeleteThing(clockClass);
    DeleteThing(controllerClass);
    DeleteThing(spaceBackPanelClass);
    DeleteThing(spacePanelClass);
    DeleteThing(spaceClass);
}