?
//----------------------------------------------------------------------------------------------------------------------------------------------
//	Class Library for PD
//----------------------------------------------------------------------------------------------------------------------------------------------

// Menu class
// creates text or gif menus. 
//	Has a userdefineable onClass, OffClass, contatainer html, cell html and divider html
// if container html has <%title%> the title of the group is included
//	Which will hopefully cover all possibilities. Unlike prev versions this isn't editable out front.
//	The widths and heights are set by the css. If there's on/offgif is a colour then the entire bgcolour of a cell is set with these as mouseovers.
//  The templateBuilder class has sub classes of TD, A, title etc.
//----------------------------------------------------------------------------------------------------------------------------------------------


class menu{

	var $menuValID;				// The id of the chosen menu item	

	var $category;					// category/title of menu
	var $uid;							// the id level of the punter
	var $template;

	var $pageID=array();				  // page ID		

	//------------------------------------------------------------------------------------------------------------------------------------------
		function menu($menuValID, $category,$uid,$template){
		
		$yyy=array_keys($xxx = get_defined_vars());	 // generic populate
		for ($i=((phpversion()>=5)?0:1);$i<count($xxx)  ;$i++) {$this->{$yyy[$i]}=$xxx[$yyy[$i]];}	




	} // draw menu function ends.

	// output the menu
	//	designed to be as flexible as poss for all but dhtml dropdown type menus.
	//	It can handle vertical, horizontal, gif and mouseover div menus
	//
	//
	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function outputMenu(){	

		$db=new db();

		$str_sql="select * from DB_010_MENU where DB_002_MENUGROUP_ID='".$this->category."'";
		$str_sql.=" order by DB_010_ORDER";
		$vals=$db->get2dArray($str_sql);

		$this->menuValID=$this->menuValID!=''?$this->menuValID:$vals[3][0]; //set the value passed in to the first in the list by default

		// Table Layout : id, name, menugroup, pageid, order, externalurl, popup,  accesslevel.
		$n=0;
		for ($i=0;$i<count($vals[0]) ;$i++) {
			$accessLevel=$vals[9][$i];
			
			// this is done by checking the accessability of the page rather than the menu id itself

			if ($accessLevel==0 or (!$vals[3][$i] and $accessLevel!=1)  or ($accessLevel==-1 and !$this->uid) or ($accessLevel==1 and $this->uid) or ($accessLevel==2 and isAllowed($this->uid, 'page', $vals[3][$i]))) {

				$okToShow='y';
				if ($vals[3][$i] and $db->getFieldVal('DB_001_PAGE',$vals[3][$i],2,0)==2) {
					$okToShow=isAllowed($this->uid, 'page', $vals[3][$i]);
				}
				if ($okToShow) {

					if ($vals[5][$i] and !$vals[3][$i]) {
						$url=stripslashes($vals[5][$i]);
					}elseif($vals[5][$i] and $vals[3][$i]){
						$url="index.php?pageID=".$vals[3][$i].$vals[5][$i];
					}else{
						$url="index.php?pageID=".$vals[3][$i];
					}

					$presetClass=$vals[7][$i]?$vals[7][$i]:"";

					if ($this->menuValID==$vals[3][$i] or $db->getFieldVal('DB_001_PAGE',$this->menuValID,6,0)==$vals[0][$i]) {
						$class=$presetClass?$presetClass.'Active':'active';
					}else{
						$class=$presetClass?$presetClass:'plain';
					}

					$target=$vals[6][$i]?" target=\"_blank\"":"";
					
					if ($vals[7][$i] and $vals[8][$i] ) {	// each menu element has a seperate class, so you can have image gifs.
						$class=$class==$onClass?$vals[7][$i]:$vals[8][$i];
						$display="<img src=\"images/1x1.gif\" alt=\"".stripslashes($vals[1][$i])."\" border=\"0\">";			// the css needs to have an img subtag.
					}else{
						$display=stripslashes($vals[1][$i]);
					}

					$loopVals[0][$n]=$class;
					$loopVals[1][$n]="<a href=\"".$url."\"".$target.">".$display."</a>";
					$showFlag='y';
					$n++;
				}
			}
		}

		if ($showFlag) {
			$loopTags=array('<%class%>','<%link%>');
			$m=new templateBuilder($this->template);
			$menu=$m->cellContainerLoop('<%container%>','<%cell%>','<%divider%>',$loopTags, $loopVals);

					
			$menu="\n\n".str_replace("<%title%>",$db->getFieldVal('DB_002_MENUGROUP',$this->category,1,0), $menu)."\n\n";
		}else{
			$menu="";
		}
		return $menu;


	} // output menu ends

}	// draw menu class ends





//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
// The database class - a load of database type things that are used a lot.
// genericTableUpdate($type, $valArray,$tableName,$id,$fields)
// getArray($table,$idNum)										- returns a row
// getFieldVal($tableName,$id,$fieldNum,$keyNum)	- returns a field
// getDateVal($tableName,$id,$fieldNum,$keyNum)		- returns a formatted date
// getMysqlArray($str_sql,$idNum)							- returns a column
// get2dArray($str_sql)											- returns a 2darray
// get1dArray($str_sql)											- returns a 1darray
// qry($str_sql)
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
class db{
//	var $conn;
//	var $config;

var $thetable;
var $n;
var $IDField;
var $idstring;
var $tableIDField;
var $type;
var $valArray;
var $tableName;
var $id;
var $fields;
var $fieldNum;
var $keyNum;
var $msg;
var $table;
var $idNum;
var $str_sql;
var $result;

	// variables for connection held in an external file
	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function getFields($thetable,$n){
		
		if (eregi('select ', $thetable)) {
			$str_sql=$thetable;
		}else{
			$str_sql="SELECT * FROM ".$thetable. " limit 1";
		}
		$result = mysql_query($str_sql) or die($this->outputError($str_sql."<br /><br />".mysql_error()));
		for($i=0;$i<mysql_num_fields($result);$i++){
			if (mysql_field_Type($result, $i)!='timestamp') {
				$fields[] =mysql_field_name($result, $i);
			}
		}

		if ($n>-1) {
			$fields=mysql_field_name($result, $n);
		}
		mysql_free_result($result);
		
		return $fields;
	
	}	// getfields ends

	// 	next ID for Appending

	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function getnextid($thetable,$IDField){
		if ($thetable){
			$str="SELECT Max(".$IDField.") FROM ".$thetable;
			
			$rs=mysql_query($str) or die($this->outputError($str_sql."<br /><br />".mysql_error()));
			$row = mysql_fetch_array($rs);
			mysql_free_result($rs);
			return $row[0]+1;	
		}
	} // getnextid ends

	// if there is a search string then get the ids.
	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function makeSearchSql($idstring, $tableIDField){

	if ($idstring) {
		$ids=explode(":",$idstring);
		if (count($ids)) {
			$idStr.=" and (";
			for ($i=0;$i<count($ids) ;$i++) {
				$idStr.=(strlen($idStr)>7?" or ":"").$tableIDField."=".$ids[$i];
			}
			$idStr.=") ";
		}
	}
	return $idStr;
	} // function makeSearchSql($idstring, $tableIDField)


	// This will update add or delete any table regardless of format.
	// when updating %skip% in val array means the field stays the same.
	// returns a new ID
	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function genericTableUpdate($type, $valArray,$tableName,$id,$fields){

		if (!$fields) {	$fields=$this->getfields($tableName,-1);}		// if the fields aren't passed in it finds them
		
		list($type,$slashes)=explode(":",$type);

		switch($type){
			case 'delete':
				if ($id) {
					$str_sql="delete from ".$tableName." where ".$fields[0]."=".$id;
					$result=mysql_query($str_sql);
					$id=$this->getnextid($tableName,$fields[0])-1;
				}
			break;

			case 'update':

			if ($id) {
					$str_sql="UPDATE ".$tableName." SET ";
					$str_sql.=$tableName.".".$fields[0]."='".$valArray[0]."'";
					for($i=1; $i<count($fields); $i++){
						if ($valArray[$i]!='%skip%') {	 // filter  out hidden fields
							$str_sql.=", ".$tableName.".".$fields[$i]."='".($slashes?$valArray[$i]:addslashes($valArray[$i]))."'";
						}
					}
					$str_sql.=" WHERE ".$tableName.".".$fields[0]."=".$id;
					$result=mysql_query($str_sql) or die($this->outputError($str_sql."<br /><br />".mysql_error()));

				}
			break;

			case 'add':
				$str_sql="INSERT INTO  ".$tableName." ( ";
				$str_sql.=$fields[0];
				for($i=1; $i<count($fields); $i++){
					$str_sql.=", ".$fields[$i];
				}
				$id=$this->getnextid($tableName,$fields[0]);
				$id=$id?$id:1;
				$str_sql.=") VALUES (".$id;
				for($i=1; $i<count($fields); $i++){
					if ($valArray[$i]!='%skip%') {						// hidden fields are skipped on update, kept on append
						$valArray[$i]=str_replace('%skip%','',$valArray[$i]);
					}
					$str_sql.=", '".($slashes?$valArray[$i]:addslashes($valArray[$i]))."'";
					}
				$str_sql.=")";
				$result=mysql_query($str_sql) or die($this->outputError($str_sql."<br /><br />".mysql_error()));
			break;

			case 'REGISTER':
				$str_sql="INSERT INTO  ".$tableName." ( ";
				$str_sql.=$fields[0];
				for($i=1; $i<count($fields); $i++){
					$str_sql.=", ".$fields[$i];
				}
				$id=$this->getnextid($tableName,$fields[0]);
				$id=$id?$id:1;
				$str_sql.=") VALUES (".$id;
				for($i=1; $i<count($fields); $i++){
					if ($valArray[$i]!='%skip%') {						// hidden fields are skipped on update, kept on append
						$valArray[$i]=str_replace('%skip%','',$valArray[$i]);
					}
					$str_sql.=", '".($slashes?$valArray[$i]:addslashes($valArray[$i]))."'";
					}
				$str_sql.=")";
				$result=mysql_query($str_sql) or die($this->outputError($str_sql."<br /><br />".mysql_error()));
			break;

			case 'next >':
				$str_sql="INSERT INTO  ".$tableName." ( ";
				$str_sql.=$fields[0];
				for($i=1; $i<count($fields); $i++){
					$str_sql.=", ".$fields[$i];
				}
				$id=$this->getnextid($tableName,$fields[0]);
				$id=$id?$id:1;
				$str_sql.=") VALUES (".$id;
				for($i=1; $i<count($fields); $i++){
					if ($valArray[$i]!='%skip%') {						// hidden fields are skipped on update, kept on append
						$valArray[$i]=str_replace('%skip%','',$valArray[$i]);
					}
					$str_sql.=", '".($slashes?$valArray[$i]:addslashes($valArray[$i]))."'";
					}
				$str_sql.=")";
				$result=mysql_query($str_sql) or die($this->outputError($str_sql."<br /><br />".mysql_error()));
			break;

			case 'next >>':

			if ($id) {
					$str_sql="UPDATE ".$tableName." SET ";
					$str_sql.=$tableName.".".$fields[0]."='".$valArray[0]."'";
					for($i=1; $i<count($fields); $i++){
						if ($valArray[$i]!='%skip%') {	 // filter  out hidden fields
							$str_sql.=", ".$tableName.".".$fields[$i]."='".($slashes?$valArray[$i]:addslashes($valArray[$i]))."'";
						}
					}
					$str_sql.=" WHERE ".$tableName.".".$fields[0]."=".$id;
					$result=mysql_query($str_sql) or die($this->outputError($str_sql."<br /><br />".mysql_error()));

				}
			break;


				$str_sql="INSERT INTO  ".$tableName." ( ";
				$str_sql.=$fields[0];
				for($i=1; $i<count($fields); $i++){
					$str_sql.=", ".$fields[$i];
				}
				$id=$this->getnextid($tableName,$fields[0]);
				$id=$id?$id:1;
				$str_sql.=") VALUES (".$id;
				for($i=1; $i<count($fields); $i++){
					if ($valArray[$i]!='%skip%') {						// hidden fields are skipped on update, kept on append
						$valArray[$i]=str_replace('%skip%','',$valArray[$i]);
					}
					$str_sql.=", '".($slashes?$valArray[$i]:addslashes($valArray[$i]))."'";
					}
				$str_sql.=")";
				$result=mysql_query($str_sql) or die($this->outputError($str_sql."<br /><br />".mysql_error()));
			break;

		}

		if ($GLOBALS['debug']=='y') {
			print "<br />".$str_sql."<br />";
		}

		return $id;
	}	// genericTableUpdate ends

	// this gets a field value from a table, given a field and a parameter to match it to.
	// v.01 - 05/04/02
	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function getFieldVal($tableName,$id,$fieldNum,$keyNum){
		$keyField=$this->getfields($tableName,$keyNum);
		$str_sql="select * from ".$tableName." where ".$keyField."='".$id."'";

		$result=mysql_query($str_sql) or die($this->outputError($str_sql."<br /><br />".mysql_error()));
		if($row=mysql_fetch_array($result)){
			mysql_free_result($result);
			return $row[$fieldNum];
		}
	}	// getFieldVal ends

	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function outputError($msg){
		$errorStr="<p><font face=\"arial\" size=\"-1\"><br />";
		$errorStr.="<strong>Sorry but there's a temporary fault with the website.</strong> We're aware of what's happening and are in the process of fixing it.<br /><br />";
		$errorStr.="In the meantime, if you want to contact Press Dispensary, please phone <strong>0845 430 4433</strong> (+44 845 430 4433) or email <a href=\"mailto:ask@pressdispensary.co.uk\">ask@pressdispensary.co.uk</a><br /><br />";
		$errorStr.="Our apologies for any inconvenience.</font></p>";

//		if ($GLOBALS['isDeveloper']) {
			$str.=$errorStr."<p></p>-------------------------------------------------------------------------------------------------------------------------------------------------";
			$str.="<p><div style=\"font-family:arial;font-size:11px;\"><b>MYSQL ERROR</b><br /><span style=\"color:#3300CC\">".$msg."</span><br /><br />";

			$vars=debug_backtrace();

			$str.="<fieldset style=\"padding:10px;\"><legend>Trace</legend>";
			// <br />-------------------------------------------------------------------------------------------------------------------------------------------------<br />";

			foreach($vars as $arr){
				if ($arr["function"]!='outputerror') {
					$str.="<b>".str_replace($_SERVER['DOCUMENT_ROOT'],"",$arr["file"])."</b> : line ".$arr["line"]." : ";
					$str.=$arr["class"]?$arr["class"].$arr["type"]:"";
					$str.=$arr["function"]."(".implode(",",$arr["args"]).")<br /><br />";
				}
			}
			$str.="</fieldset>";
			//$str.="-------------------------------------------------------------------------------------------------------------------------------------------------<br />";
/*		}else{
			$str.=$errorStr;
		} */
		$str.="</div>";
		print $str;

	}



	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function getArray($table,$idNum){
		
		$str_sql="select * from ".$table." where ".$this->getfields($table,0)."=".$idNum;
		$result=mysql_query($str_sql) or die($this->outputError($str_sql."<br /><br />".mysql_error()));
		if($row=mysql_fetch_array($result)){
			mysql_free_result($result);
			return $row;
		}
	}	// getArray ends

	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function getMysqlArray($str_sql,$idNum){
		$vals=array();
		$result=mysql_query($str_sql) or die($this->outputError($str_sql."<br /><br />".mysql_error()));
		if($row=mysql_fetch_array($result)){
			do{
				$vals[]=$row[$idNum];
			}while($row=mysql_fetch_array($result));
			mysql_free_result($result);
		}

		return $vals;
	} // getMysqlArray ends

	// returns a 2d array of a query.
	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------	
	function get2dArray($str_sql){
		$result=mysql_query($str_sql) or die($this->outputError($str_sql."<br /><br />".mysql_error()));
		if($row=mysql_fetch_array($result)){
			$n=0;
			do{
				for ($i=0;$i<mysql_num_fields($result) ;$i++) {
					$vals[$i][$n]=$row[$i];					// the ids
				}
				$n++;
			}while($row=mysql_fetch_array($result));
			mysql_free_result($result);
			return $vals;
		}	
	} // get2dArray ends
	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------	
	function get1dArray($str_sql){
		$result=mysql_query($str_sql) or die($this->outputError($str_sql."<br /><br />".mysql_error()));
		if($row=mysql_fetch_array($result)){
			mysql_free_result($result);
			return $row;
		}	
	} // get1dArray ends

	// performs query - for updates etc.
	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function qry($str_sql){
		$result=mysql_query($str_sql) or die($this->outputError($str_sql."<br /><br />".mysql_error()));
	} // qry ends

} // db class ends



