/*********************************************************************************************
 * Copyright 2005 - Volian Enterprises, Inc. All rights reserved.
 * Volian Enterprises - Proprietary Information - DO NOT COPY OR DISTRIBUTE
 * ------------------------------------------------------------------------------
 * $Workfile: ROFST.cs $     $Revision: 13 $
 * $Author: Kathy $   $Date: 8/31/05 11:32a $
 *
 * $History: ROFST.cs $
 * 
 * *****************  Version 13  *****************
 * User: Kathy        Date: 8/31/05    Time: 11:32a
 * Updated in $/LibSource/ROFST
 * B2005-032: new groups crashed when writing to ro.fst during approve
 * sel.
 * 
 * *****************  Version 12  *****************
 * User: Kathy        Date: 8/16/05    Time: 2:52p
 * Updated in $/LibSource/ROFST
 * B2005-030: crash when writing ro.fst for new ro
 * 
 * *****************  Version 11  *****************
 * User: Kathy        Date: 6/21/05    Time: 1:36p
 * Updated in $/LibSource/ROFST
 * FindModROs for approve selected, crash on xyplot with missing end ">"
 * 
 * *****************  Version 10  *****************
 * User: Jsj          Date: 6/02/05    Time: 11:31a
 * Updated in $/LibSource/ROFST
 * fix for approving with conditional ROs
 * 
 * *****************  Version 9  *****************
 * User: Jsj          Date: 5/20/05    Time: 9:21a
 * Updated in $/LibSource/ROFST
 * fixed getro for cases when using unit specific info to process the RO
 * return value.
 * 
 * *****************  Version 8  *****************
 * User: Jsj          Date: 5/17/05    Time: 11:48a
 * Updated in $/LibSource/ROFST
 * fixed approve graphic bug, added default graphic extension as part of
 * ROFST class initialization, code cleanup
 * 
 * *****************  Version 7  *****************
 * User: Kathy        Date: 5/11/05    Time: 9:26a
 * Updated in $/LibSource/ROFST
 * add close method
 * 
 * *****************  Version 6  *****************
 * User: Jsj          Date: 4/07/05    Time: 11:15a
 * Updated in $/LibSource/ROFST
 * fixes
 * 
 * *****************  Version 5  *****************
 * User: Jsj          Date: 3/31/05    Time: 9:16a
 * Updated in $/LibSource/ROFST
 * 
 * *****************  Version 4  *****************
 * User: Jsj          Date: 3/28/05    Time: 12:18p
 * Updated in $/LibSource/ROFST
 * 
 * *****************  Version 3  *****************
 * User: Jsj          Date: 3/22/05    Time: 9:52a
 * Updated in $/LibSource/ROFST
 * March 22 2005 update for merge
 * 
 * *****************  Version 2  *****************
 * User: Jsj          Date: 3/14/05    Time: 1:36p
 * Updated in $/LibSource/ROFST
 * update
 * 
 * *****************  Version 1  *****************
 * User: Jsj          Date: 3/10/05    Time: 3:53p
 * Created in $/LibSource/ROFST
 * 
 * *****************  Version 1  *****************
 * User: Jsj          Date: 3/10/05    Time: 3:49p
 * Created in $/LibSource/ROFST/ROFST
 * 
  *********************************************************************************************/
using System;
using System.IO;
using System.Windows.Forms;
using System.Text;
using System.Collections;
using VlnStatus;
using Utils;

/*
 * This namespace is used in both VE-PROMS and the RO Editor programs.
 */
namespace ROFST_FILE
{
	/*
	 * Globally used functions amoung a few of the classes in this namespace
	 */
	public class ROProcessTools
	{
		// For now, have hooks to set and get the current
		// procedure number along with the Maxium Procedure
		// Number length.  The 16-bit code used globals
		// jsj - 6/2/2005

		private static string PNumber = " "; // default to blank
		private static int mxPrcLen = 30; // default to 30 chars

		static ROProcessTools()
		{
		}
		
		public static string ProcedureNumber
		{
			set { PNumber = value.ToString();}
			get { return PNumber; }
		}

		public static int MaxProcNumLen
		{
			set { mxPrcLen = (int)value;}
			get { return mxPrcLen;}
		}
	
		public static string UnitSpecific(string str, int len, int trm, int maxPrcNumLen)
		{
			// This routine retrieves the procedure number format from the
			// current directory and uses it to adjust the procedure number
			// in the specified string
			string retvalu="";
			string asis="#";
			string pnum;
			if( str == null || str.Length == 0 ) return null;
			/*
			 * Bug fix: B2005-017 3/2/2005
			 * Need to use the largest procedure number length that's in the
			 * SET.DFF file.  "LargestNumber" is the largest length after the
			 * procedure number is replaced via the SET.INI file "replace" list.
			 *
				if(len==0)len=LargestNumber;
			 */
			if(len==0)len=maxPrcNumLen; //LargestRawSetNumber
			string mstr;
			PrivateProfile proc_ini = new PrivateProfile("proc.ini");
			mstr = proc_ini.Attr("unit", "procedure number");
			if (mstr == null) mstr = asis;
			pnum=mstr;
			if(pnum.Equals(asis))
			{
				retvalu=str;
			} 
			else if (!pnum.Equals("") && pnum[0] == '!') 
			{
				if (File.Exists("set.ini"))
				{
					string p = str;
					string q, tonum;
					StringBuilder rbldr = new StringBuilder();
					int newl, dw, cnt=0, lstr;

					p = p.TrimStart(" ".ToCharArray());
					lstr = p.Length;
					if (len > lstr) len = lstr;
					mstr = p.Substring(0,len);
					mstr = mstr.TrimEnd(" \t\r\n".ToCharArray());
					/* debug
					string debugstr = "|" + mstr + "|";
					*/
		
					PrivateProfile set_ini = new PrivateProfile("set.ini");

					tonum = set_ini.Attr("replace", mstr);
					if (tonum == null || tonum.Equals("")) tonum = mstr;
					newl = tonum.Length;
					dw = newl - (lstr);

					q = str; p = tonum;
					int strptr=0;
					for (strptr=0; str[strptr] == ' '; strptr++)
						rbldr.Append(" ");//initial spaces
					int pptr=0;
					while (cnt < len) 
					{
						if (tonum!=null && pptr < tonum.Length) 
							rbldr.Append(tonum[pptr++]);
						else if (trm == 1) break;
						else if (cnt < lstr) rbldr.Append(" ");
						else break;
						cnt++;
					}
					if (trm==0) 
					{
						strptr+=len;
						while (str!=null && strptr < str.Length) 
							rbldr.Append(str[strptr++]);
					}
					retvalu = rbldr.ToString();
				}
				else
				{
					retvalu=str;
				}
			} 
			else 
			{
				StringBuilder rbldr = new StringBuilder();
				// create pointers to use to transfer info
				int pnumPtr = 0, strPtr=0, endStrPtr = str.Length-1;
				string pad = "";
				// determine if the procedure number should be padded instead
				if(str[0]==' ')pad=" ";
				// copy from the procedure number definition to the pound symbol
				if (!pnum.Equals(""))
				{
					while(pnumPtr < pnum.Length && pnum[pnumPtr] != '#')
					{
						rbldr.Append(((!pad.Equals(""))? pad : pnum[pnumPtr].ToString()));
						pnumPtr++;
					}
					// skip the pound sign
					if(pnumPtr < pnum.Length && pnum[pnumPtr]!=0)pnumPtr++;
				}
				// assuming that the procedure number occurs at the beginning of
				// str, check to see where it ends
				if(str.Length > len)endStrPtr=len-1;
				// find the end of the procedure number
				while(endStrPtr > strPtr && str[endStrPtr]==' ')endStrPtr--;
				// copy the procedure number
				while(strPtr <= endStrPtr)rbldr.Append(str[strPtr++]);
				// copy the rest of the format
				while(pnumPtr < pnum.Length)
				{
					rbldr.Append(((!pad.Equals(""))? pad : pnum[pnumPtr].ToString()));
					pnumPtr++;
				}
				// copy the rest of the given string
				while(strPtr < str.Length)rbldr.Append(str[strPtr++]);
				retvalu = rbldr.ToString();
			}
			return retvalu;
		}

		public static int matchingBrace(string str)
		{
			int strptr = 0;
			int  level=1;
			while(level > 0)
			{
				strptr++;
				switch(str[strptr])
				{
					case '{':
						level++;
						break;
					case '}':
						level--;
						break;
				}
			}
			return strptr;
		}

		public static int nextDelimiter(string delim,string str,int l)
		{
			int nxtdelim = -1;
			int strptr = 0;
			while(l-- > 0 && (nxtdelim == -1))
			{
				if (delim.IndexOf(str[strptr])>-1)
					nxtdelim = strptr;
				strptr++;
			}
			return nxtdelim;
		}

		public static string getProfile(string grp, string nam)
		{
			return getProfile(grp,nam,0);
		}

		public static string getProfile(string grp, string nam, int flag)
		{
			string buff=null;
			if( grp==null ) return null;
			PrivateProfile proc_ini = new PrivateProfile("proc.ini");
			buff = proc_ini.Attr(grp,nam);
			if (buff == null)
				buff = "";
			if(buff.Equals(""))
			{
				if (flag == 0)
					buff = "<" + grp + "-" + nam + ">";
				else
					return null;
			}
			return buff;
		}

		public static string evaluate(string str,int len)
		{
			string retval=null;
			string swhir = "PSU"; /* order inwhich to check */
			string pn;
			if(str[1]=='-')
			{
				int swptr = swhir.IndexOf((str.ToUpper())[0]);
				byte swchar = 0;
				if( swptr > -1 ) swchar = (byte)swhir[swptr];

				byte sav=(byte)str[len];
				str = str.Substring(0,len);
				while ((swptr > -1) && (swhir[swptr] != 0) && retval == null)
				{
					if (swchar == 0) swchar = (byte)str[0];
					switch((char)swchar)
					{
						case 'U':
							retval=getProfile("Unit",str.Substring(2),swhir[swptr]);
							break;
						case 'S':
							retval=getProfile("Procedure Set",str.Substring(2),swhir[swptr]);
							break;
						case 'P':
							pn = UnitSpecific(PNumber, 0, 1, mxPrcLen);
							retval=getProfile(pn,str.Substring(2),swhir[swptr]);
							break;
					}
					if (retval == null)
						swchar= (byte)swhir[++swptr];
				}
				StringBuilder sb1 = new StringBuilder(str);
				sb1.Insert(len,sav);
				str = sb1.ToString();
			} 
			else if(len==1 && (str.ToUpper())[0]=='U') 
			{
				retval=getProfile("Unit","Number");
			} 
			else if(len==2 && str.ToUpper().StartsWith("ID")) 
			{
				retval=getProfile("Unit","ID");
			}
			if(retval == null)
			{
				retval=str.Substring(0,len+2>str.Length?str.Length:len+2);
			}
			return retval;
		}

	}


	/// <summary>
	/// Summary description for ROFSTHeader.
	/// </summary>

	public class FST_FileHeader
	{
		public int hSize; // size of header structure (record)
		public short hYear;// year this header was designed (1993)
		public byte hMonth;// month this header was designed (10)
		public byte hDay;// day this header was designed (25)
		public short hcYear;// FST file creation year
		public byte hcMonth;// FST file creation month
		public byte hcDay;// FST file creation day
		public byte hcHour;// FST file creation hour
		public byte hcMin;// FST file creation minute
		public byte hcSec;// FST file creation seconds
		public byte hcHund;// FST file creation hundredth seconds
		public uint dboffset;// end of RO data, start of database list


		// Constructors
		// default constructor creates with zero'd out values
		public FST_FileHeader()
		{
			hSize = 0;
			hYear = 0;
			hMonth =  0;
			hDay = 0;
			hcYear = 0;
			hcMonth = 0;
			hcDay = 0;
			hcHour = 0;
			hcMin = 0;
			hcSec = 0;
			hcHund = 0;
			dboffset = 0;
		}


