/************************************************/
/*												*/
/*	Params.c - Parameter handler routines.		*/
/*												*/
/*	Revised 7/6/94	by RMR						*/
/*												*/
/************************************************/

#include "Snakes.h"

/************************************************/
/*		Global Parameter Dialog Routines		*/
/************************************************/

static void LoadGlobals(void)
{
	ScalarToPString(gGlobalParams->timeIncrement, gTempStr, "%6.2f");
	SkelSetDlogStr(gGlobalDialog, iTimeIncrStr, gTempStr);
	ScalarToPString(gGlobalParams->gravityConstant, gTempStr, "%6.2f");
	SkelSetDlogStr(gGlobalDialog, iGravConstStr, gTempStr);
	ScalarToPString(gGlobalParams->viscousFriction, gTempStr, "%6.2f");
	SkelSetDlogStr(gGlobalDialog, iViscFrictStr, gTempStr);
	NumToString((long)(gGlobalParams->threshold), gTempStr);
	SkelSetDlogStr(gGlobalDialog, iThresholdStr, gTempStr);
	NumToString((long)(gGlobalParams->gradientScale), gTempStr);
	SkelSetDlogStr(gGlobalDialog, iGradScaleStr, gTempStr);
	SkelSetDlogCtlValue(gGlobalDialog, iSmoothKern, gGlobalParams->smoothKernSize);
	SkelSetDlogCtlValue(gGlobalDialog, iGradKern, gGlobalParams->gradKernSize);
}

static void SaveGlobals(void)
{
	long num;
	
	SkelGetDlogStr(gGlobalDialog, iTimeIncrStr, gTempStr);
	PStringToScalar(gTempStr, &(gGlobalParams->timeIncrement));
	SkelGetDlogStr(gGlobalDialog, iGravConstStr, gTempStr);
	PStringToScalar(gTempStr, &(gGlobalParams->gravityConstant));
	SkelGetDlogStr(gGlobalDialog, iViscFrictStr, gTempStr);
	PStringToScalar(gTempStr, &(gGlobalParams->viscousFriction));
	SkelGetDlogStr(gGlobalDialog, iThresholdStr, gTempStr);
	StringToNum(gTempStr, &num);
	if (num > 100L)
		num = 100L;
	else if (num < 0)
		num = 0L;
	gGlobalParams->threshold = (Value)num;
	SkelGetDlogStr(gGlobalDialog, iGradScaleStr, gTempStr);
	StringToNum(gTempStr, &num);
	if (num > 9999L)
		num = 9999L;
	else if (num < 0)
		num = 0L;
	gGlobalParams->gradientScale = (short)num;
	gGlobalParams->smoothKernSize = SkelGetDlogCtlValue(gGlobalDialog, iSmoothKern);
	gGlobalParams->gradKernSize = SkelGetDlogCtlValue(gGlobalDialog, iGradKern);
}

static pascal Boolean GlobalDlogFilter(DialogPtr dlog, EventRecord *evt, short *item)
{
	return SkelDlogMapKeyToButton(dlog, evt, item, iGlobalOK, iGlobalCancel);
}

static pascal void GlobalDlogSelect(DialogPtr dlog, short item)
{
	if (dlog == gGlobalDialog)
		switch (item)
		{
			case iGlobalCancel:
				HideWindow(gGlobalDialog);
				AdjustMenus(true);
				break;
				
			case iGlobalOK:
				SaveGlobals();
				HideWindow(gGlobalDialog);
				AdjustMenus(true);
		}
}

static pascal void GlobalDlogClose(void)
{
	HideWindow(gGlobalDialog);
	AdjustMenus(true);
}

static pascal void GlobalDlogClobber(void)
{
	DisposeDialog(gGlobalDialog);
}

Boolean InitGlobalDialog(void)
{
	return SkelDialog(gGlobalDialog, GlobalDlogFilter, GlobalDlogSelect, GlobalDlogClose, GlobalDlogClobber);
}

void OpenGlobalDialog(void)
{
	LoadGlobals();
	ShowWindow(gGlobalDialog);
	SelectWindow(gGlobalDialog);
	RGBForeColor(&kBlack);
	RGBBackColor(&kWhite);
	SkelDlogTracksCursor(true);
	SkelDrawButtonOutline(SkelGetDlogCtl(gGlobalDialog, iGlobalOK));
	AdjustMenus(false);
}


/************************************************/
/*		Model Parameter Dialog Routines			*/
/************************************************/