//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
//	this takes a template, arrays of elements to be replace and returns the output string.
//	eg    
//
//
//			$pwdForm=new templateBuilder($this->pwdTemplate);
//			
//			// pass the template the loop vars
//			$loopName="<%loop_pwd%>";													the name of the loop
//			$loopTags=array('<%id%>','<%name%>','<%msg%>');				the items within the loop
//			$loopVals=array($ids, $names,$this->msg);									 an array of arrays
//			$pwdForm->loopHandler($loopName, $loopTags, $loopVals);
//
//			// pass the template the non loop vars.
//			$switchTags=array('<%msg%>','<%num_pwds%>');				
//			$switchVals=array($this->msg,count($ids));	
//			$pwdForm->simpleTemplate($switchTags, $switchVals);
//			
//			print $pwdForm->getTemplateStr();
// 
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
class templateBuilder{
	var $templateStr;
	var $editTable;			// sometimes there's a table that needs editing.
	var $isAllowed;
	var $template;
	var $loopName;
	var $loopTags;
	var $loopVals;
	var $innerLoopTag;
	var $outerLoopTag;
	var $loopTag;
	var $width;
	var $class;
	var $title;
	var $str;
	var $tag;
	var $val;
	var $n;
	var $value;
	var $switchTags;
	var $switchVals;
	var $containerTag;
	var $cellTag;
	var $dividerTag;
	var $tag1;
	var $tag2;
	var $valArray;
	var $showArray;
	var $fieldname;
	var $valToShow;
	var $null;
	var $submit;
	var $showArray1;
	var $showArray2;
	var $name;
	var $dVal;
	var $mVal;
	var $yVal;
	var $backForward;

	var $ifTags=array();
	var $ifValTrue=array();
	var $ifValFalse=array();
	var $ifIndicators=array();

	var $libDirectory;

	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function templateBuilder($template){
		
		if (strlen($template)>3) {

			if (strlen($template)>30) { // make sure it's a file
					$this->templateStr=explode("\n",$template);		
			}else{
				if (file_exists($template)) {
					$this->templateStr=file($template);
				}else{
					$this->templateStr=explode("\n",$template);
				}
			}
		}

		$this->libDirectory=$GLOBALS['templateLibDirectory'];
	}

// NEXT FEW LINES QUESTIONABLE
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function setTable($editTable,$isAllowed){
		$this->editTable=$editTable;	
		$this->isAllowed=$isAllowed;
	} // function setTable($editTable) ends


	// gets the number of stack tags in a template

//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function getStacks(){
		$str=implode('',$this->templateStr);
		for ($i=0;$i<100 ;$i++) {
			if (@eregi('<%'.$i.'%>',$str)) {
				$stacks[]='<%'.$i.'%>';
			}
		}
		return $stacks;
	} // 




	// loop handler
	// this is called seperately for each loop.
	// 
	// $loopName="<%loop_pwds%>";				- parses for this, until <%/loop_pwds%> this creating a text block
	// cycles through the loop Vals for each loopTag doing a str replace, appending the new block of text
	// when finished, this is inserted back into where the block originally came from.
	// $loopTags=array('<%id%>','<%name%>','<%pwd1%>','<%pwd2%>');
	// $loopVals=array($id, $name, $pwd1, $pwd2);
	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------		
	function loopHandler($loopName, $loopTags, $loopVals){
		if (count($this->templateStr)) {
			$f=array_values($this->templateStr);
			// this bit gets a post, pre and block string.
			for ($i=0;$i<count($f) ;$i++) {

				if (trim($f[$i])==$loopName) {					// found start of block
						for ($i=$i+1;$i<count($f) ;$i++) {	// cunning double loop with same variable name.
							if (trim($f[$i])==str_replace("<%","<%/",$loopName)){// find end of loop
								for ($i=$i+1;$i<count($f) ;$i++) {	// cunning double loop with same variable name.
									$postStr.=$f[$i]."splitHere";
								}
							}else{
								$blockStr.=$f[$i]."splitHere";
							}
						}	
				}else{
					$preStr.=$f[$i]."splitHere";
				}
			}    // by the time we get to here we have a post, pre and block string.
			
			// now go through the block str inserting variables.

			for ($i=0;$i<count($loopVals[0]) ;$i++) {

		
				
				$tmpBlock=$blockStr;
				for ($n=0;$n<count($loopTags) ;$n++) {		// each loopVal is an array
					$vals=@array_values($loopVals[$n]);
					$tmpBlock=$this->special_replace($loopTags[$n],stripslashes($vals[$i]),$tmpBlock,$n);

				}
				$tmpBlock=str_replace('<%n%>',$i,$tmpBlock);	//put counter variable in as well - needed for forms sometimes
				$filledBlock.=$tmpBlock;										
			}
			$s=$preStr.$filledBlock.$postStr; 

			$this->templateStr=explode("splitHere",$s);
		}	
	}	//loopHandler ends

	// this populates a template with a 2d array
	// also converts the templateStr from an array to a string. Why does this have to be an array in the first place?
	//-----------------------------------------------------------------------------------------------------------------------------------------------------------
	function nestedLoop($loopVals,$innerLoopTag,$outerLoopTag,$loopTag){
		
		$s=implode("\n",$this->templateStr);

		$innerLoopTag2=str_replace('<%','<%/',$innerLoopTag);
		$outerLoopTag2=str_replace('<%','<%/',$outerLoopTag);

		$outerBit=$this->between($outerLoopTag,$outerLoopTag2, $s);
		$innerBit=$this->between($innerLoopTag, $innerLoopTag2, $outerBit);

		for ($i=0;$i<count($loopVals[0]) ;$i++) {
			
			$temp1='';
			for ($n=0;$n<count($loopVals) ;$n++) {
				$temp1.=$this->special_replace($loopTag,$loopVals[$n][$i],$innerBit,$i);
			}
			$temp2.=str_replace($innerLoopTag.$innerBit.$innerLoopTag2, $temp1,$outerBit);

		}
		
		$this->templateStr=explode("\n",str_replace($outerLoopTag.$outerBit.$outerLoopTag2, $temp2,$s));

	}	


	// If there's a | then we try to include a plugin file.
	// to avoid keyword clashes, all plugin files and functions are prefixed with t_
	//-----------------------------------------------------------------------------------------------------------------------------------------------------------
	function special_replace($tag,$val,$str,$n){
		

		// look in the template to see if any of the tags have extra bits
			
		$tagsInTemplate=getTags(implode("\n",$this->templateStr));

		for ($i=0;$i<count($tagsInTemplate) ;$i++) {

			if (strpos($tagsInTemplate[$i], '|')!= false) {

				$temp=str_replace("<%",'',$tagsInTemplate[$i]);
				$temp=str_replace("%>",'',$temp);
				list($t,$fnStuff,$default)=explode("|",$temp);		

				if ($tag=='<%'.$t.'%>') {

					$fullTag=$tagsInTemplate[$i];
					$i=count($tagsInTemplate);

				}
			}
		}

		if ($fullTag) {
			list($pluginFile)=explode(":",$fnStuff);	// get the filename, without possible parameters
				if ($pluginFile!="nl2br_url" and $pluginFile!="nl2br"){
				}
			if (file_exists($this->libDirectory."plugin.".trim($pluginFile).".php")) {

				require_once($this->libDirectory."plugin.".trim($pluginFile).".php");
				$functionName=trim("plugin_".$pluginFile);
				$val=$functionName($fnStuff,$val,$n);					
				$tag=$fullTag;
			}
			if ($default and !$val) {
				$val=str_replace("%>","",$default);
			}
		}

		$str=str_replace($tag,$val,$str);
		
		return $str;
	} // function specialReplace() ends


	// this comes from other functions - has to happen first
	/* eg:
	<%if yn=y%>
	firstbit
	<%else%>
	second bit
	<%/if yn=y%>
	*/
	//-------------------------------------------------------------------------------------------------------------------------------------------------------
	function ifHandler($str,$tag,$value){

		if ($tag) {

			$str=str_replace('<%/if ','<%if ',$str);		
			$test=$this->between("=", "%>", $tag);

			list($pre,$ifPart,$post)=explode($tag,$str);

			if ($ifPart) {

				list($truePart,$falsePart)=explode("<%else%>",$ifPart);

				if ($value==$test) {
					$str=$pre.$truePart.$post;
				}else{
					$str=$pre.$falsePart.$post;				
				}
			}
		}
	
		return $str;
	} // function ifHandler() ends



	// output the the template with the data inserted.
	//
	//	
	//Ifs are now handled. If the tag starts with <%if~ then it will be in the format 
	//      <%if_tagname~value%>truePart<%else%>falsePart<%/if_tagname~value%>
	//	The ifs must always come first as they can contain further tags.
	//
	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function simpleTemplate($switchTags, $switchVals){


		if (count($this->templateStr)) {
			$str=implode('',$this->templateStr);

			for ($i=0;$i<count($switchTags) ;$i++) {

				if (eregi('<%if ',$switchTags[$i])) {
					$str=$this->ifHandler($str,$switchTags[$i],$switchVals[$i]);
				}

				$str=$this->special_replace($switchTags[$i],$switchVals[$i],$str,0);

			}
		}
		$str=str_replace("<%self%>",$GLOBALS['PHP_SELF'],$str);
		$this->templateStr=$str;
	}

	// this takes a string in the form <%container%><%container%><%cell%><%cell%><%divider%><%divider%>
	// the container string will always have <%body%> in it.
	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function cellContainerLoop($containerTag='<%container%>',$cellTag='<%cell%>',$dividerTag='<%divider%>',$loopTags, $loopVals){

		$s=is_array($this->templateStr)?implode('',$this->templateStr):$this->templateStr;
	
		$container=$this->between($containerTag, str_replace('<%','<%/',$containerTag), $s);
		$cell=$this->between($cellTag, str_replace('<%','<%/',$cellTag), $s);
		$divider=$this->between($dividerTag, str_replace('<%','<%/',$dividerTag), $s);

		for ($i=0;$i<count($loopVals[0]) ;$i++) {
			$temp=$cell;

			for ($n=0;$n<count($loopVals) ;$n++) {
				$temp=$this->special_replace($loopTags[$n],$loopVals[$n][$i],$temp,$i);
			}

			$singleItem[]=$temp;			
		}
		$str=@implode($divider,$singleItem);
		$str=str_replace('<%body%>',$str,$container);

		return $str;
		

	}


	// returns string between two others
	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function between($tag1, $tag2, $str){
		$str=str_replace($tag2, $tag1, $str);
		$s=explode($tag1, $str);

		return $s[1];
	} // function between()

	// this goes to a global array kept in db.php and fills in the gaps.
	//-------------------------------------------------------------------------------------------------------------------------------------------------------
	function doGLobals($str){
		$db=new db; // THIS LINE (732) ADDED AS PART OF NICK UPDATE - NEEDED?
		if (count($GLOBALS['globalTags']) and !$GLOBALS['isAdmin']) {
			for ($i=0;$i<count($GLOBALS['globalTags']) ;$i++) {
				
				list($null1,$name,$null2)=explode("%",$GLOBALS['globalTags'][$i]);
				$str=str_replace($GLOBALS['globalTags'][$i],$GLOBALS[$name],$str);
			}
		}
		return $str;
	
	} // 	function doGLobals() ends


	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function getTemplateStr(){
			$str=$this->doGLobals($this->templateStr);
		return $str;
	}

	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function simpleDropdown($valArray,$showArray,$fieldname, $valToShow,$null,$submit){
			
		$str.= "<select name=\"".$fieldname."\"".($submit?" onchange=\"".$submit."\"":"")." class=\"dropdown\">\n"; 
		if ($null) {$str.="<option value=''></option>\n";}
		for ($i=0;$i<count($valArray) ;$i++) {
			$str.="<option value=\"".$valArray[$i]."\"".(($valToShow==$valArray[$i])?" selected":"").">".$showArray[$i]."</option>\n";
		}
		$str.= "</select>\n";

		return $str;
	} // simpleDropdown ends


	// for recent dates.
	//----------------------------------------------------------------------------------------------------------------------------------------------------------
	function drawDateDropdowns($name,$dVal,$mVal,$yVal,$backForward){
		for ($i=1; $i<32 ;$i++) {$days[]=$i;}
		$str.=$this->simpleDropdown($days,$days,$name.'Days', $dVal,'','');
		for ($i=1; $i<13 ;$i++) {
			$months[]=$i;
			$monthNames[]=date('F',mktime (0,0,0,$i,1,2002));
			
		}		
		$str.=$this->simpleDropdown($months,$monthNames,$name.'Months', $mVal,'','');

		list($back,$forward)=explode(":",$backForward);

		for ($i=date('Y')-$back; $i<date('Y')+$forward+1 ;$i++) {$years[]=$i;}	
		$str.=$this->simpleDropdown($years,$years,$name.'Years', $yVal,'','');		

		return $str;
	} //function drawDateDropdowns()


}	// class templateBuilder ends




// this class makes a thumbnail of a given size in a given directory from a given image.
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
class thumb{
	var $width;					// width of new img 
	var $height;					// width of new img 		
	var $imgName;
	var $thumbName;	
	var $rnd;	// flag to wobble the output
	var $type;
	var $im;

	//-------------------------------------------------------------------------------------------------------------------------------------------------
	function thumb($width, $height, $imgName,$thumbName, $rnd){
		$yyy=array_keys($xxx = get_defined_vars());
		for ($i=((phpversion()>=5)?0:1);$i<count($xxx)  ;$i++) {$this->{$yyy[$i]}=$xxx[$yyy[$i]];}	
		$this->thumbMaker();
	}

	//-------------------------------------------------------------------------------------------------------------------------------------------------
	function thumbMaker() {
	   // Returns true if thumbnail was created, else false
	   $size = GetImageSize($this->imgName);
	   $width  = $size[0];
	   $height = $size[1];
	   $type   = $size[2];
	   $memoryLimit = ini_get('memory_limit');
	   $origMemoryLimit = $memoryLimit;
	   $memoryNeeded = round(($width * $height * $size['bits'] * $size['channels'] / 8 + Pow(2, 16)) * 1.65);
	   $start_mem = memory_get_usage();

		// This next section reports differences between memory available and memory needed, for troubleshooting 
		echo 'Limit: ' . $memoryLimit . "<br />";
		echo 'Memory needed to create thumbnail: ';

		if ($memoryNeeded < 1024) {
			echo $memoryNeeded . ' bytes';
		} else {
			$memoryNeededx = round($memoryNeeded / 1024, 2);
			$suffix = 'KB';
			if ($memoryNeededx >= 1024) {
				$memoryNeededx = round($memoryNeededx / 1024, 2);
				$suffix = 'MB';
			}
			echo $memoryNeededx.$suffix.'<br />';
		}
		echo 'Usage before: ';
	
		if ($start_mem < 1024) {
			echo $start_mem . ' bytes';
		} else {
			$sizehere = round($start_mem / 1024, 2);
			$suffix = 'KB';
			if ($sizehere >= 1024) {
				$sizehere = round($sizehere / 1024, 2);
				$suffix = 'MB';
			}
			echo $sizehere.$suffix.'<br />';
		}
		// end of reporting memory for troubleshooting


		// The next section analyses memory available and needed, and raises the memory limit if necessary

		if ($start_mem + $memoryNeeded > (integer) $memoryLimit * pow(1024, 2)) {
  
		$fudgedOverhead = 33554432; // because sometimes the difference can be too close without an extra bit. And since ImageCreateTrueColor now works (with the GD library) it seems to need 32MB overhead, not the 8MB I'd originally put in, or even 16MB!

		  ini_set('memory_limit', (integer) $memoryLimit + ceil((($start_mem) + $memoryNeeded + $fudgedOverhead - (integer) $memoryLimit * pow(1024, 2)) / pow(1024, 2)) . 'M');
			
			echo 'New memory limit: ' . ini_get('memory_limit') . "<br />";
                   
		} // end of memory analysis and management


		// This is where the width of the image is sorted out
		// basically it's the longest side reduced to $w, with a bit of randomness added if $rand
		if ($this->height) {
			$twidth=$this->width;
		}else{
			$twidth=($width>$height)?$this->width:$width/$height*$this->width;
		}
		if ($this->rnd) {
			srand((double)microtime() * 1000000);
			$rndnum=rand()%10-5;
			$twidth=$twidth+$rndnum;
		}

	   if ($im = $this->ReadImageFromFile($type)) {

		  if ($this->height) {
			$theight = $this->height;
		  }else{
			$theight = ($twidth / $width) * $height;
		  }
	
		  if (function_exists("ImageCreateTrueColor")) {
			 $im2 = ImageCreateTrueColor($twidth,$theight) or die("Cannot initialize new GD true colour image stream");
		  } else {
			 $im2 = ImageCreate($twidth,$theight) or die("Cannot initialize new GD image stream");
		  }
		  if (function_exists("ImageCopyResampled")) {
			  ImageCopyResampled($im2,$im,0,0,0,0,$twidth,$theight,$width,$height) or die("Cannot resample");
		  } else {
			  ImageCopyResized($im2,$im,0,0,0,0,$twidth,$theight,$width,$height) or die("Cannot resize");
		  }
		

		  if ($this->WriteImageToFile($im2, $type)){
			return true;
		  } else {
			  echo "<font size=2 color=red><br /><br />Unable to save thumbnail<br /><br /></font>";

  
		  }

	   }

	   echo "<font size=2 color=red><br /><br />Thumbnail was not created!<br /><br /></font>";

	   // this restores the memory limit back to its original setting

	   return false;


	} // end of function thumbMaker()