		// Constructor that initializes with pass in values
		FST_FileHeader(int Size, short Year, byte Month, byte Day, short cYear, byte cMonth,
			byte cDay, byte cHour, byte cMin, byte cSec, byte cHund, uint offset)
		{
			hSize = Size;
			hYear = Year;
			hMonth =  Month;
			hDay = Day;
			hcYear = cYear;
			hcMonth = cMonth;
			hcDay = cDay;
			hcHour = cHour;
			hcMin = cMin;
			hcSec = cSec;
			hcHund = cHund;
			dboffset = offset;
		}


		public void Read (BinaryReader br)
		{
			hSize = br.ReadInt32();
			hYear = br.ReadInt16();
			hMonth = br.ReadByte();
			hDay = br.ReadByte();
			hcYear = br.ReadInt16();
			hcMonth = br.ReadByte();
			hcDay = br.ReadByte();
			hcHour = br.ReadByte();
			hcMin = br.ReadByte();
			hcSec = br.ReadByte();
//			byte tbyte = br.ReadByte();
//			hcHund = (sbyte)tbyte;
			hcHund = br.ReadByte();
			dboffset = br.ReadUInt32();

			//			return new FST_FileHeader(fSize,fYear,fMonth,fDay,
			//				fcYear,fcMonth,fcDay,fcHour,fcMin,fcSec,fcHund,fdboffset);
		}


		public void Write (BinaryWriter bw)
		{
			bw.Write(hSize);
			bw.Write(hYear);
			bw.Write(hMonth);
			bw.Write(hDay);
			bw.Write(hcYear);
			bw.Write(hcMonth);
			bw.Write(hcDay);
			bw.Write(hcHour);
			bw.Write(hcMin);
			bw.Write(hcSec);
			bw.Write(hcHund);
			bw.Write(dboffset);
		}


		public int GetStructSize()
		{
			int rtval = 0;

			// You can only use sizeof() in unsafe compiles
			// so we'll do it by hand...
			// each number is the number of bytes

			rtval += 4; //sizeof(hSize);
			rtval += 2; //sizeof(hYear);
			rtval += 1; //sizeof(hMonth);
			rtval += 1; //sizeof(hDay);
			rtval += 2; //sizeof(hcYear);
			rtval += 1; //sizeof(hcMonth);
			rtval += 1; //sizeof(hcDay);
			rtval += 1; //sizeof(hcHour);
			rtval += 1; //sizeof(hcMin);
			rtval += 1; //sizeof(hcSec);
			rtval += 1; //sizeof(hcHund);
			rtval += 4; //sizeof(dboffset);

			return rtval;
		}


		public void SetHeader(uint offset)
		{
			hSize = GetStructSize();
			hYear = 1993;
			hMonth = 10;
			hDay = 25;
			DateTime dt = DateTime.Now;
			hcYear = (short)dt.Year;
			hcMonth = (byte)dt.Month;
			hcDay = (byte)dt.Day;
			hcHour = (byte)dt.Hour;
			hcMin = (byte)dt.Minute;
			hcSec = (byte)dt.Second;
			hcHund = (byte)dt.Millisecond;
			dboffset = offset;
		}
	}


	public class ROFST_DbInfo
	{
		public ushort dbiID; // Number part of table name (RO000002 => 02)
		public ushort dbiType; // database type (Setpoint,Graphics,User defined)
		public ushort dbiAW; // length of widest AccPageID
		public uint dbiGL; // FST file position of this group
		public uint dbiIL; // FST file position of list of ROIDs
		public uint dbiAL; // FST file position of list of AccPageIDs
		public uint dbiEND; // FST file position of the end of this group
		// !!! make sure to convert strings to char arrays when writing
		public string dbiTitle; // database title
		public string dbiAP;  // AccPageID Prefix (ex. SP- )


		// Constructors
		// default constructor creates with zero'd out values
		public ROFST_DbInfo()
		{
			dbiID = 0;
			dbiType = 0;
			dbiAW = 0;
			dbiGL = 0;
			dbiIL = 0;
			dbiAL = 0;
			dbiEND = 0;
			dbiTitle = ""; 
			dbiAP = "";
		}


		// Constructor that initializes with pass in values
		ROFST_DbInfo(ushort ID, ushort Type, ushort AW, uint GL, uint IL, uint AL,	uint END, 
			string Title, string dbiAP)
		{
			dbiID = ID;
			dbiType = Type;
			dbiAW = AW;
			dbiGL = GL;
			dbiIL = IL;
			dbiAL = AL;
			dbiEND = END;
			dbiTitle = Title; 
			dbiAP = dbiAP;
		}


		public void WriteUntAndShort(BinaryWriter bw)
		{
			bw.Write(dbiID);
			bw.Write(dbiType);
			bw.Write(dbiAW);
			bw.Write(dbiGL);
			bw.Write(dbiIL);
			bw.Write(dbiAL);
			bw.Write(dbiEND);
		}


		void WriteString(BinaryWriter bw, string str)
		{
			byte nullbyte = 0;
			byte []wrBytes = new byte[str.Length + 1];
			int i;
			for(i =0; i < str.Length; i++)
			{
//				byte WrByte;
//				WrByte = (byte)str[i];
//				bw.Write(WrByte);
				wrBytes[i] = (byte)str[i];
			}
			wrBytes[i] = nullbyte;
			bw.Write(wrBytes);
//			bw.Write(nullbyte);
		}


		public void WriteStrings(BinaryWriter bw)
		{
			WriteString(bw,dbiTitle);
			WriteString(bw,dbiAP);
		}


		public uint GetStructSize()
		{
			uint rtval = 0;

			// You can only use sizeof() in unsafe compiles
			// so we'll do it by hand...
			// each number is the number of bytes

			rtval += 2; //sizeof(dbiID);
			rtval += 2; //sizeof(dbiType);
			rtval += 2; //sizeof(dbiAW);
			rtval += 4; //sizeof(dbiGL);
			rtval += 4; //sizeof(dbiIL);
			rtval += 4; //sizeof(dbiAL);
			rtval += 4; //sizeof(dbiEND);
			rtval += 4; //sizeof(uint); // to simulate the (char *) in the old code (16 datatypes)
			rtval += 4; //sizeof(uint); // to simulate the (char *) in the old code (16 datatypes)

			return rtval;
		}


		public void Load(BinaryReader br)
		{
			ReadValues(br);
		}

		//		public void ReadStrings(BinaryReader br)
		//		{
		//			dbiTitle = ROFST_File.LoadString(br);
		//			dbiAP = ROFST_File.LoadString(br);
		//		}


		public void ReadValues(BinaryReader br)
		{
			dbiID = br.ReadUInt16();
			dbiType = br.ReadUInt16();
			dbiAW = br.ReadUInt16();
			dbiGL = br.ReadUInt32();
			dbiIL = br.ReadUInt32();
			dbiAL = br.ReadUInt32();
			dbiEND = br.ReadUInt32();
			uint tmp = br.ReadUInt32();
			uint tmp1 = br.ReadUInt32();
		}
	}



	// structure to hold information to add a new group
	public struct AddGroup
	{
		public uint grp_id;
		public uint grp_parid;
		public string grp_name;
		public short grp_type;
		public short grp_stat;
		public uint grp_offset;
		public int grp_pargrpidx;


		// These functions are needed to update values when
		// referenced from the ArrayLists (allNewGrps)
//		public void OR_grp_type(short val)
//		{
//			ushort gtype = (ushort)grp_type;
//			gtype |= (ushort)val;
//			grp_type = (short)gtype;
//		}
//
//
//		public void SET_grp_parid(uint val)
//		{
//			grp_parid = val;
//		}
//	
//	
//		public void SET_grp_pargrpidx(int val)
//		{
//			grp_pargrpidx = val;
//		}
//
//
//		public void SET_grp_stat(short val)
//		{
//			grp_stat = val;
//		}
//
//
//		public void SET_grp_offset(uint val)
//		{
//			grp_offset = val;
//		}
	}


	// structure to hold information to add a new RO
	public struct AddRO
	{
		public uint ro_id;
		public uint ro_parid;
		public string ro_num;
		public string ro_desc;
		public string ro_val;
		public short ro_type;
		public short ro_stat;
		public int ro_offset;
		public int ro_pargrpidx; // index into allNewGrps


		// These functions are needed to update values when
		// referenced from the ArrayLists (allNewRos)
//		public void SET_ro_pargrpidx(int val)
//		{
//			ro_pargrpidx = val;
//		}
//	
//	
//		public void SET_ro_parid(uint val)
//		{
//			ro_parid = val;
//		}
//
//
//		public void SET_ro_stat(short val)
//		{
//			ro_stat = val;
//		}
//
//
//		public void SET_ro_offset(int val)
//		{
//			ro_offset = val;
//		}
	}


	// structure to hold RO difference information
	public struct DiffRO
	{
		public uint id;
		public short type;
		public string desc;
		public string val;
		public uint oldoff; // index into old RO.FST file (approved)
	}


	// RO update info arrays.
	// one of these structures is created from each RO database
	// (Setpoints, Graphics, User Defined, etc.)
	public struct dbinew
	{
		public ArrayList aryAddedRO;
		public ArrayList aryAddedGroup;
		public ArrayList aryAddedDiff;
	}


	// structure to store file positions in the RO.FST file
	public struct locinc
	{
		public uint maxloc;
		public int inc;
	}


	/*
	** Structure of the graphics' values.
	** LocalGrfStats ( in ROFST_File class) is used to hold the current 
	** values "locally" in memory 
	*/
	public struct GrfStats 
	{
		public string PixFileName;
		public int PixFileTime;
		public short PixFileHeight;
		public short PixFileWidth;

		public void Clear()
		{
			PixFileName="";
			PixFileTime = 0;
			PixFileHeight = 0;
			PixFileWidth = 0;
		}

		public void Load(string instr)
		{
			short DeciPerRow = 120;
			short DeciPerCol = 60;
			StringBuilder sb = new StringBuilder();
			int i=0;
			bool nl = false;
			/*
			sscanf(retval,"%s\n%08lx\n%04x\n%04x",LocalGrfStats.PixFileName,
				&LocalGrfStats.PixFileTime,&LocalGrfStats.PixFileHeight,
				&LocalGrfStats.PixFileWidth);
			LocalGrfStats.PixFileHeight *= DeciPerRow;
			LocalGrfStats.PixFileWidth *= DeciPerCol;
			*/
			while (!nl && (instr[i]!= 0))
			{
				if (instr[i]=='\n')
					nl=true;
				else
					sb.Append(instr[i]);
				i++;
			}
			if (nl)
			{
				PixFileName = sb.ToString();
			}

			nl = false;
			sb.Remove(0,sb.Length);
			while (!nl && (instr[i]!=0))
			{
				if (instr[i]=='\n')
					nl=true;
				else
					sb.Append(instr[i]);
				i++;
			}
			PixFileTime = Convert.ToInt32(sb.ToString(),16);

			nl = false;
			sb.Remove(0,sb.Length);
			while (!nl && (instr[i]!=0))
			{
				if (instr[i]=='\n')
					nl=true;
				else
					sb.Append(instr[i]);
				i++;
			}
			PixFileHeight = Convert.ToInt16(sb.ToString(),16);
			PixFileHeight *= DeciPerRow;

			sb.Remove(0,sb.Length);
			while ((i < instr.Length) && (instr[i]!=0))
			{
				sb.Append(instr[i]);
				i++;
			}
			PixFileWidth = Convert.ToInt16(sb.ToString(),16);
			PixFileWidth *= DeciPerCol;
		}
	}


	public class ROFST_File
	{
		public enum ROTypes
		{
			None=0, Text=1, Table=2, Plot=4, Figure=8
		};

		private string [] UnitVariables =
			{
				"All of the following",//
				"Number",		// 1L; - 1, 2 etc.
				"Other Number",	// 2L; - 2, 1 etc.
				"Text",			// 3L; - One, Two etc. or Unit One, Unit Two
				"Other Text",	// 4L; - Two, One etc. or Unit Two, Unit One
				"ID",			// 5L; - 1Bw, 2Bw etc.
				"Other ID",		// 6L; - 2Bw, 1Bw etc.
				"Name",			// 7L; - Braidwood Unit 1
				"Other Name"	// 8L; - Braidwood Unit 2
			};
		private uint NumUnitVariables =9;


