using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;
using System.ComponentModel;
using System.Drawing;

namespace VEPROMS.CSLA.Library
{
	#region PlantFormat
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class PlantFormat
	{
		public PlantFormat(IFormatOrFormatInfo format)
		{
			_MyFormat = format;
		}
		private IFormatOrFormatInfo _MyFormat;
		public IFormatOrFormatInfo MyFormat
		{
			get { return _MyFormat; }
			set { _MyFormat = value; }
		}
		private vlnFormatDocument _XmlDoc;
		internal vlnFormatDocument XmlDoc
		{
			get
			{
				if (_XmlDoc == null)
					_XmlDoc = new vlnFormatDocument(_MyFormat);
				return _XmlDoc;
			}
		}
		private FormatData _FormatData;
		public FormatData FormatData
		{
			get
			{
				if (_FormatData == null) _FormatData = new FormatData(XmlDoc.SelectSingleNode("/PlantFormat/FormatData"));
				return _FormatData;
			}
		}
		private PageStyles _PageStyles;
		public PageStyles PageStyles
		{
			get
			{
				if (_PageStyles == null) _PageStyles = new PageStyles(XmlDoc.SelectNodes("/PlantFormat/PageStyles/PageStyle"));
				return _PageStyles;
			}
		}
		private DocStyles _DocStyles;
		public DocStyles DocStyles
		{
			get
			{
				if (_DocStyles == null) _DocStyles = new DocStyles(XmlDoc.SelectSingleNode("/PlantFormat/DocStyles"));
				return _DocStyles;
			}
		}
		public bool HasPageListToken(string token)
		{;
		string xpath = string.Format("/PlantFormat/PageStyles/PageStyle/Item[@Token = '{0}']", token);
		XmlNodeList nl = XmlDoc.SelectNodes(xpath);
			return nl.Count > 0;
		}
	}
	#endregion
	#region VE_Font
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class VE_Font : vlnFormatItem
	{
		public VE_Font(XmlNode xmlNode) : base(xmlNode) { }
		public VE_Font(string family, int size, E_Style style, float CPI)
		{
			_Family = new LazyLoad<string>(family);
			_Size = new LazyLoad<int?>(size);
			_Style = new LazyLoad<E_Style?>(style);
			_CPI = new LazyLoad<float?>(CPI);
		}
		private LazyLoad<string> _Family;
		private Font _WindowsFont;
		public Font WindowsFont
		{
			get
			{
				if (_WindowsFont == null)
				{
					//FontStyle style = (Family == "Cornet")?FontStyle.Italic : FontStyle.Regular;
					FontStyle style = FontStyle.Regular;
					if (Style != E_Style.None)
					{
						if (((Style & E_Style.Bold) != 0) || ((Style & E_Style.MmBold) !=0))
							style |= FontStyle.Bold;
						if ((Style & E_Style.Italics) != 0)
							style |= FontStyle.Italic;
						if ((Style & E_Style.Underline) != 0)
							style |= FontStyle.Underline;
					}
					// for now - check size to be 0 and set to 10 if so, error in fmtxml?
					if (Family == null)  // Need to get inherited font
						_WindowsFont = new Font("Arial", 10, FontStyle.Regular);
					else
						_WindowsFont = new Font(Family, Size == 0 ? 10 : (float)Size, style);
				}
				return _WindowsFont;
			}
			set
			{
				_WindowsFont = value;
			}
		}
		[Description("Font Family")]
		public string Family
		{
			get
			{
				return LazyLoad(ref _Family,"Font/@Family");
			}
		}
		private LazyLoad<int?> _Size;
		[Description("Font Size (in Double Points)")]
		public int? Size
		{
			get
			{
				return LazyLoad(ref _Size, "Font/@Size");
			}
		}
		private LazyLoad<E_Style?> _Style;
		public E_Style? Style
		{
			get
			{
				return LazyLoad<E_Style>(ref _Style, "Font/@Style");
			}
			//set
			//{
			//  _Style.Value = value;
			//}
		}
		private LazyLoad<float?> _CPI;
		public float? CPI
		{
			get
			{
				return LazyLoad(ref _CPI, "Font/@CPI");
			}
		}
		public float CharsToTwips
		{
			get
			{
				return (72 / (CPI ?? 12));
			}

		}
		public override string ToString()
		{
			return string.Format("{0}, {1} pt, {2}", Family, Size, Style);
		}
		public bool FontIsProportional()
		{
			if (Family.Contains("Arial") || Family.Contains("Times New Roman")) return true;
			return false;
		}
	}
	#endregion
	#region FormatData
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class FormatData : vlnFormatItem
	{
		public FormatData(XmlNode xmlNode) : base(xmlNode) { }
		private LazyLoad<string> _Name;
		public string Name
		{ 
			get 
			{
				return LazyLoad(ref _Name, "@Name");
			} 
		}
		// TPL represents Templates which are sizes of columns for 'table' type data.  If the format
		// has the 'UseSmartTemplate' format flag, this table will have starting location & widths, and
		// other data for the listed step types.  Data from this table overrides width data as specified
		// by the step type format data.  The only active format that has 'UseSmartTemplate' is WCNCKL.
		// The TPL data is also used by other formats, many of which are using it for Enhanced Background
		// & Deviations.  The actual format of the template can be in an old or new format.  The old format
		// uses spaces as delimiters, the new uses commas.
		private LazyLoad<string> _TPL;
		public string TPL
		{
			get
			{
				return LazyLoad(ref _TPL, "@TPL");
			}
		}
		private bool _NewTemplateFormat;
		public bool NewTemplateFormat
		{
			get { return _NewTemplateFormat; }
			set { _NewTemplateFormat = value; }
		}
		private Dictionary<int, int> _TopTemplateTypes;
		public Dictionary<int, int> TopTemplateTypes
		{
			get
			{
				if (_TopTemplateTypes == null && Templates != null)
				{
					_TopTemplateTypes = new Dictionary<int, int>();
					// loop through all of templates to find those that are top level, i.e.
					// right below the '0'.
					int indx = 0;
					while (indx < Templates.Count)
					{
						// level of 0 starts a new group. 
						if (Templates[indx].level == 0) TopTemplateTypes[Templates[indx + 1].type] = indx + 1;
						indx++;
					}
				}
				return _TopTemplateTypes;
			}
		}
		private List<TPlate> _Templates;
		public List<TPlate> Templates
		{
			get
			{
				if (_Templates == null)   // Load template class from format's string data.
				{
					NewTemplateFormat = false;
					// count newlines - which gives number of template records.
					int NumTemplates = 0;
					if (TPL == null) return null;
					// if the template is modified by the plant specific code in the format migration,
					// it will contain an '&amp;' rather than '&'. 
					string tTPL = TPL.Replace("&amp;", "&");
					int indx = tTPL.IndexOf('\n');
					while (indx > -1)
					{
						NumTemplates++;
						indx = tTPL.Length > indx + 1 ? tTPL.IndexOf('\n', indx + 1) : -1;
					}
					if (NumTemplates == 0) return null;

					_Templates = new List<TPlate>(NumTemplates);
					// for each item, create and add to list
					if (TPL.IndexOf(',') > -1) NewTemplateFormat = true;
					int cnt = 0;

					int tmpStrIndxStart = 0;
					int tmpStrIndxEnd = 0;
					while (cnt < NumTemplates)
					{
						tmpStrIndxEnd = TPL.IndexOf("\n", tmpStrIndxStart);
						if (tmpStrIndxEnd < 0)
						{
							cnt++;
							continue;		// maybe extra newlines at end of string.
						}
						string tpl = TPL.Substring(tmpStrIndxStart, tmpStrIndxEnd-tmpStrIndxStart);
						tmpStrIndxStart = tmpStrIndxEnd + 1;
						int level = 0;
						int type = 0;
						int start = 0;
						int width = 0;
						short nocol = 0;
						int row = 0;
						string stmp = null;
						if (!NewTemplateFormat)
						{
							string[] tmpOld = tpl.Split(" ".ToCharArray());
							level = Convert.ToInt32(tmpOld[0]);
							type = Convert.ToInt32(tmpOld[1]);
							stmp = tmpOld.Length <= 2 ? null : tmpOld[2];
						}
						else
						{
							string[] tmpNew = tpl.Split(",".ToCharArray());
							if (tmpNew.Length < 5)
							{
								cnt++;
								continue;		// may be extra newlines at end of string
							}
							level = Convert.ToInt32(tmpNew[0]);
							type = Convert.ToInt32(tmpNew[1]);
							start = Convert.ToInt32(tmpNew[2]);
							width = Convert.ToInt32(tmpNew[3]);
							row = Convert.ToInt32(tmpNew[4]);
							nocol = Convert.ToInt16(tmpNew[5]);
							stmp = tmpNew.Length <= 6 ? null : tmpNew[6];
						}
						TPlate tp = new TPlate(level, type, start, width, row, nocol, stmp);
						_Templates.Add(tp);
						cnt++;
					}
				}
				return _Templates;
			}
		}

		private LazyLoad<E_PurchaseOptions?> _PurchaseOptions;
		public E_PurchaseOptions? PurchaseOptions
		{
			get
			{
				return LazyLoad<E_PurchaseOptions>(ref _PurchaseOptions, "@PurchaseOptions");
			}
		}
		private VE_Font _Font;
		public VE_Font Font
		{
			get
			{
				return _Font == null? _Font = new VE_Font(base.XmlNode): _Font;
			}
		}
		private SymbolList _SymbolList;
		public SymbolList SymbolList
		{
			get
			{
				return (_SymbolList == null) ? _SymbolList = new SymbolList(SelectNodes("Symbols/Symbol")) : _SymbolList;
			}
			set { _SymbolList = value; }
		}
		private EditData _EditData;
		public EditData EditData
		{
			get
			{
				return _EditData == null ? _EditData = new EditData(SelectSingleNode("EditData")): _EditData;
			}
		}
		private PrintData _PrintData;
		public PrintData PrintData
		{
			get
			{
				return _PrintData == null? _PrintData = new PrintData(SelectSingleNode("PrintData")):_PrintData;
			}
		}
		private ProcData _ProcData;
		public ProcData ProcData
		{
			get
			{
				return _ProcData == null? _ProcData = new ProcData(SelectSingleNode("ProcData")):_ProcData;
			}
		}
		private SectData _SectData;
		public SectData SectData
		{
			get
			{
				return _SectData == null? _SectData = new SectData(SelectSingleNode("SectData")):_SectData;
			}
		}
		private BoxList _BoxList;
		public BoxList BoxList
		{
			get
			{
				return _BoxList == null? _BoxList = new BoxList(SelectNodes("BoxData/Box"),MyFormat):_BoxList;
			}
			set { _BoxList = value; }
		}
		private TransData _TransData;
		public TransData TransData
		{
			get
			{
				return _TransData == null? _TransData = new TransData(SelectSingleNode("TransData")):_TransData;
			}
		}
		private ROData _ROData;
		public ROData ROData
		{
			get
			{
				return _ROData == null ? _ROData = new ROData(SelectSingleNode("ROData")) : _ROData;
			}
		}
		private StepDataList _StepDataList;
		public StepDataList StepDataList
		{
			get
			{
				return _StepDataList == null? _StepDataList = new StepDataList(SelectNodes("StepData/Step"),MyFormat):_StepDataList;
			}
			set { _StepDataList = value; }
		}
		public List<StepDataRetval> GetSearchableSteps()
		{
			List<StepDataRetval> sds = new List<StepDataRetval>();
			foreach (StepData sd in StepDataList)
			{
                if (!sd.Inactive && sd.StepEditData.Searchable && sd.StepEditData.TypeMenu.InMenu)
                        sds.Add(new StepDataRetval(sd.StepEditData.TypeMenu.MenuItem, Convert.ToInt32(sd.Index)));
			}
			return sds;
		}
		public StepData StepTopUnderBase(StepData sd, int formatStepType)
		{
			StepData top = sd;
			while (top.ParentType != "Base")
			{
				string sParStp = StepDataList[formatStepType].ParentType;
				foreach (StepData stp in StepDataList)
				{
					if (top.ParentType == stp.Type)
					{
						top = stp;
						break;
					}
				}
			}
			return top;
		}
		public List<StepDataRetval> StepGetLevelTypes(bool alwaysAdd, StepData topType, ref int cursel, string curType, ItemInfo _CurItemInfo)
		{
			List<StepDataRetval> sds = new List<StepDataRetval>();
			int retval = -1;
			int cntitm = 0;
			// if there are alternatenames for this item, use that list, otherwise, get list from
			// xml for current node & its children....   
			if (topType.StepEditData.TypeMenu.AlternateNameList != null && topType.StepEditData.TypeMenu.AlternateNameList != "")
			{
				// loop through the AlternateName string, it has indices for step types..
				string[] split = topType.StepEditData.TypeMenu.AlternateNameList.Split(new Char[] { ',' });
				foreach (string s in split)
				{
					foreach (StepData sd in this.StepDataList)
					{
						if (sd.Type == s && !sd.Inactive)
						{
							sds.Add(new StepDataRetval(sd.StepEditData.TypeMenu.MenuItem, Convert.ToInt32(sd.Index)));
							if (curType == sd.Type) retval = cntitm;
							cntitm++;
							break;
						}
					}
				}
			}

			// some menu items (step change types) can only be done in aer column, check for that.... 
			// also tables and figures off caution/notes must use rno data.
			else if (alwaysAdd || (topType.StepEditData.TypeMenu.InMenu && ((topType.StepEditData.TypeMenu.RnoInMenu) ||
				(!topType.StepEditData.TypeMenu.RnoInMenu && !_CurItemInfo.IsInRNO && !_CurItemInfo.IsCaution && !_CurItemInfo.IsNote) ||
				(topType.StepEditData.TypeMenu.RnoInMenu && _CurItemInfo.IsInRNO) ||
				(topType.StepEditData.TypeMenu.RnoInMenu && _CurItemInfo.IsCaution) ||
				(topType.StepEditData.TypeMenu.RnoInMenu && _CurItemInfo.IsNote))))
			{
				if (!topType.Inactive)
				{
					if ((_CurItemInfo.IsInRNO||_CurItemInfo.IsCaution||_CurItemInfo.IsNote) && topType.StepEditData.TypeMenu.RnoMenuItem != null && topType.StepEditData.TypeMenu.RnoMenuItem != "")
						sds.Add(new StepDataRetval(topType.StepEditData.TypeMenu.RnoMenuItem, Convert.ToInt32(topType.Index)));
					else
						sds.Add(new StepDataRetval(topType.StepEditData.TypeMenu.MenuItem, Convert.ToInt32(topType.Index)));

					if (topType.Type == curType) retval = cntitm;
					cntitm++;
				}
				foreach (StepData sd in StepDataList)
				{
					if (sd.ParentType == topType.Type)
					{
						int tmpindx = DoListChildStepTypes(alwaysAdd, ref sds, sd, curType, _CurItemInfo, ref cntitm);
						if (sd.Type == curType) retval = tmpindx;
						if (retval < 0 && tmpindx > 0) retval = tmpindx;
					}
				}
			}
			cursel = retval;
			return sds;
		}

		private int DoListChildStepTypes(bool alwaysAdd, ref List<StepDataRetval> sds, StepData topType, string curType, ItemInfo _CurItemInfo, ref int cntitm)
		{
			int retval = -1;
			if (alwaysAdd || (topType.StepEditData.TypeMenu.InMenu && ((topType.StepEditData.TypeMenu.RnoInMenu) ||
				(!topType.StepEditData.TypeMenu.RnoInMenu && !_CurItemInfo.IsInRNO&&!_CurItemInfo.IsCaution&&!_CurItemInfo.IsNote) ||
				(topType.StepEditData.TypeMenu.RnoInMenu && _CurItemInfo.IsInRNO) ||
				(topType.StepEditData.TypeMenu.RnoInMenu && _CurItemInfo.IsCaution) ||
				(topType.StepEditData.TypeMenu.RnoInMenu && _CurItemInfo.IsNote))))
			{
				if (!topType.Inactive)
				{
					if ((_CurItemInfo.IsInRNO||_CurItemInfo.IsCaution||_CurItemInfo.IsNote) && topType.StepEditData.TypeMenu.RnoMenuItem != null && topType.StepEditData.TypeMenu.RnoMenuItem != "")
						sds.Add(new StepDataRetval(topType.StepEditData.TypeMenu.RnoMenuItem, Convert.ToInt32(topType.Index)));
					else
						sds.Add(new StepDataRetval(topType.StepEditData.TypeMenu.MenuItem, Convert.ToInt32(topType.Index)));

					if (topType.Type == curType) retval = cntitm;
					cntitm++;
				}
				foreach (StepData sd in StepDataList)
				{
					if (sd.ParentType == topType.Type)
					{
						int tmpindx = DoListChildStepTypes(alwaysAdd, ref sds, sd, curType, _CurItemInfo, ref cntitm);
						if (sd.Type == curType) retval = tmpindx;
						if (retval < 0 && tmpindx > 0) retval = tmpindx;
					}
				}
			}
			return retval;
		}
		/// <summary>
		/// for format data given a string representing the Type of step, find the index.
		/// </summary>
		public int GetIndexFromType(string type)
		{
			foreach (StepData sd in StepDataList)
			{
				if (sd.Type == type) return (int)sd.Index;
			}
			return 0;  // default to the base
		}
	}
	#endregion
	#region Symbols
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class Symbol : vlnFormatItem
	{
		public Symbol(XmlNode xmlNode) : base(xmlNode) { }
		public Symbol() : base() { }
		[Category("Ints")]
		private LazyLoad<int?> _Unicode;
		public int? Unicode
		{
			get
			{
				return LazyLoad(ref _Unicode, "@Unicode");
			}
		}
		[Category("Strings")]
		private LazyLoad<string> _Desc;
		public string Desc
		{
			get
			{
				return LazyLoad(ref _Desc, "@Desc");
			}
		}
		public override string GetPDDisplayName()
		{ return Desc; }
		public override string GetPDDescription()
		{ return string.Format("Symbol Unicode '{0}' Description '{1}'", Unicode, Desc); }
		public override string GetPDCategory()
		{ return "Supported Symbols"; }
		public override string ToString()
		{
			return Desc;
		}
	}
	[TypeConverter(typeof(vlnListConverter<SymbolList, Symbol>))]
	public class SymbolList : vlnFormatList<Symbol>
	{
		public SymbolList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
	}
	#endregion
	#region Templates
	// the nocolm field -- divided into 4 four-bit subfields;
	// starting with the 4 lowest order bits :
	// field 1 - number of columns
	// field 2 - the header macro to print instead of the text(fixed at 4 for now)
	// field 3 - the number of blank lines after the header macro
	// field 4 - 1 - identifies the template as being boxed, for latter retrieval
	public class TPlate
	{
		public int level;		// sub-step level
		public int type;		// type of step/substep
		public int start;		// starting position (for horizontal only)
		public int width;		// width of text in characters (")
		public int row;
		public short nocolm;	// 1 or 2 columns - default(0) is one column
		public string text;		// text to be automatically entered
		public bool boxed;
		public int hmacro = 0;
		public TPlate(int l, int t, int s, int w, int r, short c, string x)
		{
			level = l;
			type = t;
			start = s;
			width = w;
			row = r;
			nocolm = c;
			hmacro = 0x00F0 & nocolm >> 4;
			if (hmacro > 0) hmacro = 4;   // bge - this was in 16bit code
			int blines = (0x0F00 & nocolm) >> 8;
			boxed = ((0xF000 & nocolm) >> 12) != 0;
			nocolm = (short)(0x000F & nocolm);
			text = x;
		}
	}
	#endregion
	#region EditData
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class EditData : vlnFormatItem
	{
		public EditData(XmlNode xmlNode) : base(xmlNode) { }		
		private LazyLoad<E_EMode?> _EMode;
		public E_EMode? EMode
		{
			get
			{
				return LazyLoad<E_EMode>(ref _EMode, "@EMode");
			}
		}
		private LazyLoad<bool> _PromptForCautionType;
		public bool PromptForCautionType
		{
			get
			{
				return LazyLoad(ref _PromptForCautionType, "@PromptForCautionType");
			}
		}
	}
	#endregion
	#region PrintDataAll
	#region PrintData
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class PrintData : vlnFormatItem
	{
		public PrintData(XmlNode xmlNode) : base(xmlNode) { }
		private VersionIdTextList _VersionIdTextList;
		public VersionIdTextList VersionIdTextList
		{
			get 
			{
				return _VersionIdTextList == null? _VersionIdTextList = new VersionIdTextList(SelectNodes("VersionIdText/string")):_VersionIdTextList; 
			}
			set { _VersionIdTextList = value; }
		}
		private ProcDescrList _ProcDescrList;
		public ProcDescrList ProcDescrList
		{
			get
			{
				return _ProcDescrList == null? _ProcDescrList = new ProcDescrList(SelectNodes("ProcDescrList/ProcDescr")):_ProcDescrList;
			}
		}
		private LazyLoad<int?> _DoPrnDrvrAdjusts;
		public int? DoPrnDrvrAdjusts
		{ 
			get 
			{
				return LazyLoad(ref _DoPrnDrvrAdjusts, "@DoPrnDrvrAdjusts");
			} 
		}
		private LazyLoad<string> _TopOfPageThing;
		public string TopOfPageThing
		{ 
			get 
			{
				return LazyLoad(ref _TopOfPageThing, "@TopOfPageThing");
			} 
		}
		private LazyLoad<bool> _DoRevDate;
		public bool DoRevDate
		{
			get
			{
				return LazyLoad(ref _DoRevDate, "@DoRevDate");
			}
		}
		private LazyLoad<bool> _AlternateFoldoutPages;
		public bool AlternateFoldoutPages
		{
			get
			{
				return LazyLoad(ref _AlternateFoldoutPages, "@AlternateFoldoutPages");
			}
		}
		private LazyLoad<bool> _AlternateFloatingFoldout;
		public bool AlternateFloatingFoldout
		{
			get
			{
				return LazyLoad(ref _AlternateFloatingFoldout, "@AlternateFloatingFoldout");
			}
		}
		private LazyLoad<bool> _SectionLevelFoldouts;
		public bool SectionLevelFoldouts
		{
			get
			{
				return LazyLoad(ref _SectionLevelFoldouts, "@SectionLevelFoldouts");
			}
		}
		private LazyLoad<string> _SlashReplace;
		public string SlashReplace
		{
			get
			{
				return LazyLoad(ref _SlashReplace, "@SlashReplace");
			}
		}
		private LazyLoad<bool> _RevDateWithForwardSlash;
		public bool RevDateWithForwardSlash
		{
			get
			{
				return LazyLoad(ref _RevDateWithForwardSlash, "@RevDateWithForwardSlash");
			}
		}
		private LazyLoad<bool> _UnitNumber;
		public bool UnitNumber
		{
			get
			{
				return LazyLoad(ref _UnitNumber, "@UnitNumber");
			}
		}
		private LazyLoad<bool> _SpecialCaseCalvert;
		public bool SpecialCaseCalvert
		{
			get
			{
				return LazyLoad(ref _SpecialCaseCalvert, "@SpecialCaseCalvert");
			}
		}
		private LazyLoad<bool> _SpecialCaseCalvertAlarm;
		public bool SpecialCaseCalvertAlarm
		{
			get
			{
				return LazyLoad(ref _SpecialCaseCalvertAlarm, "@SpecialCaseCalvertAlarm");
			}
		}
		private LazyLoad<bool> _SpecialStepsFoldout;
		public bool SpecialStepsFoldout
		{
			get
			{
				return LazyLoad(ref _SpecialStepsFoldout, "@SpecialStepsFoldout");
			}
		}
		private LazyLoad<bool> _AllowDuplex;
		public bool AllowDuplex
		{
			get
			{
				return LazyLoad(ref _AllowDuplex, "@AllowDuplex");
			}
		}
		private LazyLoad<bool> _AccessoryDocsInDuplex;
		public bool AccessoryDocsInDuplex
		{
			get
			{
				return LazyLoad(ref _AccessoryDocsInDuplex, "@AccessoryDocsInDuplex");
			}
		}
		private LazyLoad<bool> _FoldoutsInDuplex;
		public bool FoldoutsInDuplex
		{
			get
			{
				return LazyLoad(ref _FoldoutsInDuplex, "@FoldoutsInDuplex");
			}
		}
		private LazyLoad<bool> _PagelistChangeIDsWithCommas;
		public bool PagelistChangeIDsWithCommas
		{
			get
			{
				return LazyLoad(ref _PagelistChangeIDsWithCommas, "@PagelistChangeIDsWithCommas");
			}
		}
		private LazyLoad<bool> _SpecialCaseWestinghouse;
		public bool SpecialCaseWestinghouse
		{
			get
			{
				return LazyLoad(ref _SpecialCaseWestinghouse, "@SpecialCaseWestinghouse");
			}
		}
		// Put in for Comanche Peak to print "COMMON" for the unit number instead of "Unit 0"
		private LazyLoad<bool> _PrintCommonForZeroUnit;
		public bool PrintCommonForZeroUnit
		{
			get
			{
				return LazyLoad(ref _PrintCommonForZeroUnit, "@PrintCommonForZeroUnit");
			}
		}
	}
	#endregion
	#region VersionIdText
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class VersionIdText : vlnFormatItem
	{
		public VersionIdText(XmlNode xmlNode) : base(xmlNode) { }
		public VersionIdText() : base() { }
		private LazyLoad<string> _Text;
		public string Text
		{ 
			get 
			{
				return LazyLoad(ref _Text, "text()");
			} 
		}
		public override string GetPDDisplayName()
		{ return "Text"; }
		public override string GetPDDescription()
		{ return string.Format("VersionIdText '{0}'", Text); }
		public override string GetPDCategory()
		{ return "Version Id Text"; }
		public override string ToString()
		{
			return Text;
		}
	}
	#endregion
	#region VersionIdTextList
	[TypeConverter(typeof(vlnListConverter<VersionIdTextList, VersionIdText>))]
	public class VersionIdTextList : vlnFormatList<VersionIdText>
	{
		public VersionIdTextList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
	}
	#endregion
	#region ProcDescr
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public partial class ProcDescr : vlnFormatItem //: BusinessBase<ProcDescr>, IDisposable
	{
		public ProcDescr(XmlNode xmlNode) : base(xmlNode) {	}
		public ProcDescr() : base() { }
		private LazyLoad<string> _MatchProcNumber;
		public string MatchProcNumber
		{
			get
			{
				return LazyLoad(ref _MatchProcNumber, "@MatchProcNumber");
			}
		}
		private LazyLoad<string> _ProcDescr1;
		public string ProcDescr1
		{
			get
			{
				return LazyLoad(ref _ProcDescr1, "@ProcDescr1");
			}
		}
		private LazyLoad<string> _ProcDescr2;
		public string ProcDescr2
		{
			get
			{
				return LazyLoad(ref _ProcDescr2, "@ProcDescr2");
			}
		}
		public override string ToString()
		{
			return string.Format("{0}, {1}", ProcDescr1, MatchProcNumber);
		}
	}
	#region ProcDescrList
	[TypeConverter(typeof(vlnListConverter<ProcDescrList, ProcDescr>))]
	public class ProcDescrList : vlnFormatList<ProcDescr>
	{
		public ProcDescrList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
	}
	#endregion
	#endregion
	#endregion
	#region ProcDataAll
	#region ProcData
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class ProcData : vlnFormatItem
	{
		public ProcData(XmlNode xmlNode): base(xmlNode)	{}
		private ProcedureSuffixList _ProcedureSuffixList;
		public ProcedureSuffixList ProcedureSuffixList
		{
			get
			{
				return _ProcedureSuffixList == null? _ProcedureSuffixList = new ProcedureSuffixList(SelectNodes("ProcedureSuffix/string")):	_ProcedureSuffixList;
			}
			set { _ProcedureSuffixList = value; }
		}
		private ChangeBarData _ChangeBarData;
		public ChangeBarData ChangeBarData
		{
			get
			{
				return _ChangeBarData == null? _ChangeBarData = new ChangeBarData(SelectSingleNode("ChangeBarData")):_ChangeBarData;
			}
		}
		private CheckOffData _CheckOffData;
		public CheckOffData CheckOffData
		{
			get
			{
				return _CheckOffData == null? _CheckOffData = new CheckOffData(SelectSingleNode("CheckOffData")):_CheckOffData;
			}
		}
		private PSI _PSI;
		public PSI PSI
		{
			get
			{
				return _PSI == null ? _PSI = new PSI(SelectSingleNode("PSI")) : _PSI;
			}
		}
		private LazyLoad<int?> _TitleLength;
		public int? TitleLength
		{ 
			get 
			{
				return LazyLoad(ref _TitleLength, "@TitleLength");
			} 
		}
		private LazyLoad<int?> _CoverTitleLength;
		public int? CoverTitleLength
		{ 
			get 
			{
				return LazyLoad(ref _CoverTitleLength, "@CoverTitleLength");
			} 
		}
		private LazyLoad<string> _ProcedureSuffixFlags;
		public string ProcedureSuffixFlags
		{ 
			get 
			{
				return LazyLoad(ref _ProcedureSuffixFlags, "@ProcedureSuffixFlags"); 
			} 
		}
		private LazyLoad<bool> _CapitalizeTitle;
		public bool CapitalizeTitle
		{
			get
			{
				return LazyLoad(ref _CapitalizeTitle, "@CapitalizeTitle");
			}
		}
		private LazyLoad<bool> _ChangeStyleForEverySection;
		public bool ChangeStyleForEverySection
		{
			get
			{
				return LazyLoad(ref _ChangeStyleForEverySection, "@ChangeStyleForEverySection");
			}
		}
		private LazyLoad<bool> _PrintNoTitle;
		public bool PrintNoTitle
		{
			get
			{
				return LazyLoad(ref _PrintNoTitle, "@PrintNoTitle");
			}
		}
		private LazyLoad<bool> _CountFoldoutPages;
		public bool CountFoldoutPages
		{
			get
			{
				return LazyLoad(ref _CountFoldoutPages, "@CountFoldoutPages");
			}
		}
		private LazyLoad<string> _ForeColor;
		public string ForeColor
		{
			get
			{
				return LazyLoad(ref _ForeColor, "@ForeColor");
			}
		}
		private LazyLoad<string> _BackColor;
		public string BackColor
		{
			get
			{
				return LazyLoad(ref _BackColor, "@BackColor");
			}
		}
	}
	#endregion
	#region ProcedureSuffix
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class ProcedureSuffix : vlnFormatItem
	{
		public ProcedureSuffix(XmlNode xmlNode) : base(xmlNode) { }
		public ProcedureSuffix() : base() { }
		private LazyLoad<string> _Text;
		public string Text
		{ 
			get 
			{
				return LazyLoad(ref _Text, "text()");
			} 
		}
		public override string GetPDDisplayName()
		{ return "Text"; }
		public override string GetPDDescription()
		{ return string.Format("ProcedureSuffix '{0}'", Text); }
		public override string GetPDCategory()
		{ return "Procedure Suffix"; }
		public override string ToString()
		{
			return Text;
		}
	}
	#endregion
	#region ProcedureSuffixList
	[TypeConverter(typeof(vlnListConverter<ProcedureSuffixList, ProcedureSuffix>))]
	public class ProcedureSuffixList : vlnFormatList<ProcedureSuffix>
	{
		public ProcedureSuffixList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
	}
	#endregion
	#region PsiAll
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class PSI : vlnFormatItem
	{
		public PSI(XmlNode xmlNode) : base(xmlNode) { }
		private LazyLoad<int?> _x;
		public int? x
		{
			get
			{
				return LazyLoad(ref _x, "@x");
			}
		}
		private LazyLoad<int?> _y;
		public int? y
		{
			get
			{
				return LazyLoad(ref _y, "@y");
			}
		}
		private LazyLoad<string> _Caption;
		public string Caption
		{
			get
			{
				return LazyLoad(ref _Caption, "@Caption");
			}
		}
		private LazyLoad<string> _ButtonsOnBottom;	// change to bool
		public string ButtonsOnBottom
		{
			get
			{
				return LazyLoad(ref _ButtonsOnBottom, "@ButtonsOnBottom");
			}
		}
		private PsiLabels _LabelList;
		public PsiLabels LabelList
		{
			get
			{
				return _LabelList == null ? _LabelList = new PsiLabels(SelectNodes("/PlantFormat/FormatData/ProcData/PSI/Label")) : _LabelList;
			}
		}
		private PsiFields _FieldList;
		public PsiFields FieldList
		{
			get
			{
				return _FieldList == null ? _FieldList = new PsiFields(SelectNodes("/PlantFormat/FormatData/ProcData/PSI/Field")) : _FieldList;
			}
		}
	}
	public class PsiLabels : vlnFormatList<PsiLabel>
	{
		public PsiLabels(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
	}