	//--------------------------------------------------------------------------------------------------------------------------------------------
	function ReadImageFromFile($type) {
	   $imagetypes = ImageTypes();

	   switch ($type) {
		  case 1 :
			 if ($imagetypes & IMG_GIF)
				// this doesn't work - php bug	
				 return ImageCreateFromGIF($this->imgName);
			 break;
		  case 2 :
			 if ($imagetypes & IMG_JPEG)
				 return ImageCreateFromJPEG($this->imgName);
			 break;
		  case 3 :
			 if ($imagetypes & IMG_PNG)
				 return ImageCreateFromPNG($this->imgName);
			 break;
		  default:
			 return 0;
	   }
	}

	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function WriteImageToFile($im, $type) {
	   switch ($type) {
		  case 1 :
			 return ImageGIF($im, $this->thumbName);
		  case 2 :
			return ImageJpeg($im, $this->thumbName, 80);
		  case 3 :
			 return ImagePNG($im, $this->thumbName);
		  default:
			 return false;
	   }
	}


}




//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
class uploader {

	var $name=Array();			// array...name->filename, type->file type,size->file size, tmp_name->filename in temp directory on server
	var $allowed=array();		// lower case
	var $dir;

	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function uploader($allowed) {
		$this->name=$_FILES;
//		$this->name=$GLOBALS['HTTP_POST_FILES']; // IF NOT WORKING, CHECK THESE LINES !!!
		$this->allowed=$allowed;

	} // uploader ends

	// 0   - error 
	// >0  - all files are OK
	function transfer() {
		foreach($this->name as $name => $file)
			if (!@$file['size']) return 0;
		return count($this->name);
	} // transfer ends

	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function move($dir) {

	$dir=substr($GLOBALS['SCRIPT_FILENAME'], 0, strrpos($GLOBALS['SCRIPT_FILENAME'], "/"))."/".$dir;  //IF STILL NOT WORKING, CHECK HERE!!

	foreach($this->name as $file)
			// delete it if it exists - so it overwrites.
		$fullFile=$dir."/".$file['name'];
		if (file_exists($fullFile)) {
			@chmod($fullFile,0777);	
			@unlink($fullFile);
		}
		$ext=explode(".",$file['name']);
		if (strtolower(in_array($ext[1],$this->allowed))) {
 			move_uploaded_file($file['tmp_name'],$dir."/".$file['name']);
			@chmod($fullFile,0777);
			return $file['name'];
		}else{
			return "not the right kind of file";
		}
	}// move ends 
	
} //uploader of class





// encryption class
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
class Encrypt extends rc4crypt {
	var $classname = "ANMF_Encrypt";
	var $OneWayEncrypt = '!>'; // One way encryption salt
	var $TwoWayEncrypt = "Souventpoursamuserleshommesdequipage";
	var $String;
	var $pwd;
	var $data;
	var $case;


	function Enc2($String) {
		// encrypt a string with two way encryption
		return $this->endecrypt($this->TwoWayEncrypt,$String,"en");
	}

	function Dec2($String) {
		// decrypt a string using two way encryption
		return $this->endecrypt($this->TwoWayEncrypt,$String,"de");
	}

}

// Class Made By Mukul Sabharwal [mukulsabharwal@yahoo.com]
// http://www.devhome.net/php/
// On October 21, 2000
// Updated February 24, 2001
// Now passes RC4 Vector Harness

//-----------------------------------------------------------------------------------------------------------------------------------------------------------
class rc4crypt {
	function endecrypt ($pwd, $data, $case) {

		if ($case == 'de') {	$data = urldecode($data);}

		$key[] = "";
		$box[] = "";
		$temp_swap = "";
		$pwd_length = 0;
		$pwd_length = strlen($pwd);
		for ($i = 0; $i <= 255; $i++) {
			$key[$i] = ord(substr($pwd, ($i % $pwd_length), 1));
			$box[$i] = $i;
		}
		$x = 0;
		for ($i = 0; $i <= 255; $i++) {
			$x = ($x + $box[$i] + $key[$i]) % 256;
			$temp_swap = $box[$i];

			$box[$i] = $box[$x];
			$box[$x] = $temp_swap;

		}
		$temp = "";
		$k = "";
		$cipherby = "";
		$cipher = "";
		$a = 0;
		$j = 0;
		for ($i = 0; $i < strlen($data); $i++) {
			$a = ($a + 1) % 256;
			$j = ($j + $box[$a]) % 256;

			$temp = $box[$a];
			$box[$a] = $box[$j];

			$box[$j] = $temp;
			$k = $box[(($box[$a] + $box[$j]) % 256)];
			$cipherby = ord(substr($data, $i, 1)) ^ $k;
			$cipher .= chr($cipherby);
		}

		if ($case == 'de') {
			$cipher = urldecode(urlencode($cipher));
		} else {
			$cipher = urlencode($cipher);
		}
		return $cipher;
	}
}




// Authorisation class.  
//	
//	depends upon sessions. creates a uid and an accessLevel session variable. 
//	this should be called from the db.inc file, straight after connection to the database 
//	Also includes a login box and a number out error messages.
//
//	There are different levels of access.  there needs to be a table
//	where passwords, logins, disable etc is kept as well as a table for logging IPs for intrusion
// if need be an htaccess level security check can be used as well.
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------

class securityCheck{

	var $standardGroupID;		// if a user is going to be made up - this is the id.
	var $emailPwd;				// the email address passed in to send an pwd to
	var $msg;
	var $uid;					// user id level
	var $template;
	var $trys;
	var $redirectPageID;
	var $userName;
	var $userPassword;
	var $ref;
	var $from;
	var $id;
	var $regEmailMsg;
	//----------------------------------------------------------------------------------------------------------------------------------------------------------------
	function securityCheck($standardGroupID, $emailPwd, $msg, $uid,$template, $trys,$redirectPageID){

		$yyy=array_keys($xxx = get_defined_vars());
		for ($i=((phpversion()>=5)?0:1);$i<count($xxx)  ;$i++) {$this->{$yyy[$i]}=$xxx[$yyy[$i]];}	

		
		$db=new db;

		// sort out the number of trys.
		$str_sql="select IP from sys_badIp where IP='".getenv("REMOTE_ADDR")."' and TO_DAYS(time)=TO_DAYS(now()) and (TIME_TO_SEC(now())-TIME_TO_SEC(time) )<20";
		$vals=$db->get2dArray($str_sql);
		$this->trys=(count($vals[0])>6)?7:$this->trys=count($vals[0]);

		if ($this->uid) {
			if ($this->verifySession($GLOBALS['PHPSESSID'])=='error') {
				$this->msg=$GLOBALS['cookieMsg'];
			}
		}
	}

	//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
	function checkAgainstDB($userName, $userPassword){
		
		$db=new db;
		$e= new encrypt;
		
		$str_sql="select DB_011_ID,DB_011_ENABLED,DB_013_GROUP_ID, DB_011_PERSISTENT, DB_011_BACKSTAGE_PERMIT,DB_011_PASSWORD from DB_011_USER,DB_013_GROUPS";
		
		$str_sql.=" where DB_013_GROUP_ID=DB_013_ID";
		$str_sql.=" and DB_011_PASSWORD='".$e->Enc2($userPassword)."'";
		$str_sql.=" and length(DB_011_PASSWORD)>0";
//		$str_sql.=" and DB_011_PASSWORD='shad0w'";
		$str_sql.=" and (DB_011_USERNAME='".$userName."' or DB_011_EMAIL='".$userName."')";

		$row=$db->get2dArray($str_sql);
		if(count($row)){
			// account disabled or not yet activated
			if ($row[1][0]!='y' and $row[1][0]!='1' and $row[4][0]!='1' and $row[5][0]=='') {
				echo $row[1][0]." and ".$row[1][0]." and ".$row[4][0];
				$msg=$GLOBALS['activationMsg'];	
			}else{
				$this->uid=$row[0][0];

				$result=$db->qry("delete from sys_badIp where IP='".getenv("REMOTE_ADDR")."'");
				$this->msg=$GLOBALS['loginSuccessMsg'];
				if ($row[3][0]=='y') {
					setcookie ("userName", $userName,time()+360000);  
					setcookie ("userPassword", $userPassword,time()+360000);  
				}
			}

			// redirect?
			$redirPage=$db->getFieldVal('DB_013_GROUPS',$db->getFieldVal('DB_011_USER',$this->uid,15,0),2,0);
				echo "RedirPage: ".$redirPage; // QQQ - 	function getFieldVal($tableName,$id,$fieldNum,$keyNum)
			$redirPage=$this->redirectPageID?$this->redirectPageID:$redirPage;
			if ($redirPage) {
				header("Location: index.php?pageID=".$redirPage.($GLOBALS['id']?"&id=".$GLOBALS['id']:"")); 
			}

		}else{									// they've made an unsuccesful attempt.
			$this->logIP();
		}	
		return $msg;
	}


	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
    function logIP() {

		$db=new db;
		$result=$db->qry("insert into sys_badIp values('".getenv("REMOTE_ADDR")."', '".date('Y-m-d H-i-s')."')");

    }

//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
    function verifyReferer ($ref) {
        $headerref = getenv("HTTP_REFERER");
		$pwd=getenv("HTTP_REFERER");
		$usr=getenv("HTTP_REFERER");

		if (!$pwd or !$usr) {	// if they're in admin mode then 

			if (ereg("/",$headerref)){
				$s=explode("/",$headerref);
				$headerref = $s[2];
			}
			if ($headerref!=$ref){
				return "error";
			}
		}
    }

	// This shows a login box. If more than 3 tries are made it shows a box allowing a password to be emailed.
	//------------------------------------------------------------------------------------------------------------------------------------------
	function loginBox(){
		if ($this->trys>=0) {
			$loginBox=new templateBuilder($this->template);

			// pass the template the non loop vars.
			$switchTags=array('<%msg%>','<%pageID%>','<%showBlock%>','<%triesMsg%>','<%username%>','<%emailPwd%>','<%showBlockLogoff%>');				
			$switchVals=array($this->msg,$GLOBALS['pageID'], 'block','',$this->userName,$this->emailPwd,'none');
						// these values depend on the number of tries etc 
		
			if (eregi('@',$this->emailPwd)) {
				if ($this->sendEmailPwd()){
					$switchVals[0]=$GLOBALS["rightEmailMsg"];
					// and put a cookie down to stop retrying.
					$switchVals[0].="\n<script language=javascript>\ndocument.cookie='trys=-1';\n</script>\n";
				}else{
					$switchVals[0]=$GLOBALS["wrongEmailMsg"];
				}
			}else{
				if ($this->trys<4) {
					if ($this->trys) {
						$switchVals[3]=$GLOBALS["numLoginTrys"].$this->trys;
					}
				}
			}
			
			if ($this->trys>3) {
				$switchVals[0]=$GLOBALS["antiHackMsg"];
				$switchVals[2]='none';
			}

			if ($this->uid) { // logged in already.
				$switchVals[2]='none';
				$switchVals[6]='block';
				
									
			}
			$loginBox->simpleTemplate($switchTags, $switchVals);
			return $loginBox->getTemplateStr();
		}
	}

	// This shows a registration box, with some functionality beyond a simple form.
	//------------------------------------------------------------------------------------------------------------------------------------------
	function regBox(){
		$registerBox=new templateBuilder($this->template);

			// pass the template the non loop vars.
			$switchTags=array('<%msg%>','<%pageID%>','<%emailAddr%>');				
			$switchVals=array($this->msg,$GLOBALS['pageID'], $this->emailAddr);

			if (eregi('@',$this->emailPwd)) {
				if ($this->sendEmailPwd()){
					$switchVals[0]="Hello";
				}else{
					$switchVals[0]="Goodbye";
				}
			} /*else{
				if ($this->trys<4) {
					if ($this->trys) {
						$switchVals[3]=$GLOBALS["numLoginTrys"].$this->trys;
					}
				}
			}
			
			if ($this->trys>3) {
				$switchVals[0]=$GLOBALS["antiHackMsg"];
				$switchVals[2]='none';
			}

			if ($this->uid) { // logged in already.
				$switchVals[2]='none';
				$switchVals[6]='block';				
			}
*/



			$registerBox->simpleTemplate($switchTags, $switchVals);

					mail($this->emailAddr,"Press Dispensary Login", "hello", "From:ask@pressdispensary.co.uk(Press Dispensary)");
echo "hi: ".$this->emailAddr;

			return $registerBox->getTemplateStr();
		}
	

	// this emails the user their login id and password.
	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function sendEmailPwd(){
		$db=new db;

		$str_sql="select DB_011_USERNAME,DB_011_PASSWORD from DB_011_USER where DB_011_EMAIL='".$this->emailPwd."'";
		$row=$db->get2dArray($str_sql);
		if (count($row)) {	
			$e=new encrypt;
			$userName=$row[0][0];
			
			$sendString=str_replace("<%userName%>",$userName,$GLOBALS["sendEmailPassword"]);
			$sendString=str_replace("<%password%>",$e->Dec2($row[1][0]),$sendString);

			mail($this->emailPwd,"Press Dispensary Login", $sendString, "From:ask@pressdispensary.co.uk(Press Dispensary)");

			return "success";
		}

	}	// function emailPwd ends


	// this creates a password and emails the user their login id and password.
	// sets login id to be= password.
	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function emailNewPwd($from, $id, $regEmailMsg){

		$e=new encrypt;
		$db=new db;

		// get email address
		$str_sql="select DB_011_EMAIL from DB_011_USER where DB_011_ID='".$id."'";
		$vars=$db->get2dArray($str_sql);
		$this->emailPwd=$vars[0][0];
			
		$pwd=$this->generatePwd();

		$sendString=str_replace("<%username%>",$this->emailPwd,$regEmailMsg);
		$sendString=str_replace("<%pwd%>",$pwd,$sendString);
	
		// this creates a normal user by default.
		$str_sql="update DB_011_USER set DB_011_PASSWORD='".$e->Enc2($pwd)."', DB_011_USERNAME='".$this->emailPwd."' , DB_013_GROUP_ID=".$this->standardGroupID.", DB_011_ENABLED=1 where DB_011_ID=".$id;

		$s=$db->qry($str_sql);

		mail($this->emailPwd,$from, $sendString, "From : <".$from.">");
	
	}	// function emailPwd ends


	// generates 6 digit lowerercase password. 
	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function generatePwd(){
		for ($i=0;$i<6 ;$i++) {	
			srand((double)microtime() * 1000000);
			$pwd.=chr((rand()%26)+65);
		}
		return strtoLower($pwd);
	}

	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function verifyPageAgainstAccess($id){

		$db=new db;
		
		// knock out persistent login if it's been switched off.
		$str_sql="select DB_011_PERSISTENT from DB_011_USER where DB_011_ID='".$this->uid."'";

		$persistent=$db->get1dArray($str_sql);

		if ($persistent[0]!='1') {
			setcookie ("userName", '',1);  
			setcookie ("userPassword", '',1);  
		}

		$str_sql="select * from DB_001_PAGE where DB_001_ID=".$id;
		$vals=$db->get1dArray($str_sql);

		if ($vals[2]==0 or ($vals[2]==-1 and !$this->uid) or $vals[2]==1 or ($vals[2]==2 and isAllowed($this->uid, $type='page', $id))) {
			return $vals;
		}else{
			return -1;
		}
	}

	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function verifySession($PHPSESSID) {
		if (!isset($PHPSESSID) and count($_COOKIE)==0){
			$GLOBALS['logOff']='y';
			return "error";
		}
	}

	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function destroySession() {
		session_unset();
		session_destroy();
	}

	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function getTrys(){ 
		return $this->trys;
	}

	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function getUid(){
		return $this->uid;
	}

	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function getMsg(){
		return $this->msg;
	}


}	// security class ends.





// This is a logging class 
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
class logs{

	var $thisSite;							// this site - filter out from referrers

	// initialize
	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function logs($thisSite){


		$yyy=array_keys($xxx = get_defined_vars());	 // generic populate
		for ($i=((phpversion()>=5)?0:1);$i<count($xxx)  ;$i++) {$this->{$yyy[$i]}=$xxx[$yyy[$i]];}	

	}	// logs end