		private ArrayList [] allNewRos; // new ROs
		private ArrayList [] allDifferences; // changed ROs
		private ArrayList [] allNewGrps; // new Groups
		private ArrayList allLocations; // positions in RO.FST


		private int curTblIdx=0; // index into allxxxxx arraylists
		private uint NewID = 0xFFFF0000;
		private uint whereisgl = 0;
		private ushort maxaw=0;
		private ushort maxtype=0;
		private int lastLocationIdx = 0;

		public BinaryReader brROFst; // file handle into RO.FST
		public ArrayList DatabasesInfo; // Holds the current RO.FST data
		public ArrayList dbiNewInfo; // will hold new RO.FST data

		public short numDatabases; // number of databases in RO.FST
		public FST_FileHeader Header;
		//		public UserRunTime usrRunTime;
		public string DirPath;

		public string DefaultGraphicFileExt = "";

		// RO Graphics information
		GrfStats LocalGrfStats;

		// constructor loads ro.fst databases
		//		public ROFST(string path, UserRunTime urt)
		public ROFST_File(string path)
		{
			try
			{
				brROFst = new BinaryReader(File.Open(path,System.IO.FileMode.Open,System.IO.FileAccess.ReadWrite,FileShare.ReadWrite));
			}
			catch (Exception e)
			{
				MessageBox.Show("Open "+path+"\n\n" + e.Message,"RO.FST Error");
				return;
			}
			DirPath = path; // path of RO.FST file

			//			usrRunTime = urt;

			// Read the RO.FST header information
			Header = new FST_FileHeader();
			Header.Read(brROFst);
			brROFst.BaseStream.Seek(Header.dboffset,SeekOrigin.Begin);
			uint howbig = brROFst.ReadUInt32();
			short howmany = brROFst.ReadInt16();

			numDatabases = howmany;
			//			dbcount = numDatabases;
			DatabasesInfo = new ArrayList();
			dbiNewInfo = new ArrayList();

			// Load the database into the arrays
			for (int i=0;i<numDatabases;i++)
			{
				dbinew dbinewItem;
				ROFST_DbInfo tmpDBinfo;
				tmpDBinfo = new ROFST_DbInfo();
				tmpDBinfo.Load(brROFst);
				DatabasesInfo.Add(tmpDBinfo);
				dbinewItem = new dbinew();
				dbiNewInfo.Add(dbinewItem);
			}
			for (int i=0;i<numDatabases;i++)
			{
				// load the titles and accessory page ids
				//				((ROFST_DbInfo)DatabasesInfo[i]).ReadStrings(brROFst);
				((ROFST_DbInfo)DatabasesInfo[i]).dbiTitle = GetAsciiString(brROFst);
				((ROFST_DbInfo)DatabasesInfo[i]).dbiAP = GetAsciiString(brROFst);
			}
			// get the default graphic file extension
			GetDefaultGraphicFileExtension();
		}


		~ ROFST_File()
		{
			if (brROFst!=null)brROFst.Close();
		}

		public void Close()
		{
			if (brROFst!=null)brROFst.Close();
			brROFst=null;
		}
		
		private void GetDefaultGraphicFileExtension()
		{
			// get the full path to the VEPROMS.INI file
			string ApplicationPath = Application.StartupPath;
			string ApplPathUp = ApplicationPath.ToUpper();
			int idx = ApplPathUp.IndexOf("VE-PROMS.NET\\BIN");
			string PromsINI = ApplicationPath.Substring(0,idx);
			PromsINI += "VE-PROMS\\VEPROMS.INI";

			PrivateProfile extINI = new PrivateProfile(PromsINI);
			string defGrExt=extINI.Attr("Graphics", "defaultext");
			if (defGrExt == null || defGrExt == "") 
			{
				// check the ROAPP.INI in the RO directory 
				string ropath = extINI.Attr("RO Defaults","ROPATH");
				if (ropath == null || ropath == "") ropath = "..\\RO";
				string src = ropath + "\\ROAPP.INI";
				if (File.Exists(src))
				{
					PrivateProfile roappINI = new PrivateProfile(src);
					defGrExt = roappINI.Attr("ROApp","Extention");
				}
				if (defGrExt == null || defGrExt == "")
					defGrExt="TIF";
			}
			DefaultGraphicFileExt = defGrExt;
		}


		// Find the location of an RO value in the RO.FST file
		private uint FindRO(uint id, uint start, uint end)
		{
			uint retval=0;
			uint topid=0,botid=0,recs=0,siz=0;
			siz=8;   // c code:sizeof(topid)*2;
			recs=(end-start)/siz;
			uint guessr,guess=0,guessid=0;
			uint botr=0,topr=recs;
			//getID(end-siz,&topoff);
			brROFst.BaseStream.Seek(end-siz,SeekOrigin.Begin);
			topid=brROFst.ReadUInt32(); 

			if(id==topid)return end-siz; // Last record

			//getID(start,&botoff);
			brROFst.BaseStream.Seek(start,SeekOrigin.Begin);
			botid=brROFst.ReadUInt32();

			if(id==botid)return start; // First record

			if(id < botid || id > topid)return 0; // Beyond range
			while (topr > botr+1)
			{
				guessr=botr+((topr-botr)*(id-botid))/(topid-botid);

				if (guessr==botr) guessr=botr+1;
				else if (guessr==topr) guessr=topr-1;

				guess=start+guessr*siz;
				brROFst.BaseStream.Seek(guess,SeekOrigin.Begin);
				//getID(guess,&retval)
				guessid=brROFst.ReadUInt32();

				if(guessid==id)
				{
					break; // found, break out of while loop
				} 
				else if(guessid < id) 
				{
					botr=guessr;
					botid=guessid;
				} 
				else 
				{
					topr=guessr;
					topid=guessid;
				}
			}
			if(guessid==id)retval=guess;  // Any other record
			return retval;
		}

		private uint _getID(uint off,ref uint nxtoff)
		{
			uint retval = 0;
			if (off > 0)
			{
				brROFst.BaseStream.Seek(off,SeekOrigin.Begin);
				retval = brROFst.ReadUInt32();
				nxtoff = brROFst.ReadUInt32();
			}
			return retval;
		}

		// Find the location of an RO value in the RO.FST file
		private uint toolsFindRO(uint id, uint start, uint end)
		{
			uint retval=0;
			uint topid=0,botid=0,recs=0,siz=0;
			siz=8;   // c code:sizeof(topid)*2;
			recs=(end-start)/siz; //c code: (end-start)>>3
			uint guessr,guess=0,guessid=0;
			uint botr=0,topr=recs;
			uint topoff =0, botoff=0;
			//getID(end-siz,&topoff);
			topid=_getID(end-siz,ref topoff);
			if(id==topid)return topoff; // Last record

			//getID(start,&botoff);
			botid=_getID(start,ref botoff);
			if(id==botid)return botoff; // First record

			if(id < botid || id > topid)return 0; // Beyond range
			while (topr > botr+1)
			{
				guessr=botr+((topr-botr)/2);

				if (guessr==botr) guessr++;
				else if (guessr==topr) guessr--;

				//getID(guess,&retval)
				guessid=_getID(start+guessr*siz,ref retval);

				if(guessid==id)
				{
					break; // found, break out of while loop
				} 
				else if(guessid < id) 
				{
					botr=guessr;
					botid=guessid;
				} 
				else 
				{
					topr=guessr;
					topid=guessid;
				}
			}
			if (guessid == id) return retval;
			return 0;
		}


		// return the type of the given RO
		private ROTypes FindROType(uint rec, uint start, uint end)
		{
			short retval=0;
			byte[] tbyte= new byte[100];
			uint fnd;
			if((fnd=FindRO(rec,start,end))>0)
			{
				uint offset=brROFst.ReadUInt32();
				brROFst.BaseStream.Seek((long)offset,SeekOrigin.Begin);
				uint guessid=brROFst.ReadUInt32();
				uint parid=brROFst.ReadUInt32();
				short count=brROFst.ReadInt16();
				retval=brROFst.ReadInt16(); // RO Type
			}
			return (ROTypes)retval;
		}


		// Get the RO Type from the ROID
		public ROTypes GetROType(string ROID)
		{
			// break up ROID into table and record
			ushort tbl = System.Convert.ToUInt16(ROID.Substring(0,4),16);
			uint rec = System.Convert.ToUInt32(ROID.Substring(4,8),16);
			ushort opt=0;
			if (ROID.Length>12) opt = System.Convert.ToUInt16(ROID.Substring(8,ROID.Length-12),16);
			if (tbl==0xFFFF) 
				return ROTypes.None;    // 0xFFFF is ro from proc.ini file
			int num=0;
			for (int i=0; i < numDatabases && ((ROFST_DbInfo)DatabasesInfo[i]).dbiID!=tbl;i++) num++;
			if (num < numDatabases)
			{
				return FindROType(rec,((ROFST_DbInfo)DatabasesInfo[num]).dbiIL,((ROFST_DbInfo)DatabasesInfo[num]).dbiAL);
			}
			return ROTypes.None;
		}

		
		private string FindROText(uint id, uint start,uint end)
		{
			string retval=null;
			uint fnd;
			if((fnd=FindRO(id,start,end))>0)
			{
				uint offset=brROFst.ReadUInt32();
				brROFst.BaseStream.Seek((long)offset,SeekOrigin.Begin);
				uint guessid=brROFst.ReadUInt32();
				uint parid=brROFst.ReadUInt32();
				short count=brROFst.ReadInt16();
				ushort typ=brROFst.ReadUInt16();
				if (count<0)retval=GetAsciiString(brROFst);
			}
			return retval;
		}


		// return the RO defined in the PROC.INI file
		// (master / slave logic)
		private string roUnitValue(uint rec)
		{
			string buff="";
			PrivateProfile proc_ini = new PrivateProfile("proc.ini");
			for(int i=0; i < NumUnitVariables; i++)
			{
				if((i+1) == rec)
				{
					buff = proc_ini.Attr("Unit",UnitVariables[i+1]);
					if (buff == null || buff.Equals(""))
						buff = "{"+ UnitVariables[i+1] + "}";
					break; // break out of for loop
				}
			}
			return buff;
		}


		//
		// this function will take the ro text value and see if
		// a macro has been used.  If so it will perform the macro
		// operation on the substring in the text value
		//
		// right now the only macro is @HSP(), where every space between
		// the "(" and ")" will be replaced with a hardspace
		//
		public string processMacros(string rostring)
		{
			StringBuilder bldstr = new StringBuilder();
			int cptr = -1;
			int stptr = 0;
			if( rostring == null ) return rostring;
			while( (cptr = rostring.IndexOf("@HSP(",stptr)) != -1 ) 
			{
				bldstr.Append(rostring.Substring(0,cptr-stptr));
				int cptr2 = rostring.IndexOf(")",cptr);
				if (cptr2 != -1)
				{
					int numspaces = cptr2 - cptr - 5;
					for (int i=0; i< numspaces; i++)
						bldstr.Append("\xFF");
					stptr = cptr2 + 1;
				}
				else
				{
					bldstr.Append(rostring.Substring(cptr,5));
					stptr += 5;
				}
			}
			if (stptr < rostring.Length)
				bldstr.Append(rostring.Substring(stptr));
			return bldstr.ToString();
		}



		private string processROString(string rostr, short menuitem)
		{
			string newstr="";
			strList2 strlst2 = new strList2(rostr);
			strList strlst = new strList(strlst2.toText());
			newstr = strlst.toText((int)menuitem);
			
			newstr = newstr.Replace("\\n","\n");
			newstr = processMacros(newstr);
			return newstr;
		}


		public string GetRO(string ROID)
		{
			return _GetRO(ROID,1);
		}

		public string GetEntireRO(string ROID)
		{
			return _GetRO(ROID,0);
		}

		public string GetRO(string ROID, string ProcNum)
		{
			ROProcessTools.ProcedureNumber = ProcNum;
			return GetRO(ROID);
		}

		public string GetEntireRO(string ROID, string ProcNum)
		{
			ROProcessTools.ProcedureNumber = ProcNum;
			return GetEntireRO(ROID);
		}