static void LoadModelParams(ModelPtr model, DialogPtr dlog)
{
	NumToString((long)(model->windowSize), gTempStr);
	SkelSetDlogStr(dlog, iWSize, gTempStr);
	ScalarToPString(model->kineticLimit, gTempStr, "%6.5f");
	SkelSetDlogStr(dlog, iKLimit, gTempStr);
	ScalarToPString(model->forceLimit, gTempStr, "%6.5f");
	SkelSetDlogStr(dlog, iFLimit, gTempStr);
	ScalarToPString(model->particleMass, gTempStr, "%6.2f");
	SkelSetDlogStr(dlog, iPMass, gTempStr);
	ScalarToPString(model->rungStiffness, gTempStr, "%6.2f");
	SkelSetDlogStr(dlog, iRStiff, gTempStr);
	ScalarToPString(model->rungFriction, gTempStr, "%6.2f");
	SkelSetDlogStr(dlog, iRFriction, gTempStr);
	ScalarToPString(model->edgeStiffness, gTempStr, "%6.2f");
	SkelSetDlogStr(dlog, iEStiff, gTempStr);
	ScalarToPString(model->edgeFriction, gTempStr, "%6.2f");
	SkelSetDlogStr(dlog, iEFriction, gTempStr);
	ScalarToPString(model->braceStiffness, gTempStr, "%6.2f");
	SkelSetDlogStr(dlog, iBStiff, gTempStr);
	ScalarToPString(model->braceFriction, gTempStr, "%6.2f");
	SkelSetDlogStr(dlog, iBFriction, gTempStr);
}

static void SaveModelParams(DialogPtr dlog, ModelPtr model)
{
	long num;
	
	SkelGetDlogStr(dlog, iWSize, gTempStr);
	StringToNum(gTempStr, &num);
	if (num > 100)
		num = 100L;
	else if (num < 0)
		num = 0L;
	model->windowSize = (short)num;
	SkelGetDlogStr(dlog, iKLimit, gTempStr);
	PStringToScalar(gTempStr, &(model->kineticLimit));
	SkelGetDlogStr(dlog, iFLimit, gTempStr);
	PStringToScalar(gTempStr, &(model->forceLimit));
	SkelGetDlogStr(dlog, iPMass, gTempStr);
	PStringToScalar(gTempStr, &(model->particleMass));
	SkelGetDlogStr(dlog, iRStiff, gTempStr);
	PStringToScalar(gTempStr, &(model->rungStiffness));
	SkelGetDlogStr(dlog, iRFriction, gTempStr);
	PStringToScalar(gTempStr, &(model->rungFriction));
	SkelGetDlogStr(dlog, iEStiff, gTempStr);
	PStringToScalar(gTempStr, &(model->edgeStiffness));
	SkelGetDlogStr(dlog, iEFriction, gTempStr);
	PStringToScalar(gTempStr, &(model->edgeFriction));
	SkelGetDlogStr(dlog, iBStiff, gTempStr);
	PStringToScalar(gTempStr, &(model->braceStiffness));
	SkelGetDlogStr(dlog, iBFriction, gTempStr);
	PStringToScalar(gTempStr, &(model->braceFriction));
}

static pascal Boolean RefParamDlogFilter(DialogPtr dlog, EventRecord *evt, short *item)
{
	Point p;
	
	if (evt->what == updateEvt)
	{
		DrawDialog(dlog);
		DrawDlogColorBox(dlog, iPColor, gRefModel->particleColor);
		DrawDlogColorBox(dlog, iRColor, gRefModel->rungColor);
		DrawDlogColorBox(dlog, iEColor, gRefModel->edgeColor);
		DrawDlogColorBox(dlog, iBColor, gRefModel->braceColor);
		return true;
	}
	if (evt->what == mouseDown)
	{
		p = evt->where;
		GlobalToLocal(&p);
		if (PtInDlogColorBox(p, dlog, iPColor))
		{
			*item = iPColor;
			return true;
		}
		else if (PtInDlogColorBox(p, dlog, iRColor))
		{
			*item = iRColor;
			return true;
		}
		else if (PtInDlogColorBox(p, dlog, iEColor))
		{
			*item = iEColor;
			return true;
		}
		else if (PtInDlogColorBox(p, dlog, iBColor))
		{
			*item = iBColor;
			return true;
		}
	}
	return SkelDlogMapKeyToButton(dlog, evt, item, iModelOK, iModelCancel);
}

