/* #Specification: gurusteps / principles
	The gurusteps component is used when you have a bunch of steps
	one a single line (no branches). Instead of using the gurupath
	like this (only eval,dialog and path1 tags):

	#
	<call gurupath)(...);
		<f eval>
		</>
		<f dialog>
		</f>
		<f path1>
			<call gurupath>(...);
				<f eval>
				</>
				<f dialog>
				</f>
				<f path1>
					<call gurupath>(...);
						<f eval>
						</>
						<f dialog>
						</f>
						<f path1>
							// One branche
						</f>
						<f path2>
							// Another branche
						</f>
					</call>
				</f>
			</call>
		</f>
	</call>						
	#

	you do

	#
	<call gurusteps>(...);
		<f eval1>
		</f>
		<f dialog1>
		</f>
		<f eval2>
		</f>
		<f dialog2>
		</f>
		<f eval3>
		</f>
		<f dialog3>
		</f>
		<f path1>
			// One branche
		</f>
		<f path2>
			// Another branche
		</f>
	</call>
	#
*/

#include "guruengine.h"

class gurusteps_private{
public:
	_F_gurupath *p;
	gurusteps_private(){
		p=NULL;
	}
};

void _F_gurusteps::settitle (const char *title)
{
	if (priv->p != NULL) priv->p->settitle (title);
}
void _F_gurusteps::setintro (const char *intro)
{
	if (priv->p != NULL) priv->p->setintro (intro);
}
void _F_gurusteps::seticon (const char *icon)
{
	priv->p->seticon (icon);
}
void _F_gurusteps::attention ()
{
	priv->p->attention ();
}
void _F_gurusteps::allfine ()
{
	priv->p->allfine ();
}

void _F_gurusteps::setterminal (const char *s, const char *l)
{
	if (priv->p != NULL) priv->p->setterminal (s,l);
}
bool _F_gurusteps::edit ()
{
	return priv->p->edit ();
}
bool _F_gurusteps::edit (HELP_FILE &help)
{
	return priv->p->edit (help);
}
void _F_gurusteps::setcursor (int nof)
{
	priv->p->setcursor (nof);
}

void _F_gurusteps::eval2(
	GURUPATH_MODE mode,
	GURUPATH_STATUS &status)
{
	status.is_possible = false;
	status.nodemissing = true;
}
void _F_gurusteps::dialog2(
	DIALOG &dia)
{
}
void _F_gurusteps::eval3(
	GURUPATH_MODE mode,
	GURUPATH_STATUS &status)
{
	status.is_possible = false;
	status.nodemissing = true;
}
void _F_gurusteps::dialog3(
	DIALOG &dia)
{
}
void _F_gurusteps::eval4(
	GURUPATH_MODE mode,
	GURUPATH_STATUS &status)
{
	status.is_possible = false;
	status.nodemissing = true;
}
void _F_gurusteps::dialog4(
	DIALOG &dia)
{
}
void _F_gurusteps::eval5(
	GURUPATH_MODE mode,
	GURUPATH_STATUS &status)
{
	status.is_possible = false;
	status.nodemissing = true;
}
void _F_gurusteps::dialog5(
	DIALOG &dia)
{
}
void _F_gurusteps::eval6(
	GURUPATH_MODE mode,
	GURUPATH_STATUS &status)
{
	status.is_possible = false;
	status.nodemissing = true;
}
void _F_gurusteps::dialog6(
	DIALOG &dia)
{
}

void _F_gurusteps::path1 (
	GURUPATH_MODE,
	GURUPATH_STATUS &status)
{
	status.nodemissing = true;
}
void _F_gurusteps::path2 (
	GURUPATH_MODE,
	GURUPATH_STATUS &status)
{
	status.nodemissing = true;
}
void _F_gurusteps::path3 (
	GURUPATH_MODE,
	GURUPATH_STATUS &status)
{
	status.nodemissing = true;
}