		// Get the RO value from the ROID
		private string _GetRO(string ROID_in, short procopt)
		{
			string ROID = ROID_in;
			if (ROID.Length == 12)
				ROID = ROID + "0000";
			ushort tbl = System.Convert.ToUInt16(ROID.Substring(0,4),16);
			uint rec = System.Convert.ToUInt32(ROID.Substring(4,8),16);
			ushort opt=0;
			// clear graphics info
			LocalGrfStats.Clear();
			opt = System.Convert.ToUInt16(ROID.Substring(12,ROID.Length-12),16);

			if (tbl==0xFFFF)
				return roUnitValue(rec); // RO in PROC.INI file

			int num=0;
			for(int i=0; i < numDatabases && ((ROFST_DbInfo)DatabasesInfo[i]).dbiID!=tbl;i++) num++;

			string retval = null;
			if(num < numDatabases)
			{
				retval=FindROText(rec,((ROFST_DbInfo)DatabasesInfo[num]).dbiIL,((ROFST_DbInfo)DatabasesInfo[num]).dbiAL);
			}
			if ((retval!=null&&retval!="") && (GetROType(ROID)==ROTypes.Figure))
			{
				// load graphic stats
				StringBuilder sbtmp = new StringBuilder();
				LocalGrfStats.Load(retval);
				sbtmp.Append(LocalGrfStats.PixFileName);
				sbtmp.Append("\n");
				sbtmp.Append(LocalGrfStats.PixFileTime.ToString("x8"));
				sbtmp.Append("\n");
				sbtmp.Append(LocalGrfStats.PixFileHeight.ToString("x4"));
				sbtmp.Append("\n");
				sbtmp.Append(LocalGrfStats.PixFileWidth.ToString("x4"));
				retval = sbtmp.ToString();
				
			}
			if(retval!=null && retval.Length>0 && !(GetROType(ROID)==ROTypes.Figure))
			{
				retval = retval.Replace("\r","");
				if (procopt!=0) 
				{
					string newstr = processROString(retval,(short)opt);
					if (newstr!=null && !newstr.Equals(""))
						retval = newstr;
				}
			}
			return retval;
		}


		// Get the RO's parent ID
		private uint GetParent(uint rec, uint start,uint end,ref uint offset)
		{
			uint parid=0;
			uint fnd;
			if((fnd=FindRO(rec,start,end))>0)
			{
				offset=brROFst.ReadUInt32();
				brROFst.BaseStream.Seek((long)offset,SeekOrigin.Begin);
				uint guessid=brROFst.ReadUInt32();
				parid=brROFst.ReadUInt32();
			}
			return parid;
		}
 

		// Get the RO's parent ID from the ROID
		public uint GetROParent(string ROID)
		{
			ushort tbl = Convert.ToUInt16(ROID.Substring(0,4),16);
			uint  rec = Convert.ToUInt32(ROID.Substring(4,8),16);
			uint retval=0;
			int indx=0;
			for(int i=0; i < numDatabases && ((ROFST_DbInfo)DatabasesInfo[i]).dbiID!=tbl; i++) indx++; // position to the RO database

			if(indx < numDatabases)
			{
				uint offset=0;
				retval=GetParent(rec,((ROFST_DbInfo)DatabasesInfo[indx]).dbiIL,((ROFST_DbInfo)DatabasesInfo[indx]).dbiAL,ref offset);
			}
			return retval;
		}


		// Get the group title
		private string GetDescription(ushort tbl, uint rec)
		{
			string retval=null;
			if(tbl==0xFFFF)
			{
				if(rec == 0)
				{
					retval="Unit Information";
				} 
				
				else if (rec <= NumUnitVariables)
				{
					int irec = (int)rec;
					retval=UnitVariables[irec];
				}				
			} 
			else 
			{
				int indx=0;
				for(int i=0; i < numDatabases && ((ROFST_DbInfo)DatabasesInfo[i]).dbiID!=tbl; i++) indx++;

				if(indx < numDatabases)
				{
					uint id;
					brROFst.BaseStream.Seek(((ROFST_DbInfo)DatabasesInfo[indx]).dbiGL,SeekOrigin.Begin);
					id = brROFst.ReadUInt32();

					if((rec==0) || rec==id)
					{
						retval=((ROFST_DbInfo)DatabasesInfo[indx]).dbiTitle;
					} 
					else 
					{
						uint offset=0;
						uint parid = this.GetParent(rec,((ROFST_DbInfo)DatabasesInfo[indx]).dbiIL,((ROFST_DbInfo)DatabasesInfo[indx]).dbiAL,ref offset);
						if(parid!=0)
						{
							uint t1 = FindRO(parid,((ROFST_DbInfo)DatabasesInfo[indx]).dbiIL,((ROFST_DbInfo)DatabasesInfo[indx]).dbiAL);
							t1 = brROFst.ReadUInt32();
							uint guessid;
							brROFst.BaseStream.Seek(t1,SeekOrigin.Begin);
							guessid = brROFst.ReadUInt32();
							parid = brROFst.ReadUInt32();
							short count;
							count = brROFst.ReadInt16();
							for(int i=0; i < count && retval == null; i++)
							{
								uint off;
								off=brROFst.ReadUInt32();
								ushort typ;
								typ=brROFst.ReadUInt16();
								if(off==offset)
								{
									retval = GetAsciiString(brROFst);
								} 
								else 
								{
									SkipString(brROFst);
								}
							}
						}
					}
				}
			}
			return retval;
		}


		// Get the group title by ROID
		public string GetRODescription(string ROID)
		{
			ushort tbl = Convert.ToUInt16(ROID.Substring(0,4),16);
			uint rec = Convert.ToUInt32(ROID.Substring(4,8),16);
			return (GetDescription(tbl,rec));
		}

		
		// get the Accessory Page ID
		string FindROAccID(uint id, uint start, uint end)
		{
			// Returns allocated space
			string retval=null;
			if(FindRO(id,start,end)!=0)
			{
				uint offset = brROFst.ReadUInt32();
				brROFst.BaseStream.Seek(offset,SeekOrigin.Begin);
				uint guessid = brROFst.ReadUInt32();
				uint parid = brROFst.ReadUInt32();
				short count = brROFst.ReadInt16();
				ushort ltyp = brROFst.ReadUInt16();
				SkipString(brROFst);
				retval = GetAsciiString(brROFst);
			}
			return retval;
		}


		private string roUnitAccID(uint rec)
		{
			string rotbuf="";
			for(int i=0; i < NumUnitVariables; i++)
			{
				if((i+1L)==rec)
				{
					rotbuf = "U-"+UnitVariables[i+1];
					break; // break out of for loop
				}
			}
			return rotbuf;
		}


		// Get accessory page ID via the table and record
		// also include unit specs from ini file
		private string GetAccID(ushort tbl, uint rec)
		{
			string retval=null;

			if (tbl==0xFFFF)
			{
				return roUnitAccID(rec); // PROC.INI ro
			}
			int indx=0;
			for(int i=0; i < numDatabases && ((ROFST_DbInfo)DatabasesInfo[i]).dbiID!=tbl; i++)indx++;

			if(indx < numDatabases)
			{
				retval=FindROAccID(rec,((ROFST_DbInfo)DatabasesInfo[indx]).dbiIL,((ROFST_DbInfo)DatabasesInfo[indx]).dbiAL);
				if (retval ==  null)
					retval="";	// RO not found, has ? in procedures
				else
					retval = ((ROFST_DbInfo)DatabasesInfo[indx]).dbiAP + "-" + retval;
			}
			return retval;
		}


		// Get the accessory page ID from the ROID
		// includes unit specs from ini file
		public string RoidToAccId(string ROID)
		{
			ushort tbl = Convert.ToUInt16(ROID.Substring(0,4),16);
			uint rec = Convert.ToUInt32(ROID.Substring(4,8),16);
			if(tbl != 0)
				return GetAccID(tbl,rec);
			return null;
		}


		// Get the accessory page ID
		private string GetAppID(ushort tbl)
		{
			string retval = null;
			if (tbl==0xFFFF)
			{
				return "U"; // PROC.INI ro
			}
			int indx=0;
			for(int i=0; i < numDatabases && ((ROFST_DbInfo)DatabasesInfo[i]).dbiID!=tbl; i++) indx++;

			if(indx < numDatabases) 
				return ((ROFST_DbInfo)DatabasesInfo[indx]).dbiAP;
			return retval;
		}


		// Get the accessory page ID from the ROID
		public string GetROAppID(string ROID)
		{
			ushort tbl = Convert.ToUInt16(ROID.Substring(0,4),16);
			uint rec = Convert.ToUInt32(ROID.Substring(4,8),16);
			return GetAppID(tbl);
		}


		public uint FindROFromTblRec(ushort tbl, uint id)
		{
			if(tbl==0xFFFF)
			{
				//PROC.INI ro
				if (id < NumUnitVariables) return 1;
				return 0;
			}
			int indx=0;
			for(int i=0; i < numDatabases && ((ROFST_DbInfo)DatabasesInfo[i]).dbiID!=tbl;i++) indx++;
			if (indx==numDatabases) return 0;
			return FindRO(id,((ROFST_DbInfo)DatabasesInfo[indx]).dbiIL,((ROFST_DbInfo)DatabasesInfo[indx]).dbiAL);
		}


		public bool ROExists(string ROID)
		{
			ushort tbl = Convert.ToUInt16(ROID.Substring(0,4),16);
			uint rec = Convert.ToUInt32(ROID.Substring(4,8),16);
			uint off = FindROFromTblRec(tbl,rec);
			return (off!=0);
		}


		public static void SkipString(BinaryReader br)
		{
			byte []input = {0};
			do
			{
				try
				{
					input[0] = br.ReadByte();
				}
				catch (System.IO.EndOfStreamException)
				{
					input[0] = 0;
				}
			}while (input[0] != 0);
			return;
		}


		public static string GetAsciiString(BinaryReader br, int len)
		{
			StringBuilder inpstr = new StringBuilder();
			byte input = 0;
			int cnt = 0;
			do
			{
				try
				{
					input = br.ReadByte();
					inpstr.Append(Convert.ToChar(input));
				}
				catch (System.IO.EndOfStreamException)
				{
					input = 0;
					while (cnt < len)
					{
						inpstr.Append(Convert.ToChar(input));
						cnt++;
					}
				}
				cnt++;
			}while (cnt < len);

			return (inpstr.ToString());
		}


		public static string GetAsciiString(BinaryReader br)
		{
			StringBuilder inpstr = new StringBuilder();
			byte input = 0;
			do
			{
				try
				{
					input = br.ReadByte();
					if (input > 0)
					{
						inpstr.Append(Convert.ToChar(input));
					}
				}
				catch (System.IO.EndOfStreamException)
				{
					input = 0;
				}
			}while (input != 0);
			return (inpstr.ToString());
		}


		// return the index into the the DatabasesInfo array
		private short GetTable(ushort tblid)
		{
			short found = -1;
			for(short i = 0; (i < numDatabases) && (found == -1); i++)
			{
				if (tblid == ((ROFST_DbInfo)DatabasesInfo[i]).dbiID) 
					found = i;
			}

			if (found == -1)
			{
				// add a new item to the list
				found = numDatabases;
				ROFST_DbInfo tmpDbInfo = new ROFST_DbInfo();
				tmpDbInfo.dbiID = tblid;
				DatabasesInfo.Add(tmpDbInfo);
				dbinew dbinewItem;
				dbinewItem = new dbinew();
				dbiNewInfo.Add(dbinewItem);
				numDatabases++;
			}
			return found;
		}
		

		// Add a new RO record to the arraylist of allNewRos
		private int AddNewRO(uint id,string num,string desc,string val,short type,uint grpn)
		{
			int rtval;
			AddRO tmpAddRO = new AddRO();
			tmpAddRO.ro_id = id;
			tmpAddRO.ro_num = num;
			tmpAddRO.ro_desc = desc;
			tmpAddRO.ro_val = val;
			tmpAddRO.ro_type = type;
			tmpAddRO.ro_parid = grpn;
			(allNewRos[curTblIdx]).Add(tmpAddRO);
			rtval = (allNewRos[curTblIdx]).Count -1;
			return rtval;
		}