static pascal void RefParamDlogSelect(DialogPtr dlog, short item)
{
	if (dlog == gRefParamDialog)
	{
		switch (item)
		{
			case iPColor:
				PickDlogColor("\pChoose Ref Model Particle Color:", dlog, item, &gRefModel->particleColor);
				break;
				
			case iRColor:
				PickDlogColor("\pChoose Ref Model Rung Color:", dlog, item, &gRefModel->rungColor);
				break;
				
			case iEColor:
				PickDlogColor("\pChoose Ref Model Edge Color:", dlog, item, &gRefModel->edgeColor);
				break;
				
			case iBColor:
				PickDlogColor("\pChoose Ref Model Brace Color:", dlog, item, &gRefModel->braceColor);
				break;
				
			case iModelCancel:
				HideWindow(dlog);
				AdjustMenus(true);
				break;
				
			case iModelOK:
				SaveModelParams(dlog, gRefModel);
				HideWindow(dlog);
				AdjustMenus(true);
		}
	}
}

static pascal void RefParamDlogClose(void)
{
	HideWindow(gRefParamDialog);
	AdjustMenus(true);
}

static pascal void RefParamDlogClobber(void)
{
	DisposeDialog(gRefParamDialog);
}

Boolean InitRefParamDialog(void)
{
	return SkelDialog(gRefParamDialog, RefParamDlogFilter, RefParamDlogSelect, RefParamDlogClose, RefParamDlogClobber);
}

void OpenRefParamDialog(void)
{
	LoadModelParams(gRefModel, gRefParamDialog);
	ShowWindow(gRefParamDialog);
	SelectWindow(gRefParamDialog);
	RGBForeColor(&kBlack);
	RGBBackColor(&kWhite);
	SkelDlogTracksCursor(true);
	SkelDrawButtonOutline(SkelGetDlogCtl(gRefParamDialog, iThrsOK));
}

static pascal Boolean TestParamDlogFilter(DialogPtr dlog, EventRecord *evt, short *item)
{
	Point p;
	
	if (evt->what == updateEvt)
	{
		DrawDialog(dlog);
		DrawDlogColorBox(dlog, iPColor, gTestModel->particleColor);
		DrawDlogColorBox(dlog, iRColor, gTestModel->rungColor);
		DrawDlogColorBox(dlog, iEColor, gTestModel->edgeColor);
		DrawDlogColorBox(dlog, iBColor, gTestModel->braceColor);
		return true;
	}
	if (evt->what == mouseDown)
	{
		p = evt->where;
		GlobalToLocal(&p);
		if (PtInDlogColorBox(p, dlog, iPColor))
		{
			*item = iPColor;
			return true;
		}
		else if (PtInDlogColorBox(p, dlog, iRColor))
		{
			*item = iRColor;
			return true;
		}
		else if (PtInDlogColorBox(p, dlog, iEColor))
		{
			*item = iEColor;
			return true;
		}
		else if (PtInDlogColorBox(p, dlog, iBColor))
		{
			*item = iBColor;
			return true;
		}
	}
	return SkelDlogMapKeyToButton(dlog, evt, item, iModelOK, iModelCancel);
}

static pascal void TestParamDlogSelect(DialogPtr dlog, short item)
{
	if (dlog == gTestParamDialog)
		switch (item)
		{
			case iPColor:
				PickDlogColor("\pChoose Test Model Particle Color:", dlog, item, &gTestModel->particleColor);
				break;
				
			case iRColor:
				PickDlogColor("\pChoose Test Model Rung Color:", dlog, item, &gTestModel->rungColor);
				break;
				
			case iEColor:
				PickDlogColor("\pChoose Test Model Edge Color:", dlog, item, &gTestModel->edgeColor);
				break;
				
			case iBColor:
				PickDlogColor("\pChoose Test Model Brace Color:", dlog, item, &gTestModel->braceColor);
				break;
				
			case iModelCancel:
				HideWindow(dlog);
				AdjustMenus(true);
				break;
				
			case iModelOK:
				SaveModelParams(dlog, gTestModel);
				HideWindow(dlog);
				AdjustMenus(true);
		}
}

static pascal void TestParamDlogClose(void)
{
	HideWindow(gTestParamDialog);
	AdjustMenus(true);
}

static pascal void TestParamDlogClobber(void)
{
	DisposeDialog(gTestParamDialog);
}

Boolean InitTestParamDialog(void)
{
	return SkelDialog(gTestParamDialog, TestParamDlogFilter, TestParamDlogSelect, TestParamDlogClose, TestParamDlogClobber);
}

void OpenTestParamDialog(void)
{
	LoadModelParams(gTestModel, gTestParamDialog);
	ShowWindow(gTestParamDialog);
	SelectWindow(gTestParamDialog);
	RGBForeColor(&kBlack);
	RGBBackColor(&kWhite);
	SkelDlogTracksCursor(true);
	SkelDrawButtonOutline(SkelGetDlogCtl(gTestParamDialog, iModelOK));
}