	// This function writes log data to the db everytime it's run .
	// This data is accumulated monthly. At the end of every month the data is written to a flat file, it's deleted and re-started. This
	// happens via a cron job.
	//
	//	The session ID is based on a permanent cookie and IP
	//
	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function logit(){
		
		$db=new db;

		// take PHPSESSID out of the query string and get a page name, if possible.
		if ($GLOBALS["QUERY_STRING"]) {
			$pStr=explode("&",$GLOBALS["QUERY_STRING"]);
			for ($i=0;$i<count($pStr) ;$i++) {
				if (!eregi('PHPSESSID',$pStr[$i])) {	// ignore the session ID
					$queryString.=$pStr[$i].($i<count($pStr)-1?"&":"");
					if (eregi('pageID',$pStr[$i])) {
						list(,$pageID)=explode('=',$pStr[$i]);
					}
				}
			}
			if (!$pageID) {
				$pageID=1;
			}
		}

		$referrer=@eregi($this->thisSite,$GLOBALS["HTTP_REFERER"])?'':$GLOBALS["HTTP_REFERER"];

		$logTable='sys_logs';	// this is hard coded because there are so many sql strings dependent on it.
		$valArray=array($db->getnextid($logTable,$db->getfields($logTable,0)),date("Y-m-d h-i-s"),$GLOBALS["PHP_SELF"],$queryString,$referrer,'id'.$GLOBALS["REMOTE_ADDR"],	$GLOBALS["HTTP_USER_AGENT"],session_id(),$GLOBALS["uid"],$pageID);
	
		$db->genericTableUpdate('add', $valArray,$logTable,'','');

		if (date('j')==1) {
			$this->condenseTable();
		}

	}
	
	// this trims details to the last month
	//	It gets informations from the sys_logs table and the sys_logstotals table.
	//sys_logstotals holds information over a month old - long strings in text fields - a line per day
	//ie:	totals for each page per day, - 1~23:2~32 etc
	//	totals for each session per day - 123:23:23
	//	total referrers. ||delimeted string
	//----------------------------------------------------------------------------------------------------------------------------------------------------------
	function condenseTable(){

		$db=new db;

		// first check that we haven't already done it by looking in the logstotal table for any last month's entries

		$lastMonth=date('m',mktime (0,0,0,date('m')-1,1,date('Y')));

		$str_sql="select * from sys_logTotal where date_format(logDate,'%m')='".$lastMonth."'";

		$vals=$db->get2dArray($str_sql);
		
		// no matches - proceed
		if (!count($vals[0])) {
			
			// loop through each day of the previous month
			for ($i=1;$i<=date('t',mktime (0,0,0,date('m')-1,1,date('Y'))); $i++) {
				
				$valArray=array('',date('Y-m-d',mktime (0,0,0,date('m')-1,$i,date('Y'))));

				// page totals
				$str_sql="select concat(sys_log_sitepage,'~', count(*)),sys_log_sitepage from sys_logs where date_format(sys_log_datetime,'%m%e')='".$lastMonth.$i."'  group by sys_log_sitepage ";	
				$vals=$db->get2dArray($str_sql);
				$valArray[]=count($vals[0])?implode(":",$vals[0]):'';
				
				// session lengths
				$str_sql="select count(*),sys_log_session from sys_logs where date_format(sys_log_datetime,'%m%e')='".$lastMonth.$i."' and length(sys_log_session)>1 group by sys_log_session";	
				$vals=$db->get2dArray($str_sql);
				$valArray[]=count($vals[0])?implode(":",$vals[0]):'';

				// referrers

				$str_sql="select concat(sys_log_referer ,'~', count(*)),sys_log_referer from sys_logs where date_format(sys_log_datetime,'%m%e')='".$lastMonth.$i."' and  length(sys_log_referer)>1 group by sys_log_referer";	
				$vals=$db->get2dArray($str_sql);
				$valArray[]=count($vals[0])?implode(":",$vals[0]):'';

				$db->genericTableUpdate('add', $valArray,'sys_logTotal','','');	// add the usergroup
			}
		}
		
		$str_sql="delete from sys_logs where date_format(sys_log_datetime,'%m')='".$lastMonth."'";
		$db->qry($str_sql);


	} // function condenseTable()

/*

CREATE TABLE sys_logTotal (id INT not null , logDate DATE not null , pages TEXT not null , sessions TEXT not null , referrers TEXT not null ) 



CREATE TABLE sys_logs (
   sys_log_id int(11) NOT NULL,
   sys_log_datetime datetime,
   sys_log_page varchar(250),
   sys_querystr varchar(250),
   sys_log_referer varchar(250),
   sys_log_userid varchar(30),
   sys_log_browser varchar(100),
   sys_log_session varchar(30) NOT NULL,
   sys_log_user int(11),
   sys_log_sitepage int(11) NOT NULL
);


*/

}	// logs end



// creates a calendar.
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
class cal{
	
	var $startMonth;
	var $displayType;
	var $numMonths;
	var $startYear;
	var $sMonth;
	var $thisDate;
	var $normalClass;
	var $weekendClass;
	var $dayHeader;
	var $linkClass;
	var $HeadingClass;
	var $todayClass;
	var $thisDateClass;
	var $listTable;
	var $deadlineClass;
	var $pgeID;
	var $width;
	var $urlStr;
	var $catStr;

	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function cal($startMonth,$displayType,$numMonths,$startYear,$sMonth,$thisDate){
		$yyy=array_keys($xxx = get_defined_vars());
		for ($i=((phpversion()>=5)?0:1);$i<count($xxx)  ;$i++) {$this->{$yyy[$i]}=$xxx[$yyy[$i]];}	

		$this->startMonth=$this->startMonth+$this->sMonth;

		if ($this->startMonth==0) {
			$this->startMonth=12;
			$this->startYear--;
		}

		if ($this->startMonth==13) {
			$this->startMonth=1;
			$this->startYear++;
		}
	
	}	// funcition cal ends

	
	// this outputs a cal - 7x table with colspn 7 for month
	// is fed an array of days and links?
	// the links have a dateStr and a displayType. 
	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function outputCal($normalClass,$weekendClass,$dayHeader,$linkClass,$HeadingClass, $todayClass,$thisDateClass,$listTable,$deadlineClass,$pgeID,$width,$urlStr, $catStr){

		$str.="<table border=0 cellspacing=0 cellpadding=0>\n";
		$str.=!eregi("vert",$this->displayType)?"<tr>":"";
		
		for ($i=0;$i<$this->numMonths ;$i++) {
			
			$str.=eregi("vert",$this->displayType)?"<tr><td valign=top>":($i?"<td valign=top width=\"12\"></td><td valign=top>\n":"<td valign=top>\n");
			
			$month=($i+$this->startMonth)>12?($i+$this->startMonth)-12:($i+$this->startMonth);
			$year=$this->startYear + floor(($i+$this->startMonth-1)/12);
			$str.=$this->outputMonth($normalClass,$weekendClass,$dayHeader,$linkClass,$HeadingClass,$todayClass,$thisDateClass,$deadlineClass,$month,$year,$width,$listTable,$this->thisDate,$pgeID,$urlStr, $catStr,$i);
			$str.=eregi("vert",$this->displayType)?"</td></tr>":"</td>";
		}
		$str.=!eregi("vert",$this->displayType)?"</tr>":"";
		$str.="</table>";

		return $str;
	}	// function outputCal() ends.


	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function controller(){
		$str="<form name=\"calControl\" action=\"".($GLOBALS['PHP_SELF'])."\" method=\"get\">";
	
		$str.="<div onClick=\"calControl.sMonth.value=-1; calControl.submit();\">\n<img src=\"images/admin/up.gif\" style=\"cursor:hand;\" alt=\"up\"></div>\n";	
	//	$str.="<input type=\"text\" NAME=\"numMonths\" value=\"".$this->numMonths."\" size=\"1\" onchange=\"calControl.submit();\" class=\"calChooser\">\n";
		
		$str.="<div onClick=\"calControl.sMonth.value=1; calControl.submit();\">\n<img src=\"images/admin/down.gif\" style=\"cursor:hand;\" alt=\"down\"></div>\n";	

		$str.="<input type=\"hidden\" name=\"startYear\" value=\"".$this->startYear."\">\n";
		$str.="<input type=\"hidden\" name=\"startMonth\" value=\"".$this->startMonth."\">\n";
		$str.="<input type=\"hidden\" name=\"sMonth\">\n";
		$str.="</form>\n";
		
		return $str;
	}	// function controller() ends


	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function outputMonth($normalClass,$weekendClass,$dayHeader,$linkClass,$HeadingClass,$todayClass,$thisDateClass,$deadlineClass,$month,$year,$width,$listTable,$thisDate,$pgeID,$urlStr, $catStr,$num){

		$m=new	
		month($normalClass,$weekendClass,$dayHeader,$linkClass,$HeadingClass,$todayClass,$thisDateClass,$deadlineClass,$month,$year,$width,$listTable,$thisDate,$urlStr, $catStr,$num);
		
		return $m->outputM($pgeID);


	} //function outputMonth() ends


}

//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
class month{
	var $normalClass;
	var $weekendClass;
	var $dayHeader;
	var $linkClass;
	var $HeadingClass;
	var $todayClass;
	var $thisDateClass;
	var $month;
	var $year;
	var $width;	
	var $listTable;
	var $thisDate;
	var $urlStr;
	var $catStr;
	var $num;
	var $date;
	var $pgeID;

	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function month($normalClass,$weekendClass,$dayHeader,$linkClass,$HeadingClass,$todayClass,$thisDateClass,$deadlineClass,$month,$year,$width,$listTable,$thisDate,$urlStr,$catStr,$num){
		$yyy=array_keys($xxx = get_defined_vars());
		for ($i=((phpversion()>=5)?0:1);$i<count($xxx)  ;$i++) {$this->{$yyy[$i]}=$xxx[$yyy[$i]];}
	} //function month ends


	
	// this gets any repeater where the todate is greater than the current date - and back tracks to see if there is a match
	//--------------------------------------------------------------------------------------------------------------------------------------------------------
	function searchRepeater($date){
		$db=new db;
		$f=$db->getfields($this->listTable,-1);
		$str_sql="select * from ".$this->listTable." where ".$f[13]."='1' "; //enabled
		$str_sql.=" and ".$f[15].">'".$date."' and ".$f[14].">0 ";

		// this is to filter the categories - if there are any
		$str_sql.=($this->catStr)?" and (DB_123_CATEGORY_ID='".str_replace(":","' or DB_123_CATEGORY_ID='",$this->catStr)."')":"";
		$vals=$db->get2dArray($str_sql);

		$found='';
		for ($i=0;$i<count($vals[0]) ;$i++) { // loop through all the possible repeaters.
			list($year,$month,$day)=explode("-",$vals[6][$i]);		
			$n=0;

			while ($temp<$date) {				
				$temp=date('Y-m-d',mktime (0,0,0,$month,$day+($n*$vals[14][$i]),$year));

				$n++;
				if ($temp==$date) {
					$found='y';
				}
			}	
		}
		return $found;

	} // function searchRepeater() ends


	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function outputM($pgeID){
		
		// first get an array of all the days that have events.
		$db=new db;
		if ($this->listTable) {
			// $str_sql="select * from ".$this->listTable." where ".$db->getfields($this->listTable,13)."='1'"; //enabled

			// mindgym only
			$str_sql=$GLOBALS["calendarSql"];



			// this is to filter the categories - if there are any
			$str_sql.=($this->catStr)?" and (DB_123_CATEGORY_ID='".str_replace(":","' or DB_123_CATEGORY_ID='",$this->catStr)."')":"";

			//$links=$db->getMysqlArray($str_sql,6);	// the date
			$links=$db->getMysqlArray($str_sql,0);	// the date


		//	$str_sql="select * from ".$this->listTable." where ".$db->getfields($this->listTable,13)."='y'"; //enabled
		//	$deadlines=$db->getMysqlArray($str_sql,2);
			$deadlines=array();								// not currently implemented
		}

		$thisMonth=date("F - Y",mktime (0,0,0,$this->month,1,$this->year));



		//$str.="<table  width=".$this->width." cellspacing=\"1\"><tr><td colspan=7 class=\"".$this->HeadingClass."\" align=center>".$thisMonth;

		// mindgym specific --------------------------
		
		if ($GLOBALS['noChooser']) {
				$str.="<table  width=".$this->width." cellspacing=\"1\"><tr><td colspan=7 class=\"".$this->HeadingClass."\" align=center>".$thisMonth;		
		}else{
			if (!$this->num){
				$urlForChooser="pageID=".$GLOBALS['pageID']."&startYear=".$this->year."&startMonth=".$this->month."&id=".$GLOBALS['id']."&thisDate=".$GLOBALS['thisDate'];
				$chooser="<a href=\"index.php?".$urlForChooser."&sMonth=-1\" style=\"text-decoration:none;\">&nbsp;&nbsp;&nbsp;</a>";
				$str.="<table  width=".$this->width." cellspacing=\"1\"><tr><td  class=\"cal_month_back\">".$chooser."</td><td colspan=6 class=\"".$this->HeadingClass."\" align=center>".$thisMonth;

			}else{
				$startYr=date("Y",mktime (0,0,0,$this->month,-1,$this->year));
				$startMn=date("m",mktime (0,0,0,$this->month,-1,$this->year));
				$urlForChooser="pageID=".$GLOBALS['pageID']."&startYear=".$startYr."&startMonth=".$startMn."&id=".$GLOBALS['id']."&thisDate=".$GLOBALS['thisDate'];
				$chooser="<a href=\"index.php?".$urlForChooser."&sMonth=1\"  style=\"text-decoration:none;\">&nbsp;&nbsp;&nbsp;</a>";
				$str.="<table  width=".$this->width." cellspacing=\"1\"><tr><td colspan=6 class=\"".$this->HeadingClass."\" align=center>".$thisMonth."</td><td  class=\"cal_month_forward\">".$chooser;
			}
		}
		// mindgym specific ends --------------------
		
		$str.="</td></tr>\n";
	
		$str.="<tr align=center><td class=\"".$this->dayHeader."\">M</td><td class=\"".$this->dayHeader."\">T</td><td class=\"".$this->dayHeader."\">W</td><td class=\"".$this->dayHeader."\">T</td><td class=\"".$this->dayHeader."\">F</td><td class=\"".$this->dayHeader."\">S</td><td class=\"".$this->dayHeader."\">S</td></tr>";
		$i=1;
		while (date("m",$date=mktime (0,0,0,$this->month,$i,$this->year))==$this->month){
			// starts on Monday ends Sunday.
			$wkdy=date("w",$date);
			$linkDate=date('Y-m-d',$date);
			if ($i==1) {
				$str.="<tr>";
				for ($n=0;$n<($wkdy?$wkdy-1:6);$n++) {
					$str.="<td class=".$this->normalClass."></td>";
				}
			}

			$class=($wkdy==0 or $wkdy==6)?$this->weekendClass:$this->normalClass;
			$class=@in_array($linkDate,$links)?$this->linkClass:$class;
			$class=$this->searchRepeater($linkDate)?$this->linkClass:$class;

			$class=@in_array($linkDate,$deadlines)?$this->deadlineClass:$class;
			$class=(date('Y-m-d')==$linkDate)?$this->todayClass:$class;
			$class=($this->thisDate==$linkDate)?$this->thisDateClass:$class;
		
			

			$str.= ($wkdy==1 and $i>1)?"<tr>":"";	

			if ($class==$this->weekendClass or $class==$this->normalClass) {
				$str.="<td class=".$class.">".date("d",$date)."</td>\n";
			}else{
				$str.="<td class=".$class."><a href=\"index.php?";				
				$str.="pageID=".$pgeID."&thisDate=".$linkDate.$this->urlStr;
				$str.="\">".date("d",$date)."</a></td>\n";
			}
			$str.= ($wkdy==0)?"</tr>":"";	
			$i++;
		}
		//wind up.
		if ($wkdy!=0){
			for ($n=$wkdy; $n<7;$n++){
				$str.="<td class=".$this->normalClass.">&nbsp;</td>\n";		
			}
			$str.="</tr>";
		}


		$str.="</table>\n";
	
		return $str;
	} // function outputMonth() ends

} // class month ends


// this class makes an index of items going down a page - looping template
// It automatically detects urls <%url%> <%mailto%> and images <%img%>and doesn't display things
// that aren't there.
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
class listPage{

	var $listLen;								// the limit of the list
	var $str_sql;								// the sql used to call the list
	var $template;
	var $switchTags=array();
	var $switchVals=array();
	var $switchLoopTags=array();
	var $listPos;								// the position we're at eg limit 60, 30
	var $imgDir;
	var $editorPageID;
	var $n;
	var $uid;
	var $type;
	var $var;
	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function listPage($listLen,$str_sql,$template,$switchTags, $switchVals, $switchLoopTags,$listPos,$imgDir,$editorPageID){

			$yyy=array_keys($xxx = get_defined_vars());	 // generic populate
			for ($i=((phpversion()>=5)?0:1);$i<count($xxx)  ;$i++) {$this->{$yyy[$i]}=$xxx[$yyy[$i]];}	

	} // function listPage ends