		private int AddNewRO(string num,string desc,string val,short type,uint grpn)
		{
			return AddNewRO(NewID++, num, desc, val, type, grpn);
		}


		// Add a new Group record to the arraylist of allNewGrps
		private int AddNewGroup(uint id,string grpname,short type)
		{
			int rtval;
			AddGroup tmpAddGroup = new AddGroup();
			tmpAddGroup.grp_id = id;
			tmpAddGroup.grp_name = grpname;
			tmpAddGroup.grp_type = type;
			(allNewGrps[curTblIdx]).Add(tmpAddGroup);
			rtval = (allNewGrps[curTblIdx]).Count -1;
			return rtval;
		}


		private int AddNewGroup(string grpname,short type)
		{
			return AddNewGroup(NewID++,grpname,type);
		}


		// Return the index into the allNewGrps arraylist
		private int FindNewGroup(uint rec)
		{
			int rtval = -1;
			for (int i=0; i < (allNewGrps[curTblIdx]).Count && rtval == -1; i++)
			{
				if (((AddGroup)(allNewGrps[curTblIdx])[i]).grp_id == rec)
					rtval = i;
			}
			return rtval;
		}


		private int connectToNewGroupfRO(int lastaddROIDX,uint rec,uint parid,string desc)
		{
			int newgrpIDX;
			// position to the correct RO group
			if((newgrpIDX=FindNewGroup(rec))== -1)
			{
				// group not found, add a new one
				newgrpIDX=AddNewGroup(rec,desc,0);
			}
			//update parent info
			AddRO taddro = (AddRO)(allNewRos[curTblIdx][lastaddROIDX]);
			taddro.ro_pargrpidx = newgrpIDX;
			taddro.ro_parid = rec;
			allNewRos[curTblIdx].RemoveAt(lastaddROIDX);
			allNewRos[curTblIdx].Insert(lastaddROIDX,taddro);

			//update group info
			AddGroup taddgroup = (AddGroup)(allNewGrps[curTblIdx][newgrpIDX]);
			taddgroup.grp_type |= ((AddRO)(allNewRos[curTblIdx])[lastaddROIDX]).ro_type;
			taddgroup.grp_parid = parid;
			allNewGrps[curTblIdx].RemoveAt(newgrpIDX);
			allNewGrps[curTblIdx].Insert(newgrpIDX,taddgroup);
			return newgrpIDX;
		}


		private int connectToNewGroup(int lastaddgrpIDX,uint rec,uint parid,string desc)
		{
			// update group info
			int newgrpIDX;
			// position to the correct RO group
			if((newgrpIDX=FindNewGroup(rec))== -1)
			{
				// group not found, add a new one
				newgrpIDX=AddNewGroup(rec,desc,0);
			}
			AddGroup taddgroup = (AddGroup)(allNewGrps[curTblIdx][lastaddgrpIDX]);
			taddgroup.grp_pargrpidx = newgrpIDX;
			taddgroup.grp_parid = rec;
			allNewGrps[curTblIdx].RemoveAt(lastaddgrpIDX);
			allNewGrps[curTblIdx].Insert(lastaddgrpIDX,taddgroup);

			taddgroup = (AddGroup)(allNewGrps[curTblIdx][newgrpIDX]);
			taddgroup.grp_type |= ((AddGroup)(allNewGrps[curTblIdx])[lastaddgrpIDX]).grp_type;
			taddgroup.grp_parid = parid;
			allNewGrps[curTblIdx].RemoveAt(newgrpIDX);
			allNewGrps[curTblIdx].Insert(newgrpIDX,taddgroup);
			return newgrpIDX;
		}


		private void addDifference(uint id,string val,string desc,short type,uint offset)
		{
			DiffRO tmpDiff  = new DiffRO();
			tmpDiff.id=id;
			tmpDiff.type=type;
			tmpDiff.desc=desc;
			tmpDiff.val=val;
			tmpDiff.oldoff=offset;
			allDifferences[curTblIdx].Add(tmpDiff);
		}


		private short ReadShort(BinaryReader br)
		{
			short rtnval = -1;
			try
			{
				rtnval = br.ReadInt16();
			}
			catch (Exception)
			{
				rtnval = -1;
			}
			return rtnval;
		}

/*
 * Read in the ROFST Update file.  Put the changes in array lists
 * to that will be used to organize and merge the differences into
 * the target RO.FST file (usually in the Approved directory). For
 * array lists, use the number of databases from the working draft
 * (there may be new databases created since last approval)
 */
		public void processAppUpdFile(string sAppUpdFile, short nDB)
		{
			BinaryReader brAppUpd;
			string num, desc, val;
			short typ, inch;
			uint rec;
			ushort tbl;
			uint parid;
			int LastAddedROIDX=-1, LastAddedGrpIDX=-1;
			curTblIdx = 0; // initialize Current Table Index
			allNewRos = (ArrayList [])new ArrayList[nDB];
			allNewGrps = (ArrayList [])new ArrayList[nDB];
			allDifferences = (ArrayList [])new ArrayList[nDB];
			allLocations = new ArrayList();

			for (int i=0; i<nDB; i++)
			{
				allNewRos[i] = new ArrayList();
				allNewGrps[i] = new ArrayList();
				allDifferences[i] = new ArrayList();
			}
			// Initialize the allLocations array
			locinc tmplocinc = new locinc();
			tmplocinc.inc = 0;
			tmplocinc.maxloc = 0xFFFFFFFF;
			allLocations.Add(tmplocinc);

			// Open the AppUpd file and read in the RO.FST changes
			try
			{
				brAppUpd = new BinaryReader(File.Open(sAppUpdFile,System.IO.FileMode.Open,System.IO.FileAccess.Read,FileShare.Read));
			}
			catch (Exception e)
			{
				MessageBox.Show("Open "+sAppUpdFile+"\n\n" + e.Message,"Approval Error");
				return;
			}

			while ((inch = ReadShort(brAppUpd)) != -1)
			{
				if (inch == 0 || inch == 1)
				{
					// Read the ROID for the Table and Record Number
					tbl = brAppUpd.ReadUInt16(); // table number
					rec = brAppUpd.ReadUInt32(); // RO Record number

					// Position to the correct RO database
					// ex. Setpoint, Graphics, User Defined, etc.
					curTblIdx = GetTable(tbl);

					// Read in the RO FST record information
					parid = brAppUpd.ReadUInt32(); // Parid
					typ = brAppUpd.ReadInt16();	// type
					desc = GetAsciiString(brAppUpd); // description
					val = GetAsciiString(brAppUpd); // value
					num = GetAsciiString(brAppUpd); // acc ID
					if (inch==0) 
						// New RO FST record
						LastAddedROIDX = AddNewRO(rec,num,desc,val,typ,parid);
					else
					{
						// Find existing RO FST record in Approved RO.FST
						uint start = ((ROFST_DbInfo)DatabasesInfo[curTblIdx]).dbiIL;
						uint end = ((ROFST_DbInfo)DatabasesInfo[curTblIdx]).dbiAL;
						//NOTE: the FindRO() used in the old rofstupd.c code
						// had some differences, but we will try the following
						// version of this function since its logic appears in 
						// other areas of VE-PROMS code.
						uint OldOff = toolsFindRO(rec,start,end);
						// Save the differences
						addDifference(rec,val,desc,typ,OldOff);
					}
				} 
				else
				{
					rec = brAppUpd.ReadUInt32(); // RO Record number
					parid = brAppUpd.ReadUInt32();
					desc = GetAsciiString(brAppUpd);
					if (parid == 0)
					{
						string apid= GetAsciiString(brAppUpd);
						((ROFST_DbInfo)DatabasesInfo[curTblIdx]).dbiTitle = desc;
						((ROFST_DbInfo)DatabasesInfo[curTblIdx]).dbiAP = apid;
					}
					if (LastAddedROIDX != -1)
						// update value in allNewRos
						LastAddedGrpIDX = connectToNewGroupfRO(LastAddedROIDX,rec,parid,desc);
					else
						// update value in allNewGrps
						LastAddedGrpIDX = connectToNewGroup(LastAddedGrpIDX,rec,parid,desc);
					LastAddedROIDX = -1;
				}
			}
			brAppUpd.Close();
		}


		// format strings used in the RO.FST menus that are displayed
		// in the VE-PROMS Editor
		private void placeText(StringBuilder buff,ushort doff,ushort wid,string instr)
		{
			ushort siznum=0;
			string str = instr;
			int idx =0;
			if(doff != 0)
			{
				str = str.TrimStart(' '); // skip leading spaces
				ushort l=(ushort)str.Length;
				string numandsigns = "0123456789+-";
				while (numandsigns.IndexOf(str[idx])!=-1)
				{
					siznum++;
					idx++;
				}
				if(siznum==0)
				{// doff is calculated to keep the values positive
					doff=((ushort)(siznum+(wid-l)/2)); // if no digits - center
				} 
				else if(((doff-siznum)+l) > wid)
				{
					doff=(ushort)(wid-siznum-l);
				}
				while(wid > 0 && siznum < doff)
				{ // add spaces if necessary for alignment
					buff.Append(' ');
					siznum++;
					wid--;
				}
			}
			idx = 0;
			while(wid > 0)
			{ // output the value or spaces to the specified width
				if (idx < str.Length && str[idx] != 0 && str[idx] != '\n')
					buff.Append(str[idx]);
				else
					buff.Append(" ");
				wid--;
				idx++;
			}
		}


		private string getMenuString(short type,string val,string desc)
		{
			StringBuilder buff = new StringBuilder();
			switch(type)
			{
				case 1:
					placeText(buff,5,17,val);
					buff.Append(" ");
					break;
				case 2:
					placeText(buff,5,17,"(Table)");
					buff.Append(" ");
					break;
				case 4:
					placeText(buff,5,17,"(Graph)");
					buff.Append(" ");
					break;
			}
			buff.Append(desc);
			return buff.ToString();
		}


		public void WriteString(BinaryWriter NewFSTFile, string str,bool AddNull)
		{
			int n=str.Length;
			if (AddNull) 
				n++;
			byte [] b = new byte[n];
			for(int i =0; i < str.Length; i++)
			{
				b[i] = (byte)str[i];
			}
			NewFSTFile.Write(b,0,n);
		}


		public uint saveNewMenuEntries(BinaryWriter NewFSTFile,uint id)
		{
			long start=NewFSTFile.Seek(0,System.IO.SeekOrigin.Current);
			int numNewRos = (allNewRos[curTblIdx]).Count;
			int cntNewRos = 0;
			while (cntNewRos < numNewRos)
			{
				// Skip to the one to be saved
				while ((cntNewRos < numNewRos) &&
					(((AddRO)(allNewRos[curTblIdx])[cntNewRos]).ro_stat != 1) &&
					((AddRO)(allNewRos[curTblIdx])[cntNewRos]).ro_parid != id)
					cntNewRos++;
				// If one exists, save it and skip to the next one
				if (cntNewRos < numNewRos)
				{
					AddRO taddro = (AddRO)(allNewRos[curTblIdx][cntNewRos]);
					taddro.ro_stat = 2;
					allNewRos[curTblIdx].RemoveAt(cntNewRos);
					allNewRos[curTblIdx].Insert(cntNewRos,taddro);
					// Save the offset
					NewFSTFile.Write(((AddRO)(allNewRos[curTblIdx])[cntNewRos]).ro_offset);
					// Save the type
					NewFSTFile.Write(((AddRO)(allNewRos[curTblIdx])[cntNewRos]).ro_type);
					// Get the menu string
					string mnustr = getMenuString(((AddRO)(allNewRos[curTblIdx])[cntNewRos]).ro_type,((AddRO)(allNewRos[curTblIdx])[cntNewRos]).ro_val,((AddRO)(allNewRos[curTblIdx])[cntNewRos]).ro_desc);
					// Save menu entry
					WriteString(NewFSTFile,mnustr,true);
					cntNewRos++;
				}
			}
			int cntNewGrps = 0;
			int numNewGrps = (allNewGrps[curTblIdx]).Count;
			while (cntNewGrps < numNewGrps)
			{
				// Skip to the one to be saved
				while ((cntNewGrps < numNewGrps) &&
					(((AddGroup)(allNewGrps[curTblIdx])[cntNewGrps]).grp_stat != 1 ||
					((AddGroup)(allNewGrps[curTblIdx])[cntNewGrps]).grp_parid != id))
					cntNewGrps++;
				// If one exists, save it and skip to the next one
				if(cntNewGrps < numNewGrps)
				{
					// Change stat to menu entry saved
					AddGroup taddgroup = (AddGroup)(allNewGrps[curTblIdx][cntNewGrps]);
					taddgroup.grp_stat = 2;
					allNewGrps[curTblIdx].RemoveAt(cntNewGrps);
					allNewGrps[curTblIdx].Insert(cntNewGrps,taddgroup);
					// Save the offset
					NewFSTFile.Write(((AddGroup)(allNewGrps[curTblIdx])[cntNewGrps]).grp_offset);
					// Save the type
					NewFSTFile.Write(((AddGroup)(allNewGrps[curTblIdx])[cntNewGrps]).grp_type);
					// Save menu entry
					WriteString(NewFSTFile,((AddGroup)(allNewGrps[curTblIdx])[cntNewGrps]).grp_name,true);
					cntNewGrps++;
				}
			}
			return ((uint)((NewFSTFile.Seek(0,System.IO.SeekOrigin.Current)) - start));
		}