	public class PsiLabel : vlnFormatItem
	{
		public PsiLabel(XmlNode xmlNode) : base(xmlNode) { }
		public PsiLabel() : base() { }
		private LazyLoad<string> _text;
		public string text
		{
			get
			{
				return LazyLoad(ref _text, "@text");
			}
		}
		private LazyLoad<string> _Justify;
		public string Justify
		{
			get
			{
				return LazyLoad(ref _Justify, "@Justify");
			}
		}
		private LazyLoad<int?> _x;
		public int? x
		{
			get
			{
				return LazyLoad(ref _x, "@x");
			}
		}
		private LazyLoad<int?> _y;
		public int? y
		{
			get
			{
				return LazyLoad(ref _y, "@y");
			}
		}
		private LazyLoad<int?> _width;
		public int? width
		{
			get
			{
				return LazyLoad(ref _width, "@width");
			}
		}
		private LazyLoad<int?> _height;
		public int? height
		{
			get
			{
				return LazyLoad(ref _height, "@height");
			}
		}
	}
	public class PsiFields : vlnFormatList<PsiField>
	{
		public PsiFields(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
	}
	public class PsiField : vlnFormatItem
	{
		public PsiField(XmlNode xmlNode) : base(xmlNode) { }
		public PsiField() : base() { }
		private LazyLoad<string> _name;
		public string name
		{
			get
			{
				return LazyLoad(ref _name, "@name");
			}
		}
		private LazyLoad<string> _type;
		public string type
		{
			get
			{
				return LazyLoad(ref _type, "@type");
			}
		}
		private LazyLoad<string> _text;
		public string text
		{
			get
			{
				return LazyLoad(ref _text, "@text");
			}
		}
		private LazyLoad<int?> _Length;
		public int? Length
		{
			get
			{
				return LazyLoad(ref _Length, "@Length");
			}
		}
		private LazyLoad<int?> _x;
		public int? x
		{
			get
			{
				return LazyLoad(ref _x, "@x");
			}
		}
		private LazyLoad<int?> _y;
		public int? y
		{
			get
			{
				return LazyLoad(ref _y, "@y");
			}
		}
		private LazyLoad<int?> _width;
		public int? width
		{
			get
			{
				return LazyLoad(ref _width, "@width");
			}
		}
		private LazyLoad<int?> _height;
		public int? height
		{
			get
			{
				return LazyLoad(ref _height, "@height");
			}
		}
	}
	#endregion
	#region CheckOffAll
	#region CheckOffData
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class CheckOffData : vlnFormatItem
	{
		public CheckOffData(XmlNode xmlNode) : base(xmlNode) { }
		private CheckOffList _CheckOffList;
		public CheckOffList CheckOffList
		{
			get
			{
				return _CheckOffList == null? _CheckOffList = new CheckOffList(SelectNodes("CheckOffList/CheckOff"),MyFormat):_CheckOffList;
			}
		}
		private CheckOffHeaderList _CheckOffHeaderList;
		public CheckOffHeaderList CheckOffHeaderList
		{
			get
			{
				return _CheckOffHeaderList == null? _CheckOffHeaderList = new CheckOffHeaderList(SelectNodes("CheckOffHeaderList/CheckOffHeader"),MyFormat):	_CheckOffHeaderList;
			}
		}
		private LazyLoad<string> _Menu;
		public string Menu
		{
			get
			{
				return LazyLoad(ref _Menu, "@Menu");
			}
		}
		private LazyLoad<bool> _AllowSectEdit;
		public bool AllowSectEdit
		{
			get
			{
				return LazyLoad(ref _AllowSectEdit, "@AllowSectEdit");
			}
		}
		private LazyLoad<bool> _AllowStepEdit;
		public bool AllowStepEdit
		{
			get
			{
				return LazyLoad(ref _AllowStepEdit, "@AllowStepEdit");
			}
		}
		private LazyLoad<int?> _UseCheckOffsIn;
		public int? UseCheckOffsIn
		{
			get
			{
				return LazyLoad(ref _UseCheckOffsIn, "@UseCheckOffsIn");
			}
		}
		private LazyLoad<float?> _CheckOffAdjustment;
		public float? CheckOffAdjustment
		{ 
			get 
			{
				return LazyLoad(ref _CheckOffAdjustment, "@CheckOffAdjustment");
			}
		}
		private LazyLoad<float?> _XLocation;
		public float? XLocation
		{
			get
			{
				return LazyLoad(ref _XLocation, "@XLocation");
			}
		}
		private LazyLoad<float?> _RelXLocation;
		public float? RelXLocation
		{
			get
			{
				return LazyLoad(ref _RelXLocation, "@RelXLocation");
			}
		}
		private LazyLoad<int?> _CheckOffXtraLines;
		public int? CheckOffXtraLines
		{
			get
			{
				return LazyLoad(ref _CheckOffXtraLines, "@CheckOffXtraLines");
			}
		}
		private LazyLoad<bool> _DropCheckOff;
		public bool DropCheckOff
		{
			get
			{
				return LazyLoad(ref _DropCheckOff, "@DropCheckOff");
			}
		}
		private LazyLoad<bool> _CheckOffOnHLSOnly;
		public bool CheckOffOnHLSOnly
		{
			get
			{
				return LazyLoad(ref _CheckOffOnHLSOnly, "@CheckOffOnHLSOnly");
			}
		}
		private LazyLoad<bool> _SkipSpaces;
		public bool SkipSpaces
		{
			get
			{
				return LazyLoad(ref _SkipSpaces, "@SkipSpaces");
			}
		}
		// put in for Bryon and Braidwood
		private LazyLoad<bool> _CheckoffOnSubStepsOnly;
		public bool CheckoffOnSubStepsOnly
		{
			get
			{
				return LazyLoad(ref _CheckoffOnSubStepsOnly, "@CheckoffOnSubStepsOnly");
			}
		}
	}
	#endregion
	//#region RightCheckOffBox
	//[TypeConverter(typeof(ExpandableObjectConverter))]
	//public class RightCheckOffBox : vlnFormatItem, IVlnIndexedFormatItem
	//{
	//    public RightCheckOffBox(XmlNode xmlNode) : base(xmlNode) { }
	//    public RightCheckOffBox() : base() { }
	//    private LazyLoad<int?> _Index;
	//    public int? Index
	//    { 
	//        get 
	//        {
	//            return LazyLoad(ref _Index, "@Index");
	//        } 
	//    }
	//    private LazyLoad<int?> _RightCheckOffBoxChar;
	//    public int? RightCheckOffBoxChar
	//    { 
	//        get 
	//        {
	//            return LazyLoad(ref _RightCheckOffBoxChar, "@RightCheckOffBoxChar");
	//        } 
	//    }
	//    public override string GetPDDisplayName()
	//    { return string.Format("[{0}]", Index); }
	//    public override string GetPDDescription()
	//    { return string.Format("[{0}] - {1}", Index, RightCheckOffBoxChar); }
	//    public override string GetPDCategory()
	//    { return "RightCheckOffBox Data"; }
	//    public override string ToString()
	//    {
	//        return RightCheckOffBoxChar.ToString();
	//    }
	//}
	//#endregion
	//#region RightCheckOffBoxList
	//[TypeConverter(typeof(vlnIndexedListConverter<RightCheckOffBoxList, RightCheckOffBox>))]
	//public class RightCheckOffBoxList : vlnIndexedFormatList<RightCheckOffBox>
	//{
	//    public RightCheckOffBoxList(XmlNodeList xmlNodeList,IFormatOrFormatInfo myFormat) : base(xmlNodeList,myFormat) { }
	//    public override vlnIndexedFormatList<RightCheckOffBox> InheritedList
	//    {
	//        get
	//        {
	//            IFormatOrFormatInfo parentFormat = MyFormat.MyIParent;
	//            if (parentFormat != null)
	//                return parentFormat.PlantFormat.FormatData.ProcData.CheckOffData.RightCheckOffBoxList;
	//            return null;
	//        }
	//    }
	//}
	//#endregion
	#region CheckOff
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class CheckOff : vlnFormatItem,IVlnIndexedFormatItem
	{
		public CheckOff(XmlNode xmlNode) : base(xmlNode) { }
		public CheckOff() : base() { }
		private LazyLoad<int?> _Index;
		public int? Index
		{
			get
			{
				return LazyLoad(ref _Index, "@Index");
			}
		}
		private LazyLoad<int?> _UIMark;
		public int? UIMark
		{
			get
			{
				return LazyLoad(ref _UIMark, "@UIMark");
			}
		}
		private LazyLoad<float?> _CheckOffWidAdjust;
		public float? CheckOffWidAdjust
		{ 
			get 
			{
				return LazyLoad(ref _CheckOffWidAdjust, "@CheckOffWidAdjust");
			} 
		}
		private LazyLoad<string> _MenuItem;
		public string MenuItem
		{ 
			get 
			{
				return LazyLoad(ref _MenuItem, "@MenuItem");
			} 
		}
		private LazyLoad<string> _Macro;
		public string Macro
		{
			get
			{
				return LazyLoad(ref _Macro, "@Macro");
			}
		}
		private LazyLoad<bool> _NotOnEmpty;
		public bool NotOnEmpty
		{
			get
			{
				return LazyLoad(ref _NotOnEmpty, "@NotOnEmpty");
			}
		}
		public override string GetPDDisplayName()
		{ return string.Format("[{0}]",Index); }
		public override string GetPDDescription()
		{ return string.Format("[{0}] - {1}", Index, MenuItem); }
		public override string GetPDCategory()
		{ return "Checkoff Data"; }
		public override string ToString()
		{
			return MenuItem;
		}
	}
	#endregion
	#region CheckOffList
	[TypeConverter(typeof(vlnIndexedListConverter<CheckOffList, CheckOff>))]
	public class CheckOffList : vlnIndexedFormatList<CheckOff>
	{
		public CheckOffList(XmlNodeList xmlNodeList,IFormatOrFormatInfo myFormat) : base(xmlNodeList,myFormat) { }
		public override vlnIndexedFormatList<CheckOff> InheritedList
		{
			get
			{
				IFormatOrFormatInfo parentFormat = MyFormat.MyIParent;
				if (parentFormat != null)
					return parentFormat.PlantFormat.FormatData.ProcData.CheckOffData.CheckOffList;
				return null;
			}
		}
	}
	#endregion
	#region CheckOffHeader
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class CheckOffHeader : vlnFormatItem,IVlnIndexedFormatItem
	{
		public CheckOffHeader(XmlNode xmlNode) : base(xmlNode) { }
		public CheckOffHeader() : base() { }
		private LazyLoad<int?> _Index;
		public int? Index
		{
			get
			{
				return LazyLoad(ref _Index, "@Index");
			}
		}
		private VE_Font _Font;
		public VE_Font Font
		{
			get
			{
				return (_Font == null ? _Font = new VE_Font(base.XmlNode) : _Font);
			}
		}
		private LazyLoad<string> _CheckOffHeading;
		public string CheckOffHeading
		{ 
			get 
			{
				return LazyLoad(ref _CheckOffHeading, "@CheckOffHeading"); 
			} 
		}
		public override string GetPDDisplayName()
		{ return string.Format("[{0}]", Index); }
		public override string GetPDDescription()
		{ return string.Format("[{0}] - {1}", Index, CheckOffHeading); }
		public override string GetPDCategory()
		{ return "Checkoff Header Data"; }
		public override string ToString()
		{
			return CheckOffHeading;
		}
	}
		#endregion
	#region CheckOffHeaderList
	[TypeConverter(typeof(vlnIndexedListConverter<CheckOffHeaderList, CheckOffHeader>))]
	public class CheckOffHeaderList : vlnIndexedFormatList<CheckOffHeader>
	{
		public CheckOffHeaderList(XmlNodeList xmlNodeList,IFormatOrFormatInfo myFormat) : base(xmlNodeList,myFormat) { }
		public override vlnIndexedFormatList<CheckOffHeader> InheritedList
		{
			get
			{
				IFormatOrFormatInfo parentFormat = MyFormat.MyIParent;
				if (parentFormat != null)
					return parentFormat.PlantFormat.FormatData.ProcData.CheckOffData.CheckOffHeaderList;
				return null;
			}
		}
	}
	#endregion
	#endregion
	#region ChangeBarData
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class ChangeBarData : vlnFormatItem
	{
		public ChangeBarData(XmlNode xmlNode) : base(xmlNode) { }
		private LazyLoad<string> _DefaultCBLoc;
		public string DefaultCBLoc
		{
			get
			{
				return LazyLoad(ref _DefaultCBLoc, "@DefaultCBLoc");
			}
		}
		private LazyLoad<string> _ChangeBarMessage;
		public string ChangeBarMessage
		{ 
			get 
			{ 
				return LazyLoad(ref _ChangeBarMessage, "@ChangeBarMessage"); 
			} 
		}
		private LazyLoad<int?> _FixedChangeColumn;
		public int? FixedChangeColumn
		{ 
			get 
			{ 
				return LazyLoad(ref _FixedChangeColumn, "@FixedChangeColumn");
			} 
		}
		private LazyLoad<int?> _FixedAERChangeColumn;
		public int? FixedAERChangeColumn
		{ 
			get 
			{
				return LazyLoad(ref _FixedAERChangeColumn, "@FixedAERChangeColumn"); 
			} 
		}
		private LazyLoad<E_Style?> _ChangeSummaryStyle;
		public E_Style? ChangeSummaryStyle
		{
			get
			{
				return LazyLoad<E_Style>(ref _ChangeSummaryStyle, "@ChangeSummaryStyle");
			}
		}
		private LazyLoad<E_Style?> _ChangeBarStyle;
		public E_Style? ChangeBarStyle
		{
			get
			{
				return LazyLoad<E_Style>(ref _ChangeBarStyle, "@ChangeBarStyle");
			}
		}
		private LazyLoad<string> _SpecialChangeBar;
		public string SpecialChangeBar
		{ 
			get 
			{ 
				return LazyLoad(ref _SpecialChangeBar, "@SpecialChangeBar"); 
			} 
		}
		private LazyLoad<bool> _CondensedChangeBar;
		public bool CondensedChangeBar
		{
			get
			{
				return LazyLoad(ref _CondensedChangeBar, "@CondensedChangeBar");
			}
		}
		private LazyLoad<bool> _AbsoluteFixedChangeColumn;
		public bool AbsoluteFixedChangeColumn
		{
			get
			{
				return LazyLoad(ref _AbsoluteFixedChangeColumn, "@AbsoluteFixedChangeColumn");
			}
		}
		private LazyLoad<bool> _ContinuousChangeBars;
		public bool ContinuousChangeBars
		{
			get
			{
				return LazyLoad(ref _ContinuousChangeBars, "@ContinuousChangeBars");
			}
		}
		private LazyLoad<bool> _ChgBarMessageFromEdit;
		public bool ChgBarMessageFromEdit
		{
			get
			{
				return LazyLoad(ref _ChgBarMessageFromEdit, "@ChgBarMessageFromEdit");
			}
		}
		private LazyLoad<bool> _ChangeIds;
		public bool ChangeIds
		{
			get
			{
				return LazyLoad(ref _ChangeIds, "@ChangeIds");
			}
		}
		private LazyLoad<bool> _ChangeBarToRNOSep;
		public bool ChangeBarToRNOSep
		{
			get
			{
				return LazyLoad(ref _ChangeBarToRNOSep, "@ChangeBarToRNOSep");
			}
		}
		private LazyLoad<bool> _ChangeBarsOnLinkedText;
		public bool ChangeBarsOnLinkedText
		{
			get
			{
				return LazyLoad(ref _ChangeBarsOnLinkedText, "@ChangeBarsOnLinkedText");
			}
		}
	}
	#endregion
	#endregion
	#region SectDataAll
	#region SectData
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class SectData : vlnFormatItem
	{
		public SectData(XmlNode xmlNode) : base(xmlNode) { }
		private SectionNumber _SectionNumber;
		public SectionNumber SectionNumber
		{
			get
			{
				if (_SectionNumber == null) _SectionNumber = new SectionNumber(SelectSingleNode("SectionNumber"));
				return _SectionNumber;
			}
		}
		private SectionHeader _SectionHeader;
		public SectionHeader SectionHeader
		{
			get
			{
				if (_SectionHeader == null) _SectionHeader = new SectionHeader(SelectSingleNode("SectionHeader"));
				return _SectionHeader;
			}
		}
		private StepSectionData _StepSectionData;
		public StepSectionData StepSectionData
		{
			get
			{
				if (_StepSectionData == null) _StepSectionData = new StepSectionData(SelectSingleNode("StepSectionData"));
				return _StepSectionData;
			}
		}
		private AccSectionData _AccSectionData;
		public AccSectionData AccSectionData
		{
			get
			{
				if (_AccSectionData == null) _AccSectionData = new AccSectionData(SelectSingleNode("AccSectionData"));
				return _AccSectionData;
			}
		}
		private MetaSectionList _MetaSectionList;
		public MetaSectionList MetaSectionList
		{
			get
			{
				if (_MetaSectionList == null) _MetaSectionList = new MetaSectionList(SelectNodes("MetaSectionData/MetaSection"),MyFormat);
				return _MetaSectionList;
			}
			set { _MetaSectionList = value; }
		}
		private ReplaceStrList _ReplaceStrList;
		public ReplaceStrList ReplaceStrList
		{
			get
			{
				return (_ReplaceStrList == null) ? _ReplaceStrList = new ReplaceStrList(SelectNodes("ReplaceStrData/ReplaceStr")) : _ReplaceStrList;
			}
			set { _ReplaceStrList = value; }
		}
		private LazyLoad<int?> _SectionTitleLength;
		public int? SectionTitleLength
		{ 
			get 
			{ 
				return LazyLoad(ref _SectionTitleLength, "@SectionTitleLength"); 
			} 
		}
		private LazyLoad<string> _ForeColor;
		public string ForeColor
		{
			get
			{
				return LazyLoad(ref _ForeColor, "@ForeColor");
			}
		}
		private LazyLoad<string> _BackColor;
		public string BackColor
		{
			get
			{
				return LazyLoad(ref _BackColor, "@BackColor");
			}
		}
		private LazyLoad<bool> _MetaSectEndMessage;
		public bool MetaSectEndMessage
		{
			get
			{
				return LazyLoad(ref _MetaSectEndMessage, "@MetaSectEndMessage");
			}
		}
		private LazyLoad<bool> _ReadOnlyTypeInContMsg;
		public bool ReadOnlyTypeInContMsg
		{
			get
			{
				return LazyLoad(ref _ReadOnlyTypeInContMsg, "@ReadOnlyTypeInContMsg");
			}
		}
		private LazyLoad<bool> _ReplaceWordsInROs;
		public bool ReplaceWordsInROs
		{
			get
			{
				return LazyLoad(ref _ReplaceWordsInROs, "@ReplaceWordsInROs");
			}
		}
		private LazyLoad<bool> _UseMetaSections;
		public bool UseMetaSections
		{
			get
			{
				return LazyLoad(ref _UseMetaSections, "@UseMetaSections");
			}
		}
		private LazyLoad<bool> _PrintPhoneList;
		public bool PrintPhoneList
		{
			get
			{
				return LazyLoad(ref _PrintPhoneList, "@PrintPhoneList");
			}
		}
		private LazyLoad<bool> _DefaultNoSubAutoIndent;
		public bool DefaultNoSubAutoIndent
		{
			get
			{
				return LazyLoad(ref _DefaultNoSubAutoIndent, "@DefaultNoSubAutoIndent");
			}
		}
		private LazyLoad<bool> _NonEditableSteps;
		public bool NonEditableSteps
		{
			get
			{
				return LazyLoad(ref _NonEditableSteps, "@NonEditableSteps");
			}
		}
		private LazyLoad<bool> _SearchAllReplaceWords;
		public bool SearchAllReplaceWords
		{
			get
			{
				return LazyLoad(ref _SearchAllReplaceWords, "@SearchAllReplaceWords");
			}
		}
		private LazyLoad<bool> _SecTitleContinue;
		public bool SecTitleContinue
		{
			get
			{
				return LazyLoad(ref _SecTitleContinue, "@SecTitleContinue");
			}
		}
		private LazyLoad<bool> _ConvertCaretToDelta;
		public bool ConvertCaretToDelta
		{
			get
			{
				return LazyLoad(ref _ConvertCaretToDelta, "@ConvertCaretToDelta");
			}
		}
		// This format flag turns off the Replace Words functionality.
		// in 16-bit proms, this was done simply by having an empty Replace Words list.
		// in 32-bit the inheiradence logic finds a replace words list in the base format
		// if the plant format does not have one.  Thus the need of this format flag.
		private LazyLoad<bool> _TurnOffReplaceWords;
		public bool TurnOffReplaceWords
		{
			get
			{
				return LazyLoad(ref _TurnOffReplaceWords, "@TurnOffReplaceWords");
			}
		}
	}
	#endregion
	#region SectionNumber
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class SectionNumber : vlnFormatItem
	{
		public SectionNumber(XmlNode xmlNode) : base(xmlNode) { }
		public SectionNumber() : base() { }
		private LazyLoad<float?> _Pos;
		public float? Pos
		{ 
			get 
			{ 
				return LazyLoad(ref _Pos, "@Pos"); 
			} 
		}
		private LazyLoad<string> _Just;
		public string Just
		{ 
			get 
			{
				return LazyLoad(ref _Just, "@Just");
			} 
		}
		private LazyLoad<bool> _Level0Big;
		public bool Level0Big
		{
			get
			{
				return LazyLoad(ref _Level0Big, "@Level0Big");
			}
		}
		private VE_Font _Font;
		public VE_Font Font
		{
			get
			{
				return (_Font == null ? _Font = new VE_Font(base.XmlNode) : _Font);
			}
		}
	}
	#endregion
	#region SectionHeader
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class SectionHeader : vlnFormatItem
	{
		public SectionHeader(XmlNode xmlNode) : base(xmlNode) { }
		public SectionHeader() : base() { }
		private LazyLoad<float?> _Pos;
		public float? Pos
		{
			get
			{
				return LazyLoad(ref _Pos, "@Pos");
			}
		}
		private LazyLoad<string> _Just;
		public string Just
		{
			get
			{
				return LazyLoad(ref _Just, "@Just");
			}
		}
		private LazyLoad<bool> _Level0Big;
		public bool Level0Big
		{
			get
			{
				return LazyLoad(ref _Level0Big, "@Level0Big");
			}
		}
		private VE_Font _Font;
		public VE_Font Font
		{
			get
			{
				return (_Font == null ? _Font = new VE_Font(base.XmlNode) : _Font);
			}
		}
	}
	#endregion
	#region StepSectionDataAll
	#region StepSectionData
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class StepSectionData : vlnFormatItem
	{
		public StepSectionData(XmlNode xmlNode) : base(xmlNode) { }
		private TextTypeValueList _TextTypeValueList;
		public TextTypeValueList TextTypeValueList
		{
			get
			{
				return (_TextTypeValueList == null)? _TextTypeValueList = new TextTypeValueList(SelectNodes("TextTypeValue/short")): _TextTypeValueList;
			}
			set { _TextTypeValueList = value; }
		}
		private TextTypeList _TextTypeList;
		public TextTypeList TextTypeList
		{
			get
			{
				return (_TextTypeList == null)? _TextTypeList = new TextTypeList(SelectNodes("TextType/string")): _TextTypeList;
			}
			set { _TextTypeList = value; }
		}
		//private SeqTabList _SeqTabList;
		//public SeqTabList SeqTabList
		//{
		//    get
		//    {
		//        return (_SeqTabList == null)? _SeqTabList = new SeqTabList(SelectNodes("SeqTab/string")): _SeqTabList;
		//    }
		//    set { _SeqTabList = value; }
		//}
		//private PreSeqTabEditList _PreSeqTabEditList;
		//public PreSeqTabEditList PreSeqTabEditList
		//{
		//    get
		//    {
		//        return (_PreSeqTabEditList == null) ?_PreSeqTabEditList = new PreSeqTabEditList(SelectNodes("PreSeqTabEdit/string")): _PreSeqTabEditList;
		//    }
		//    set { _PreSeqTabEditList = value; }
		//}
		//private PreSeqTabPrintList _PreSeqTabPrintList;
		//public PreSeqTabPrintList PreSeqTabPrintList
		//{
		//    get
		//    {
		//        return (_PreSeqTabPrintList == null)? _PreSeqTabPrintList = new PreSeqTabPrintList(SelectNodes("PreSeqTabPrint/string")):_PreSeqTabPrintList;
		//    }
		//    set { _PreSeqTabPrintList = value; }
		//}
		//private PostSeqTabEditList _PostSeqTabEditList;
		//public PostSeqTabEditList PostSeqTabEditList
		//{
		//    get
		//    {
		//        return (_PostSeqTabEditList == null)? _PostSeqTabEditList = new PostSeqTabEditList(SelectNodes("PostSeqTabEdit/string")): _PostSeqTabEditList;
		//    }
		//    set { _PostSeqTabEditList = value; }
		//}
		//private PostSeqTabPrintList _PostSeqTabPrintList;
		//public PostSeqTabPrintList PostSeqTabPrintList
		//{
		//    get
		//    {
		//        return (_PostSeqTabPrintList == null)? _PostSeqTabPrintList = new PostSeqTabPrintList(SelectNodes("PostSeqTabPrint/string")): _PostSeqTabPrintList;
		//    }
		//    set { _PostSeqTabPrintList = value; }
		//}
		private UnderlineTerminateList _UnderlineTerminateList;
		public UnderlineTerminateList UnderlineTerminateList
		{
			get
			{
				return (_UnderlineTerminateList == null)? _UnderlineTerminateList = new UnderlineTerminateList(SelectNodes("UnderlineTerminate/string")):_UnderlineTerminateList;
			}
			set { _UnderlineTerminateList = value; }
		}
		private ObserveNCString1List _ObserveNCString1List;
		public ObserveNCString1List ObserveNCString1List
		{
			get
			{
				return (_ObserveNCString1List == null)? _ObserveNCString1List = new ObserveNCString1List(SelectNodes("ObserveNCString1/string")): _ObserveNCString1List;
			}
			set { _ObserveNCString1List = value; }
		}
		private ObserveNCString2List _ObserveNCString2List;
		public ObserveNCString2List ObserveNCString2List
		{
			get
			{
				return (_ObserveNCString2List == null)? _ObserveNCString2List = new ObserveNCString2List(SelectNodes("ObserveNCString2/string")):_ObserveNCString2List;
			}
			set { _ObserveNCString2List = value; }
		}
		private StepSectionLayoutData _StepSectionLayoutData;
		public StepSectionLayoutData StepSectionLayoutData
		{
			get
			{
				return (_StepSectionLayoutData == null)? _StepSectionLayoutData = new StepSectionLayoutData(SelectSingleNode("StpSectLayData")):_StepSectionLayoutData;
			}
		}
		private StepSectionEditData _StepSectionEditData;
		public StepSectionEditData StepSectionEditData
		{
			get
			{
				return (_StepSectionEditData == null)? _StepSectionEditData = new StepSectionEditData(SelectSingleNode("StpSectEditData")):	 _StepSectionEditData;
			}
		}
		private SeqTabFmtList _SeqTabFmtList;
		public SeqTabFmtList SeqTabFmtList
		{
			get
			{
				return (_SeqTabFmtList == null) ? _SeqTabFmtList = new SeqTabFmtList(SelectNodes("SequentialTabFormat/SeqTabFmt"),MyFormat) : _SeqTabFmtList;
			}
		}
		private StepSectionPrintData _StepSectionPrintData;
		public StepSectionPrintData StepSectionPrintData
		{
			get
			{
				return (_StepSectionPrintData == null) ? _StepSectionPrintData = new StepSectionPrintData(SelectSingleNode("StpSectPrtData")) : _StepSectionPrintData;
			}
		}
		private LazyLoad<int?> _TopRow;
		public int? TopRow
		{ 
			get 
			{ 
				return LazyLoad(ref _TopRow, "@TopRow");
			} 
		}
		//private LazyLoad<string> _SeqStart;
		//public string SeqStart
		//{ 
		//    get 
		//    {
		//        return LazyLoad(ref _SeqStart, "@SeqStart");
		//    } 
		//}
		//private LazyLoad<string> _LeftJustSeqTab;
		//public string LeftJustSeqTab
		//{ 
		//    get 
		//    {
		//        return LazyLoad(ref _LeftJustSeqTab, "@LeftJustSeqTab") ;
		//    } 
		//}
		//private LazyLoad<int?> _HighSeqStart;
		//public int? HighSeqStart
		//{ 
		//    get 
		//    { 
		//        return LazyLoad(ref _HighSeqStart, "@HighSeqStart"); 
		//    } 
		//}
		private LazyLoad<string> _IndentToken;
		public string IndentToken
		{ 
			get 
			{ 
				return LazyLoad(ref _IndentToken, "@IndentToken");
			} 
		}
		private LazyLoad<int?> _NumberOfHighLevelSteps;
		public int? NumberOfHighLevelSteps
		{ 
			get 
			{
				return LazyLoad(ref _NumberOfHighLevelSteps, "@NumberOfHighLevelSteps");
			} 
		}
		private LazyLoad<int?> _NumberOfSubStypeTypes;
		public int? NumberOfSubStypeTypes
		{ 
			get
			{
				return LazyLoad(ref _NumberOfSubStypeTypes, "@NumberOfSubStepTypes");
			} 
		}
		private LazyLoad<string> _IdentB;
		public string IdentB
		{ 
			get 
			{
				return LazyLoad(ref _IdentB, "@IdentB");
			} 
		}
		private LazyLoad<bool> _WolfCreekBackgroundFormat;
		public bool WolfCreekBackgroundFormat
		{
			get
			{
				return LazyLoad(ref _WolfCreekBackgroundFormat, "@WolfCreekBackgroundFormat");
			}
		}
		private LazyLoad<bool> _WolfcreekCKLFormat;
		public bool WolfcreekCKLFormat
		{
			get
			{
				return LazyLoad(ref _WolfcreekCKLFormat, "@WolfcreekCKLFormat");
			}
		}
		private LazyLoad<bool> _WolfcreekCKLBackgndFormat;
		public bool WolfcreekCKLBackgndFormat
		{
			get
			{
				return LazyLoad(ref _WolfcreekCKLBackgndFormat, "@WolfcreekCKLBackgndFormat");
			}
		}
		private LazyLoad<bool> _FortranFormatNumbers;
		public bool FortranFormatNumbers
		{
			get
			{
				return LazyLoad(ref _FortranFormatNumbers, "@FortranFormatNumbers");
			}
		}
		private LazyLoad<bool> _UseTopContinueMessageAtEnd;
		public bool UseTopContinueMessageAtEnd
		{
			get
			{
				return LazyLoad(ref _UseTopContinueMessageAtEnd, "@UseTopContinueMessageAtEnd");
			}
		}
		private LazyLoad<bool> _FloatingContinueMessage;
		public bool FloatingContinueMessage
		{
			get
			{
				return LazyLoad(ref _FloatingContinueMessage, "@FloatingContinueMessage");
			}
		}
		private LazyLoad<bool> _WrapSameAsEdit;
		public bool WrapSameAsEdit
		{
			get
			{
				return LazyLoad(ref _WrapSameAsEdit, "@WrapSameAsEdit");
			}
		}
		private LazyLoad<bool> _ContinueSectionHeader;
		public bool ContinueSectionHeader
		{
			get
			{
				return LazyLoad(ref _ContinueSectionHeader, "@ContinueSectionHeader");
			}
		}
		private LazyLoad<bool> _CompressHPSub;
		public bool CompressHPSub
		{
			get
			{
				return LazyLoad(ref _CompressHPSub, "@CompressHPSub");
			}
		}
		private LazyLoad<bool> _CompressHPSuper;
		public bool CompressHPSuper
		{
			get
			{
				return LazyLoad(ref _CompressHPSuper, "@CompressHPSuper");
			}
		}
		private LazyLoad<bool> _CompressPropSubSup;
		public bool CompressPropSubSup
		{
			get
			{
				return LazyLoad(ref _CompressPropSubSup, "@CompressPropSubSup");
			}
		}
		private LazyLoad<bool> _UndSpecialStepsFoldout;
		public bool UndSpecialStepsFoldout
		{
			get
			{
				return LazyLoad(ref _UndSpecialStepsFoldout, "@UndSpecialStepsFoldout");
			}
		}
		private LazyLoad<bool> _UnderlineAllMetaTitles;
		public bool UnderlineAllMetaTitles
		{
			get
			{
				return LazyLoad(ref _UnderlineAllMetaTitles, "@UnderlineAllMetaTitles");
			}
		}
		private LazyLoad<bool> _BoldOnlySectionZero;
		public bool BoldOnlySectionZero
		{
			get
			{
				return LazyLoad(ref _BoldOnlySectionZero, "@BoldOnlySectionZero");
			}
		}
		private LazyLoad<bool> _ImperfectStructure;
		public bool ImperfectStructure
		{
			get
			{
				return LazyLoad(ref _ImperfectStructure, "@ImperfectStructure");
			}
		}
		private LazyLoad<bool> _ImperfectSubstep;
		public bool ImperfectSubstep
		{
			get
			{
				return LazyLoad(ref _ImperfectSubstep, "@ImperfectSubstep");
			}
		}
		private LazyLoad<bool> _ImperfectStructurePlus4;
		public bool ImperfectStructurePlus4
		{
			get
			{
				return LazyLoad(ref _ImperfectStructurePlus4, "@ImperfectStructurePlus4");
			}
		}
		private LazyLoad<bool> _CountAllSubLevels;
		public bool CountAllSubLevels
		{
			get
			{
				return LazyLoad(ref _CountAllSubLevels, "@CountAllSubLevels");
			}
		}
		private LazyLoad<bool> _UseMultiLineSectionTitle;
		public bool UseMultiLineSectionTitle
		{
			get
			{
				return LazyLoad(ref _UseMultiLineSectionTitle, "@UseMultiLineSectionTitle");
			}
		}
		private LazyLoad<bool> _AdjustRNOCautionNoteWidth;
		public bool AdjustRNOCautionNoteWidth
		{
			get
			{
				return LazyLoad(ref _AdjustRNOCautionNoteWidth, "@AdjustRNOCautionNoteWidth");
			}
		}
	}
	#endregion
	#region TextTypeValue
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class TextTypeValue : vlnFormatItem
	{
		public TextTypeValue(XmlNode xmlNode) : base(xmlNode) { }
		public TextTypeValue() : base() { }
		private LazyLoad<int?> _TheValue;
		public int? TheValue
		{ 
			get 
			{
				return LazyLoad(ref _TheValue, "text()");
			} 
		}
		public override string GetPDDisplayName()
		{ return "Value"; }
		public override string GetPDDescription()
		{ return string.Format("TextTypeValue '{0}'", TheValue); }
		public override string GetPDCategory()
		{ return "Text Type Value"; }
		public override string ToString()
		{
			return TheValue.ToString();
		}
	}
	#endregion
	#region TextTypeValueList
	[TypeConverter(typeof(vlnListConverter<TextTypeValueList, TextTypeValue>))]
	public class TextTypeValueList : vlnFormatList<TextTypeValue>
	{
		public TextTypeValueList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
	}
	#endregion
	#region TextType
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class TextType : vlnFormatItem
	{
		public TextType(XmlNode xmlNode) : base(xmlNode) { }
		public TextType() : base() { }
		//[Category("Strings")]
		private LazyLoad<string> _Text;
		public string Text
		{ 
			get 
			{
				return LazyLoad(ref _Text, "text()"); 
			} 
		}
		public override string GetPDDisplayName()
		{ return "Text"; }
		public override string GetPDDescription()
		{ return string.Format("TextType '{0}'", Text); }
		public override string GetPDCategory()
		{ return "Text Type"; }
		public override string ToString()
		{
			return Text;
		}
	}
	#endregion
	#region TextTypeList
	[TypeConverter(typeof(vlnListConverter<TextTypeList, TextType>))]
	public class TextTypeList : vlnFormatList<TextType>
	{
		public TextTypeList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
	}
	#endregion
	#region OLD - SeqTab
	//[TypeConverter(typeof(ExpandableObjectConverter))]
	//public class SeqTab : vlnFormatItem
	//{
	//    public SeqTab(XmlNode xmlNode) : base(xmlNode) { }
	//    public SeqTab() : base() { }
	//    private LazyLoad<string> _Text;
	//    public string Text
	//    {
	//        get
	//        {
	//            return LazyLoad(ref _Text, "text()");
	//        }
	//    }
	//    public override string GetPDDisplayName()
	//    { return "Text"; }
	//    public override string GetPDDescription()
	//    { return string.Format("SeqTab '{0}'", Text); }
	//    public override string GetPDCategory()
	//    { return "Seq Tab"; }
	//    public override string ToString()
	//    {
	//        return Text;
	//    }
	//}
	#endregion
	#region OLD - SeqTabList
	//[TypeConverter(typeof(vlnListConverter<SeqTabList, SeqTab>))]
	//public class SeqTabList : vlnFormatList<SeqTab>
	//{
	//    public SeqTabList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
	//}
	#endregion
	#region OLD - PreSeqTabEdit
	//[TypeConverter(typeof(ExpandableObjectConverter))]
	//public class PreSeqTabEdit : vlnFormatItem
	//{
	//    public PreSeqTabEdit(XmlNode xmlNode) : base(xmlNode) { }
	//    public PreSeqTabEdit() : base() { }
	//    //[Category("Strings")]
	//    private LazyLoad<string> _Text;
	//    public string Text
	//    {
	//        get
	//        {
	//            return LazyLoad(ref _Text, "text()");
	//        }
	//    }
	//    public override string GetPDDisplayName()
	//    { return "Text"; }
	//    public override string GetPDDescription()
	//    { return string.Format("PreSeqTabEdit '{0}'", Text); }
	//    public override string GetPDCategory()
	//    { return "PreSeq Tab Edit"; }
	//    public override string ToString()
	//    {
	//        return Text;
	//    }
	//}
	#endregion
	#region OLD - PreSeqTabEditList
	//[TypeConverter(typeof(vlnListConverter<PreSeqTabEditList, PreSeqTabEdit>))]
	//public class PreSeqTabEditList : vlnFormatList<PreSeqTabEdit>
	//{
	//    public PreSeqTabEditList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
	//}
	#endregion
	#region OLD - PreSeqTabPrint
	//[TypeConverter(typeof(ExpandableObjectConverter))]
	//public class PreSeqTabPrint : vlnFormatItem
	//{
	//    public PreSeqTabPrint(XmlNode xmlNode) : base(xmlNode) { }
	//    public PreSeqTabPrint() : base() { }
	//    private LazyLoad<string> _Text;
	//    public string Text
	//    {
	//        get
	//        {
	//            return LazyLoad(ref _Text, "text()");
	//        }
	//    }
	//    public override string GetPDDisplayName()
	//    { return "Text"; }
	//    public override string GetPDDescription()
	//    { return string.Format("PreSeqTabPrint '{0}'", Text); }
	//    public override string GetPDCategory()
	//    { return "PreSeq Tab Printt"; }
	//    public override string ToString()
	//    {
	//        return Text;
	//    }
	//}
	#endregion
	#region OLD - PreSeqTabPrintList
	//[TypeConverter(typeof(vlnListConverter<PreSeqTabPrintList, PreSeqTabPrint>))]
	//public class PreSeqTabPrintList : vlnFormatList<PreSeqTabPrint>
	//{
	//    public PreSeqTabPrintList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
	//}
	#endregion
	#region OLD - PostSeqTabEdit
	//[TypeConverter(typeof(ExpandableObjectConverter))]
	//public class PostSeqTabEdit : vlnFormatItem
	//{
	//    public PostSeqTabEdit(XmlNode xmlNode) : base(xmlNode) { }
	//    public PostSeqTabEdit() : base() { }
	//    private LazyLoad<string> _Text;
	//    public string Text
	//    {
	//        get
	//        {
	//            return LazyLoad(ref _Text, "text()");
	//        }
	//    }
	//    public override string GetPDDisplayName()
	//    { return "Text"; }
	//    public override string GetPDDescription()
	//    { return string.Format("PostSeqTabEdit '{0}'", Text); }
	//    public override string GetPDCategory()
	//    { return "PostSeq Tab Edit"; }
	//    public override string ToString()
	//    {
	//        return Text;
	//    }
	//}
	#endregion
	#region OLD - PostSeqTabEditList
	//[TypeConverter(typeof(vlnListConverter<PostSeqTabEditList, PostSeqTabEdit>))]
	//public class PostSeqTabEditList : vlnFormatList<PostSeqTabEdit>
	//{
	//    public PostSeqTabEditList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
	//}
	#endregion
	#region OLD - PostSeqTabPrint
	//[TypeConverter(typeof(ExpandableObjectConverter))]
	//public class PostSeqTabPrint : vlnFormatItem
	//{
	//    public PostSeqTabPrint(XmlNode xmlNode) : base(xmlNode) { }
	//    public PostSeqTabPrint() : base() { }
	//    private LazyLoad<string> _Text;
	//    public string Text
	//    {
	//        get
	//        {
	//            return LazyLoad(ref _Text, "text()");
	//        }
	//    }
	//    public override string GetPDDisplayName()
	//    { return "Text"; }
	//    public override string GetPDDescription()
	//    { return string.Format("PostSeqTabPrint '{0}'", Text); }
	//    public override string GetPDCategory()
	//    { return "PostSeq Tab Printt"; }
	//    public override string ToString()
	//    {
	//        return Text;
	//    }
	//}
	#endregion
	#region OLD - PostSeqTabPrintList
	//[TypeConverter(typeof(vlnListConverter<PostSeqTabPrintList, PostSeqTabPrint>))]
	//public class PostSeqTabPrintList : vlnFormatList<PostSeqTabPrint>
	//{
	//    public PostSeqTabPrintList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
	//}
	#endregion
	#region UnderlineTerminate
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class UnderlineTerminate : vlnFormatItem
	{
		public UnderlineTerminate(XmlNode xmlNode) : base(xmlNode) { }
		public UnderlineTerminate() : base() { }
		private LazyLoad<string> _Text;
		public string Text
		{
			get
			{
				return LazyLoad(ref _Text, "text()");
			}
		}
		public override string GetPDDisplayName()
		{ return "Text"; }
		public override string GetPDDescription()
		{ return string.Format("UnderlineTerminate '{0}'", Text); }
		public override string GetPDCategory()
		{ return "Underline Terminate"; }
		public override string ToString()
		{
			return Text;
		}
	}
	#endregion
	#region UnderlineTerminateList
	[TypeConverter(typeof(vlnListConverter<UnderlineTerminateList, UnderlineTerminate>))]
	public class UnderlineTerminateList : vlnFormatList<UnderlineTerminate>
	{
		public UnderlineTerminateList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
	}
	#endregion
	#region ObserveNCString1
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class ObserveNCString1 : vlnFormatItem
	{
		public ObserveNCString1(XmlNode xmlNode) : base(xmlNode) { }
		public ObserveNCString1() : base() { }
		private LazyLoad<string> _Text;
		public string Text
		{
			get
			{
				return LazyLoad(ref _Text, "text()");
			}
		}
		public override string GetPDDisplayName()
		{ return "Text"; }
		public override string GetPDDescription()
		{ return string.Format("ObserveNCString1 '{0}'", Text); }
		public override string GetPDCategory()
		{ return "ObserveNCString1"; }
		public override string ToString()
		{
			return Text;
		}
	}
	#endregion
	#region ObserveNCString1List
	[TypeConverter(typeof(vlnListConverter<ObserveNCString1List, ObserveNCString1>))]
	public class ObserveNCString1List : vlnFormatList<ObserveNCString1>
	{
		public ObserveNCString1List(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
	}
	#endregion
	#region ObserveNCString2
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class ObserveNCString2 : vlnFormatItem
	{
		public ObserveNCString2(XmlNode xmlNode) : base(xmlNode) { }
		public ObserveNCString2() : base() { }
		private LazyLoad<string> _Text;
		public string Text
		{
			get
			{
				return LazyLoad(ref _Text, "text()");
			}
		}
		public override string GetPDDisplayName()
		{ return "Text"; }
		public override string GetPDDescription()
		{ return string.Format("ObserveNCString2 '{0}'", Text); }
		public override string GetPDCategory()
		{ return "ObserveNCString2"; }
		public override string ToString()
		{
			return Text;
		}
	}
	#endregion
	#region ObserveNCString2List
	[TypeConverter(typeof(vlnListConverter<ObserveNCString2List, ObserveNCString2>))]
	public class ObserveNCString2List : vlnFormatList<ObserveNCString2>
	{
		public ObserveNCString2List(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
	}
	#endregion
	#region ReplaceStr
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class ReplaceStr : vlnFormatItem
	{
		public ReplaceStr(XmlNode xmlNode) : base(xmlNode) { }
		public ReplaceStr() : base() { }
		[Category("Strings")]
		private LazyLoad<string> _ReplaceWord;
		public string ReplaceWord
		{ 
			get 
			{
				return LazyLoad(ref _ReplaceWord, "@ReplaceWord");
			} 
		}
		[Category("Strings")]
		private LazyLoad<string> _ReplaceWith;
		public string ReplaceWith
		{ 
			get 
			{
				return LazyLoad(ref _ReplaceWith, "@ReplaceWith");
			} 
		}
		private LazyLoad<E_ReplaceFlags?> _Flag;
		public E_ReplaceFlags? Flag
		{
			get
			{
				return LazyLoad<E_ReplaceFlags>(ref _Flag, "@Flag");
			}
		}
		public override string GetPDDisplayName()
		{ return ReplaceWord; }
		public override string GetPDDescription()
		{ return string.Format("Replace '{0}' with '{1}'",ReplaceWord,ReplaceWith); }
		public override string GetPDCategory()
		{ return "Words to Replace"; }
		public override string ToString()
		{
			return ReplaceWith;
		}
	}