	// output the list
	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function outputList(){
		$t=new templateBuilder($this->template);
		$db=new db;

		$total=$db->get2dArray($this->str_sql);
		$totalCount=count($total[0]);

		$this->str_sql.=($this->listLen)?" limit ".($this->listPos?$this->listPos*$this->listLen:0).",".$this->listLen:"";

		$loopVals=$db->get2dArray($this->str_sql);
		for ($i=0;$i<count($this->switchLoopTags) ;$i++) {
			switch ($this->switchLoopTags[$i]){
				case "<%img%>":
					for ($n=0;$n<count($loopVals[0]) ;$n++) {
						$ok=(eregi(".gif",$loopVals[$i][$n]) or eregi(".jpg",$loopVals[$i][$n]))?"y":"";
						$loopVals[$i][$n]=(file_exists($this->imgDir.$loopVals[$i][$n]) and $ok)?"<img src=\"".$this->imgDir.$loopVals[$i][$n]."\" border=\"0\">\n":"";
					}
				break;
				case "<%url%>":
					for ($n=0;$n<count($loopVals[0]) ;$n++) {
						$s=explode(":",$loopVals[$i][$n]);
						$loopVals[$i][$n]=($s[0])?"<a href=\"".$s[0]."\">".($s[1]?$s[1]:$s[0])."</a>\n":"";
					}
				break;
				case "<%mailto%>":
					for ($n=0;$n<count($loopVals[0]) ;$n++) {
						$loopVals[$i][$n]=($loopVals[$i][$n])?"<a href=\"mailto:".$loopVals[$i][$n]."\">".$loopVals[$i][$n]."</a>\n":"";
					}
				break;				
				case "<%stripHtml%>":
					for ($n=0;$n<count($loopVals[0]) ;$n++) {
						$loopVals[$i][$n]=strip_tags($loopVals[$i][$n]);
					}
				break;	
				case "<%text%>":
					for ($n=0;$n<count($loopVals[0]) ;$n++) {
						$loopVals[$i][$n]=nl2br($loopVals[$i][$n]);
					}
				break;	
				case "<%editor%>":
					for ($n=0;$n<count($loopVals[0]) ;$n++) {
						
						// editor buttons. For this we need to acertain rights, and an editor page

						if ($GLOBALS['groupID']==1 and $this->editorPageID) {
					
							$loopVals[$i][$n]="<br /><a href=\"index.php?pageID=".$this->editorPageID."&id=".$loopVals[$i][$n]."\" target=\"_blank\" class=red><img src=\"images/admin/greenIconLite.gif\" alt=\"Edit\" border=0  id=\"menuDiv".$loopVals[0][$n]."\" style=\"display:none;\"></a>";	// edit thing.


						}else{
							$loopVals[$i][$n]='';
						}
					}
				break;					
			}

		}


		for ($i=0;$i<count($this->switchTags) ;$i++) {
			switch ($this->switchTags[$i]){
				case "<%img%>":
						$ok=(eregi(".gif",$this->switchVals[$i]) or eregi(".jpg",$this->switchVals[$i]))?"y":"";
						$this->switchVals[$i]=(file_exists($this->switchVals[$i]) and $ok)?"<img src=\"".$this->imgDir.$this->switchVals[$i]."\" border=\"0\">\n":"";
				break;
				case "<%url%>":
						$this->switchVals[$i]=($this->switchVals[$i])?"<a href=\"".$this->switchVals[$i]."\">".$this->switchVals[$i]."</a>\n":"";
				break;
				case "<%urlExt%>":
						$this->switchVals[$i]=($this->switchVals[$i])?"<a href=\"".$this->switchVals[$i]."\" target=_blank>".$this->switchVals[$i]."</a>\n":"";
				break;
				case "<%mailto%>":
						$this->switchVals[$i]=($this->switchVals[$i])?"<a href=\"mailto:".$this->switchVals[$i]."\">".$this->switchVals[$i]."</a>\n":"";
				break;				
				case "<%text%>":
					$this->switchVals[$i]=nl2br($this->switchVals[$i]);
				break;				
			}

		}



		$this->switchTags[]="<%pageList%>";
		$this->switchVals[]=$this->pageList($totalCount);

		$t->loopHandler("<%loop%>", $this->switchLoopTags, $loopVals);		

		$t->simpleTemplate($this->switchTags, $this->switchVals);

		return $t->getTemplateStr();
	} // function outputList() ends


	//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
	function pageList($n){
		if ($n>$this->listLen) {
			$str.="<br />Page ";
			$this->listLen=$this->listLen?$this->listLen:1;
			for ($i=0;$i<$n/$this->listLen ;$i++) {
				$link=$this->listPos==$i?"<b>".($i+1)."</b>":($i+1);
				$str.=($first?" | ":"")."<a href=\"index.php?pageID=".$GLOBALS['pageID']."&listPos=".$i."&searchStr=".$GLOBALS['searchStr']."\">$link</a>";
				$first='y';
			}
			if (($this->listPos+1)<$n/$this->listLen) {
				$str.="<a href=\"index.php?pageID=".$GLOBALS['pageID']."&listPos=".($this->listPos+1)."&searchStr=".$GLOBALS['searchStr']."\"> | Next</a><br /><br />";
			}
		}

		return $str;
	} // function pageList() ends

} // class listPage ends



//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------					functions					 ----------------------------------------------------------------
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------

// this checks if a punter has access to various elements
// this either happens via their main or aux ids
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
function isAllowed($uid, $type='page', $var){
	$db= new db;

	if ($uid and $var) {

		$groupID=$db->getFieldVal('DB_011_USER',$uid,15,0);
		$auxIDs=$db->get2dArray("select * from DB_023_USER_X_GROUP where DB_011_USER_ID=".$uid);
		$groupStr=$groupID.(count($auxIDs[2])?",".@implode(",",$auxIDs[2]):"");
		


		if ($groupID==1) {	 // is developer? - always 1
			$ok=2;
		}else{
			if ($groupID) {
				switch ($type){
					case 'page':
						$str_sql="select DB_012_PAGE_X_GROUP.DB_012_ID from DB_012_PAGE_X_GROUP";
						$str_sql.=" where DB_013_GROUP_ID in (".$groupStr.")";
						$str_sql.=" and DB_001_PAGE_ID=".$var;
						break;

					case 'pageFunction':
						$str_sql="select DB_016_PAGEFUNCTION_X_GROUP.DB_016_ID from DB_016_PAGEFUNCTION_X_GROUP";
						$str_sql.=" where DB_013_GROUP_ID in (".$groupStr.")";
						$str_sql.=" and DB_005_PAGEFUNCTION_ID=".$var;
						break;

					case 'menu':
						$str_sql="select DB_015_MENU_X_GROUP.DB_015_ID from DB_015_MENU_X_GROUP";
						$str_sql.=" where DB_013_GROUP_ID in (".$groupStr.")";
						$str_sql.=" and DB_010_MENU_ID=".$var;
						break;			
				}
				$vals=$db->get1dArray($str_sql);	
			}

			$ok=(count($vals))?1:0;

		}
	}
	return $ok;
} // function isAllowed() ends


// this class creates a series of (fairly large) links/blocks of text down a page - along the lines of 'features... more info' etc.
// 
// ------------------------------------------------------------------------------------------------------------------------------------------------------
class textLinks{

	var $template;
	var $menuID; 

	// assumes structure ID, title, group, text, link, order. If something else then provide dif sql.
	// -----------------------------------------------------------------------------------------------------------------------------------------------
	function textLinks($template,$menuID){


		$yyy=array_keys($xxx = get_defined_vars());
		for ($i=((phpversion()>=5)?0:1);$i<count($xxx)  ;$i++) {$this->{$yyy[$i]}=$xxx[$yyy[$i]];}	

	} // function textLinks ends

	//-----------------------------------------------------------------------------------------------------------------------------------------------------------
	function outputLinks(){
		
		$db=new db;
		// DB_018_ID,DB_018_TITLE,DB_019_GROUP_ID,DB_018_TEXT,DB_001_PAGE_ID, DB_018_EXTURL,DB_018_ORDER,DB_018_POPUP,DB_018_KEYWORDS,DB_018_DATE, DB_018_CSS
		$loopVals=$db->get2dArray('select * from DB_018_TEXTLINKS where DB_019_GROUP_ID='.$this->menuID." order by DB_018_ORDER");

		for ($i=0;$i<count($loopVals[0]) ;$i++) {
			$loopVals[1][$i]=stripslashes($loopVals[1][$i]);							// title
			$loopVals[2][$i]=nl2br(stripslashes($loopVals[3][$i]));					// text
			$loopVals[3][$i]=$loopVals[5][$i]?stripslashes($loopVals[5][$i]):"index.php?pageID=".$loopVals[4][$i];	// link
			$loopVals[4][$i]=$loopVals[7][$i]?" target=\"_blank\"":"";					// popup
			$loopVals[5][$i]=$loopVals[10][$i]?" class=\"".$loopVals[10][$i]."\"":"";

		}

		$loopTags=array('<%n%>','<%title%>','<%text%>','<%link%>','<%target%>','<%css%>');
		$m=new templateBuilder($this->template);

		
		$str=$m->cellContainerLoop('<%container%>','<%cell%>','<%divider%>',$loopTags, $loopVals);

		return $str;

	} // function outputLinks() ends

/*


CREATE TABLE DB_018_TEXTLINKS (
  DB_018_ID int(11) NOT NULL default '0',
  DB_018_TITLE varchar(200) NOT NULL default '',
  DB_019_GROUP_ID int(11) NOT NULL default '0',
  DB_018_TEXT text NOT NULL,
  DB_018_LINKS varchar(200) NOT NULL default '',
  DB_018_ORDER int(11) NOT NULL default '0',
  PRIMARY KEY  (DB_018_ID),
  KEY DB_019_GROUP_ID (DB_019_GROUP_ID)
) TYPE=MyISAM;

CREATE TABLE DB_019_TEXTLINKGROUP (
  DB_019_ID int(11) NOT NULL default '0',
  DB_019_TITLE varchar(200) NOT NULL default '',
  DB_019_CONTAINER text NOT NULL,
  DB_019_CLASS1 varchar(20) NOT NULL default '',
  DB_019_CLASS2 varchar(20) NOT NULL default '',
  DB_019_TYPE varchar(20) NOT NULL default '',
  PRIMARY KEY  (DB_019_ID)
) TYPE=MyISAM;

*/

        
//-------------------------------------------------------------------------------------------------------------------$
        function amNeed(){

                $db=new db;
                // DB_042_ID,DB_042_TITLE,DB_041_NAV_GROUP_ID,DB_042_CONTENT,DB_001_PAGE_ID,DB_042_EXTURL,DB_042_ORDER,DB_042_POPUP$
                $loopVals=$db->get2dArray('select * from DB_042_NAVIGATOR_NEED where DB_041_NAV_GROUP_ID='.$this->menuID." order by DB_042_ORDER");

                for ($i=0;$i<count($loopVals[0]) ;$i++) {

                        $loopVals[1][$i]=stripslashes($loopVals[1][$i]);                                                        // title
                        $loopVals[2][$i]=nl2br(stripslashes($loopVals[3][$i]));                                 // text
                        $loopVals[3][$i]=$loopVals[5][$i]?stripslashes($loopVals[5][$i]):"index.php?pageID=".$loopVals[4][$i];  // link
                        $loopVals[4][$i]=$loopVals[7][$i]?" target=\"_blank\"":"";                              // popup
                        $loopVals[5][$i]=$loopVals[10][$i]?" class=\"".$loopVals[10][$i]."\"":"";

                }

                $loopTags=array('<%n%>','<%title%>','<%text%>','<%link%>','<%target%>');
                $m=new templateBuilder($this->template);
                $str=$m->cellContainerLoop('<%container%>','<%cell%>','<%divider%>',$loopTags, $loopVals);

                return $str;

        } // function amNeed() ends


} // class textLinks ends



//--------------------------------------------------------------------------------------------------------------------------------------------------------
// display data class
// This class displays a table of data
// - that has alternating bg colours - by row or by field
// - where fields are clickable - to filter by that field
// - where fields are sort able
// - where complex links can come of the fields
// - have filter field box at the top?


//--------------------------------------------------------------------------------------------------------------------------------------------------------
class tableDisplay{

	var $str_sql;
	var $fieldLinks=array();	//  array with <%fieldNames%> for insertion.
	var $headings=array();
	var $sortColumn;		// this is an integer - the number of the field being sorted by
	var $sortDirection;
	var $filter;
	var $filterField;			// this is an integer - the number of the field being filtered by
	var $tableClass;
	var $class1;
	var $class2;
	var $filterFields;	
	var $sum=array();
	var $sortArray=array();
	var $urlStr;

	//--------------------------------------------------------------------------------------------------------------------------------------------------------
	function tableDisplay($str_sql,$fieldLinks,$headings,$sortColumn,$sortDirection,$filter, $filterField, $tableClass,$class1,$class2,$sum,$sortArray,$urlStr){


		$yyy=array_keys($xxx = get_defined_vars());	 // generic populate
		for ($i=((phpversion()>=5)?0:1);$i<count($xxx)  ;$i++) {$this->{$yyy[$i]}=$xxx[$yyy[$i]];}	

		if (substr(strtolower(trim($this->str_sql)),0,6)=='select'){
			$this->str_sql=$this->makeSql($str_sql,$sortColumn,$sortDirection,$filter, $filterField);		
		}

	} // function tableDisplay()

	//--------------------------------------------------------------------------------------------------------------------------------------------------------
	function makeSql($str_sql, $sortColumn, $sortDirection,$filter, $filterField){

		$db=new db;

		// make filter fields.

		$this->filterFields=$db->getfields($str_sql,-1);

		if ($filter and $filterField!='') {
			$str_sql.=eregi(" where ", $str_sql)?" and ":" where ";

			if (eregi((" as ".$this->filterFields[$filterField]),$str_sql)) {// strip out the initial string
				$s1=explode(" as ".$this->filterFields[$filterField],$str_sql);

				$inBracks=0;
				$s=str_replace("select ",'',$s1[0]);

				for ($i=strlen($s);$i>0 ;$i--) { // go backward looking for the first comma outside brackets.
					if ($s[$i]==')') {$inBracks++;}
					if ($s[$i]=='(') {$inBracks--;}
					if ($s[$i]==',' and !$inBracks) {
						$s[$i]='^';
						$i=0;
					}
				}

				if (strpos($s,'^')) {
					$temp=explode("^",$s);
					$f=$temp[1];
				}else{
		
					$f=$s;
				}



			}else{
				$f=$this->filterFields[$filterField];
			}
			$str_sql.=$f." like '".$filter."%' ";

		}
		// sort by

		$str_sql.=$sortColumn?" order by ".($this->sortArray[$sortColumn]?$this->sortArray[$sortColumn]:$this->filterFields[$sortColumn])." ".$sortDirection:"";

		return $str_sql;
		
	} // function makeSql() ends


	//--------------------------------------------------------------------------------------------------------------------------------------------------------
	function drawTable(){
		$db=new db;	

		if (substr(strtolower(trim($this->str_sql)),0,6)=='select'){	
			$vals=$db->get2dArray($this->str_sql);
		}else{
			$cols=explode("\n",$this->str_sql);
			$legends=explode(",",$cols[0]);

			for ($i=1;$i<count($cols) ;$i++) {
				$x=explode(",",$cols[$i]);
				for ($n=0;$n<count($x) ;$n++) {
					$vals[$n][$i-1]=$x[$n];
				}
			}
		}


		$total=array(count($vals));

		$str="<table class=\"".$this->tableClass."\">\n<tr>";

		// headings
		for ($i=0;$i<count($this->headings) ;$i++) {
			$str.="<td class=\"heading\"><a href=\"index.php?pageID=".$GLOBALS['pageID']."&sortColumn=".$i."&sortDirection=".($this->sortDirection=='ASC'?"DESC":"ASC");
			$str.="&filter=".$this->filter."&filterField=".$this->filterField.$this->urlStr."\">".$this->headings[$i]."</a></td>\n";
		}	

		$str.="</tr>\n";
		$class=$this->class1;
		$lastVal="";	// loop holder for the css

		for ($i=0;$i<count($vals[0]) ;$i++) {

			// sort out the class - this checks previous sort val - if different then change class
			if ($lastVal!=$vals[$this->sortColumn][$i]) {
				$class=($class==$this->class1)?$this->class2:$this->class1;	// switch
				$lastVal=$vals[$this->sortColumn][$i];
			}
			
			$str.="<tr>";
			for ($n=0;$n<count($this->headings) ;$n++) {
				$fField=$this->fieldLinks[$n];
				// sort out the value to show/links
				if ($this->fieldLinks[$n]) {
					if ($this->fieldLinks[$n]=='filter') {
						$valToShow="<a href=\"index.php?pageID=".$GLOBALS['pageID']."&sortColumn=".$this->sortColumn."&sortDirection=".$this->sortDirection;
						$valToShow.="&filter=".$vals[$n][$i]."&filterField=".$n.$this->urlStr."\">".$vals[$n][$i]."</a>";
					}else{
						for ($z=0;$z<count($vals) ;$z++) {
							$fField=str_replace("<%".$z."%>",$vals[$z][$i],$fField);
						}
						$valToShow="<a href=\"".$fField.$this->urlStr."\">".$vals[$n][$i]."</a>";
					}
				}else{
					$valToShow=$vals[$n][$i];
				}
				$str.="<td class=\"".$class."\">".$valToShow."</td>";
				if ($this->sum[$n]=='sum') {
					$total[$n]=$total[$n]+$vals[$n][$i];
				}else{
					$total[$n]='';
				}
			}

			$str.="</tr>";
		}
		$str.="<tr>";
		for ($n=0;$n<count($this->headings) ;$n++) {
			$str.="<td class=\"".$class."\"><b>".$total[$n]."</b></td>";
		}
		
		$str.="</tr>";

		$str.="</table>";

		return $str;
		
	} // function drawTable()
	