		public void AddLocation(uint location,int inc)
		{
			int t_inc = ((locinc)allLocations[lastLocationIdx]).inc;
			if (location == ((locinc)allLocations[lastLocationIdx]).maxloc)
			{
				// update the current record
				// - need to remove current item, then insert new item.
				locinc tmploc = (locinc)(allLocations[lastLocationIdx]);
				tmploc.inc += inc;
				allLocations.RemoveAt(lastLocationIdx);
				allLocations.Insert(lastLocationIdx,tmploc);
			}
			else
			{
				locinc tmploc = (locinc)(allLocations[lastLocationIdx]);
				locinc newloc = new locinc();
				// new item gets last item's maxloc
				newloc.maxloc = tmploc.maxloc;
				newloc.inc = tmploc.inc + inc;
				// update the current record
				// - need to remove current item, then insert new item.
				tmploc.maxloc = location; //update maxloc
				allLocations.RemoveAt(lastLocationIdx);
				allLocations.Insert(lastLocationIdx,tmploc);
				// append the new item
				allLocations.Add(newloc);
				lastLocationIdx++;
			}
		}


		public short saveAdditions(BinaryWriter NewFSTFile,uint parid,uint start)
		{
			// Initialize count of added entries
			short count = 0;
			// Initialize count of added bytes
			int bytes = 0;

			int numgroups = (allNewGrps[curTblIdx]).Count;
			int grpcnt = 0;
			while (grpcnt < numgroups)
			{
				if (((AddGroup)(allNewGrps[curTblIdx])[grpcnt]).grp_stat == 0 && ((AddGroup)(allNewGrps[curTblIdx])[grpcnt]).grp_parid == parid)
				{
					// Save new group
					// Change stat to inprogress
					AddGroup taddgroup = (AddGroup)(allNewGrps[curTblIdx][grpcnt]);
					taddgroup.grp_stat = 99;
					allNewGrps[curTblIdx].RemoveAt(grpcnt);
					allNewGrps[curTblIdx].Insert(grpcnt,taddgroup);
					count++;
					// Save any children
					short howmany = saveAdditions(NewFSTFile,((AddGroup)(allNewGrps[curTblIdx])[grpcnt]).grp_id,start);

					// Remember the offset
					taddgroup = (AddGroup)(allNewGrps[curTblIdx][grpcnt]);
					taddgroup.grp_offset = (uint)NewFSTFile.Seek(0,System.IO.SeekOrigin.Current); // ftell(ofile)
					allNewGrps[curTblIdx].RemoveAt(grpcnt);
					allNewGrps[curTblIdx].Insert(grpcnt,taddgroup);

					// Save ID
					if (((AddGroup)(allNewGrps[curTblIdx])[grpcnt]).grp_parid == 0)
					{
						whereisgl = (uint)NewFSTFile.Seek(0,System.IO.SeekOrigin.Current);
					}
					NewFSTFile.Write(((AddGroup)(allNewGrps[curTblIdx])[grpcnt]).grp_id);
					// Save the Parent ID
					NewFSTFile.Write(((AddGroup)(allNewGrps[curTblIdx])[grpcnt]).grp_parid);
					// save howmany
					NewFSTFile.Write(howmany);
					// save children
					saveNewMenuEntries(NewFSTFile,((AddGroup)(allNewGrps[curTblIdx])[grpcnt]).grp_id);
					taddgroup = (AddGroup)(allNewGrps[curTblIdx][grpcnt]);
					taddgroup.grp_stat = 1;
					allNewGrps[curTblIdx].RemoveAt(grpcnt);
					allNewGrps[curTblIdx].Insert(grpcnt,taddgroup);
					bytes += (int)(NewFSTFile.Seek(0,System.IO.SeekOrigin.Current) - ((AddGroup)(allNewGrps[curTblIdx])[grpcnt]).grp_offset);
				}
				grpcnt++;
			}
			// Second check new ROs
			int rocnt = 0;
			int numros = (allNewRos[curTblIdx]).Count;
			while (rocnt < numros)
			{
				// save new RO
				if (((AddRO)(allNewRos[curTblIdx])[rocnt]).ro_stat == 0 &&
					((AddRO)(allNewRos[curTblIdx])[rocnt]).ro_parid == parid)
				{
					// change the stat
					AddRO taddro = (AddRO)(allNewRos[curTblIdx][rocnt]);
					taddro.ro_stat = 1;
					// Increment count
					count++;
					taddro.ro_offset = (int)NewFSTFile.Seek(0,System.IO.SeekOrigin.Current);
					allNewRos[curTblIdx].RemoveAt(rocnt);
					allNewRos[curTblIdx].Insert(rocnt,taddro);
					// Save the ID
					NewFSTFile.Write(((AddRO)(allNewRos[curTblIdx])[rocnt]).ro_id);
					// Save the Parent ID
					NewFSTFile.Write(((AddRO)(allNewRos[curTblIdx])[rocnt]).ro_parid);
					// Save -1
					NewFSTFile.Write((short)-1);
					// Save type
					NewFSTFile.Write(((AddRO)(allNewRos[curTblIdx])[rocnt]).ro_type);
					maxtype |= (ushort)((AddRO)(allNewRos[curTblIdx])[rocnt]).ro_type;
					// Save value
					WriteString(NewFSTFile,((AddRO)(allNewRos[curTblIdx])[rocnt]).ro_val,true);
					// Save accid
					short aw = (short)((AddRO)(allNewRos[curTblIdx])[rocnt]).ro_num.Length;
					if (aw > maxaw) maxaw = (ushort)aw;
					WriteString(NewFSTFile,((AddRO)(allNewRos[curTblIdx])[rocnt]).ro_num,true);
					// Calculate the number of extra bytes output
					bytes+=(int)(NewFSTFile.Seek(0,System.IO.SeekOrigin.Current) - ((AddRO)(allNewRos[curTblIdx])[rocnt]).ro_offset);
				}
				rocnt++;
			}
			// Adjust the location information
			if (bytes != 0 && start > 0)
				AddLocation(start - 1,bytes);
			return count;
		}


		// was a difference flagged for this RO
		// - check via saved offsets into the RO.fST file
		public int isDifferent(uint off)
		{
			int allDiffCnt = 0;
			int NumAllDiff = (allDifferences[curTblIdx]).Count;
			while (allDiffCnt < NumAllDiff)
			{
				if (((DiffRO)(allDifferences[curTblIdx])[allDiffCnt]).oldoff == off)
					return allDiffCnt;
				allDiffCnt++;
			}
			return -1;
		}



		public uint newLocation(uint oldlocation)
		{
			int idx = 0;
			while (oldlocation > ((locinc)allLocations[idx]).maxloc) idx++;
			return oldlocation + (uint)((locinc)allLocations[idx]).inc;
		}


		public void processGroupRecords(BinaryWriter NewFSTFile,uint end)
		{
			uint start;
			while ((start=(uint)brROFst.BaseStream.Seek(0,System.IO.SeekOrigin.Current)) < end)
			{
				// Read ID
				uint id = brROFst.ReadUInt32();
				// Read Parent ID
				uint parid = brROFst.ReadUInt32();
				// Read How Many
				short howmany = brROFst.ReadInt16();
				// Check of additions and write them
				short howmanyplus = howmany;
				if (howmany >= 0)
					howmanyplus += saveAdditions(NewFSTFile,id,start);
				if (parid == 0)
					whereisgl = (uint)NewFSTFile.Seek(0,System.IO.SeekOrigin.Current); // ftell(ofile)
				// Write ID
				NewFSTFile.Write(id);
				// Write Parent ID
				NewFSTFile.Write(parid);
				// Write howmany
				NewFSTFile.Write(howmanyplus);
				// If group - read and write menu list
				int starti = (int)brROFst.BaseStream.Seek(0,System.IO.SeekOrigin.Current); // ftell(rofstfile)
				int starto = (int)NewFSTFile.Seek(0,System.IO.SeekOrigin.Current); // ftell(ofile)
				if (howmanyplus >= 0)
				{
					// for orignal entries
					for (int i=0;i<howmany;i++)
					{
						// Read Offset
						uint offset = brROFst.ReadUInt32();
						// Read Type
						short type = brROFst.ReadInt16();
						// Read Menu
						string menustr = GetAsciiString(brROFst);
						// Look for differences
						int thisdiff = isDifferent(offset);
						if (thisdiff != -1)
						{
							type = ((DiffRO)(allDifferences[curTblIdx])[thisdiff]).type;
							menustr = getMenuString(type,((DiffRO)(allDifferences[curTblIdx])[thisdiff]).val,((DiffRO)(allDifferences[curTblIdx])[thisdiff]).desc);
						}
						// Save new offset
						NewFSTFile.Write(newLocation(offset));
						// Save type
						NewFSTFile.Write(type);
						// Save menu
						WriteString(NewFSTFile,menustr,true);
					}
					// Save new entries
					if (howmanyplus > howmany)
					{
						saveNewMenuEntries(NewFSTFile,id);
					}
				}
				else
				{
					// if RO - read RO record
					// Read type
					short type = brROFst.ReadInt16();
					// Read value
					string val = GetAsciiString(brROFst);
					// Read accid
					string num = GetAsciiString(brROFst);
					// check if changed
					int thisdiff = isDifferent(start);
					if (thisdiff != -1)
					{
						type = ((DiffRO)(allDifferences[curTblIdx])[thisdiff]).type;
						val = ((DiffRO)(allDifferences[curTblIdx])[thisdiff]).val;
					}
					// Save type
					NewFSTFile.Write(type);
					// Save value
					WriteString(NewFSTFile,val,true);
					// Save accid
					WriteString(NewFSTFile,num,true);
				}
				int originalSize = (int)brROFst.BaseStream.Seek(0,System.IO.SeekOrigin.Current) - starti;
				int copySize = (int)NewFSTFile.Seek(0,System.IO.SeekOrigin.Current) - starto;
				if (copySize != originalSize)
					AddLocation(start,copySize - originalSize);
			}
			if (end == 0)
			{
				maxtype = 0;
				maxaw = 0;
				saveAdditions(NewFSTFile,0,0);
			}
		}


		public int getROAccLess(string minnum)
		{
			int romin = -1;
			int roptr = 0;
			int numroptr = (allNewRos[curTblIdx]).Count;
			while (roptr < numroptr)
			{
				// skip processed entries
				while ((roptr < numroptr) &&
					((AddRO)(allNewRos[curTblIdx])[roptr]).ro_stat == 4) roptr++;
				if ((roptr < numroptr))
				{
					// Look for "smallest"
					if ((minnum==null)||
						((AddRO)(allNewRos[curTblIdx])[roptr]).ro_num.CompareTo(minnum) < 0)
					{
						romin = roptr;
						minnum = ((AddRO)(allNewRos[curTblIdx])[roptr]).ro_num;
					}
					roptr++;
				}
			}
			return romin;
		}