	#endregion
	#region ReplaceStrList
	[TypeConverter(typeof(vlnListConverter<ReplaceStrList, ReplaceStr>))]
	public class ReplaceStrList : vlnFormatList<ReplaceStr> 
	{
		public ReplaceStrList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
	}
	#endregion
	#region StepSectionLayoutData
	public class StepSectionLayoutData : vlnFormatItem
	{
		public StepSectionLayoutData(XmlNode xmlNode) : base(xmlNode) { }
		private TopOfPage _TopOfPage;
		public TopOfPage TopOfPage
		{
			get
			{
				return (_TopOfPage == null)? _TopOfPage = new TopOfPage(SelectSingleNode("TopOfPage")): _TopOfPage;
			}
		}
		private Separator _Separator;
		public Separator Separator
		{
			get
			{
				return (_Separator == null) ?_Separator = new Separator(SelectSingleNode("Separator")):_Separator;
			}
		}
		private LazyLoad<float?> _LastLineToStartStep;
		public float? LastLineToStartStep
		{ 
			get 
			{ 
				return LazyLoad(ref _LastLineToStartStep, "@LastLineToStartStep");
			} 
		}
		private LazyLoad<int?> _LineDrawingOption;
		public int? LineDrawingOption
		{ 
			get 
			{ 
				return LazyLoad(ref _LineDrawingOption, "@LineDrawingOption");
			} 
		}
		private LazyLoad<float?> _TabPtsPerChar;
		public float? TabPtsPerChar
		{
			get
			{
				return LazyLoad(ref _TabPtsPerChar, "@TabPtsPerChar");
			}
		}
		private LazyLoad<string> _CautionNoteOrder;
		public string CautionNoteOrder
		{
			get
			{
				return LazyLoad(ref _CautionNoteOrder, "@CautionNoteOrder");
			}
		}
		private LazyLoad<float?> _ColS;
		public float? ColS
		{ 
			get 
			{ 
				return LazyLoad(ref _ColS, "@ColS");
			} 
		}
		private LazyLoad<float?> _ColT;
		public float? ColT
		{ 
			get 
			{
				return LazyLoad(ref _ColT, "@ColT");
			} 
		}
		private LazyLoad<float?> _ColAbs;
		public float? ColAbs
		{ 
			get 
			{
				return LazyLoad(ref _ColAbs, "@ColAbs");
			} 
		}
		private LazyLoad<float?> _WidT;
		public float? WidT
		{ 
			get 
			{
				return LazyLoad(ref _WidT, "@WidT");
			} 
		}
		private LazyLoad<int?> _PMode;
		public int? PMode
		{ 
			get 
			{
				return LazyLoad(ref _PMode, "@PMode");
			} 
		}
		private LazyLoad<int?> _MaxRNO;
		public int? MaxRNO
		{ 
			get 
			{
				return LazyLoad(ref _MaxRNO, "@MaxRNO");
			} 
		}
		private LazyLoad<string> _MaxRNOTable;
		public string MaxRNOTable
		{ 
			get 
			{
				return LazyLoad(ref _MaxRNOTable, "@MaxRNOTable");
			} 
		}
		private LazyLoad<bool> _RNOWidthSameAsHighParent;
		public bool RNOWidthSameAsHighParent
		{
			get
			{
				return LazyLoad(ref _RNOWidthSameAsHighParent, "@RNOWidthSameAsHighParent");
			}
		}
		private LazyLoad<float?> _SingleColumnRNOIndent;
		public float? SingleColumnRNOIndent
		{
			get
			{
				return LazyLoad(ref _SingleColumnRNOIndent, "@SingleColumnRNOIndent");
			}
		}
		private LazyLoad<string> _ColRTable;
		public string ColRTable
		{ 
			get 
			{
				return LazyLoad(ref _ColRTable, "@ColRTable");
			} 
		}
		private LazyLoad<string> _WidSTableEdit;
		public string WidSTableEdit
		{ 
			get 
			{
				return LazyLoad(ref _WidSTableEdit, "@WidSTableEdit");
			} 
		}
		private LazyLoad<string> _WidSTablePrint;
		public string WidSTablePrint
		{ 
			get 
			{ 
				return LazyLoad(ref _WidSTablePrint, "@WidSTablePrint");
			} 
		}
		private LazyLoad<float?> _AdjRNOCol;
		public float? AdjRNOCol
		{ 
			get 
			{
				return LazyLoad(ref _AdjRNOCol, "@AdjRNOCol");
			} 
		}
		private LazyLoad<int?> _EndMessagePos;
		public int? EndMessagePos
		{ 
			get 
			{
				return LazyLoad(ref _EndMessagePos, "@EndMessagePos");
			} 
		}
		private LazyLoad<string> _RNOWidthAlt;
		public string RNOWidthAlt
		{ 
			get 
			{ 
				return LazyLoad(ref _RNOWidthAlt, "@RNOWidthAlt");
			} 
		}
		private LazyLoad<string> _RNOWidthAdj;
		public string RNOWidthAdj
		{
			get
			{
				return LazyLoad(ref _RNOWidthAdj, "@RNOWidthAdj");
			}
		}
		private LazyLoad<string> _UseRNOParentIdent;
		public string UseRNOParentIdent
		{
			get
			{
				return LazyLoad(ref _UseRNOParentIdent, "@UseRNOParentIdent");
			}
		}
		private LazyLoad<string> _DevNoteOrCautionTabOffset;
		public string DevNoteOrCautionTabOffset
		{
			get
			{
				return LazyLoad(ref _DevNoteOrCautionTabOffset, "@DevNoteOrCautionTabOffset");
			}
		}
		private LazyLoad<string> _BoxLeftAdj;
		public string BoxLeftAdj
		{
			get
			{
				return LazyLoad(ref _BoxLeftAdj, "@BoxLeftAdj");
			}
		}
		private LazyLoad<int?> _HLSWidthOVRD;
		public int? HLSWidthOVRD
		{ 
			get 
			{
				return LazyLoad(ref _HLSWidthOVRD, "@HLSWidthOVRD");
			} 
		}
		private LazyLoad<int?> _SubPaginationWght;
		public int? SubPaginationWght
		{ 
			get 
			{
				return LazyLoad(ref _SubPaginationWght, "@SubPaginationWght");
			} 
		}
		private LazyLoad<int?> _TextTitleAdjustment;
		public int? TextTitleAdjustment
		{ 
			get 
			{
				return LazyLoad(ref _TextTitleAdjustment, "@TextTitleAdjustment");
			} 
		}
		private VE_Font _VertStyle;
		public VE_Font VertStyle
		{
			get
			{
				return (_VertStyle == null)? _VertStyle = new VE_Font(base.XmlNode): _VertStyle;
			}
		}
		private LazyLoad<string> _TableCenterPos;
		public string TableCenterPos
		{ 
			get 
			{
				return LazyLoad(ref _TableCenterPos, "@TableCenterPos");
			} 
		}
		private LazyLoad<string> _LowerLimitDivisor;
		public string LowerLimitDivisor
		{ 
			get 
			{ 
				return LazyLoad(ref _LowerLimitDivisor, "@LowerLimitDivisor");
			} 
		}
		private LazyLoad<string> _NonLinkedStepNumber;
		public string NonLinkedStepNumber
		{ 
			get 
			{
				return LazyLoad(ref _NonLinkedStepNumber, "@NonLinkedStepNumber");
			} 
		}
		private LazyLoad<string> _NonLinkedCautNoteNumber;
		public string NonLinkedCautNoteNumber
		{ 
			get 
			{
				return LazyLoad(ref _NonLinkedCautNoteNumber, "@NonLinkedCautNoteNumber");
			} 
		}
		private LazyLoad<string> _NonLinkedRNONumber;
		public string NonLinkedRNONumber
		{ 
			get 
			{
				return LazyLoad(ref _NonLinkedRNONumber, "@NonLinkedRNONumber");
			} 
		}
		private LazyLoad<bool> _Dev_Format;
		public bool Dev_Format
		{
			get
			{
				return LazyLoad(ref _Dev_Format, "@Dev_Format");
			}
		}
		private LazyLoad<bool> _EnhancedShortFormDev;
		public bool EnhancedShortFormDev
		{
			get
			{
				return LazyLoad(ref _EnhancedShortFormDev, "@EnhancedShortFormDev");
			}
		}
		private LazyLoad<bool> _SpecialPageBreakFlag;
		public bool SpecialPageBreakFlag
		{
			get
			{
				return LazyLoad(ref _SpecialPageBreakFlag, "@SpecialPageBreakFlag");
			}
		}
		private LazyLoad<bool> _PaginateOnFirstSubstep;
		public bool PaginateOnFirstSubstep
		{
			get
			{
				return LazyLoad(ref _PaginateOnFirstSubstep, "@PaginateOnFirstSubstep");
			}
		}
		private LazyLoad<bool> _PaginateOnFirstSubstep2X;
		public bool PaginateOnFirstSubstep2X
		{
			get
			{
				return LazyLoad(ref _PaginateOnFirstSubstep2X, "@PaginateOnFirstSubstep2X");
			}
		}
		private LazyLoad<bool> _UseHalfLines;
		public bool UseHalfLines
		{
			get
			{
				return LazyLoad(ref _UseHalfLines, "@UseHalfLines");
			}
		}
		private LazyLoad<bool> _TryToFillHalfOfPage;
		public bool TryToFillHalfOfPage
		{
			get
			{
				return LazyLoad(ref _TryToFillHalfOfPage, "@TryToFillHalfOfPage");
			}
		}
		private LazyLoad<bool> _CompressSteps;
		public bool CompressSteps
		{
			get
			{
				return LazyLoad(ref _CompressSteps, "@CompressSteps");
			}
		}
		private LazyLoad<bool> _DoSTExtraAtTop;
		public bool DoSTExtraAtTop
		{
			get
			{
				return LazyLoad(ref _DoSTExtraAtTop, "@DoSTExtraAtTop");
			}
		}
		private LazyLoad<bool> _KeepStepsOnPage;
		public bool KeepStepsOnPage
		{
			get
			{
				return LazyLoad(ref _KeepStepsOnPage, "@KeepStepsOnPage");
			}
		}
		private LazyLoad<bool> _BreakOnSections;
		public bool BreakOnSections
		{
			get
			{
				return LazyLoad(ref _BreakOnSections, "@BreakOnSections");
			}
		}
		private LazyLoad<bool> _ShowSectionTitles;
		public bool ShowSectionTitles
		{
			get
			{
				return LazyLoad(ref _ShowSectionTitles, "@ShowSectionTitles");
			}
		}
		private LazyLoad<bool> _EndForSingle;
		public bool EndForSingle
		{
			get
			{
				return LazyLoad(ref _EndForSingle, "@EndForSingle");
			}
		}
		private LazyLoad<bool> _PaginateOnFirstSubstep3X;
		public bool PaginateOnFirstSubstep3X
		{
			get
			{
				return LazyLoad(ref _PaginateOnFirstSubstep3X, "@PaginateOnFirstSubstep3X");
			}
		}
		private LazyLoad<bool> _PaginateOnLowerStepLevel;
		public bool PaginateOnLowerStepLevel
		{
			get
			{
				return LazyLoad(ref _PaginateOnLowerStepLevel, "@PaginateOnLowerStepLevel");
			}
		}
		private LazyLoad<bool> _CustomSpacing;
		public bool CustomSpacing
		{
			get
			{
				return LazyLoad(ref _CustomSpacing, "@CustomSpacing");
			}
		}
		private LazyLoad<bool> _SplitStepInPrntStep;
		public bool SplitStepInPrntStep
		{
			get
			{
				return LazyLoad(ref _SplitStepInPrntStep, "@SplitStepInPrntStep");
			}
		}
		private LazyLoad<bool> _LineAboveUnderSection;
		public bool LineAboveUnderSection
		{
			get
			{
				return LazyLoad(ref _LineAboveUnderSection, "@LineAboveUnderSection");
			}
		}
		private LazyLoad<bool> _PicaIgnoreFiveSixths;
		public bool PicaIgnoreFiveSixths
		{
			get
			{
				return LazyLoad(ref _PicaIgnoreFiveSixths, "@PicaIgnoreFiveSixths");
			}
		}
		private LazyLoad<bool> _SpaceForNoSecNumb;
		public bool SpaceForNoSecNumb
		{
			get
			{
				return LazyLoad(ref _SpaceForNoSecNumb, "@SpaceForNoSecNumb");
			}
		}
		private LazyLoad<bool> _PageBreakOnFirstBlankLine;
		public bool PageBreakOnFirstBlankLine
		{
			get
			{
				return LazyLoad(ref _PageBreakOnFirstBlankLine, "@PageBreakOnFirstBlankLine");
			}
		}
		private LazyLoad<bool> _PutOnPageByItself;
		public bool PutOnPageByItself
		{
			get
			{
				return LazyLoad(ref _PutOnPageByItself, "@PutOnPageByItself");
			}
		}
		private LazyLoad<bool> _PaginateAtHighestPaginLevel;
		public bool PaginateAtHighestPaginLevel
		{
			get
			{
				return LazyLoad(ref _PaginateAtHighestPaginLevel, "@PaginateAtHighestPaginLevel");
			}
		}
		private LazyLoad<bool> _UseSTExtraRealValue;
		public bool UseSTExtraRealValue
		{
			get
			{
				return LazyLoad(ref _UseSTExtraRealValue, "@UseSTExtraRealValue");
			}
		}
		private LazyLoad<bool> _DoSectionSeparatorLine;
		public bool DoSectionSeparatorLine
		{
			get
			{
				return LazyLoad(ref _DoSectionSeparatorLine, "@DoSectionSeparatorLine");
			}
		}
		private LazyLoad<bool> _TieTabToLevel;
		public bool TieTabToLevel
		{
			get
			{
				return LazyLoad(ref _TieTabToLevel, "@TieTabToLevel");
			}
		}
		private LazyLoad<bool> _HighLevelRNOBeforeAERSubsteps;
		public bool HighLevelRNOBeforeAERSubsteps
		{
			get
			{
				return LazyLoad(ref _HighLevelRNOBeforeAERSubsteps, "@HighLevelRNOBeforeAERSubsteps");
			}
		}
		private LazyLoad<bool> _UseStepTypeWidthOverride;
		public bool UseStepTypeWidthOverride
		{
			get
			{
				return LazyLoad(ref _UseStepTypeWidthOverride, "@UseStepTypeWidthOverride");
			}
		}
		private LazyLoad<bool> _UseStepTypeWidthOverrideEditPrint;
		public bool UseStepTypeWidthOverrideEditPrint
		{
			get
			{
				return LazyLoad(ref _UseStepTypeWidthOverrideEditPrint, "@UseStepTypeWidthOverrideEditPrint");
			}
		}
		private LazyLoad<bool> _PartialStepCompression;
		public bool PartialStepCompression
		{
			get
			{
				return LazyLoad(ref _PartialStepCompression, "@PartialStepCompression");
			}
		}
		private LazyLoad<bool> _VirtualDotInHLSTab;
		public bool VirtualDotInHLSTab
		{
			get
			{
				return LazyLoad(ref _VirtualDotInHLSTab, "@VirtualDotInHLSTab");
			}
		}
		private LazyLoad<bool> _OverrideEnhancedTabs;
		public bool OverrideEnhancedTabs
		{
			get
			{
				return LazyLoad(ref _OverrideEnhancedTabs, "@OverrideEnhancedTabs");
			}
		}
		private LazyLoad<bool> _RNO;
		public bool RNO
		{
			get
			{
				return LazyLoad(ref _RNO, "@RNO");
			}
		}
		private LazyLoad<bool> _OnlySingleColumn;
		public bool OnlySingleColumn
		{
			get
			{
				return LazyLoad(ref _OnlySingleColumn, "@OnlySingleColumn");
			}
		}
		private LazyLoad<bool> _NullBox;
		public bool NullBox
		{
			get
			{
				return LazyLoad(ref _NullBox, "@NullBox");
			}
		}
		private LazyLoad<bool> _AllowNoteCautionAdd;
		public bool AllowNoteCautionAdd
		{
			get
			{
				return LazyLoad(ref _AllowNoteCautionAdd, "@AllowNoteCautionAdd");
			}
		}
	}
	#endregion
	#region TopOfPage
	public class TopOfPage : vlnFormatItem
	{
		public TopOfPage(XmlNode xmlNode) : base(xmlNode) { }
		private LazyLoad<float?> _Row;
		public float? Row
		{
			get 
			{ 
				return LazyLoad(ref _Row, "@Row");
			} 
		}
		private LazyLoad<float?> _Col;
		public float? Col
		{
			get 
			{ 
				return LazyLoad(ref _Col, "@Col");
			} 
		}
		private VE_Font _Font;
		public VE_Font Font
		{
			get
			{
				return (_Font == null? _Font = new VE_Font(base.XmlNode): _Font);
			}
		}
	}
	#endregion
	#region Separator
	public class Separator : vlnFormatItem
	{
		public Separator(XmlNode xmlNode) : base(xmlNode) { }
		private LazyLoad<int?> _Location;
		public int? Location
		{ 
			get 
			{ 
				return LazyLoad(ref _Location, "@Location");
				//return LazyLoad(ref _SeparatorLocation, "@SeparatorLocation");
			} 
		}
		private VE_Font _Font;
		public VE_Font Font
		{
			get
			{
				return (_Font == null ? _Font = new VE_Font(base.XmlNode) : _Font);
			}
		}
	}
	#endregion
	#region StepSectionEditData
	public class StepSectionEditData : vlnFormatItem
	{
		public StepSectionEditData(XmlNode xmlNode) : base(xmlNode) { }
		private LazyLoad<float?> _ColSScreenAdj;
		public float? ColSScreenAdj
		{ 
			get 
			{
				return LazyLoad(ref _ColSScreenAdj, "@ColSScreenAdj");
			} 
		}
		private LazyLoad<float?> _ScrnAdjRNOText;
		public float? ScrnAdjRNOText
		{ 
			get 
			{
				return LazyLoad(ref _ScrnAdjRNOText, "@ScrnAdjRNOText");
			} 
		}
		private LazyLoad<string> _ColRScreen;
		public string ColRScreen
		{ 
			get 
			{
				return LazyLoad(ref _ColRScreen, "@ColRScreen");
			} 
		}
	}
	#endregion
	#region StepSectionPrintData
	public class StepSectionPrintData : vlnFormatItem
	{
		public StepSectionPrintData(XmlNode xmlNode) : base(xmlNode) { }
		private LazyLoad<float?> _ImmStepHdrCol;
		public float? ImmStepHdrCol
		{ 
			get 
			{
				return LazyLoad(ref _ImmStepHdrCol, "@ImmStepHdrCol");
			} 
		}
		private LazyLoad<bool> _DiffContActBox;
		public bool DiffContActBox
		{
			get
			{
				return LazyLoad(ref _DiffContActBox, "@DiffContActBox");
			}
		}
		private LazyLoad<bool> _ContActBoxOnSubSteps;
		public bool ContActBoxOnSubSteps
		{
			get
			{
				return LazyLoad(ref _ContActBoxOnSubSteps, "@ContActBoxOnSubSteps");
			}
		}
		private LazyLoad<int?> _SecColHdrforActPMode;
		public int? SecColHdrforActPMode
		{ 
			get 
			{
				return LazyLoad(ref _SecColHdrforActPMode, "@SecColHdrforActPMode");
			} 
		}
		private LazyLoad<string> _RNOSepString;
		public string RNOSepString
		{ 
			get 
			{
				return LazyLoad(ref _RNOSepString, "@RNOSepString");
			} 
		}
		private LazyLoad<float?> _RNOSepLineLength;
		public float? RNOSepLineLength
		{
			get
			{
				return LazyLoad(ref _RNOSepLineLength, "@RNOSepLineLength");
			}
		}
		private LazyLoad<string> _HLStpSeparatorString;
		public string HLStpSeparatorString
		{ 
			get 
			{
				return LazyLoad(ref _HLStpSeparatorString, "@HLStpSeparatorString");
			} 
		}
		private LazyLoad<string> _HLRNOStpSeparatorString;
		public string HLRNOStpSeparatorString
		{ 
			get 
			{
				return LazyLoad(ref _HLRNOStpSeparatorString, "@HLRNOStpSeparatorString");
			} 
		}
		private LazyLoad<bool> _LowerCaseRevNum;
		public bool LowerCaseRevNum
		{
			get
			{
				return LazyLoad(ref _LowerCaseRevNum, "@LowerCaseRevNum");
			}
		}
		private LazyLoad<bool> _UseXtraRevNumber;
		public bool UseXtraRevNumber
		{
			get
			{
				return LazyLoad(ref _UseXtraRevNumber, "@UseXtraRevNumber");
			}
		}
		private LazyLoad<bool> _SpecialLandscapeMode;
		public bool SpecialLandscapeMode
		{
			get
			{
				return LazyLoad(ref _SpecialLandscapeMode, "@SpecialLandscapeMode");
			}
		}
		private LazyLoad<bool> _LimitWidToPageWid;
		public bool LimitWidToPageWid
		{
			get
			{
				return LazyLoad(ref _LimitWidToPageWid, "@LimitWidToPageWid");
			}
		}
		private VE_Font _ModifiedTextStyle;
		public VE_Font ModifiedTextStyle
		{
			get
			{
				return (_ModifiedTextStyle == null)? _ModifiedTextStyle = new VE_Font(base.XmlNode):_ModifiedTextStyle;
			}
		}
		private VE_Font _ImmStepHdrStyle;
		public VE_Font ImmStepHdrStyle
		{
			get
			{
				return (_ImmStepHdrStyle == null)? _ImmStepHdrStyle = new VE_Font(base.XmlNode):_ImmStepHdrStyle;
			}
		}
		private ImmStepHdrList _ImmStepHdrList;
		public ImmStepHdrList ImmStepHdrList
		{
			get
			{
				return (_ImmStepHdrList == null)? _ImmStepHdrList = new ImmStepHdrList(SelectNodes("ImmStepHdrList/string")):_ImmStepHdrList;
			}
			set { _ImmStepHdrList = value; }
		}
		private LeftJustifyList _LeftJustifyList;
		public LeftJustifyList LeftJustifyList
		{
			get
			{
				return (_LeftJustifyList == null) ? _LeftJustifyList = new LeftJustifyList(SelectNodes("LeftJustifyList/LeftJustify")) : _LeftJustifyList;
			}
			set { _LeftJustifyList = value; }
		}
	}
	#region ImmStepHdr
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class ImmStepHdr : vlnFormatItem
	{
		public ImmStepHdr(XmlNode xmlNode) : base(xmlNode) { }
		public ImmStepHdr() : base() { }
		private LazyLoad<string> _Text;
		public string Text
		{
			get
			{
				return LazyLoad(ref _Text, "text()");
			}
		}
		public override string GetPDDisplayName()
		{ return "Text"; }
		public override string GetPDDescription()
		{ return string.Format("ImmStepHdr '{0}'", Text); }
		public override string GetPDCategory()
		{ return "Imm Step Hdr"; }
		public override string ToString()
		{
			return Text;
		}
	}
	#endregion
	#region ImmStepHdrList
	[TypeConverter(typeof(vlnListConverter<ImmStepHdrList, ImmStepHdr>))]
	public class ImmStepHdrList : vlnFormatList<ImmStepHdr>
	{
		public ImmStepHdrList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
	}
	#endregion
	#region LeftJustifyList
	[TypeConverter(typeof(vlnListConverter<LeftJustifyList, LeftJustify>))]
	public class LeftJustifyList : vlnFormatList<LeftJustify>
	{
		public LeftJustifyList(XmlNodeList xmlNodeList) : base(xmlNodeList) { }
	}
	#endregion
	#region LeftJustify
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class LeftJustify : vlnFormatItem, IVlnIndexedFormatItem
	{
		public LeftJustify(XmlNode xmlNode) : base(xmlNode) { }
		public LeftJustify() : base() { }
		private LazyLoad<int?> _Index;
		public int? Index
		{
			get
			{
				return LazyLoad(ref _Index, "@Index");
			}
		}
		private LazyLoad<float?> _Size;
		public float? Size
		{
			get
			{
				return LazyLoad(ref _Size, "@Size");
			}
		}
	}
	#endregion
	#endregion
	#region SeqTabFmtAll
	#region SeqTabFmt
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class SeqTabFmt : vlnFormatItem,IVlnIndexedFormatItem
	{
		public SeqTabFmt() : base() { }
		private LazyLoad<int?> _Index;  //not included - is it needed?
		[Description("SeqTab Index")]
		public int? Index
		{
			get
			{
				return LazyLoad(ref _Index, "@Index");
			}
		}
		private LazyLoad<string> _TabToken;
		public string TabToken
		{
			get
			{
				return LazyLoad(ref _TabToken, "@TabToken");
			}
		}
		private LazyLoad<string> _TabFormat;
		public string TabFormat
		{
			get
			{
				return LazyLoad(ref _TabFormat, "@TabFormat");
			}
		}
		private LazyLoad<string> _PrintTabFormat;
		public string PrintTabFormat
		{
			get
			{
				return LazyLoad(ref _TabFormat, "@PrintTabFormat");
			}
		}
		public override string GetPDDisplayName()
		{ return string.Format("Index [{0}]",Index); }
		public override string GetPDDescription()
		{ return string.Format("Sequential Tab Format Index '{0}' Format '{1}'", Index, TabFormat); }
		public override string GetPDCategory()
		{ return "Sequential Tab Formatting"; }
		public override string ToString()
		{
			return TabFormat;
		}
	}	
	#endregion
	#region SeqTabFmtList
	[TypeConverter(typeof(vlnIndexedListConverter<SeqTabFmtList, SeqTabFmt>))]
	public class SeqTabFmtList : vlnIndexedFormatList<SeqTabFmt>
	{
		public SeqTabFmtList(XmlNodeList xmlNodeList,IFormatOrFormatInfo myFormat) : base(xmlNodeList,myFormat) { }
		public override vlnIndexedFormatList<SeqTabFmt> InheritedList
		{
			get
			{
				IFormatOrFormatInfo parentFormat = MyFormat.MyIParent;
				if (parentFormat != null)
					return parentFormat.PlantFormat.FormatData.SectData.StepSectionData.SeqTabFmtList;
				return null;
			}
		}
	}
	#endregion
	#endregion
	#endregion
	#region AccSectionDataAll
	#region AccSectionData
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class AccSectionData : vlnFormatItem
	{
		public AccSectionData(XmlNode xmlNode) : base(xmlNode) { }
		private LazyLoad<int?> _AutoContActSumSection;
		public int? AutoContActSumSection
		{ 
			get 
			{
				return LazyLoad(ref _AutoContActSumSection, "@AutoContActSumSection");
			} 
		}
		private TableOfContentsData _TableOfContentsData;
		public TableOfContentsData TableOfContentsData
		{
			get
			{
				return (_TableOfContentsData == null ? _TableOfContentsData = new TableOfContentsData(SelectSingleNode("TableOfContentsData")) : _TableOfContentsData);
			}
		}
	}
	#endregion
	#region TableOfContentsData
	public class TableOfContentsData : vlnFormatItem
	{
		public TableOfContentsData(XmlNode xmlNode) : base(xmlNode) { }
		private LazyLoad<float?> _TofCSecNumPos;
		public float? TofCSecNumPos
		{ 
			get 
			{
				return LazyLoad(ref _TofCSecNumPos, "@TofCSecNumPos");
			} 
		}
		private LazyLoad<float?> _TofCSecTitlePos;
		public float? TofCSecTitlePos
		{ 
			get 
			{
				return LazyLoad(ref _TofCSecTitlePos, "@TofCSecTitlePos");
			}
		}
		private LazyLoad<int?> _TofCSecTitleLen;
		public int? TofCSecTitleLen
		{ 
			get 
			{
				return LazyLoad(ref _TofCSecTitleLen, "@TofCSecTitleLen");
			} 
		}
		private LazyLoad<float?> _TofCPageNumPos;
		public float? TofCPageNumPos
		{ 
			get 
			{
				return LazyLoad(ref _TofCPageNumPos, "@TofCPageNumPos");
			} 
		}
		private LazyLoad<string> _TofCSpaceChar;
		public string TofCSpaceChar
		{ 
			get 
			{
				return LazyLoad(ref _TofCSpaceChar, "@TofCSpaceChar");
			} 
		}
		private LazyLoad<int?> _TofCLineSpacing;
		public int? TofCLineSpacing
		{ 
			get 
			{
				return LazyLoad(ref _TofCLineSpacing, "@TofCLineSpacing");
			} 
		}
		private LazyLoad<int?> _TofCNumLevels;
		public int? TofCNumLevels
		{
			get
			{
				return LazyLoad(ref _TofCNumLevels, "@TofCNumLevels");
			}
		}
		private VE_Font _Font;
		public VE_Font Font
		{
			get
			{
				return (_Font == null) ?_Font = new VE_Font(base.XmlNode):_Font;
			}
		}
	}
	#endregion
	#endregion
	#region MetaSectionAll
	#region MetaSection
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class MetaSection : vlnFormatItem,IVlnIndexedFormatItem
	{
		public MetaSection(XmlNode xmlNode) : base(xmlNode) { }
		public MetaSection() : base() { }
		private LazyLoad<int?> _Index;
		public int? Index
		{
			get
			{
				return LazyLoad(ref _Index, "@Index");
			}
		}
		private LazyLoad<float?> _SecNumPositionAdj;
		public float? SecNumPositionAdj
		{ 
			get 
			{
				return LazyLoad(ref _SecNumPositionAdj, "@SecNumPositionAdj");
			} 
		}
		private LazyLoad<float?> _SecTitlePositionAdj;
		public float? SecTitlePositionAdj
		{ 
			get 
			{
				return LazyLoad(ref _SecTitlePositionAdj, "@SecTitlePositionAdj");
			} 
		}
		private LazyLoad<float?> _ColSByLevel;
		public float? ColSByLevel
		{ 
			get 
			{
				return LazyLoad(ref _ColSByLevel, "@ColSByLevel");
			} 
		}
		private LazyLoad<float?> _TofCPositionAdj;
		public float? TofCPositionAdj
		{ 
			get 
			{
				return LazyLoad(ref _TofCPositionAdj, "@TofCPositionAdj");
			} 
		}
		private LazyLoad<float?> _WidSAdjByLevel;
		public float? WidSAdjByLevel
		{ 
			get 
			{
				return LazyLoad(ref _WidSAdjByLevel, "@WidSAdjByLevel");
			} 
		}
		public override string GetPDDisplayName()
		{ return string.Format("[{0}]", Index); }
		public override string GetPDCategory()
		{ return "Meta Section Values"; }
		public override string ToString()
		{
			return String.Format("{0}, {1}, {2}, {3}, {4}", SecNumPositionAdj, SecTitlePositionAdj, ColSByLevel, TofCPositionAdj, TofCPositionAdj);
		}
	}