	// this makes a to, from dropdown for dates.
	// default this month.
	//--------------------------------------------------------------------------------------------------------------------------------------------------------
	function dateChooser(){
			
		$backForward="1:1";

		list($d,$m,$y)=explode("-",date('d-m-Y'));
		
		$clr=$GLOBALS['filter']=='clearAll'?'':'n';
		$this->filter=$clr?$this->filter:"";

		$todVal=($GLOBALS['toDays'] and $clr)?$GLOBALS['toDays']:'01';
		$tomVal=($GLOBALS['toMonths'] and $clr)?$GLOBALS['toMonths']:$m;
		$toyVal=($GLOBALS['toYears'] and $clr)?$GLOBALS['toYears']:$y;
		
		$frdVal=($GLOBALS['frDays'] and $clr)?$GLOBALS['frDays']:date('t');
		$frmVal=($GLOBALS['frMonths'] and $clr)?$GLOBALS['frMonths']:$m;
		$fryVal=($GLOBALS['frYears'] and $clr)?$GLOBALS['frYears']:$y;

		$str="\n<table class=formTable><tr><td>\n";
		$str.="<form name=chooser action=".$GLOBALS['PHP_SELF']." method=get>\n";
		
		$str.="<input type=\"hidden\" name=pageID value=".$GLOBALS['pageID'].">\n";
		$str.="<input type=\"hidden\" name=sortColumn value=".$this->sortColumn.">\n";
		$str.="<input type=\"hidden\" name=sortDirection value=".$this->sortDirection.">\n";
		$str.="<input type=\"hidden\" name=filter value=".$this->filter.">\n";
		$str.="<input type=\"hidden\" name=filterField value=".$this->filterField.">\n";

		$str.="from ".drawDateDropdowns('to',$todVal,$tomVal,$toyVal,$backForward);
		$str.=" to ".drawDateDropdowns('fr',$frdVal,$frmVal,$fryVal,$backForward);

		$str.="<input type=\"submit\" class=btn value=filter>\n";
		$str.="<input type=\"submit\" value=\"clear\" class=btn onclick=\"chooser.filter.value='clearAll'; chooser.filterField.value='';\">\n";

		$str.="</form>";
		$str.="\n</td></tr></table>\n";

		return $str;
	
	} // function dateChooser();
	



} // class tableDisplay ends


//-----------------------------------------------------------------------------------------------------------------------------------------------------------
function showTextBlock($template, $textBlockID,$isDeveloper,$pageID){

	$db=new db;
	$tp=new templateBuilder($template);

	if ($_POST["go".$textBlockID] and $isDeveloper) {
		$db->qry("update DB_003_TEXTBLOCK set DB_003_TITLE='".addslashes($_POST["title".$textBlockID])."' , DB_003_TEXT='".addslashes($_POST["txt".$textBlockID])."' where DB_003_ID=".$textBlockID);
	}	

	$sTags=array('<%title%>','<%body%>');	// heading is assumed to be the same as the menu.
	$sVals[0]=stripslashes($db->getFieldVal('DB_003_TEXTBLOCK',$textBlockID,3,0));	
	
	$text=stripslashes($db->getFieldVal('DB_003_TEXTBLOCK',$textBlockID,2,0));
	$title=stripslashes($db->getFieldVal('DB_003_TEXTBLOCK',$textBlockID,3,0));

	$sVals[1]=nl2br($text);

	// kindof bodge to insert a random image - assume there's only one
	if (eregi('random image-',$template)) {
		$sTemp=explode('random image-',$template);
		list($dir,$null)=explode("%>",$sTemp[1]);

		$sVals[2]=getRandomImage($dir."/");
		$sTags[2]="<%random image-".$dir."%>";
	}
		
        // another bodge to insert a random css background - assume there's only one
        if (eregi('random bg-',$template)) {
                $sTemp=explode('random bg-',$template);
                list($dir,$null)=explode("%>",$sTemp[1]);

                $sVals[2]=getRandomCss($dir."/");
                $sTags[2]="<%random bg-".$dir."%>";
        }

	$tp->simpleTemplate($sTags,$sVals);
	
	$string=$tp->getTemplateStr();


	if ($isDeveloper) {
		$f=explode("\n",$text);	
		$numRows=strlen($text)/47 + count($f)/5;

		if ($numRows<count($f)) {
			$numRows=count($f);
		}

		$str.="<div id=\"tb1".$textBlockID."\" >";
		$str.=$string;
		$str.="</div>";
				
		$str.="<div id=\"tb0".$textBlockID."\" class=\"formTable\" style=\"display:none\" >";
		$str.="<form name=\"frm".$textBlockID."\" action=\"index.php?pageID=".$pageID."\" method=\"post\">";

		$str.="<input type=\"text\" NAME=\"title".$textBlockID."\" style=\"width:100%\" class=\"formText\" value=\"".$title."\">";
		
		$str.="<textarea name=\"txt".$textBlockID."\" style=\"width:100%\" rows=\"".$numRows."\">".$text."</textarea>";
		$str.="<input type=\"hidden\" name=\"pageID\" value=\"".$pageID."\">";
		$str.="<input type=\"submit\" class=\"btn\" name=\"go".$textBlockID."\" value=\"submit\"></form></div>";
		
		$str.="<a href=\"javascript:void(0)\" onclick=\"flip('tb0".$textBlockID."'); flip('tb1".$textBlockID."'); \"><img src=\"images/admin/edit.gif\" border=\"0\"  style=\"display:none;\" id=\"btn".$textBlockID."\"></a>\n";
		

	}else{
		$str=$string;
	}

	return $str;
}

// returns a random image from a directory.
//-------------------------------------------------------------------------------------------------------------------------------------------------------
function getRandomImage($directory){
	$db=new db; // INSERTED AFTER NICK UPDATE

	if (is_dir($directory)) {
		// make a list of files.
		$dir=dir($directory);
		while ($file=$dir->read()) {
			if (eregi(".jpg",$file)) {
				$fileName[]=$file;
			}
		}

		srand((double)microtime() * 1000000);
		$img=$fileName[rand()%(count($fileName))];

		//now select a random one
		$str="<img src=\"".$directory.$img."\" border=\"0\" alt=\"\">\n";
		

		return $str;
	
	}
} // function getRandomImage() ends


// returns a random stylesheet from a directory.
//-------------------------------------------------------------------------------------------------------------------------------------------------------
function getRandomCss($directory){

	if (is_dir($directory)) {
		// make a list of files.
		$dir=dir($directory);
		while ($file=$dir->read()) {
			if (eregi(".css",$file)) {
				$fileName[]=$file;
			}
		}

		srand((double)microtime() * 1000000);
		$cssfile=$fileName[rand()%(count($fileName))];

		//now select a random one
		$str="http://www.whiteoaks.co.uk/".$directory.$cssfile."\n";
		

		return $str;
	
	}
} // function getRandomCss() ends



// ------------------------------------------------------------------------------------------------------------------------------------------------------
class dataDisplay{
	
	var $displayType;
	var $str_sql;
	var $title;
	var $configStr;	// this is a | delimited string of params that need to be fed to the chart class.
		
	var $tableClass;
	var $class1;
	var $class2;

	var $cachePath="lib/graph/cache/";

	// -----------------------------------------------------------------------------------------------------------------------------------------------
	function dataDisplay($displayType,$str_sql,$title,$configStr,$tableClass,$class1,$class2){

		$yyy=array_keys($xxx = get_defined_vars());
		for ($i=((phpversion()>=5)?0:1);$i<count($xxx)  ;$i++) {$this->{$yyy[$i]}=$xxx[$yyy[$i]];}	
	

	} // function dataDisplay ends

	//--------------------------------------------------------------------------------------------------------------------------------------------------------
	function drawData(){

		$this->displayType=trim($this->displayType);
		$db=new db;

		// check to see if there's a cached version.
		// this checks the last update flag and compares it to the datestamp of the cached file.
		$fileName=$this->makeFileName($this->title);

		if (file_exists($this->cachePath.$fileName)) {
			$fp = fopen($this->cachePath.$fileName, "r");
			$fstat = fstat($fp);
			$lastUpdate=$db->getFieldVal('RN_006_LASTUPDATE',1,1,0);
			$thisFileDate=date ("YmdHis", $fstat['ctime']);
			$refresh='';
			fclose($fp );
			

		}else{
			$refresh='y';
		}
		
		if ($lastUpdate>$thisFileDate or $refresh) {
		
			// sql or csv
			if (substr(strtolower(trim($this->str_sql)),0,6)=='select') {
				
				if ($this->displayType=='pie'){
					$vals=$db->get1dArray($this->str_sql);
					$goAhead=count($vals);
				}else{
					$vals=$db->get2dArray($this->str_sql);		
					$goAhead=count($vals[0]);
				}
				// get the legends
				$legends=$db->getFields($this->str_sql,-1);

			}else{	// csv

				$cols=explode("\n",$this->str_sql);
				$legends=explode(",",$cols[0]);

				if ($this->displayType=='pie'){		
					
					$x=explode(",",$cols[$i]);
					for ($n=0;$n<count($x) ;$n++) {
						$vals[$n]=$x[$n];
					}
					$goAhead=count($vals);
				}else{
					for ($i=1;$i<count($cols) ;$i++) {
						$x=explode(",",$cols[$i]);
						for ($n=0;$n<count($x) ;$n++) {
							$vals[$n][$i-1]=$x[$n];
						}
					}
					$goAhead=count($vals[0]);
				}
			}

			if ($goAhead) {

				// sort out the confiStr
				$cf=explode("|",$this->configStr);
				$tableParams=explode(",",$cf[0]);
				$graphParams=explode(",",$cf[1]);
				$pieParams=explode(",",$cf[2]);

				for ($i=0;$i<count($legends) ;$i++) {
					$fieldLinks[$i]='filter';	 // this is table stuff
					if (eregi("_",$legends[$i])) {
						list(,,$s)=explode("_",$legends[$i]);									
						$legends[$i]=strtolower($s);
					}else{

		// if at some point we need a link to another page
		//				if ($legends[$i]=='matchlink') {
		//      			$fieldLinks[$i]="index.php?pageID=172&id=<%".$i."%> target=_blank";
		//				}
					}

					$sum[$i]='';
					$sortArray[$i]='';

				}


				switch(trim($this->displayType)){
					case 'pie':	
						// because we can't pass variables to the fucking thing, we write them to a tempfile.			
						$urlStr="title=".$this->title."&width=".$pieParams[0]."&height=".$pieParams[1]."&n=".count($legends);
						$urlStr.="&fileName=".$fileName;
						if (array_sum($vals)) {
							for ($i=0;$i<count($legends) ;$i++) {
								$urlStr.="&legends".$i."=".$legends[$i];
								$urlStr.="&vals".$i."=".$vals[$i];
				
							}

							$str="\n<img src=\"pieChart.php?".$urlStr."\" border=0>\n";	
						}else{
				//			$str="number of values=".count($vals);
				//			$str.="<br />".$this->str_sql."<br />";
				//			for ($ii=0;$ii<count($vals) ;$ii++) {
				//				$str.=$vals[$ii]."<br />";
				//			}
						}
					break;
					case 'graph':
						
						// for barChart($Ydata,$xData,$title,$legend,$x,$y)
						$urlStr="title=".$this->title."&width=".$graphParams[1]."&height=".$graphParams[0]."&n=".count($vals[0])."&legend=".$graphParams[2];
						$urlStr.="&fileName=".$fileName;
						for ($i=0;$i<count($vals[0]) ;$i++) {

							$urlStr.="&Ydata".$i."=".$vals[0][$i];
							$urlStr.="&xData".$i."=".$vals[1][$i];
							
						}
					
					
						$str="\n<img src=\"barChart.php?".$urlStr."\" border=0>\n";

					break;

					case 'graph2':

						// for barChart($Ydata,$xData,$title,$legend,$x,$y)
						$urlStr="title=".$this->title."&width=".$graphParams[1]."&height=".$graphParams[0]."&n=".count($vals[0])."&legend=".$graphParams[2];
						$urlStr.="&fileName=".$fileName;
						for ($i=0;$i<count($vals[0]) ;$i++) {

							$urlStr.="&y1data".$i."=".$vals[0][$i];
							$urlStr.="&y2data".$i."=".$vals[1][$i];
							$urlStr.="&xData".$i."=".$vals[2][$i];
							
						}
					
						$str="\n<img src=\"barChart2.php?".$urlStr."\" border=0>\n";

					break;
					case 'line2':
						
						// for 2dLineGraph($ydata,$y2data,$xData,$x,$y,$title,$xtitle,$ytitle)
						$urlStr="title=".$this->title."&width=".$graphParams[0]."&height=".$graphParams[1]."&n=".count($vals[0]);
						$urlStr.="&xtitle=".$legends[0];
						$urlStr.="&ytitle=".$legends[1];
						$urlStr.="&fileName=".$fileName;

						for ($i=0;$i<count($vals[0]) ;$i++) {

							$urlStr.="&ydata".$i."=".$vals[0][$i];
							$urlStr.="&y2data".$i."=".$vals[1][$i];
							$urlStr.="&xData".$i."=".$vals[2][$i];
							
						}
					
						$str="\n<img src=\"lineChart2.php?".$urlStr."\" border=0>\n";

					break;


					case 'table':
						
						if ($pieParams[1]) {
							$sum=explode("~",$tableParams[1]);
						}

						$sortCol=$GLOBALS['sortColumn']?$GLOBALS['sortColumn']:$tableParams[0];	// default sort column. 
						$sortDirec=$GLOBALS['sortDirection']?$GLOBALS['sortDirection']:$tableParams[1];	// default sort direction. 
						$tbl=new tableDisplay($this->str_sql,$fieldLinks,$legends,$sortCol,$sortDirec,$GLOBALS['filter'], $GLOBALS['filterField'], $this->tableClass,$this->class1,$this->class2,$sum,$sortArray,$urlStr);
						$str=$tbl->drawTable();

					break;

				}
			}
		}else{
			$str="\n<img src=\"".$this->cachePath.$fileName."\" border=0>\n";
		}
		
		return $str;

	} // function drawData()


	//-----------------------------------------------------------------------------------------------------------------------------------------------------------
	function makeFileName($title){
		
		$fileName=str_replace(" ","",$title);
		$fileName=str_replace("<br />","",$fileName);
		$fileName=str_replace("/","",$fileName);
		$fileName=str_replace(":","",$fileName);
		$fileName=str_replace("(","",$fileName);
		$fileName=str_replace(")","",$fileName);
		$fileName=str_replace("-","",$fileName);
		$fileName.="micro.png";
	

		return $fileName;
	}

} // class dataDisplay ends



//--------------------------------------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------------------------------------------




//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
function simpleDropdown($valArray,$showArray,$fieldname, $valToShow,$null,$submit){
	$str.= "<select name=\"".$fieldname."\"".($submit?" onchange=\"".$submit."\"":"")." class=\"formText\">\n"; 
	if ($null) {$str.="<option value=''></option>\n";}
	for ($i=0;$i<count($valArray) ;$i++) {
		$str.="<option value=\"".$valArray[$i]."\"".(($valToShow==$valArray[$i])?" selected":"").">".$showArray[$i]."</option>\n";
	}
	$str.= "</select>\n";

	return $str;
} // simpleDropdown ends