void _F_gurusteps::path4 (
	GURUPATH_MODE,
	GURUPATH_STATUS &status)
{
	status.nodemissing = true;
}
void _F_gurusteps::path5 (
	GURUPATH_MODE,
	GURUPATH_STATUS &status)
{
	status.nodemissing = true;
}
void _F_gurusteps::path6 (
	GURUPATH_MODE,
	GURUPATH_STATUS &status)
{
	status.nodemissing = true;
}
static void gurusteps0 (
	_F_gurusteps &c, 
	GURUPATH_MODE mode,
	GURUPATH_STATUS &status,
	int step,
	int nbstep);


<mod>
static void gurusteps0 (
	_F_gurusteps &c, 
	GURUPATH_MODE mode,
	GURUPATH_STATUS &status,
	int step,
	int nbstep)
{
	<glocal>
		_F_gurusteps *c;
		int step;
		int nbstep;
		bool moresteps;
	</glocal>
	glocal.c = &c;
	glocal.step = step;
	glocal.nbstep = nbstep;
	glocal.moresteps = step < nbstep-1;
	<call gurupath>(mode,status);
		<f eval>
			glocal.c->priv->p = this;
			switch (glocal.step){
			case 0:
				glocal.c->eval1(mode,status);
				break;
			case 1:
				glocal.c->eval2(mode,status);
				break;
			case 2:
				glocal.c->eval3(mode,status);
				break;
			case 3:
				glocal.c->eval4(mode,status);
				break;
			case 4:
				glocal.c->eval5(mode,status);
				break;
			case 5:
				glocal.c->eval6(mode,status);
				break;
			}
		</f>
		<f dialog>
			glocal.c->priv->p = this;
			switch (glocal.step){
			case 0:
				glocal.c->dialog1(dia);
				break;
			case 1:
				glocal.c->dialog2(dia);
				break;
			case 2:
				glocal.c->dialog3(dia);
				break;
			case 3:
				glocal.c->dialog4(dia);
				break;
			case 4:
				glocal.c->dialog5(dia);
				break;
			case 5:
				glocal.c->dialog6(dia);
				break;
			}
		</f>
		<f path1>
			if (glocal.moresteps){
				gurusteps0 (*glocal.c,mode,status,glocal.step+1,glocal.nbstep);
			}else{
				glocal.c->path1(mode,status);
			}
		</f>
		<f path2>
			if (glocal.moresteps){
				status.nodemissing = true;
			}else{
				glocal.c->path2(mode,status);
			}
		</f>
		<f path3>
			if (glocal.moresteps){
				status.nodemissing = true;
			}else{
				glocal.c->path3(mode,status);
			}
		</f>
		<f path4>
			if (glocal.moresteps){
				status.nodemissing = true;
			}else{
				glocal.c->path4(mode,status);
			}
		</f>
		<f path5>
			if (glocal.moresteps){
				status.nodemissing = true;
			}else{
				glocal.c->path5(mode,status);
			}
		</f>
		<f path6>
			if (glocal.moresteps){
				status.nodemissing = true;
			}else{
				glocal.c->path6(mode,status);
			}
		</f>
	</call>
}
</mod>			


void gurusteps (
	_F_gurusteps &c, 
	GURUPATH_MODE mode,
	GURUPATH_STATUS &status)
{
	gurusteps_private priv;
	c.priv = &priv;
	// We must find out how many steps are configured
	int nbstep = 6;
	for (int i=0; i<MAXGURUPATH; i++){
		GURUPATH_STATUS st(status.priv);
		switch (i){
		case 0:
			c.eval1(GURUPATH_EVAL,st);
			break;
		case 1:
			c.eval2(GURUPATH_EVAL,st);
			break;
		case 2:
			c.eval3(GURUPATH_EVAL,st);
			break;
		case 3:
			c.eval4(GURUPATH_EVAL,st);
			break;
		case 4:
			c.eval5(GURUPATH_EVAL,st);
			break;
		case 5:
			c.eval6(GURUPATH_EVAL,st);
			break;
		}
		if (st.nodemissing){
			nbstep = i;
			break;
		}
	}
	gurusteps0 (c,mode,status,0,nbstep);
}