		public void putFixed(BinaryWriter NewFstFile, string str, short len)
		{
			int n=len; //str.Length;
			int strlen = str.Length;
			byte [] b = new byte[len];
		// write a fixed length of a string.
			for (int i =0; n > 0; i++)
			{
				if (i < strlen)
					b[i] = (byte)str[i];
				else
					b[i] = (byte)0; // pad with NULLs if smaller than "len"
				n--;
			}
			NewFstFile.Write(b,0,len);
		}


		public void processAccIdRecords(BinaryWriter NewFSTFile,uint end,short len)
		{
			int extra = 0;
			int roptr = 0;
			while (brROFst.BaseStream.Seek(0,System.IO.SeekOrigin.Current) < end)
			{
				// Read ID
				uint id = brROFst.ReadUInt32();
				// Read accID
				string num = GetAsciiString(brROFst,len);
				// Check other accIDs in new records and save
				while ((roptr = getROAccLess(num)) != -1)
				{
					extra+=(len + 4); //sizeof(ulong 16bit)+len
					NewFSTFile.Write(((AddRO)(allNewRos[curTblIdx])[roptr]).ro_id);
					putFixed(NewFSTFile,((AddRO)(allNewRos[curTblIdx])[roptr]).ro_num,len);
					AddRO taddro = (AddRO)(allNewRos[curTblIdx][roptr]);
					taddro.ro_stat = 4;
					allNewRos[curTblIdx].RemoveAt(roptr);
					allNewRos[curTblIdx].Insert(roptr,taddro);
				}
				// Write ID
				NewFSTFile.Write(id);
				// Write accID
				putFixed(NewFSTFile,num,len);
			}
			// Save remaining RO info
			while ((roptr = getROAccLess(null))!=-1)
			{
				extra += (len+4); //sizeof(ulong 16bit)+len
				NewFSTFile.Write(((AddRO)(allNewRos[curTblIdx])[roptr]).ro_id);
				putFixed(NewFSTFile,((AddRO)(allNewRos[curTblIdx])[roptr]).ro_num,len);
				AddRO taddro = (AddRO)(allNewRos[curTblIdx][roptr]);
				taddro.ro_stat = 4;
				allNewRos[curTblIdx].RemoveAt(roptr);
				allNewRos[curTblIdx].Insert(roptr,taddro);
			}
			if (extra > 0) 
				AddLocation(end-1,extra);
		}


		public void nextIDandOffset(ref uint nxtid, ref uint nxtoff)
		{
			int roptr = 0, romin = -1;
			int numroptr = (allNewRos[curTblIdx]).Count;
			int grpptr = 0, grpmin = -1;
			int numgrpptr = (allNewGrps[curTblIdx]).Count;

			while (roptr < numroptr)
			{
				if (((AddRO)(allNewRos[curTblIdx])[roptr]).ro_id > nxtid &&
					(romin == -1 || ((AddRO)(allNewRos[curTblIdx])[roptr]).ro_id < ((AddRO)(allNewRos[curTblIdx])[romin]).ro_id))
					romin = roptr;
				roptr++;
			}

			while (grpptr < numgrpptr)
			{
				if (((AddGroup)(allNewGrps[curTblIdx])[grpptr]).grp_id > nxtid &&
					(grpmin == -1 || ((AddGroup)(allNewGrps[curTblIdx])[grpptr]).grp_id < ((AddGroup)(allNewGrps[curTblIdx])[grpmin]).grp_id))
					grpmin = grpptr;
				grpptr++;
			}
			if (grpmin != -1)
			{
				if ((romin != -1) && ((AddRO)(allNewRos[curTblIdx])[romin]).ro_id < ((AddGroup)(allNewGrps[curTblIdx])[grpmin]).grp_id)
				{
					AddRO taddro = (AddRO)(allNewRos[curTblIdx][romin]);
					taddro.ro_stat = 3;
					allNewRos[curTblIdx].RemoveAt(romin);
					allNewRos[curTblIdx].Insert(romin,taddro);
					nxtid = ((AddRO)(allNewRos[curTblIdx])[romin]).ro_id;
					nxtoff = (uint)((AddRO)(allNewRos[curTblIdx])[romin]).ro_offset;
				}
				else
				{
					AddGroup taddgroup = (AddGroup)(allNewGrps[curTblIdx][grpmin]);
					taddgroup.grp_stat = 3;
					allNewGrps[curTblIdx].RemoveAt(grpmin);
					allNewGrps[curTblIdx].Insert(grpmin,taddgroup);
					nxtid = ((AddGroup)(allNewGrps[curTblIdx])[grpmin]).grp_id;
					nxtoff = ((AddGroup)(allNewGrps[curTblIdx])[grpmin]).grp_offset;
				}
			}
			else
			{
				if (romin != -1)
				{
					AddRO taddro = (AddRO)(allNewRos[curTblIdx][romin]);
					taddro.ro_stat = 3;
					allNewRos[curTblIdx].RemoveAt(romin);
					allNewRos[curTblIdx].Insert(romin,taddro);
					nxtid = ((AddRO)(allNewRos[curTblIdx])[romin]).ro_id;
					nxtoff = (uint)((AddRO)(allNewRos[curTblIdx])[romin]).ro_offset;
				}
				else
				{
					nxtid = 0;
					nxtoff = 0;
				}
			}
		}


		public void processIdRecords(BinaryWriter NewFstFile,uint end)
		{
			int extra = 0;
			uint nxtid =0, nxtoff=0;
			nextIDandOffset(ref nxtid,ref nxtoff);
			while (brROFst.BaseStream.Seek(0,System.IO.SeekOrigin.Current) < end)
			{
				// Read ID
				uint id = brROFst.ReadUInt32();
				// Look for new entries that precede ID
				while (nxtid != 0 && nxtid < id)
				{
					extra += 8; // sizeof(ulong 16bit) * 2
					NewFstFile.Write(nxtid);
					NewFstFile.Write(nxtoff);
					nextIDandOffset(ref nxtid,ref nxtoff); // passed by reference
				}
				// Write ID
				NewFstFile.Write(id);
				// Read Offset
				uint off = brROFst.ReadUInt32();
				// Write new offset
				NewFstFile.Write(newLocation(off));
			}
			// Save new RO entries and Group entries
			while (nxtid != 0)
			{
				extra += 8; // sizeof(ulong 16bit)*2
				NewFstFile.Write(nxtid);
				NewFstFile.Write(nxtoff);
				nextIDandOffset(ref nxtid,ref nxtoff); // passed by reference
			}
			if (extra != 0)
				AddLocation(end-1,extra);
		}


		/*
		 * Merge the changes into the RO.FST file (usually Approved directory)
		 */
		public void CreateMergedFSTFile(string NewFStName)
		{
			BinaryWriter NewFSTFile=null;

			// Open a new FST file for writing
			try
			{
				NewFSTFile = new BinaryWriter(File.Open(NewFStName,System.IO.FileMode.Create,System.IO.FileAccess.ReadWrite,FileShare.None));
			}
			catch (Exception e)
			{
				MessageBox.Show("Error Opening "+NewFStName +"\n\n" + e.Message,"Approval Error");
			}
			
			// Write the RO.FST header
			Header.Write(NewFSTFile);

			// Position the old FST file past the header
			brROFst.BaseStream.Seek(Header.GetStructSize(),System.IO.SeekOrigin.Begin);

			// Loop through each database
			for (short i=0; i < numDatabases; i++)
			{
				// Set the current table index used to access the allNewRos,
				// allNewGrps, and allDifferences arrays
				curTblIdx = i;

				// Loop through the Group and RO records
				// Update the RO Group information
				processGroupRecords(NewFSTFile,((ROFST_DbInfo)DatabasesInfo[i]).dbiIL);
				if (((ROFST_DbInfo)DatabasesInfo[i]).dbiAW == 0)
					((ROFST_DbInfo)DatabasesInfo[i]).dbiAW = maxaw;

				if (((ROFST_DbInfo)DatabasesInfo[i]).dbiType == 0)
					((ROFST_DbInfo)DatabasesInfo[i]).dbiType = maxtype;

				((ROFST_DbInfo)DatabasesInfo[i]).dbiGL = whereisgl;
				((ROFST_DbInfo)DatabasesInfo[i]).dbiIL = (uint)NewFSTFile.Seek(0,System.IO.SeekOrigin.Current);
				
				// Loop through the ID list
				processIdRecords(NewFSTFile,((ROFST_DbInfo)DatabasesInfo[i]).dbiAL);
				((ROFST_DbInfo)DatabasesInfo[i]).dbiAL = (uint)NewFSTFile.Seek(0,System.IO.SeekOrigin.Current);
				// Loop through the accid list
				processAccIdRecords(NewFSTFile,((ROFST_DbInfo)DatabasesInfo[i]).dbiEND,(short)((ROFST_DbInfo)DatabasesInfo[i]).dbiAW);
				((ROFST_DbInfo)DatabasesInfo[i]).dbiEND = (uint)NewFSTFile.Seek(0,System.IO.SeekOrigin.Current);
			}
			// Save the Database info
			uint lngbuf = 0;
			// Save the current location in the new fst file
			uint dblength = (uint)NewFSTFile.Seek(0,System.IO.SeekOrigin.Current);
			NewFSTFile.Write(lngbuf);
			NewFSTFile.Write(numDatabases);
			uint lngval;
			ROFST_DbInfo tmpdbinfo = new ROFST_DbInfo();
			lngval = (uint)(tmpdbinfo.GetStructSize() * numDatabases);
			for (int i=0;i<numDatabases;i++)
			{
				NewFSTFile.Write(((ROFST_DbInfo)DatabasesInfo[i]).dbiID);
				NewFSTFile.Write(((ROFST_DbInfo)DatabasesInfo[i]).dbiType);
				NewFSTFile.Write(((ROFST_DbInfo)DatabasesInfo[i]).dbiAW);
				NewFSTFile.Write(((ROFST_DbInfo)DatabasesInfo[i]).dbiGL);
				NewFSTFile.Write(((ROFST_DbInfo)DatabasesInfo[i]).dbiIL);
				NewFSTFile.Write(((ROFST_DbInfo)DatabasesInfo[i]).dbiAL);
				NewFSTFile.Write(((ROFST_DbInfo)DatabasesInfo[i]).dbiEND);
				NewFSTFile.Write(lngval);
				lngval += (uint)((ROFST_DbInfo)DatabasesInfo[i]).dbiTitle.Length + 1;
				NewFSTFile.Write(lngval);
				lngval += (uint)((ROFST_DbInfo)DatabasesInfo[i]).dbiAP.Length + 1;
			}
			for (short i=0;i<numDatabases;i++)
			{
				WriteString(NewFSTFile,((ROFST_DbInfo)DatabasesInfo[i]).dbiTitle,true);
				WriteString(NewFSTFile,((ROFST_DbInfo)DatabasesInfo[i]).dbiAP,true);
			}
			// locate the end
			uint dbend = (uint)NewFSTFile.Seek(0,System.IO.SeekOrigin.Current); // ftell(ofile)
			// How long is the db info
			NewFSTFile.Seek((int)dblength,System.IO.SeekOrigin.Begin);
			lngbuf = dbend-dblength-4; //dbend-dblength-sizeof(dblength)
			NewFSTFile.Write(lngbuf);
			// Go to the beginning of the new file
			NewFSTFile.Seek(0,System.IO.SeekOrigin.Begin);
			// Save the header again
			if (Header.hcYear==0)
				Header.SetHeader(dblength); // sets the header and date/time
			else
				Header.dboffset = dblength;
			Header.Write(NewFSTFile);
			NewFSTFile.Flush();
			NewFSTFile.Close();
			uint test = (uint) Header.hcHund;
			// stamp the new FST file with the RO.FST header date/time
			DateTime dt = new DateTime((int)Header.hcYear,(int)Header.hMonth,(int)Header.hDay,(int)Header.hcHour,(int)Header.hcMin,(int)Header.hcSec,(int)Header.hcHund);
			File.SetLastWriteTime(NewFStName,dt);
		}
	}
/*************************************************************************/