//-------------------------------------------------------------------------------------------------------------------------------------------------------
function listVals($listSourceID){
	$db=new db;

	if ($listSourceID) {
		$arr=$db->getArray('DB_007_LISTSOURCE',$listSourceID);
		$listKeys=array();
		$listShow=array();


		if (strtolower($arr[3])=='sql') {
			
			// can pass in variables
			$tags=getTags($arr[2]);
			for ($i=0;$i<count($tags) ;$i++) {
				$var=str_replace("<%","",str_replace("%>","",$tags[$i]));
				$arr[2]=str_replace($tags[$i],$GLOBALS[$var],$arr[2]);
			}

			$l=$db->get2dArray($arr[2]);

			if (count($l)) {
				$listKeys=array_values($l[0]);
				$listShow=count($l[1])?array_values($l[1]):array_values($listKeys);	
			}
		}elseif(substr($arr[3],0,3)=='dir'){

			if (substr($arr[2],0,1)=='$') {	// interpret a variable if a variable name is passed in.
				$arr[2]=$GLOBALS[str_replace('$',"",$arr[2])];
			}

			$dir=dir($GLOBALS['pathToRoot'].$arr[2]);
			while ($fileName=$dir->read()) {
				if ($fileName!='..' && $fileName!='.' && $fileName!='index.html') {
					if (strtolower($arr[3])=='dirtrim') {
						list($file,)=explode(".",$fileName);
						$listKeys[]=$file;
						$listShow[]=$file;
					} elseif (strtolower($arr[3])=='dir2trim') {
						$dirName=$fileName;
							$dir2=dir($GLOBALS['pathToRoot'].$arr[2].'/'.$dirName);
							while ($fileName=$dir2->read()) {
								list($file,)=explode(".",$fileName);
								if ($file!='thumbs' && $file!='' && $file!='site' && $file!='library') {
									$listKeys[]=$file;
									$listShow[]=$file;
								}

						}

					} else {
						$file=$fileName;	
						$listKeys[]=$file;
						$listShow[]=$file;
					}
				}
			}
			array_multisort($listShow, $listKeys);
		}else{
			$listShow=explode(",",$arr[2]);
			$listKeys=$arr[3]?explode(",",$arr[3]):array_values($listShow);
		}
		if ($hasNull) {
			array_unshift($listKeys,'');
			array_unshift($listShow,''); 
		}
	}

		$result=array($listKeys,$listShow);

	return $result;
} // function listVals() ends


//-----------------------------------------------------------------------------------------------------------------------------------------------------------
function drawDateDropdowns($name,$dVal,$mVal,$yVal,$backForward){

	$days[]='00';
	for ($i=1; $i<32 ;$i++) {$days[]=$i;}
	$str.=simpleDropdown($days,$days,$name.'Days', $dVal,'','');


	for ($i=1; $i<13 ;$i++) {
		$months[]=$i;
		$monthNames[]=date('F',mktime (0,0,0,$i,1,2002));
		
	}		
	$str.=simpleDropdown($months,$monthNames,$name.'Months', $mVal,'y','');

	list($back,$forward)=explode(":",$backForward);
	
	$years[]='0000';
	for ($i=date('Y')-$back; $i<date('Y')+$forward+1 ;$i++) {$years[]=$i;}	
	$str.=simpleDropdown($years,$years,$name.'Years', $yVal,'','');		

	return $str;
} //function drawDateDropdowns()



// This function returns a 2d array of the elements in an xml str.
//-------------------------------------------------------------------------------------------------------------------------------------------------------
function xml2dArray2($tagArray,$xmlstr){

	if (!$dom = domxml_open_mem($xmlstr)) {
	  echo "Error while parsing the document\n";
	  exit;
	}

	$root = $dom->document_element();

	for ($i=0;$i<count($tagArray) ;$i++) {
		${$tagArray[$i]}= $root->get_elements_by_tagname($tagArray[$i]);
	}

	for ($i=0;$i<count(${$tagArray[0]}) ;$i++) {
		for ($n=0;$n<count($tagArray) ;$n++) {
		     $node = ${$tagArray[$n]}[$i];
		      $arr[$n][$i]=$node->get_content();
		}
	}

	return $arr;
} // function xml2dArray() ends


// This function returns a 2d array of the elements in an xml str - uses dif php functions
//-------------------------------------------------------------------------------------------------------------------------------------------------------
function xml2dArray($tagArray,$xmlstr){

	$p = xml_parser_create();


	xml_parse_into_struct($p, $xmlstr, $vals, $tags);
	xml_parser_free($p);
	
	foreach ($vals as $key=>$val) {
		for ($n=0;$n<count($tagArray) ;$n++) {
			if (strtoupper($val["tag"])==strtoupper($tagArray[$n])) {
				$arr[$n][]=$val["value"];
			}
		}
	}

	return $arr;
} // function xml2dArray() ends


//-------------------------------------------------------------------------------------------------------------------------------------------------------
//function getTags($str){
	
//	$s=explode('<%',$str);

//	for ($i=1;$i<count($s) ;$i++) {
//		list($tag,$body)=explode("%>",$s[$i]);
//		if (strlen($tag)<20) {
//			$tags[]="<%".$tag."%>"; // IF STILL NOT WORKING, CHECK HERE
//		}
//	}
//
//	return $tags;
//
//} // function stripTags() ends

//-------------------------------------------------------------------------------------------------------------------------------------------------------
function getTags($str){
	
	$s=explode('<%',$str);
	$str=$s[0];
	for ($i=1;$i<count($s) ;$i++) {
		list($tag,$body)=explode("%>",$s[$i]);
		if (strlen($tag)<20) {
			$tags[]="<%".$tag."%>"; 
		}
	}

	return $tags;

} // function stripTags() ends

// ------------------------------------------------------------------------------------------------------------------------------------------------------
class formEdit{

	var $template;
	var $id;
	var $pageID;
	var $formID;
	var $formTag;			// this uniquely identifies this form instance - usually made up of the formID and a filter.
						// it is inserted into all fieldnames.
	var $btns;				// button types.
	var $isDeveloper;
	var $formEditModuleDir;
	var $idForMultiLine;

	var $mainTable;
	var $fVals=array();		// array of formField values.
	var $chooser;			// is there a dropdown list?
	var $listSourceID;		// sql for the dd list
	var $fields=array();		// fields in the table
	var $noMessageFields=array("hidden",'datestamp');

	var $mandatoryBailouts=array();


	// -----------------------------------------------------------------------------------------------------------------------------------------------
	function formEdit($template, $id,$pageID,$formID,$formTag,$btns,$isDeveloper,$formEditModuleDir,$idForMultiLine){


		$yyy=array_keys($xxx = get_defined_vars());	 // generic populate
		for ($i=((phpversion()>=5)?0:1);$i<count($xxx)  ;$i++) {$this->{$yyy[$i]}=$xxx[$yyy[$i]];}	

		$db=new db;

		// get Form Vals
		$str_sql="select DB_009_MAINTABLE,DB_007_LISTSOURCE_ID,DB_009_CHOOSER,DB_009_FORMNAME,DB_009_FORCEID from DB_009_FORMS where DB_009_ID='".$this->formID."'";	
		list($this->mainTable,$this->listSourceID, $this->chooser,$formName,$forceID)=$db->get1dArray($str_sql);
		
		if (!$this->mainTable) {
			print "There's a database error - form number '".$this->formID."' doesn't have a table to go with it";
			exit();
		}

		// get formfields
		// DB_008_ID,DB_008_TITLE,DB_008_FIELDNAME,DB_009_FORM_ID,DB_008_TYPE,DB_007_LISTSOURCE_ID,DB_008_HASNULL,DB_008_ROWS,DB_008_WIDTH,DB_008_MAND,DB_008_DEFAULT,DB_008_ORDER,DB_008_ERROR,DB_008_LINE_HEIGHT,DB_008,TITLE_WIDTH,DB_008_ENDLINE,DB_008_TITLE_POS,DB_008_SPLIT
		$str_sql="select * from DB_008_FORMFIELD where DB_009_FORM_ID='".$this->formID."' order by DB_008_ORDER";	
		$this->fVals=$db->get2dArray($str_sql);

		// get the fields in the table.
		$this->fields=$db->getFields($this->mainTable,-1);
		
		// make the template if there isn't one
		if (!$this->template) {	
			if ($this->chooser) {
				$this->template="<table class=\"formTable\">\n<tr><td colspan=\"2\" class=\"title\">Choose record <%chooser%></td></tr>\n";
			}else{
				$this->template="<table class=\"formTable\">\n<caption><%chooser%></caption>\n";
			}

			if ($this->isDeveloper) {
				$this->template.="<tr><td align=right>";

				// chooser2 is the chooser id for the form form. Getting nasty really.
				$this->template.="<a href=\"index.php?pageID=".$GLOBALS['formEditingID']."&id=".$this->formID."&chooser2_=".$this->formID."\" title=\"configure this form\" target=\"_blank\"><img src=\"images/admin/greenIcon.gif\" border=\"0\"></a>"; 
		
			} //RJS: ends chooser box and/or form title
			

// RJS: The next 3 lines create a table form ...
//			for ($i=0;$i<count($this->fVals[0]) ;$i++) {
//				$this->template.="<tr><td valign=\"top\"><%title".$i."%></td><td valign=\"top\"><%field".$i."%|nl2br></td></tr>\n";
//			}

// RJS: The next lines create a CSS laid-out form ... and one day I'll finish it and get it right! ...


		$this->template.="<tr><td>\n";
		$this->template.=$mandErrorHead;

		for ($i=0;$i<count($this->fVals[0]) ;$i++) {
		$height=($this->fVals[13][$i]);
		$leftWidth=0;
		$rightWidth=0;

		if ($height>0) { //only write a line if height > 0
			$lineSplit=$this->fVals[17][$i];
			$lineEnd=$this->fVals[15][$i];
			$leftWidth=$this->fVals[14][$i];
			$rightWidth=$this->fVals[8][$i];
			$titlePos=$this->fVals[16][$i];
			if ($lineSplit>0) {
				$lineWidth=$rightWidth;
			} else {
				$lineWidth=$rightWidth+$leftWidth;
			}
			$lineWidth="width:".$lineWidth."px;";
			$height=$height."px;";

			$rightWidth=$rightWidth."px;";
			if ($leftWidth>0) {
				$leftWidth=" margin-left:".$leftWidth."px;";
			}
		
			if ($titlePos>0) {
				$titlePos=" margin-left:".$titlePos."px;";
			} else {
				$titlePos="";
			}
			if ($lineEnd<1) {
				$titlePos.=" style=\"top:-".$rightTop."px;\" ";
			}


				if ($lineSplit>0) {				// if the question is above the answer
					$this->template.="\n\r<div class=\"formLine\" style=\"".$lineWidth."\">\n\r";
					$this->template.="\n\r<div class=\"formLineContent\" style=\"height:".$height."\">\n\r";
					$this->template.="\n\r<div class=\"formLeft\"><%title".$i."%></div>\n\r</div></div>\n\r";
					$this->template.="\n\r<div class=\"formLine\" style=\"".$lineWidth." position:relative; top:0px;\">\n\r";
					$this->template.="\n\r<div class=\"formLineContent\">\n\r";
					$this->template.="<div class=\"formRight\" style=\"width:".$rightWidth."\"><%field".$i."%></div>\n\r";
				} else {				// if the question is to the left of the answer
					$this->template.="\n\r<div class=\"formLine\" style=\"".$lineWidth."; clear:both;\">\n\r";
					$this->template.="\n\r<div class=\"formLineContent\" style=\"height:".$height."\">\n\r";
					$this->template.="\n\r<span class=\"formLeft\" style=\"vertical-align:top;\"><%title".$i."%></span>\n\r";
					$this->template.="\n\r<span class=\"formRight\" style=\"width:".$rightWidth."\"><%field".$i."%></span>\n\r";
				}

				if ($lineEnd>0) {
					$this->template.="</div></div>\n\r";
				}

			} // end of (if height>0)
		} // end of if (!$this->template)

		$this->template.="</div></td></tr>";

// RJS: end of CSS layout hack

		$this->template.="<tr><td colspan=\"2\"><%btns%></td></tr></table>\n\n";
		}else{
			$tags=getTags($this->template); // IF STILL DOESN'T WORK< CHECK HERE
			if (!@in_array("<%title0%>",$tags) or !in_array("<%field0%>",$tags) ) {
				print "something's up with the template (view source <!-- ".$this->template." -->) - for form number '".$this->formID."' - there aren't any opening tags in it.";
				exit();
			}
		}

		if ($forceID) {
			$this->id=$GLOBALS[$forceID];
		}else{
			$this->id=$this->id?$this->id:$GLOBALS['chooser'.$formTag];	// a hard coded id overrides the chooser tag
		}
	} // function formEdit ends

	//-----------------------------------------------------------------------------------------------------------------------------------------------------------
	function handleInput($go){
		$db=new db;
		// do we need to regenerate? - assume only developer gets to see the form form which uses this function
		if ($go=='rebuild' and $GLOBALS["f2_".$this->formTag]) {
			$this->rebuild($GLOBALS["f2_".$this->formTag],$this->id,$GLOBALS["f5_".$this->formTag]);	// the table name and the filter
		}else{
			for ($i=0;$i<count($this->fVals[0]) ;$i++) {
				
				$fieldsToUse[$i]=$this->fVals[2][$i];
				$type=strtolower($this->fVals[4][$i]);		// kindof redundant but it makes it a lot easier to read.	
				$mandatory=$this->fVals[9][$i];
				$default=$this->fVals[10][$i];
				if (substr($default,0,1)=='$' ){
					eval('$default='.$default.';');
				}

				// import the module
				//-----------------------------------------------------------------------------------------------------------
				if (file_exists($this->formEditModuleDir.$type.".php") and $type) {
					require_once($this->formEditModuleDir.$type.".php");
					$functionName="getVal_".$type;
					$name="f".$i."_".$this->formTag;
					$valArray[$i]=$functionName($name,$default,$this->id,$this->mainTable);		
				}
				//-----------------------------------------------------------------------------------------------------------

				if ($valArray[$i]=='' and $mandatory and $go!='delete') {

					$mandatoryAbort='y';
					$this->mandatoryBailouts[$i]='y';
				}
			}
			
				
			// table updates		
			if ((!$mandatoryAbort and $go!='delete') or $go=='delete') {
				if (($go=='delete' or $go=='update') and (!$this->id or !$valArray[0])) {
					$go='';
				}

			if ($go=='add' or $go=='update' or $go=='next' or $go=='REGISTER') {$go.=":noslashes";}

			if ($go) {
				$this->id=$db->genericTableUpdate($go, $valArray,$this->mainTable,$this->id,$fieldsToUse);
				}
			if ($go=='delete') {$this->id='';}
				
			}
		}
		echo "thisID=".$this->id;
		return $this->id;

	} // function handleInput($go) ends

	// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
	function success(){

		$ok='Y';

		if (count($this->mandatoryBailouts)) {
			if (@implode("",$this->mandatoryBailouts)) {
				$ok='';
			}
		}

		return $ok;
	} // function success(){} ends

	//-------------------------------------------------------------------------------------------------------------------------------------------------------
	function noChooser(){
		$this->chooser='';
	} // 	function noChooser() ends