	#endregion
	#region MetaSectionList
	[TypeConverter(typeof(vlnIndexedListConverter<MetaSectionList, MetaSection>))]
	public class MetaSectionList : vlnIndexedFormatList<MetaSection>
	{
		public MetaSectionList(XmlNodeList xmlNodeList,IFormatOrFormatInfo myFormat) : base(xmlNodeList,myFormat) { }
		public override vlnIndexedFormatList<MetaSection> InheritedList
		{
			get
			{
				IFormatOrFormatInfo parentFormat = MyFormat.MyIParent;
				if (parentFormat != null)
					return parentFormat.PlantFormat.FormatData.SectData.MetaSectionList;
				return null;
			}
		}


	}
	#endregion
	#endregion
	#endregion
	#region StepDataAll
	#region Step
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class StepData : vlnFormatItem,IVlnIndexedFormatItem
	{
		public StepData() : base() { }
		private LazyLoad<int?> _Index;
		[Description("Step Index")]
		public int? Index
		{
			get
			{
				return LazyLoad(ref _Index, "@Index");
			}
		}
		private LazyLoad<string> _Type;
		public string Type
		{ 
			get 
			{
				return LazyLoad(ref _Type, "@Type");
			}
		}
		private LazyLoad<string> _ParentType;
		public string ParentType
		{
			get
			{
				return LazyLoad(ref _ParentType, "@ParentType");
			}
		}
		private LazyLoad<bool> _ReadOnly;
		public bool ReadOnly
		{
			get
			{
				return LazyLoad(ref _ReadOnly, "@ReadOnly");
			}
		}
		private LazyLoad<bool> _Inactive;
		public bool Inactive
		{
			get
			{
				return LazyLoad(ref _Inactive, "@Inactive");
			}
		}
		private LazyLoad<float?> _ColOverride;
		public float? ColOverride
		{
			get
			{
				return LazyLoad(ref _ColOverride, "@ColOverride");
			}
		}
		private LazyLoad<float?> _ColOverrideEdit;

		public float? ColOverrideEdit
		{
			get
			{
				return LazyLoad(ref _ColOverrideEdit, "@ColOverrideEdit");
			}
		}
		private LazyLoad<string> _WidthOverride;

		public string WidthOverride
		{
			get
			{
				return LazyLoad(ref _WidthOverride, "@WidthOverride");
			}
		}
		//private LazyLoad<float?> _WidthOverride;

		//public float? WidthOverride
		//{
		//    get
		//    {
		//        return LazyLoad(ref _WidthOverride, "@WidthOverride");
		//    }
		//}
		private LazyLoad<float?> _WidthOverrideEdit;

		public float? WidthOverrideEdit
		{
			get
			{
				return LazyLoad(ref _WidthOverrideEdit, "@WidthOverrideEdit");
			}
		}
		private LazyLoad<string> _Sep;
		public string Sep
		{ 
			get 
			{
				return LazyLoad(ref _Sep, "@Sep");
			} 
		}
		private LazyLoad<string> _Prefix;
		public string Prefix
		{ 
			get 
			{
				return LazyLoad(ref _Prefix, "@Prefix");
			}
		}
		private LazyLoad<string> _Suffix;
		public string Suffix
		{ 
			get 
			{
				return LazyLoad(ref _Suffix, "@Suffix");
			} 
		}
		private LazyLoad<string> _UnderlineTheseChar;
		public string UnderlineTheseChar
		{ 
			get 
			{
				return LazyLoad(ref _UnderlineTheseChar, "@UnderlineTheseChar");
			} 
		}
		private LazyLoad<string> _VertPos;
		public string VertPos
		{ 
			get 
			{
				return LazyLoad(ref _VertPos, "@VertPos");
			} 
		}
		
		private LazyLoad<bool> _DoubleSpace;
		public bool DoubleSpace
		{
			get
			{
				return LazyLoad(ref _DoubleSpace, "@DoubleSpace");
			}
		}
		private LazyLoad<bool> _EnhancedStepNumFromPrev;
		public bool EnhancedStepNumFromPrev
		{
			get
			{
				return LazyLoad(ref _EnhancedStepNumFromPrev, "@EnhancedStepNumFromPrev");
			}
		}
		private LazyLoad<bool> _UseSmartTemplate;
		public bool UseSmartTemplate
		{
			get
			{
				return LazyLoad(ref _UseSmartTemplate, "@UseSmartTemplate");
			}
		}
		
		private LazyLoad<bool> _UseOldTemplate;
		public bool UseOldTemplate
		{
			get
			{
				return LazyLoad(ref _UseOldTemplate, "@UseOldTemplate");
			}
		}
		private LazyLoad<bool> _AlwaysUseExtraLines;
		public bool AlwaysUseExtraLines
		{
			get
			{
				return LazyLoad(ref _AlwaysUseExtraLines, "@AlwaysUseExtraLines");
			}
		}
		private LazyLoad<bool> _SeparateBox;
		public bool SeparateBox
		{
			get
			{
				return LazyLoad(ref _SeparateBox, "@SeparateBox");
			}
		}
		private LazyLoad<bool> _SeparateBoxCautions;
		public bool SeparateBoxCautions
		{
			get
			{
				return LazyLoad(ref _SeparateBoxCautions, "@SeparateBoxCautions");
			}
		}
		private LazyLoad<bool> _SpaceDouble;
		public bool SpaceDouble
		{
			get
			{
				return LazyLoad(ref _SpaceDouble, "@SpaceDouble");
			}
		}
		private LazyLoad<bool> _ReduceLineAfter;
		public bool ReduceLineAfter
		{
			get
			{
				return LazyLoad(ref _ReduceLineAfter, "@ReduceLineAfter");
			}
		}
		private LazyLoad<bool> _SameLevel;
		public bool SameLevel
		{
			get
			{
				return LazyLoad(ref _SameLevel, "@SameLevel");
			}
		}
		private LazyLoad<bool> _BoldHighLevel;
		public bool BoldHighLevel
		{
			get
			{
				return LazyLoad(ref _BoldHighLevel, "@BoldHighLevel");
			}
		}
		private LazyLoad<bool> _OneLineBeforeTab;
		public bool OneLineBeforeTab
		{
			get
			{
				return LazyLoad(ref _OneLineBeforeTab, "@OneLineBeforeTab");
			}
		}
		private LazyLoad<bool> _CheckOffOnAllSteps;
		public bool CheckOffOnAllSteps
		{
			get
			{
				return LazyLoad(ref _CheckOffOnAllSteps, "@CheckOffOnAllSteps");
			}
		}
		private LazyLoad<bool> _BoxIt;
		public bool BoxIt
		{
			get
			{
				return LazyLoad(ref _BoxIt, "@BoxIt");
			}
		}
		private LazyLoad<bool> _Boxed;
		public bool Boxed
		{
			get
			{
				return LazyLoad(ref _Boxed, "@Boxed");
			}
		}
		private LazyLoad<bool> _XLines_StepFix;
		public bool XLines_StepFix
		{
			get
			{
				return LazyLoad(ref _XLines_StepFix, "@XLines_StepFix");
			}
		}
		private LazyLoad<bool> _Rebox;
		public bool Rebox
		{
			get
			{
				return LazyLoad(ref _Rebox, "@Rebox");
			}
		}
		private LazyLoad<bool> _SpcHdr;
		public bool SpcHdr
		{
			get
			{
				return LazyLoad(ref _SpcHdr, "@SpcHdr");
			}
		}
		private LazyLoad<bool> _ContinueOnly;
		public bool ContinueOnly
		{
			get
			{
				return LazyLoad(ref _ContinueOnly, "@ContinueOnly");
			}
		}
		private LazyLoad<bool> _SepAfterAER;
		public bool SepAfterAER
		{
			get
			{
				return LazyLoad(ref _SepAfterAER, "@SepAfterAER");
			}
		}
		private LazyLoad<bool> _UseAlternateStepBox;
		public bool UseAlternateStepBox
		{
			get
			{
				return LazyLoad(ref _UseAlternateStepBox, "@UseAlternateStepBox");
			}
		}
		private LazyLoad<bool> _UnderlineAfterDashSpace;
		public bool UnderlineAfterDashSpace
		{
			get
			{
				return LazyLoad(ref _UnderlineAfterDashSpace, "@UnderlineAfterDashSpace");
			}
		}
		private LazyLoad<bool> _SpaceIn;
		public bool SpaceIn
		{
			get
			{
				return LazyLoad(ref _SpaceIn, "@SpaceIn");
			}
		}
		private LazyLoad<bool> _PageBreakOnStep;
		public bool PageBreakOnStep
		{
			get
			{
				return LazyLoad(ref _PageBreakOnStep, "@PageBreakOnStep");
			}
		}
		private LazyLoad<bool> _AlignNullTabWSectHead;
		public bool AlignNullTabWSectHead
		{
			get
			{
				return LazyLoad(ref _AlignNullTabWSectHead, "@AlignNullTabWSectHead");
			}
		}
		private LazyLoad<bool> _AlignHLSTabWithSectOvride;
		public bool AlignHLSTabWithSectOvride
		{
			get
			{
				return LazyLoad(ref _AlignHLSTabWithSectOvride, "@AlignHLSTabWithSectOvride");
			}
		}
		private LazyLoad<bool> _TextSubFollowsTextStyle;
		public bool TextSubFollowsTextStyle
		{
			get
			{
				return LazyLoad(ref _TextSubFollowsTextStyle, "@TextSubFollowsTextStyle");
			}
		}
		private LazyLoad<int?> _CautionOrNoteSubstepIndent;
		public int? CautionOrNoteSubstepIndent
		{
			get
			{
				return LazyLoad(ref _CautionOrNoteSubstepIndent, "@CautionOrNoteSubstepIndent");
			}
		}
		private LazyLoad<bool> _TreatAsSequential;
		public bool TreatAsSequential
		{
			get
			{
				return LazyLoad(ref _TreatAsSequential, "@TreatAsSequential");
			}
		}
		private LazyLoad<bool> _MatchUpRNO;
		public bool MatchUpRNO
		{
			get
			{
				return LazyLoad(ref _MatchUpRNO, "@MatchUpRNO");
			}
		}
		private LazyLoad<bool> _InPageList;
		public bool InPageList
		{
			get
			{
				return LazyLoad(ref _InPageList, "@InPageList");
			}
		}
		private LazyLoad<bool> _CenterOneLineOnly;
		public bool CenterOneLineOnly
		{
			get
			{
				return LazyLoad(ref _CenterOneLineOnly, "@CenterOneLineOnly");
			}
		}
		private LazyLoad<bool> _SubTableGetsUp1Level;
		public bool SubTableGetsUp1Level
		{
			get
			{
				return LazyLoad(ref _SubTableGetsUp1Level, "@SubTableGetsUp1Level");
			}
		}
		private LazyLoad<bool> _Remember;
		public bool Remember
		{
			get
			{
				return LazyLoad(ref _Remember, "@Remember");
			}
		}
		private LazyLoad<bool> _CenterOneLineAdjust;
		public bool CenterOneLineAdjust
		{
			get
			{
				return LazyLoad(ref _CenterOneLineAdjust, "@CenterOneLineAdjust");
			}
		}
		private LazyLoad<bool> _Break;
		public bool Break
		{
			get
			{
				return LazyLoad(ref _Break, "@Break");
			}
		}
		private LazyLoad<bool> _BreakEquipmentList;
		public bool BreakEquipmentList
		{
			get
			{
				return LazyLoad(ref _BreakEquipmentList, "@BreakEquipmentList");
			}
		}
		private LazyLoad<bool> _BreakCautionsNotesOnSubstps;
		public bool BreakCautionsNotesOnSubstps
		{
			get
			{
				return LazyLoad(ref _BreakCautionsNotesOnSubstps, "@BreakCautionsNotesOnSubstps");
			}
		}
		private LazyLoad<bool> _CenterTextWithinWidth;
		public bool CenterTextWithinWidth
		{
			get
			{
				return LazyLoad(ref _CenterTextWithinWidth, "@CenterTextWithinWidth");
			}
		}
		private LazyLoad<bool> _NewlineAfter;
		public bool NewlineAfter
		{
			get
			{
				return LazyLoad(ref _NewlineAfter, "@NewlineAfter");
			}
		}
		private LazyLoad<bool> _StartLineWithDash;
		public bool StartLineWithDash
		{
			get
			{
				return LazyLoad(ref _StartLineWithDash, "@StartLineWithDash");
			}
		}
		private LazyLoad<bool> _BlankLineBeforeSubStep;
		public bool BlankLineBeforeSubStep
		{
			get
			{
				return LazyLoad(ref _BlankLineBeforeSubStep, "@BlankLineBeforeSubStep");
			}
		}
		private LazyLoad<bool> _AlwaysTab;
		public bool AlwaysTab
		{
			get
			{
				return LazyLoad(ref _AlwaysTab, "@AlwaysTab");
			}
		}
		private LazyLoad<bool> _NoSpaceMultipleRNOs;
		public bool NoSpaceMultipleRNOs
		{
			get
			{
				return LazyLoad(ref _NoSpaceMultipleRNOs, "@NoSpaceMultipleRNOs");
			}
		}
		private LazyLoad<bool> _MixCautionsAndNotes;
		public bool MixCautionsAndNotes
		{
			get
			{
				return LazyLoad(ref _MixCautionsAndNotes, "@MixCautionsAndNotes");
			}
		}
		private LazyLoad<bool> _NumberHighLevel;
		public bool NumberHighLevel
		{
			get
			{
				return LazyLoad(ref _NumberHighLevel, "@NumberHighLevel");
			}
		}
		private LazyLoad<bool> _NumberWithLevel;
		public bool NumberWithLevel
		{
			get
			{
				return LazyLoad(ref _NumberWithLevel, "@NumberWithLevel");
			}
		}
		private LazyLoad<bool> _OffsetTab;
		public bool OffsetTab
		{
			get
			{
				return LazyLoad(ref _OffsetTab, "@OffsetTab");
			}
		}
		private LazyLoad<float?> _AdjHighLevelTab;
		public float? AdjHighLevelTab
		{
			get
			{
				return LazyLoad(ref _AdjHighLevelTab, "@AdjHighLevelTab");
			}
		}
		private LazyLoad<float?> _ChildIndent;
		public float? ChildIndent
		{
			get
			{
				return LazyLoad(ref _ChildIndent, "@ChildIndent");
			}
		}
		private LazyLoad<bool> _LeftJustifyBorderless;
		public bool LeftJustifyBorderless
		{
			get
			{
				return LazyLoad(ref _LeftJustifyBorderless, "@LeftJustifyBorderless");
			}
		}
		private LazyLoad<bool> _StepNumIfOnlyOne;
		public bool StepNumIfOnlyOne
		{
			get
			{
				return LazyLoad(ref _StepNumIfOnlyOne, "@StepNumIfOnlyOne");
			}
		}
		private LazyLoad<bool> _LJTabs;
		public bool LJTabs
		{
			get
			{
				return LazyLoad(ref _LJTabs, "@LJTabs");
			}
		}
		private LazyLoad<bool> _NumberSubs;
		public bool NumberSubs
		{
			get
			{
				return LazyLoad(ref _NumberSubs, "@NumberSubs");
			}
		}
		private LazyLoad<bool> _BulletOnContinuous;
		public bool BulletOnContinuous
		{
			get
			{
				return LazyLoad(ref _BulletOnContinuous, "@BulletOnContinuous");
			}
		}
		private LazyLoad<bool> _StepNumberForHighLevel;
		public bool StepNumberForHighLevel
		{
			get
			{
				return LazyLoad(ref _StepNumberForHighLevel, "@StepNumberForHighLevel");
			}
		}
		private LazyLoad<bool> _SameRowAsParent;
		public bool SameRowAsParent
		{
			get
			{
				return LazyLoad(ref _SameRowAsParent, "@SameRowAsParent");
			}
		}
		private LazyLoad<bool> _CheckOffSameAsParent;
		public bool CheckOffSameAsParent
		{
			get
			{
				return LazyLoad(ref _CheckOffSameAsParent, "@CheckOffSameAsParent");
			}
		}
		private LazyLoad<bool> _AtLeastTwoDigits;
		public bool AtLeastTwoDigits
		{
			get
			{
				return LazyLoad(ref _AtLeastTwoDigits, "@AtLeastTwoDigits");
			}
		}
		private LazyLoad<bool> _UseInAcTable;
		public bool UseInAcTable
		{
			get
			{
				return LazyLoad(ref _UseInAcTable, "@UseInAcTable");
			}
		}
		private LazyLoad<bool> _Number;
		public bool Number
		{
			get
			{
				return LazyLoad(ref _Number, "@Number");
			}
		}
		private LazyLoad<bool> _ThreeBlanksAbove;
		public bool ThreeBlanksAbove
		{
			get
			{
				return LazyLoad(ref _ThreeBlanksAbove, "@ThreeBlanksAbove");
			}
		}
		private LazyLoad<bool> _CheckOffs;
		public bool CheckOffs
		{
			get
			{
				return LazyLoad(ref _CheckOffs, "@CheckOffs");
			}
		}
		private LazyLoad<bool> _Quoted;
		public bool Quoted
		{
			get
			{
				return LazyLoad(ref _Quoted, "@Quoted");
			}
		}
		private VE_Font _Font;
		public VE_Font Font
		{
			get
			{
				return  (_Font == null) ?_Font = new VE_Font(base.XmlNode):	_Font;
			}
		}
		private StepLayoutData _StepLayoutData;
		public StepLayoutData StepLayoutData
		{
			get
			{
				return (_StepLayoutData == null)? _StepLayoutData = new StepLayoutData(base.XmlNode): _StepLayoutData;
			}
		}
		private StepEditData _StepEditData;
		public StepEditData StepEditData
		{
			get
			{
				return (_StepEditData == null) ? _StepEditData = new StepEditData(base.XmlNode) : _StepEditData;
			}
		}
		private StepPrintData _StepPrintData;
		public StepPrintData StepPrintData
		{
			get
			{
				return (_StepPrintData == null) ? _StepPrintData = new StepPrintData(base.XmlNode) : _StepPrintData;
			}
		}
		private TabData _TabData;
		public TabData TabData
		{
			get
			{
				return (_TabData == null) ? _TabData = new TabData(base.XmlNode) : _TabData;
			}
		}
		public override string ToString()
		{
			return string.Format("{0}", Type);
		}
	}
	#endregion
	#region StepDataList
	[TypeConverter(typeof(vlnIndexedListConverter<StepDataList, StepData>))]
	public class StepDataList : vlnIndexedFormatList<StepData>
	{
		//public new StepData this[int index]
		//{
		//  get
		//  {
		//    foreach (StepData stepData in this)
		//      if (stepData.Index == index) return stepData;
		//    return null;
		//  }
		//}
		public override vlnIndexedFormatList<StepData> InheritedList
		{
			get
			{
				IFormatOrFormatInfo parentFormat = MyFormat.MyIParent;
				if (parentFormat != null)
					return parentFormat.PlantFormat.FormatData.StepDataList;
				return null;
			}
		}
		public StepData this[string type]
		{
			get
			{
				foreach (StepData stepData in this)
					if (stepData.Type == type) return stepData;
				return null;
			}
		}
		public StepData this[int index]
		{
			get
			{
				foreach (StepData stepData in this)
					if (stepData.Index == index) return stepData;
				return null;
			}
		}
		public StepDataList(XmlNodeList xmlNodeList, IFormatOrFormatInfo myFormat) : base(xmlNodeList, myFormat) { }
		private StepData _HLS;
		public StepData HLS
		{
			get
			{
				if (_HLS!=null) return _HLS;
				foreach (StepData sd in this)
				{
					if (sd.Type == "High")
					{
						_HLS = sd;
						return sd;
					}
				}
				return null;
			}
		}
		private StepData _Caution;
		public StepData Caution
		{
			get
			{
				if (_Caution != null) return _Caution;
				foreach (StepData sd in this)
				{
					if (sd.Type == "Caution")
					{
						_Caution = sd;
						return sd;
					}
				}
				return null;
			}
		}
		private StepData _Note;
		public StepData Note
		{
			get
			{
				if (_Note != null) return _Note;
				foreach (StepData sd in this)
				{
					if (sd.Type == "Note")
					{
						_Note = sd;
						return sd;
					}
				}
				return null;
			}
		}
		private StepData _RNO;
		public StepData RNO
		{
			get
			{
				if (_RNO != null) return _RNO;
				foreach (StepData sd in this)
				{
					if (sd.Type == "RNOType")
					{
						_RNO = sd;
						return sd;
					}
				}
				return null;
			}
		}
		private StepData _Fig;
		public StepData Fig
		{
			get
			{
				if (_Fig != null) return _Fig;
				foreach (StepData sd in this)
				{
					if (sd.Type == "Figure")
					{
						_Fig = sd;
						return sd;
					}
				}
				return null;
			}
		}
		private StepData _Table;
		public StepData Table
		{
			get
			{
				if (_Table != null) return _Table;
				foreach (StepData sd in this)
				{
					if (sd.Type == "Table")
					{
						_Table = sd;
						return sd;
					}
				}
				return null;
			}
		}
		private StepData _Substep;
		public StepData Substep
		{
			get
			{
				if (_Substep != null) return _Substep;
				foreach (StepData sd in this)
				{
					if (sd.Type == "Substep")
					{
						_Substep = sd;
						return sd;
					}
				}
				return null;
			}
		}
	}
	#endregion
	#region StepLayoutData
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class StepLayoutData : vlnFormatItem
	{
		public StepLayoutData(XmlNode xmlNode)
			: base(xmlNode)
		{
		}
		private LazyLoad<string> _ForeColor;
		public string ForeColor
		{
			get
			{
				return LazyLoad(ref _ForeColor, "StepLayoutData/@ForeColor");
			}
		}
		private LazyLoad<string> _BackColor;
		public string BackColor
		{
			get
			{
				return LazyLoad(ref _BackColor, "StepLayoutData/@BackColor");
			}
		}
		private LazyLoad<int?> _STExtraSpace;
		public int? STExtraSpace
		{
			get
			{
				return LazyLoad(ref _STExtraSpace, "StepLayoutData/@STExtraSpace");
			}
		}
		private LazyLoad<int?> _STBoxindex;
		public int? STBoxindex
		{
			get
			{
				return LazyLoad(ref _STBoxindex, "StepLayoutData/@STBoxindex");
			}
		}
		private LazyLoad<int?> _EveryNLines;
		public int? EveryNLines
		{
			get
			{
				return LazyLoad(ref _EveryNLines, "StepLayoutData/@EveryNLines");
			}
		}
		private LazyLoad<bool> _AlignWithParentTab;
		public bool AlignWithParentTab
		{
			get
			{
				return LazyLoad(ref _AlignWithParentTab, "StepLayoutData/@AlignWithParentTab");
			}
		}

	}
	#endregion
	#region StepEditData
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class StepEditData : vlnFormatItem
	{
		public StepEditData(XmlNode xmlNode)
			: base(xmlNode)
		{
		}
		private TypeMenu _TypeMenu;
		public TypeMenu TypeMenu
		{
			get
			{
				return (_TypeMenu == null) ? _TypeMenu = new TypeMenu(base.XmlNode) : _TypeMenu;
			}
		}
		private LazyLoad<string> _ForeColor;
		public string ForeColor
		{
			get
			{
				return LazyLoad(ref _ForeColor, "StepEditData/@ForeColor");
			}
		}
		private LazyLoad<string> _BackColor;
		public string BackColor
		{
			get
			{
				return LazyLoad(ref _BackColor, "StepEditData/@BackColor");
			}
		}
		private LazyLoad<E_AccStep?> _AcTable;
		public E_AccStep? AcTable
		{
			get
			{
				return LazyLoad<E_AccStep>(ref _AcTable, "StepEditData/@AcTable");
			}
		}
		private LazyLoad<bool> _Searchable;
		public bool Searchable
		{
			get
			{
				return LazyLoad(ref _Searchable, "StepEditData/@Searchable");
			}
		}
	}
	#endregion
	#region StepPrintData
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class StepPrintData : vlnFormatItem
	{
		public StepPrintData(XmlNode xmlNode)
			: base(xmlNode)
		{
		}
		private LazyLoad<float?> _PosAdjust;
		public float? PosAdjust
		{
			get
			{
				return LazyLoad(ref _PosAdjust, "StepPrintData/@PosAdjust");
			}
		}
		private LazyLoad<int?> _HLSLength;
		public int? HLSLength
		{
			get
			{
				return LazyLoad(ref _HLSLength, "StepPrintData/@HLSLength");
			}
		}
		private LazyLoad<string> _Justify;
		public string Justify
		{
			get
			{
				return LazyLoad(ref _Justify, "StepPrintData/@Justify");
			}
		}
	}
	#endregion
	#region TypeMenu
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class TypeMenu : vlnFormatItem
	{
		public TypeMenu(XmlNode xmlNode)
			: base(xmlNode)
		{
		}
		private LazyLoad<bool> _InMenu;
		public bool InMenu
		{
			get
			{
				return LazyLoad(ref _InMenu, "StepEditData/TypeMenu/@InMenu");
			}
		}
		private LazyLoad<bool> _RnoInMenu;
		public bool RnoInMenu
		{
			get
			{
				return LazyLoad(ref _RnoInMenu, "StepEditData/TypeMenu/@RnoInMenu");
			}
		}
		private LazyLoad<string> _MenuItem;
		public string MenuItem
		{
			get
			{
				return LazyLoad(ref _MenuItem, "StepEditData/TypeMenu/@MenuItem");
			}
		}
		private LazyLoad<string> _RnoMenuItem;
		public string RnoMenuItem
		{
			get
			{
				return LazyLoad(ref _RnoMenuItem, "StepEditData/TypeMenu/@RnoMenuItem");
			}
		}
		private LazyLoad<string> _NoChgReason;
		public string NoChgReason
		{
			get
			{
				return LazyLoad(ref _NoChgReason, "StepEditData/TypeMenu/@NoChgReason");
			}
		}
		private LazyLoad<string> _AlternateNameList;
		public string AlternateNameList
		{
			get
			{
				return LazyLoad(ref _AlternateNameList, "StepEditData/TypeMenu/@AlternateNameList");
			}
		}
	}
	#endregion
	#region Bullet
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class Bullet : vlnFormatItem
	{
		public Bullet(XmlNode xmlNode) : base(xmlNode) { }
		private LazyLoad<bool> _Separate;
		public bool Separate
		{
			get
			{
				return LazyLoad(ref _Separate, "TabData/Bullet/@Separate");
			}
		}
		private VE_Font _Font;
		public VE_Font Font
		{
			get
			{
				if (_Font == null)
				{
					XmlNode xn = vlnFormatDocument.LookupSingleStepNode(base.XmlNode, "Bullet[Font]");
					_Font = new VE_Font(xn);
				}
				return _Font;
			}
		}
	}