	public class strEntry
	{

		public strEntry()
		{
		}

		public virtual string toText(int mi){return "";}

		public virtual int getLength(int mi){return 0;}

	}


	
	public class seText : strEntry
	{
		public string str;
		public int len;

		public seText(string instr, int inlen)
		{
			str = instr.Substring(0,inlen);
			len = inlen;
		}

		public override string toText(int mi)
		{
			return str;
		}

		public override int getLength(int mi)
		{
			return len;
		}
	}


	public class seUser : strEntry
	{
		string uvalue;
		int len;

		public seUser(string str, int l)
		{
			uvalue = ROProcessTools.evaluate(str,l);
			len = uvalue.Length;
		}

		public override string toText(int mi)
		{
			return uvalue;
		}

		public override int getLength(int mi)
		{
			return len;
		}
	}

	public class strList
	{
		public varList vList;
		public menuList mList;
		private ArrayList aryStrEntry;

		public strList(string str)
		{
			vList = new varList();
			mList = new menuList();
			aryStrEntry = new ArrayList();
			Process(str,str.Length);
		}

		public strList(string str, int l, varList vl, menuList ml)
		{
			if (vl == null)
				vList =  new varList();
			else
				vList = vl;
			if (ml == null)
				mList = new menuList();
			else
				mList = ml;
			if (aryStrEntry == null)
				aryStrEntry = new ArrayList();
			Process(str.Substring(0,l),l);
		}

		public void Add(strEntry se)
		{
			aryStrEntry.Add(se);
		}

		public void processCondition(string cnd, string opt, int lc, int lo)
		{
			// equaluate condition
			string stat = ROProcessTools.evaluate(cnd,lc);
			int ls = stat.Length;
			// look for match - remember default
			string match=null;
			int matchlen = 0;
			string def = null;
			int deflen = 0;
			while (lo > 0 && match == null)
			{
				int end = ROProcessTools.matchingBrace(opt);
				int eq = opt.IndexOf('=');
				int len = end + 1; // +1 to include the '}'
				int li = eq-1;
				int ld = len-li-3; // One for '{', '=' and '}'
				if (def == null || eq == 1)
				{
					def = opt.Substring(eq+1,ld);
					deflen =  ld;
				}
				if (ls == li && stat.StartsWith(opt.Substring(1,li)))
					{
					match = opt.Substring(eq+1,ld);
					matchlen = ld;
				}
				opt =  opt.Substring(len);
				lo -= len;
			}
			// if match process option - or process default
			if (match == null)
			{
				match = def;
				matchlen = deflen;
			}
			Process(match,matchlen);
		}

		public void processBrace(string str, int l, ref int nfnd)
		{
			int nxt = ROProcessTools.nextDelimiter("{=",str,l); // -1 means not found
			if(nxt == -1) // varUse
			{
				strList found = null;
				found = vList.lookFor(str,l);
				if (found != null)
					Add(new seVarUse(found));
				else
					nfnd = 1;
			}
			else
			{
				if (str[nxt] == '{') // conditonal or menu
				{
					if(nxt==0)
					{ // menu
						mList.Process(str,l,vList);
						Add(new seMenuUse(mList));
					} 
					else 
					{ // conditional
						processCondition(str, str.Substring(nxt), nxt, l -nxt);
					}
				}
				else 
				{ // must be variable definiton
					vList.Add(str, str.Substring(nxt+1), nxt, l - nxt - 1, mList);
				}
			}
		}

		public void Process (string str, int len)
		{
			int nxtDlm = -1; // -1 = not found
			while (len > 0)
			{
				nxtDlm = ROProcessTools.nextDelimiter("{",str,len);
				if (nxtDlm == -1)
				{
					// add entire string as is
					Add(new seText(str,len));
					//str = str.Substring(len);  don't think we need to do this
					len = 0;
				}
				else
				{
					int cnt = 0;
					if (nxtDlm > 0)
					{
						// add preceeding text
						Add(new seText(str,nxtDlm));
						str = str.Substring(nxtDlm);
						len-=nxtDlm;
					}
					// add text group by delimiter, including
					// the delimiters
					nxtDlm = ROProcessTools.matchingBrace(str)+1;
					cnt = nxtDlm;
					int nfnd = 0;
					processBrace(str.Substring(1),cnt-2,ref nfnd);
					if (nfnd > 0)
					{
						Add(new seText(str,cnt));
					}
					// position to next delimiter grouping
					len -= cnt;
					str = str.Substring(nxtDlm);
				}
			}
		}

		public string toText(int mi)
		{
			StringBuilder bldstr = new StringBuilder();
			for (int i=0; i < aryStrEntry.Count; i++)
			{
				bldstr.Append(((strEntry)aryStrEntry[i]).toText(mi));
			}
			return bldstr.ToString();
		}

		public int getLength(int mi)
		{
			int rtnval = 0;
			for (int i=0; i < aryStrEntry.Count; i++)
			{
				rtnval += (((strEntry)aryStrEntry[i]).getLength(mi));
			}
			return rtnval;
		}

		public int menuCount()
		{
			return mList.getCount();
		}

		public string getIds(ref int cnt)
		{
			// return a string of the IDs
			return mList.getIds(ref cnt);
		}
	}



	public class strList2
	{

		private ArrayList aryStrEntry;

		public strList2(string str)
		{
			int l=str.Length;
			if (aryStrEntry == null)
				aryStrEntry = new ArrayList();
			while(l > 0)
			{
				int ptr=ROProcessTools.nextDelimiter("<",str,l);
				int cptr = (ptr==-1)?-1:ROProcessTools.nextDelimiter(">",str.Substring(ptr,str.Length - ptr),str.Length-ptr);
				if(ptr == -1 || (ptr>-1 && cptr == -1))
				{
					Add(new seText(str,l));
					l=0;
				} 
				else 
				{
					int cnt = ptr; //(int)(ptr-str);
					if(cnt > 0)
					{
						Add(new seText(str,cnt));
						l-=cnt;
						str = str.Substring(ptr); // str=ptr
					}
					ptr=ROProcessTools.nextDelimiter(">",str,l)+1;
					cnt = ptr;//(int)(ptr-str);
					string tmpstr = str.Substring(1);
					Add(new seUser(tmpstr,cnt-2));
					l-=cnt;
					str = str.Substring(ptr);//str=ptr;
				}
			}
		}

		public void Add (strEntry se)
		{
			aryStrEntry.Add(se);
		}

		public string toText()
		{
			StringBuilder bldstr = new StringBuilder();
			for (int i=0; i < aryStrEntry.Count; i++)
			{
				bldstr.Append(((strEntry)aryStrEntry[i]).toText(0));
			}
			return bldstr.ToString();
		}
	}

	public class varEntry
	{
		string Name;
		int Len;
		strList Definition;

		public varEntry(string InName, string InDef, int lenInName, int lenInDef, varList vlist, menuList mlist)
		{
			Definition =  new strList(InDef,lenInDef,vlist,mlist);
			Name = InName.Substring(0,lenInName);
			Len = lenInName;
		}

		public  strList lookFor(string nam, int l)
		{
			string tname = nam.Substring(0,l);
			if (l == Len && (Name.CompareTo(tname)==0))
				return Definition; // found
			return null; // not found
		}
	}

	public class varList
	{
		ArrayList varEntryAry;

		public varList()
		{
			varEntryAry = new ArrayList();
		}

		public void Add(string InName, string InDef, int lenInName, int lenInDef, menuList mlist)
		{
			varEntry tmpEntry = new varEntry(InName,InDef,lenInName,lenInDef,null,mlist);
			varEntryAry.Add(tmpEntry);
		}

		public strList lookFor(string str, int len)
		{
			strList rtnval = null;
			for (int i = 0; (rtnval == null) && (i < varEntryAry.Count); i++)
			{
				rtnval = ((varEntry)varEntryAry[i]).lookFor(str,len);
			}
			return rtnval;
		}
	}

	public class seVarUse : strEntry
	{
		strList Def; 

		public seVarUse(strList d)
		{
			Def = d;
		}


		public override string toText(int mi)
		{
			return Def.toText(mi);
		}

		public override int getLength(int mi)
		{
			return Def.getLength(mi);
		}
	}

	public class menuEntry
	{
		byte id;
		strList definition;

		public menuEntry(string idptr,string def,int li,int ld,varList vlst)
		{
			definition = new strList(def, ld, vlst,null);
			// save the id
			if(li != 0)
				id=(byte)idptr[0];
			else 
				id=0;
		}

		public int getLength(int mi)
		{
			if(mi==(int)id || mi==-1)
				return definition.getLength(mi);
			else
				return 0;
		}

		public virtual string toText(int mi)
		{
			if (mi == id || mi==-1)
				return definition.toText(mi);
			else
				return "";
		}

		public string getID()
		{
			string rtnstr = id.ToString();
			return rtnstr;
		}

		public int getCount()
		{
			return 1;
		}
	}


	public class menuList : strEntry
	{
		ArrayList aryMenuList;

		public menuList()
		{
			aryMenuList = new ArrayList();
		}

		public void Add(menuEntry MnuEntry)
		{
			aryMenuList.Add(MnuEntry);
		}

		private int _getLength(int mi)
		{
			int lcnt = aryMenuList.Count;
			int rtnval =0;

			for (int i=0; i < lcnt; i++)
			{
				rtnval += (((menuEntry)aryMenuList[i])).getLength(mi);
			}
			return rtnval;
		}

		private int _getLenAndLookat(int mi, ref int lookat)
		{
			int len =0;
			lookat = mi;

			if (aryMenuList.Count > 0)
			{
				len=_getLength(lookat);
				if (len ==0)
				{
					lookat = 0;
					len = _getLength(lookat);
				}
				if (len == 0)
				{
					lookat = -1;
					len = _getLength(lookat);
				}
			}

			return len;
		}

		public override int getLength(int mi)
		{
			int lookat=0;
			return _getLenAndLookat(mi,ref lookat);
		}

		public override string toText(int mi)
		{
			StringBuilder rtnstr = new StringBuilder();
			int lookat=0;

			int len = _getLenAndLookat(mi,ref lookat);
			if (aryMenuList.Count > 0)
			{
				for (int i = 0; i< aryMenuList.Count; i++)
				{
					string roval = ((menuEntry)aryMenuList[i]).toText(lookat);
					if (lookat == -1)
					{
						// For Approve Individual, show all possible RO
						// values (for conditional RO's)
						// We may need to add a flag here later on when
						// this logic is used in the Procedure Editor.
						if (i > 0 && !roval.Equals(""))
							rtnstr.Append("\n");
					}
					rtnstr.Append(roval);
				}
			}
			return rtnstr.ToString();
		}

		public string getIds(ref int cnt)
		{
			StringBuilder rtnstr = new StringBuilder();
			cnt = getCount();
			int arycnt = aryMenuList.Count;

			for (int i=0; i<arycnt; i++)
			{
				rtnstr.Append(((menuEntry)aryMenuList[i]).getID());
			}
			return rtnstr.ToString();
		}

		public int getCount()
		{
			int rtncnt=0;
			int arycnt = aryMenuList.Count;
			for (int i=0; i<arycnt; i++)
			{
				rtncnt+=(((menuEntry)aryMenuList[i]).getCount());
			}
			return rtncnt;
		}

		public void Process(string str,int l, varList v)
		{
			// get each piece and add a new entry
			do 
			{
				int end= ROProcessTools.matchingBrace(str);
				int eq=str.IndexOf('=');
				int len = end + 1;	// +1 to include the '}'
				int li = eq - 1;
				int ld = len-li-3;	// One for '{', '=' and '}'
				Add(new menuEntry(str.Substring(1),str.Substring(eq+1),li,ld,v));
				// point to the next piece
				str = str.Substring(len);
				l -= len;
			} while(l > 0);
		}
	}

	public class seMenuUse : strEntry
	{
		menuList ml;

		public seMenuUse(menuList m)
		{
			ml=m;
		}

		public override string toText(int mi)
		{
			return ml.toText(mi);
		}

		public override int getLength(int mi)
		{
			return ml.getLength(mi);
		}
	}

}