	// this builds the form.
	//-------------------------------------------------------------------------------------------------------------------------------------------------
	function drawForm($pageNo,$linkTxt,$linkButton){		
		$db=new db;

		if ($this->formID) {

//			$str.="<input type=\"hidden\" name=\"tableName".$this->formTag."\" value=".$this->mainTable.">\n";	

			// make the dd list.	
			$sTags[]="<%chooser%>";
			if ($this->chooser) {

				if ($this->listSourceID) {
					$vals=listVals($this->listSourceID);
				}else{
					$str_sql="select ".$this->fields[0].",".$this->fields[1]." from ".$this->mainTable." order by ".$this->fields[1];

					$vals=$db->get2dArray($str_sql);
				}

				$sVals[]=simpleDropdown($vals[0],$vals[1],'chooser'.$this->formTag, $this->id,'y','submit();');
			
			}else{

				$sVals[]="<input type=\"hidden\" name=\"chooser".$this->formTag."\" value=\"".$this->id."\">\n";
			}
	
			// get the current values from the db.
			if ($this->id and count($this->fVals[2])) {

				$str_sql="select ".implode(",",$this->fVals[2])." from ".$this->mainTable." where ".$this->fields[0]."='".$this->id."'";

				$currVals=$db->get1dArray($str_sql);
			}

			for ($i=0;$i<count($this->fVals[0]) ;$i++) {

                                $title=$this->fVals[1][$i];                     // kindof redundant but it makes it a lot easier to read.    $
                                $type=strtolower($this->fVals[4][$i]);
                                $listSource=$this->fVals[5][$i];
                                $hasNull=$this->fVals[6][$i];
                                $rows=$this->fVals[7][$i];
                                $width=$this->fVals[8][$i];
                                $mandatory=$this->fVals[9][$i];

//                              $default=$this->id?$this->fVals[10][$i]:"";
                                $default=$this->fVals[10][$i];

                                if (substr($default,0,1)=='$' ){
                                        eval('$default='.$default.';');
                                }

                                $errorMessage=stripslashes($this->fVals[12][$i]);
                                if ($this->mandatoryBailouts[$i]) {

                                        $mandMsg="<span class=\"errorMsg\">".$errorMessage."</span>\n";
                                }else{
                                        $mandMsg="";
                                }

                                $lineHeight=$this->fVals[13][$i];
                                $titleWidth=$this->fVals[14][$i];
                                $endLine=$this->fVals[15][$i];
                                $titlePos=$this->fVals[16][$i];
				$lineSplit=$this->fVals[17][$i];

				$notUsed='';

                                $title=in_array($type,$this->noMessageFields)?"":$title;

//				$sVals[]=stripslashes($title)." ".($mandatory?"*".$mandMsg:"");
				$sVals[]=($mandatory?"<span class='mandField'>".stripslashes($title)." *</span>".$mandMsg:stripslashes($title));
				$sTags[]="<%title".$i."%>";

				
				// import the module
				//-----------------------------------------------------------------------------------------------------------
				if (file_exists($this->formEditModuleDir.$type.".php") and $type) {
					require_once($this->formEditModuleDir.$type.".php");
					$functionName="output_".$type;
					$name="f".$i."_".$this->formTag;
					
					// need to go to the post/global (grrr) variable if there's a mandatory error - or a global called re-edit
					

					$valToUse=(count($this->mandatoryBailouts) or $GLOBALS['re-edit'])?stripslashes($GLOBALS[$name]):$currVals[$i];

					// some of this is redundant - change it when we move all form modules over.

//					$sVals[]=$functionName($listSource,$name,$valToUse,$default,$width,$rows,$lineHeight,$notUsed,$notUsed,$accessLevel,$null,$this->id,$hasNull);
                            $sVals[]=$functionName($listSource,$name,$valToUse,$default,$width,$rows,$notUsed,$notUsed,$notUsed,$accessLevel,$null,$this->id,$hasNull);

				}else{
					$sVals[]="the form module for this doesn't seem to exist - ".$type;				
				}
				$sTags[]="<%field".$i."%>";				
			}
			
			if (!$this->btns) {
				$str_sql="select DB_009_NEXTPAGE from DB_009_FORMS where DB_009_ID='".$this->formID."'";
				$nextPageOutput=$db->get1dArray($str_sql);
				$nextPage=$nextPageOutput[0];
				if ($nextPage) {
					$this->btns=$this->id?":next >>:":"next >::";
				} else {
					$this->btns=$this->id?"add:update:delete":"add::";
				}
			}
			$b=explode(":",$this->btns);	// can choose which buttons with Y:Y:Y field
			$str='';
			for ($i=0;$i<count($b) ;$i++) {
				$str.=($b[$i])?"<input type=\"submit\" name=\"go".$this->formTag."\" value=\"".$b[$i]."\" class=\"btn\">\n":"";	
			}
			if ($linkTxt and $pageNo and $this->id) {
				$str.="<p>";
				  if ($linkButton=='1') {
					  $str.="<span class=\"btnNorm\"><a href=\"index.php?pageID=$pageNo&id=$this->id\">$linkTxt</a></span>";
				  } else if ($linkButton=='2') {
					  $str.="<span class=\"btnBig\"><a href=\"index.php?pageID=$pageNo&id=$this->id\">$linkTxt</a></span>";
				  } else {
					  $str.=" <p><a href=\"index.php?pageID=$pageNo&id=$this->id\">$linkTxt</a>";
				  }
				$str.="</p>\n";
			}

			$sVals[]=$str;

			$sTags[]="<%btns%>";
			$id=$this->id; // IF STILL DOESN'T WORK, CHECK THIS

			$tp=new templateBuilder($this->template);
			$tp->simpleTemplate($sTags, $sVals);
			$str=$tp->getTemplateStr();

		}else{
			$str="There isn't a formID";
		}
		return $str;

	} // function drawForm() ends


	// this checks the formfield table - ignores the entries that are ok, builds the absent ones, deletes the orphans.
	//-------------------------------------------------------------------------------------------------------------------------------------------------
	function rebuild($table,$id,$filter){
		$db=new db;


		$fields=$db->getfields($table,-1);
		$fieldDetails=$db->get2dArray("select * from DB_008_FORMFIELD where DB_009_FORM_ID=".$id);
		$db->qry("delete from DB_008_FORMFIELD where DB_009_FORM_ID=".$id);
		
		for ($i=0;$i<count($fields) ;$i++) {

			if (strtoupper($fields[$i])!='TIMESTAMP') {
				if (@in_array($fields[$i],$fieldDetails[2])) {
					$valArray=array();	 // reset it
					for ($n=0;$n<count($fieldDetails) ;$n++) {
						$valArray[]=$fieldDetails[$n][$i];
					}
				}else{
					//BU_010_ID BU_010_FIELDNAME BU_009_FORM_ID BU_010_TABLENAME BU_010_DESC BU_010_HELP BU_010_TYPE BU_010_CONFIGSTR BU_010_SIZE BU_010_MAND BU_010_DEFAULT BU_010_ORDER BU_010_ERROR 
					
					list(,,$desc)=explode("_",$fields[$i]);
					$desc=ucfirst(strtolower($desc));
					
					$default='';
					$fieldType=$i==0?'hidden':'text';
					if ($filter and $fields[$i]==$filter) {
						$default='$this->filter';
						$fieldType='hidden';
					}
				
					$valArray=array('',$desc,$fields[$i],$id,$fieldType,'','',1,240,0,$default,$i,'');
				}
				$db->genericTableUpdate('add', $valArray,"DB_008_FORMFIELD",'','');
			}
		}	


		return $str;
	} // function rebuild	() ends


} // class formEdit ends



// this returns a stand-alone multi-line form.
//	
//	This is designed so multiple instance of this form can be submitted from the same form. To do this, the 
//	formID needs to be appended to each field. There doesn't need to be a form name as there's one big form to cover the 
//	whole thing.  This includes the 1x forms.
//	buttons can be passed in as add:update:etc - there must however be an identically named gif with str_replace(" ","_",
// ------------------------------------------------------------------------------------------------------------------------------------------------------
class multiLineForm{

	var $moduleDir;
	var $formID;
	var $isDeveloper;

	var $id;
	var $nodeArray=array();
	var $indexID;			// this is the filtering ID for a particular MX form
	var $btns=array();
	var $filter;
	var $filterField;
	var $btnArray;

	// -----------------------------------------------------------------------------------------------------------------------------------------------
	function multiLineForm($moduleDir,$formID,$isDeveloper){


		$yyy=array_keys($xxx = get_defined_vars());	 // generic populate
		for ($i=((phpversion()>=5)?0:1);$i<count($xxx)  ;$i++) {$this->{$yyy[$i]}=$xxx[$yyy[$i]];}	

	} // function multiLineForm ends

	//-----------------------------------------------------------------------------------------------------------------------------------------------------------
	function setID($id){
		$this->id=$id;
	} // function setID() ends

	//-----------------------------------------------------------------------------------------------------------------------------------------------------------
	function setIndexID($indexID){
		$this->indexID=$indexID;
	} // setIndexID

	//-----------------------------------------------------------------------------------------------------------------------------------------------------------
	function setFilterField($filterField){
		$this->filterField=$filterField;

	} // function filter($go) ends

	//-----------------------------------------------------------------------------------------------------------------------------------------------------------
	function setFilter($filter){
		$this->filter=$filter;

	} // function filter($go) ends

	//-----------------------------------------------------------------------------------------------------------------------------------------------------------
	function setBtns($btnArray){
		$this->btns=$btnArray;
	} // function handleInput($go) ends



	//-----------------------------------------------------------------------------------------------------------------------------------------------------------
	function handleInput(){
		$db=new db;

		for ($i=0;$i<count($this->btns) ;$i++) {
			if ($_POST[str_replace(" ","_",$this->btns[$i]).$this->formID."_x"]) {$go='y';}
		}

		if ($go or $_POST["delete".$this->formID]) {

			// collect the relevent variables for this formID. These will be scattered everywhere so they need to be collected and then sorted.
			// get the data from the multiForm table - table
			$str_sql="select DB_009_MAINTABLE,DB_009_IDFIELD, DB_009_ORDERFIELD from DB_009_FORMS where DB_009_ID='".$this->formID."'";
			list($table,$idField,$orderField)=$db->get1dArray($str_sql);

			// this gives us the make up of each column.
			$str_sql="select * from DB_008_FORMFIELD where DB_009_FORM_ID='".$this->formID."' order by DB_008_ORDER";
			$columnVals=$db->get2dArray($str_sql);
			$types=$columnVals[4];
			$defaults=$columnVals[10];
			$fieldNames=$columnVals[2];
			
			for ($i=0;$i<count($defaults) ;$i++) {
				if ($fieldNames[$i]==$idField) {
					$this->filter=$GLOBALS[str_replace("$","",$defaults[$i])];
				}
			}




			// now we go off to the table itself and get the lines - used for deleting
			$str_sql="select * from ".$table;
			$str_sql.=$idField?" where ".$idField."='".$this->filter."'":"";
			$str_sql.=$orderField?" order by ".$orderField:"";

			$vals=$db->get2dArray($str_sql);

			$theIDs=array();
			reset($_POST);
//			while (list($key, $val) = each($_POST)) {
			foreach($_POST as $key=>$val) {

				list($type, $fID,$i,$filter,$thisID)=explode("_",$key);

				if ($fID==$this->formID and $filter==$this->filter){
					switch ($type){
						case "mx":
							if (!in_array($thisID,$theIDs)){
								$theIDs[]=$thisID;
							}

						break;

						case "del":
							$db->qry('delete from '.$table." where ".$db->getFields($table,0)."='".$vals[0][$thisID]."'");
							$skip='y';
						break;
					}	
				}
			}

			if ($skip!='y') {


				for ($n=0;$n<count($theIDs) ;$n++) {

					$this->id=$theIDs[$n];
					$valArray=array();

					for ($i=0;$i<count($columnVals[0]) ;$i++) { // column vals correspond to table columns

						if (file_exists($this->moduleDir.strtolower($types[$i]).".php") and $types[$i].".php") {

							// import the module
							require_once($this->moduleDir.$types[$i].".php");
							$functionName="getVal_".$types[$i];

							if (substr($defaults[$i],0,1)=='$' ){
								eval('$default='.$GLOBALS[str_replace("$","",$defaults[$i])].';');
							}else{
								$default=$defaults[$i];
							}

							$name="mx_".$this->formID."_".$i."_".$this->filter."_".$theIDs[$n];
							$valArray[$i]=$functionName($name,$default); // go get the value from the other function

						}else{
							print " module '".$type.".php' missing ";
							exit();
						}
					}
					if ($_POST["update".$this->formID."_x"]) {
						$db->genericTableUpdate('update', $valArray,$table,$valArray[0],'');

					}
				}

				// these are the responses for each button type - can be added to as time goes on.
				// above is the update one - a thing that happens for each line. This may need to mirror
				// the switch code below at some point.
				//-------------------------------------------------------------------------------------------------------
				for ($i=0;$i<count($this->btns) ;$i++) {
					if ($_POST[str_replace(" ","_",$this->btns[$i]).$this->formID."_x"]) {
						switch($this->btns[$i]){
							case "add": //qqq
								$db->genericTableUpdate('add', $valArray,$table,'','');
							break;

						}
					}
				}
			}
		}
		
	} // function handleInput($go) ends
	

	// this builds a line of the form RJS: methinks this is for backstage forms only.
	//-----------------------------------------------------------------------------------------------------------------------------------------------------------
	function drawForm(){		
		$db=new db;
		
		// get the data from the multiForm table - table
		$str_sql="select DB_009_MAINTABLE, DB_009_IDFIELD, DB_009_ORDERFIELD, DB_009_FORMNAME from DB_009_FORMS where DB_009_ID='".$this->formID."'";

		list($table,$idField,$orderField, $formName)=$db->get1dArray($str_sql);


		// this gives us the make up of each column.
		$str_sql="select * from DB_008_FORMFIELD where DB_009_FORM_ID='".$this->formID."' order by DB_008_ORDER";
		$columnVals=$db->get2dArray($str_sql);
		$titles=$columnVals[1];
		$fieldNames=$columnVals[2];
		$types=$columnVals[4];
		$rows=$columnVals[7];
		$widths=$columnVals[8];
                $lineHeights=$columnVals[13];
		$listsources=$columnVals[5];
		$nulls=$columnVals[6];
		$defaults=$columnVals[10];
			
		for ($i=0;$i<count($defaults) ;$i++) {
			if ($fieldNames[$i]==$idField) {
					$this->filter=$GLOBALS[str_replace("$","",$defaults[$i])];
			}
		}

		// This is for backstage form page

		$str.="<table class=\"formTable\" cellspacing=\"0\">";
		
		if ($this->isDeveloper) {
			// chooser2 is the chooser id for the form form. Getting nasty really.
			$btnGif=in_array("delete",$this->btns)?"greenIcon.gif":"greenIconLite.gif";
			$editLink="<a href=\"index.php?pageID=".$GLOBALS['formEditingID']."&id=".$this->formID."&chooser2_=".$this->formID."\" title=\"configure this form\" target=\"_blank\"><img src=\"images/admin/".$btnGif."\" border=\"0\"></a>"; 
		}

		for ($i=0;$i<count($titles) ;$i++) { // column vals correspond to table columns
			if (!eregi("hidden",$types[$i])) {
				$headings.="<td class=\"headings\">".$titles[$i]."</td>";
				$numH++;
			}
		}
		if (in_array("delete",$this->btns)) {
			$headings.="<td class=\"headings\">&nbsp;".$editLink."</td>";
			$numH++;
			$editLink='';
		}

		$str.="</tr>";
		

		$str.="<tr><td class=\"title\">".$formName."</td><td class=\"title\" colspan=\"".($numH-1)."\"  align=\"right\">".$editLink."</td></tr><tr>".$headings;


		if ($table and count($types)) {
	
			// now we go off to the table itself and get the lines.
			$str_sql="select * from ".$table;
			$str_sql.=$idField?" where ".$idField."='".$this->filter."'":"";
			$str_sql.=$orderField?" order by ".$orderField:"";

			$vals=$db->get2dArray($str_sql);
			for ($x=0;$x<count($vals[0])+(in_array("add",$this->btns)?1:0) ;$x++) {
				$str.="<tr>";
				for ($i=0;$i<count($titles) ;$i++) { // column vals correspond to table columns

					$str.=(!eregi("hidden",$types[$i]))?"<td valign=\"top\" ".($x>=count($vals[0])?" class=\"addLine\"":"").">":"";

				//	if (file_exists($this->moduleDir.strtolower($types[$i]).".php") and $types[$i].".php") {
						
						// import the module
						$this->moduleDir="lib/formEditModules/"; //TEMP!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//						echo "here: ".$this->moduleDir.$types[$i].".php";
						require_once($this->moduleDir.$types[$i].".php");
						$functionName="output_".$types[$i];
						if ($functionName) {

// $this->indexID used to be where 	$vals[0][$x] is. I don't think it's used.					

							$name=	"mx_".$this->formID."_".$i."_".$this->filter."_".($x<count($vals[0])?$x:"x");
							$str.=$functionName($listsources[$i],$name,$vals[$i][$x],$defaults[$i],$widths[$i],$rows[$i],'','','','','',$vals[0][$x],$nulls[$i]);	
						}
//					}else{
//						$str.=" module '".$types[$i].".php' missingg ";
//					}
					$str.=(!eregi("hidden",$types[$i]))?"</td\n>":"";
				}

				for ($i=0;$i<count($this->btns) ;$i++) {
					switch ($this->btns[$i]){
						case "delete":
							if ($x<count($vals[0])) {
								$str.="<td><input type=\"image\" SRC=\"images/admin/delete.gif\" name=\"del_".$this->formID."_".$i."_".$this->filter."_".$x."\" alt=\"delete this line\" onclick=\"delete".$this->formID.".value='y';\"></td>\n";
							}
						break;
					}
				}		

				$str.="</tr\n\n>";
			}
			

			
			$numCols=count($vals) + (in_array("delete",$this->btns)?1:0);
			$str.="<tr><td colspan=\"".$numCols."\">";

			// buttons.
			//----------------------------------------------------------------------------------			
			for ($i=0;$i<count($this->btns) ;$i++) {
				if ($this->btns[$i]!='delete' and $this->btns[$i]) {
					$str.="&nbsp;<input type=\"image\" SRC=\"images/admin/".str_replace(" ","_",$this->btns[$i]).".gif\" name=\"".str_replace(" ","_",$this->btns[$i]).$this->formID."\" alt=\"\">";
				}
			}
			
			$str.="</td></tr>\n";
		
			if (in_array("delete",$this->btns)) {
				$str.="<input type=\"hidden\" name=\"delete".$this->formID."\">\n";
			}
			if ($this->filterField) {
				$str.="<input type=\"hidden\" nam