	#endregion
	#region StepTab
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class TabData : vlnFormatItem
	{
		public TabData(XmlNode xmlNode)
			: base(xmlNode)
		{
		}
		private MacroList _MacroList;
		public MacroList MacroList
		{
			get
			{
				return _MacroList == null ? _MacroList = new MacroList(SelectNodes("TabData/MacroList/Macro")) : _MacroList;
			}
		}
		private LazyLoad<string> _IdentEdit;
		public string IdentEdit
		{
			get
			{
				return LazyLoad(ref _IdentEdit, "TabData/@IdentEdit");
			}
		}
		private LazyLoad<string> _IdentPrint;
		public string IdentPrint
		{
			get
			{
				return LazyLoad(ref _IdentPrint, "TabData/@Ident");
			}
		}
		private LazyLoad<string> _IdentAltPrint;
		public string IdentAltPrint
		{
			get
			{
				return LazyLoad(ref _IdentAltPrint, "TabData/@IdentAltPrint");
			}
		}
		private LazyLoad<string> _RNOIdentEdit;
		public string RNOIdentEdit
		{
			get
			{
				return LazyLoad(ref _RNOIdentEdit, "TabData/@RNOIdentEdit");
			}
		}
		private LazyLoad<string> _RNOIdent;
		public string RNOIdent
		{
			get
			{
				return LazyLoad(ref _RNOIdent, "TabData/@RNOIdent");
			}
		}
		private LazyLoad<string> _RNOIdentPrint;
		public string RNOIdentPrint
		{
			get
			{
				return LazyLoad(ref _RNOIdentPrint, "TabData/@RNOIdent");
			}
		}
		private LazyLoad<bool> _RNOExcludeMacros;
		public bool RNOExcludeMacros
		{
			get
			{
				return LazyLoad(ref _RNOExcludeMacros, "TabData/@RNOExcludeMacros");
			}
		}
		private LazyLoad<string> _Justify;
		public string Justify
		{
			get
			{
				return LazyLoad(ref _Justify, "TabData/@Justify");
			}
		}
		private LazyLoad<bool> _UsePreviousStyle;
		public bool UsePreviousStyle
		{
			get
			{
				return LazyLoad(ref _UsePreviousStyle, "TabData/@UsePreviousStyle");
			}
		}
		private LazyLoad<bool> _IsTransition;
		public bool IsTransition
		{
			get
			{
				return LazyLoad(ref _IsTransition, "TabData/@IsTransition");
			}
		}
		private LazyLoad<float?> _IdentWidth;
		public float? IdentWidth
		{
			get
			{
				return LazyLoad(ref _IdentWidth, "TabData/@IdentWidth");
			}
		}
		private LazyLoad<float?> _RNOAdjustTabSize;
		public float? RNOAdjustTabSize
		{
			get
			{
				return LazyLoad(ref _RNOAdjustTabSize, "TabData/@RNOAdjustTabSize");
			}
		}
		private LazyLoad<float?> _MacroTabAdjust;
		public float? MacroTabAdjust
		{
			get
			{
				return LazyLoad(ref _MacroTabAdjust, "TabData/@MacroTabAdjust");
			}
		}
		private VE_Font _Font;
		public VE_Font Font
		{
			get
			{
				if (_Font == null)
				{
					XmlNode xn = vlnFormatDocument.LookupSingleStepNode(base.XmlNode, "TabData[Font]");
					_Font = new VE_Font(xn);
				}
				return _Font;
			}
		}
		private Bullet _Bullet;
		public Bullet Bullet
		{
			get
			{
				return (_Bullet == null) ? _Bullet = new Bullet(base.XmlNode) : _Bullet;
			}
		}
		private LazyLoad<bool> _NoTrim;
		public bool NoTrim
		{
			get
			{
				return LazyLoad(ref _NoTrim, "TabData/@NoTrim");
			}
		}

	}
	#endregion
	#region MacroList
	[TypeConverter(typeof(vlnListConverter<MacroList, Macro>))]
	public class MacroList : vlnNamedFormatList<Macro>
	{
		public MacroList(XmlNodeList xmlNodeList) : base(xmlNodeList, null) { }
		public override vlnNamedFormatList<Macro> InheritedList
		{
			get
			{

				return null;
			}
		}
	}
	#endregion
	#region Macro
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class Macro : vlnFormatItem, IVlnNamedFormatItem
	{
		public Macro(XmlNode xmlNode) : base(xmlNode) { }
		public Macro() : base() { }
		private LazyLoad<string> _Name;
		public string Name
		{
			get
			{
				return LazyLoad(ref _Name, "@Name");
			}
		}
		private LazyLoad<string> _MacroDef;
		public string MacroDef
		{
			get
			{
				if (_Inherited == null) SetupStepInheritance();
				return LazyLoad(ref _MacroDef, "@Macro");
			}
		}
		private LazyLoad<string> _SingleColMacroDef;
		public string SingleColMacroDef
		{
			get
			{
				if (_Inherited == null) SetupStepInheritance();
				return LazyLoad(ref _SingleColMacroDef, "@SingleColMacro");
			}
		}
		private LazyLoad<float?> _MacroXOffSet;
		public float? MacroXOffSet
		{
			get
			{
				return LazyLoad(ref _MacroXOffSet, "@MacroXOffSet");
			}
		}
		private LazyLoad<float?> _SingleColWidthAdjust;
		public float? SingleColWidthAdjust
		{
			get
			{
				return LazyLoad(ref _SingleColWidthAdjust, "@SingleColWidthAdjust");
			}
		}
		private LazyLoad<bool> _LocWithXOff;
		public bool? LocWithXOff
		{
			get
			{
				return LazyLoad(ref _LocWithXOff, "@LocWithXOff");
			}
		}
		
		private LazyLoad<int?> _Grouping;
		public int? Grouping
		{
			get
			{
				if (_Inherited == null) SetupStepInheritance();
				return LazyLoad(ref _Grouping, "@Grouping");
			}
		}
		private LazyLoad<bool> _NotInRNO;
		public bool NotInRNO
		{
			get
			{
				if (_Inherited == null) SetupStepInheritance();
				return LazyLoad(ref _NotInRNO, "@NotInRNO");
			}
		}
		
		private bool? _Inherited;
		public bool Inherited
		{
			get
			{
				if (_Inherited == null)	SetupStepInheritance();
				return (bool) _Inherited;
			}
		}
		private void SetupStepInheritance()
		{
			if (_Inherited != null) return;
			LazyLoad<string> macroName = null;
			_Inherited = (LazyLoad(ref macroName, "@Macro") == null);
			// No MacroName, Find parent that has data
			string path = string.Format("TabData/MacroList/Macro[@Name='{0}' and @Macro]", Name);
			XmlNode xn = vlnFormatDocument.LookupSingleStepNode(XmlNode.ParentNode.ParentNode.ParentNode, path);
			if (xn != null)
			{
				_MacroDef = new LazyLoad<string>(RetrieveString(xn.SelectSingleNode("@Macro")));
				_Grouping = new LazyLoad<int?>(RetrieveInt("@Grouping" ,xn.SelectSingleNode("@Grouping")));
				_NotInRNO = new LazyLoad<bool>(RetrieveBool( xn.SelectSingleNode("@NotInRNO")));
			}
		}
	}
#endregion
	#endregion
	#region BoxDataAll
	#region Box
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class Box : vlnFormatItem,IVlnIndexedFormatItem
	{
		public Box(XmlNode xmlNode) : base(xmlNode) { }
		public Box() : base() { }
		private LazyLoad<int?> _Index;
		public int? Index
		{
			get
			{
				return LazyLoad(ref _Index, "@Index");
			}
		}
		private LazyLoad<float?> _Start;
		public float? Start
		{ 
			get 
			{
				return LazyLoad(ref _Start, "@Start");
			} 
		}
		private LazyLoad<float?> _End;
		public float? End
		{
			get
			{
				return LazyLoad(ref _End, "@End");
			}
		}
		private LazyLoad<float?> _TxtStart;
		public float? TxtStart
		{
			get
			{
				return LazyLoad(ref _TxtStart, "@TxtStart");
			}
		}
		private LazyLoad<float?> _TxtWidth;
		public float? TxtWidth
		{
			get
			{
				return LazyLoad(ref _TxtWidth, "@TxtWidth");
			}
		}
		private LazyLoad<float?> _Height;
		public float? Height
		{
			get
			{
				return LazyLoad(ref _Height, "@Height");
			}
		}
		private LazyLoad<float?> _TabPos;
		public float? TabPos
		{
			get
			{
				return LazyLoad(ref _TabPos, "@TabPos");
			}
		}
		private LazyLoad<int?> _TxtRowAdj;
		public int? TxtRowAdj
		{
			get
			{
				return LazyLoad(ref _TxtRowAdj, "@TxtRowAdj");
			}
		}
		private LazyLoad<string> _BXURC;
		public string BXURC
		{ 
			get 
			{
				return LazyLoad(ref _BXURC, "@BXURC");
			} 
		}
		private LazyLoad<string> _BXHorz;
		public string BXHorz
		{
			get
			{
				return LazyLoad(ref _BXHorz, "@BXHorz");
			}
		}
		private LazyLoad<string> _BXULC;
		public string BXULC
		{
			get
			{
				return LazyLoad(ref _BXULC, "@BXULC");
			}
		}
		private LazyLoad<string> _BXVert;
		public string BXVert
		{
			get
			{
				return LazyLoad(ref _BXVert, "@BXVert");
			}
		}
		private LazyLoad<string> _BXMLS;
		public string BXMLS
		{
			get
			{
				return LazyLoad(ref _BXMLS, "@BXMLS");
			}
		}
		private LazyLoad<string> _BXMRS;
		public string BXMRS
		{
			get
			{
				return LazyLoad(ref _BXMRS, "@BXMRS");
			}
		}
		private LazyLoad<string> _BXLRC;
		public string BXLRC
		{
			get
			{
				return LazyLoad(ref _BXLRC, "@BXLRC");
			}
		}
		private LazyLoad<string> _BXLLC;
		public string BXLLC
		{
			get
			{
				return LazyLoad(ref _BXLLC, "@BXLLC");
			}
		}
		private LazyLoad<string> _BXMID;
		public string BXMID
		{
			get
			{
				return LazyLoad(ref _BXMID, "@BXMID");
			}
		}
		private LazyLoad<string> _BXLHorz;
		public string BXLHorz
		{
			get
			{
				return LazyLoad(ref _BXLHorz, "@BXLHorz");
			}
		}
		private LazyLoad<string> _BXUMID;
		public string BXUMID
		{
			get
			{
				return LazyLoad(ref _BXUMID, "@BXUMID");
			}
		}
		private LazyLoad<string> _BXLMID;
		public string BXLMID
		{
			get
			{
				return LazyLoad(ref _BXLMID, "@BXLMID");
			}
		}
		private VE_Font _Font;
		public VE_Font Font
		{
			get
			{
				return (_Font == null) ?_Font = new VE_Font(base.XmlNode):_Font;
			}
		}
		public override string GetPDDisplayName()
		{ return string.Format("[{0}]", Index); }
		public override string GetPDCategory()
		{ return "Box Definition"; }
		public override string ToString()
		{
			return String.Format("{0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11}",
				BXURC, BXHorz, BXULC, BXVert, BXMLS, BXMRS, BXLRC, BXLLC, BXMID, BXLHorz, BXUMID, BXLMID);
		}
		public string BoxStyle
		{
			get
			{
				return String.Format("{0}.{1}.{2}.{3}.{4}.{5}.{6}.{7}.{8}.{9}.{10}.{11}",
				BXURC ?? " ", BXHorz ?? " ", BXULC ?? " ", BXVert ?? " ", BXMLS ?? " ", BXMRS ?? " ", BXLRC ?? " ", BXLLC ?? " ", BXMID ?? " ", BXLHorz ?? BXHorz, BXUMID ?? " ", BXLMID ?? " ");
			}
		}
	}
	#endregion
	#region BoxList
	[TypeConverter(typeof(vlnIndexedListConverter<BoxList, Box>))]
	public class BoxList : vlnIndexedFormatList<Box>
	{
		public BoxList(XmlNodeList xmlNodeList, IFormatOrFormatInfo myFormat) : base(xmlNodeList, myFormat) { }
		public override vlnIndexedFormatList<Box> InheritedList
		{
			get
			{
				IFormatOrFormatInfo parentFormat = MyFormat.MyIParent;
				if (parentFormat != null)
					return parentFormat.PlantFormat.FormatData.BoxList;
				return null;
			}
		}

	}
	#endregion
	#endregion
	#region TransDataAll
	#region TransData
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class TransData : vlnFormatItem
	{
		private TransTypeList _TransTypeList;
		public TransTypeList TransTypeList
		{
			get
			{
				return(_TransTypeList == null || _TransTypeList.Count==0)? _TransTypeList = new TransTypeList(SelectNodes("TransTypeData/TransTypes"),MyFormat): _TransTypeList;
			}
		}
		public TransData(XmlNode xmlNode) : base(xmlNode) { }
		private LazyLoad<string> _DelimiterForTransitionTitle;
		public string DelimiterForTransitionTitle
		{ 
			get 
			{
				return LazyLoad(ref _DelimiterForTransitionTitle, "@DelimiterForTransitionTitle");
			} 
		}
		private LazyLoad<string> _StepSubstepDelimeter;
		public string StepSubstepDelimeter
		{
			get
			{
				return LazyLoad(ref _StepSubstepDelimeter, "@StepSubstepDelimeter");
			}
		}
		private LazyLoad<string> _ThroughString;
		public string ThroughString
		{
			get
			{
				return LazyLoad(ref _ThroughString, "@ThroughString");
			}
		}
		private LazyLoad<bool> _SpecifiedSubstepsOnly;
		public bool SpecifiedSubstepsOnly
		{
			get
			{
				return LazyLoad(ref _SpecifiedSubstepsOnly, "@SpecifiedSubstepsOnly");
			}
		}
		private LazyLoad<bool> _CapsTransitions;
		public bool CapsTransitions
		{
			get
			{
				return LazyLoad(ref _CapsTransitions, "@CapsTransitions");
			}
		}
		private LazyLoad<bool> _CapsTransitionsSection;
		public bool CapsTransitionsSection
		{
			get
			{
				return LazyLoad(ref _CapsTransitionsSection, "@CapsTransitionsSection");
			}
		}
		private LazyLoad<bool> _CapTranStep;
		public bool CapTranStep
		{
			get
			{
				return LazyLoad(ref _CapTranStep, "@CapTranStep");
			}
		}
		private LazyLoad<bool> _Underline;
		public bool Underline
		{
			get 
			{
				return LazyLoad(ref _Underline, "@Underline");
			}
		}
		private LazyLoad<bool> _TStepNoFlag;
		public bool TStepNoFlag
		{
			get
			{
				return LazyLoad(ref _TStepNoFlag, "@TStepNoFlag");
			}
		}
		private LazyLoad<bool> _LowerCaseTranNumber;
		public bool LowerCaseTranNumber
		{
			get
			{
				return LazyLoad(ref _LowerCaseTranNumber, "@LowerCaseTranNumber");
			}
		}
		private LazyLoad<bool> _UpcaseTranAnd;
		public bool UpcaseTranAnd
		{
			get
			{
				return LazyLoad(ref _UpcaseTranAnd, "@UpcaseTranAnd");
			}
		}
		private LazyLoad<bool> _SuppressAndInTran;
		public bool SuppressAndInTran
		{
			get
			{
				return LazyLoad(ref _SuppressAndInTran, "@SuppressAndInTran");
			}
		}
		private LazyLoad<bool> _Cap1stCharTrans;
		public bool Cap1stCharTrans
		{
			get
			{
				return LazyLoad(ref _Cap1stCharTrans, "@Cap1stCharTrans");
			}
		}
		private LazyLoad<bool> _Cap1stCharTransSection;
		public bool Cap1stCharTransSection
		{
			get
			{
				return LazyLoad(ref _Cap1stCharTransSection, "@Cap1stCharTransSection");
			}
		}
		private LazyLoad<bool> _UseTransitionModifier;
		public bool UseTransitionModifier
		{
			get
			{
				return LazyLoad(ref _UseTransitionModifier, "@UseTransitionModifier");
			}
		}
		private LazyLoad<bool> _UseSpecificTransitionModifier;
		public bool UseSpecificTransitionModifier
		{
			get
			{
				return LazyLoad(ref _UseSpecificTransitionModifier, "@UseSpecificTransitionModifier");
			}
		}
		private LazyLoad<bool> _UseSpecificPageNo;
		public bool UseSpecificPageNo
		{
			get
			{
				return LazyLoad(ref _UseSpecificPageNo, "@UseSpecificPageNo");
			}
		}
		private LazyLoad<bool> _UseSecTitles;
		public bool UseSecTitles
		{
			get
			{
				return LazyLoad(ref _UseSecTitles, "@UseSecTitles");
			}
		}
		private LazyLoad<bool> _DoSectionTransitions;
		public bool DoSectionTransitions
		{
			get
			{
				return LazyLoad(ref _DoSectionTransitions, "@DoSectionTransitions");
			}
		}
		private LazyLoad<bool> _HardSpTranProcNumb;
		public bool HardSpTranProcNumb
		{
			get
			{
				return LazyLoad(ref _HardSpTranProcNumb, "@HardSpTranProcNumb");
			}
		}
		private LazyLoad<bool> _XchngTranSpForHard;
		public bool XchngTranSpForHard
		{
			get
			{
				return LazyLoad(ref _XchngTranSpForHard, "@XchngTranSpForHard");
			}
		}
		private LazyLoad<bool> _AbsoluteTransitionUpdate;
		public bool AbsoluteTransitionUpdate
		{
			get
			{
				return LazyLoad(ref _AbsoluteTransitionUpdate, "@AbsoluteTransitionUpdate");
			}
		}
		private LazyLoad<bool> _LowerCaseStepInTran;
		public bool LowerCaseStepInTran
		{
			get
			{
				return LazyLoad(ref _LowerCaseStepInTran, "@LowerCaseStepInTran");
			}
		}
		private LazyLoad<bool> _BoldTransition;
		public bool BoldTransition
		{
			get
			{
				return LazyLoad(ref _BoldTransition, "@BoldTransition");
			}
		}
		private LazyLoad<bool> _BoldTransitionExceptHLS;
		public bool BoldTransitionExceptHLS
		{
			get
			{
				return LazyLoad(ref _BoldTransitionExceptHLS, "@BoldTransitionExceptHLS");
			}
		}
		private LazyLoad<bool> _AdjustStepTransitionText;
		public bool AdjustStepTransitionText
		{
			get
			{
				return LazyLoad(ref _AdjustStepTransitionText, "@AdjustStepTransitionText");
			}
		}
	}
	#endregion
	#region TransType
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class TransType : vlnFormatItem,IVlnIndexedFormatItem
	{
		public TransType(XmlNode xmlNode) : base(xmlNode) { }
		public TransType() : base() { }
		private LazyLoad<int?> _Index;
		public int? Index
		{
			get
			{
				return LazyLoad(ref _Index, "@Index");
			}
		}
		private LazyLoad<int?> _Type;
		public int? Type
		{
			get
			{
				return LazyLoad(ref _Type, "@TransType");
			}
		}
		private LazyLoad<string> _TransFormat;
		public string TransFormat
		{
			get
			{
				return LazyLoad(ref _TransFormat, "@TransFormat");
			}
		}
		private LazyLoad<E_TransUI?> _TransUI;
		public E_TransUI? TransUI
		{
			get
			{
				return LazyLoad<E_TransUI>(ref _TransUI, "@TransUI");
			}
		}
		private LazyLoad<string> _TransMenu;
		public string TransMenu
		{
			get
			{
				return LazyLoad(ref _TransMenu, "@TransMenu");
			}
		}
		public override string GetPDDisplayName()
		{ return string.Format("[{0}] - Type {1}", Index, Type); }
		public override string GetPDCategory()
		{ return "Transition Type Data"; }
		public override string ToString()
		{
			return string.Format("{0} - {1}",TransFormat, TransMenu);
		}
	}
	#endregion
	#region TransTypeList
	[TypeConverter(typeof(vlnIndexedListConverter<TransTypeList, TransType>))]
	public class TransTypeList : vlnIndexedFormatList<TransType>
	{
		public TransTypeList(XmlNodeList xmlNodeList, IFormatOrFormatInfo myFormat) : base(xmlNodeList,myFormat) { }
		public override vlnIndexedFormatList<TransType> InheritedList
		{
			get
			{
				IFormatOrFormatInfo parentFormat = MyFormat.MyIParent;
				if (parentFormat != null)
					return parentFormat.PlantFormat.FormatData.TransData.TransTypeList;
				return null;
			}
		}
	}
	#endregion
	#region RoData
	[TypeConverter(typeof(ExpandableObjectConverter))]
	public class ROData : vlnFormatItem
	{
		public ROData(XmlNode xmlNode) : base(xmlNode) { }
		private LazyLoad<bool> _AllUnits;
		public bool AllUnits
		{
			get
			{
				return LazyLoad(ref _AllUnits, "@AllUnits");
			}
		}
		private LazyLoad<bool> _UpRoAftrDash;
		public bool UpRoAftrDash
		{
			get
			{
				return LazyLoad(ref _UpRoAftrDash, "@UpRoAftrDash");
			}
		}
		private LazyLoad<bool> _UpRoImmAftrDashSpace;
		public bool UpRoImmAftrDashSpace
		{
			get
			{
				return LazyLoad(ref _UpRoImmAftrDashSpace, "@UpRoImmAftrDashSpace");
			}
		}
		private LazyLoad<bool> _UpcaseAllRoUnits;
		public bool UpcaseAllRoUnits
		{
			get
			{
				return LazyLoad(ref _UpcaseAllRoUnits, "@UpcaseAllRoUnits");
			}
		}
		private LazyLoad<bool> _CapHighRo;
		public bool CapHighRo
		{
			get
			{
				return LazyLoad(ref _CapHighRo, "@CapHighRo");
			}
		}
		private LazyLoad<bool> _CapRoIfLastLower;
		public bool CapRoIfLastLower
		{
			get
			{
				return LazyLoad(ref _CapRoIfLastLower, "@CapRoIfLastLower");
			}
		}
		private LazyLoad<bool> _CapSPIfLastLower;
		public bool CapSPIfLastLower
		{
			get
			{
				return LazyLoad(ref _CapSPIfLastLower, "@CapSPIfLastLower");
			}
		}
		private LazyLoad<bool> _UpRoIfPrevUpper;
		public bool UpRoIfPrevUpper
		{
			get
			{
				return LazyLoad(ref _UpRoIfPrevUpper, "@UpRoIfPrevUpper");
			}
		}
		private LazyLoad<bool> _UnderlineRo;
		public bool UnderlineRo
		{
			get
			{
				return LazyLoad(ref _UnderlineRo, "@UnderlineRo");
			}
		}
		private LazyLoad<bool> _CapFirstLetterInHighRO;
		public bool CapFirstLetterInHighRO
		{
			get
			{
				return LazyLoad(ref _CapFirstLetterInHighRO, "@CapFirstLetterInHighRO");
			}
		}
	}
	#endregion
	#endregion
	#region SupportClasses
	public class StepDataRetval
	{
		private string _Name;
		public string Name
		{
			get { return _Name; }
			set { _Name = value; }
		}
		private int _Index;
		public int Index
		{
			get { return _Index; }
			set { _Index = value; }
		}
		public StepDataRetval(string name, int index)
		{
			Name = name;
			Index = index;
		}
	}
	#endregion
}