#define ItemWithContent

using System;
using System.Collections.Generic;
using System.Text;
using Csla;
using Csla.Data;
using System.Data;
using System.Data.SqlClient;
using System.Xml;
using System.Drawing;
using System.Text.RegularExpressions;

namespace VEPROMS.CSLA.Library
{

	#region Item
	public partial class Item : IVEDrillDown
	{
		// put in for debug
		//public static int CacheCountPrimaryKey
		//{ get { return _CacheByPrimaryKey.Count; } }
		//public static int CacheCountList
		//{ get { return _CacheList.Count; } }

		public string DisplayNumber
		{
			get { return ItemInfo.ConvertToDisplayText(MyContent.Number); }
		}
		public ItemInfo MyItemInfo /* Return Info version of the current Item */
		{ get { return ItemInfo.Get(ItemID); } }
		public static void ShowAllocated(string title)
		{
			Console.WriteLine("{0} - {1} Items in the dictionary", title, _CacheByPrimaryKey.Count);
			foreach (List<Item> itmlst in _CacheByPrimaryKey.Values)
				foreach(Item itm in itmlst)
					Console.WriteLine("Item {0} UniqueID {1}", itm.ItemID, itm.MyItemUnique);
			Console.WriteLine("- - - - - -");
		}

		public override string ToString()
		{
			return string.Format("{0} {1}", MyContent.Number, MyContent.Text).Trim();
		}
		// TODO: Move to ItemInfo Extension

		#region IVEDrillDown
		//public System.Collections.IList GetChildren()
		//{
		//  return this.MyContent.ContentParts;
		//}
		//public bool HasChildren
		//{
		//  get { return this.MyContent.ContentPartCount > 0; }
		//}
		//public Item MyProcedure
		//{
		//  get
		//  {
		//    // Walk up active parents until the parent is not an item
		//    Item tmp = this;
		//    while (tmp.ActiveParent.GetType() != typeof(DocVersion)) tmp = (Item)tmp.ActiveParent;
		//    return tmp;
		//  }
		//}		
		//private IVEDrillDown _ActiveParent = null;
		//public IVEDrillDown ActiveParent
		//{
		//  get
		//  {
		//    if (_ActiveParent == null)
		//    {
		//      if (MyPrevious != null)
		//        _ActiveParent = _MyPrevious.ActiveParent;
		//      else
		//      {
		//        if (ItemDocVersionCount > 0)
		//          _ActiveParent = this.ItemDocVersions[0].MyDocVersion;
		//        else
		//        {
		//          if (this.ItemParts == null || this.ItemPartCount == 0)
		//            _ActiveParent = this;
		//          else
		//            _ActiveParent = this.ItemParts[0].MyContent.ContentItems[0].MyItem;
		//        }
		//      }
		//    }
		//    return _ActiveParent == this ? null : _ActiveParent;
		//  }
		//}
		//private Format _ActiveFormat = null;// Added to cache ActiveFormat
		//public Format ActiveFormat
		//{
		//  get
		//  {
		//    if (_ActiveFormat == null)
		//      _ActiveFormat = (LocalFormat != null ? LocalFormat : ActiveParent.ActiveFormat);
		//    return _ActiveFormat;
		//  }
		//  set
		//  {
		//    _ActiveFormat = null; // Reset
		//  }
		//}
		//public Format LocalFormat
		//{
		//  get { return MyContent.MyFormat; }
		//}
		public ConfigDynamicTypeDescriptor MyConfig
		{
			get { return null; }
		}
		#endregion
		public void MoveItem(IVEDrillDownReadOnly pInfo, int index)
		{
			bool wasfirstchild = false;
			ItemInfo parentInfo = pInfo as ItemInfo;
			DocVersionInfo parentInfoDV = pInfo as DocVersionInfo;
			IList<ItemInfo> children = null;
			E_FromType partType = 0;			// this is needed later to determine sub-group type.
			if (parentInfo != null)
			{
				// this may have subgroups, need to use part type to get children list...
				ItemInfo thisinfo = ItemInfo.Get(ItemID);
				partType = thisinfo.FirstSibling.ItemParts[0].PartType;
				children = (IList<ItemInfo>)parentInfo.Lookup((int)partType);
			}
			else
				children = (IList<ItemInfo>)parentInfoDV.GetChildren();
			int numChild = children.Count;

			if (this.MyPrevious == null) wasfirstchild = true;
			Item origNextItem = null;

			// First, remove from this item from its list.  To do this, get the current item's next point and redirect it's myprevious
			// to this item's previous...
			if (NextItems != null && NextItems.Count > 0)
			{
				origNextItem = NextItems.Items[0];
				origNextItem.MyPrevious = this.MyPrevious;
				this.Save();
			}
			
			// check to see if the item is being moved into the middle of some items. newPreviousItem is the item defined
			// by index-1, i.e. inserting below newPreviousItem.
			ItemInfo newPreviousInfo = (index == 0) ? null : children[index - 1];
			ItemInfo newNextInfo = (index == children.Count) ? null : children[index];

			// Adjust the new next proc to be me.
			if (newNextInfo != null)
			{
				using (Item newNextItem = newNextInfo.Get())
				{
					newNextItem.MyPrevious = this;
					newNextItem.Save().Dispose();
				}
			}
				
			// adjust the previous node, i.e. may either be at same level or, if first in list, adjust the parent...
			// if 'newPreviousItem' isn't null, then adding to the middle of the list.				
			if (newPreviousInfo != null)
			{
				using (Item newPreviousItem = newPreviousInfo.Get())
				{
					MyPrevious = newPreviousItem;
					Save();
				}
			}
			// newPreviousInfo == null if moving into first child, and wasfirstchild == true if moving out of first child.
			// This will require adjusting the DocVersion to point to the correct first child if a procedure is moved.
			if (newPreviousInfo == null || wasfirstchild)
			{
				if (parentInfo != null)		// Moving Item within procedure, i.e. moving a section or step
				{
					using (Item parentItem = parentInfo.Get())
					{
						// moving first child out... reset parent to point to the original next item
						if (wasfirstchild)
						{
							parentItem.MyContent.ContentParts[(int)partType].MyItem = origNextItem;
							newPreviousInfo.RefreshItemParts();
						}
						else
							parentItem.MyContent.ContentParts[(int)partType].MyItem = this;
						parentItem.Save().Dispose();
					}
				}
				else if (parentInfoDV != null) // Moving Item (Procedure) within DocVersion 
				{
					using (DocVersion parentItemDV = parentInfoDV.Get())
					{
						ItemInfo firstinfo =  parentInfoDV.FirstChild();
						parentItemDV.MyItem = wasfirstchild?parentInfoDV.Procedures[1].Get():this;
						parentItemDV.Save().Dispose();
						if (!wasfirstchild && firstinfo != null)
						{
							using (Item firstchild = firstinfo.Get())
							{
								firstchild.MyPrevious = this;
								firstchild.Save().Dispose();
							}
						}
					}
				}
				if (!wasfirstchild)
				{
					this.MyPrevious = null;
					this.Save();
				}
				if (origNextItem != null) origNextItem.Dispose();
				if (parentInfo != null)
					parentInfo.MyContent.RefreshContentParts();
				if (parentInfoDV != null)
					parentInfoDV.ResetProcedures();
			}

		}
		protected static int MakeNewItem(IVEDrillDownReadOnly parentInfoDD, ItemInfo previousInfo, string number, string title, int type, E_FromType partType)
		{
			int newitemid = 0;
			if (parentInfoDD == null)
				parentInfoDD = previousInfo.ActiveParent;
			ItemInfo parentInfo = parentInfoDD as ItemInfo;
			DocVersionInfo parentInfoDV = parentInfoDD as DocVersionInfo;
			using (Content cont = Content.New(number, title, type, null, null))
			{
				using (Item fromitem = previousInfo == null ? null : previousInfo.Get())
				{
					ItemInfo nextInfo = null; // Check to see if the item is being inserted in the middle of some items.
					if (previousInfo != null && previousInfo.NextItems != null && previousInfo.NextItems.Count > 0)
						nextInfo = previousInfo.NextItems[0];
					using (Item itm = Item.MakeItem(fromitem, cont))
					{
						newitemid = itm.ItemID;
						if (nextInfo != null)
						{
							using (Item nextItem = nextInfo.Get())
							{
								nextItem.MyPrevious = itm;// Aim the next item back at the new item.
								nextItem.Save().Dispose();
							}
						}
						if (fromitem == null)
						{
							if (parentInfo != null) // Adding Item to Procedure, Section or Step
							{
								using (Item parentItem = parentInfo.Get())
								{
									ItemInfo firstinfo = parentInfo.FirstChild(partType);
									if (firstinfo != null)
									{
										using (Item firstchild = firstinfo.Get())
										{
											parentItem.MyContent.ContentParts[(int)partType].MyItem = itm;// First update the parent to point to the new first child
											parentItem.Save().Dispose();
											firstchild.MyPrevious = itm;// Aim the old first child to point to the new first child.
											firstchild.Save().Dispose();
										}
									}
									else
									{
										parentItem.MyContent.ContentParts.Add((int)partType, itm);// update the parent to point to the new first child
										parentItem.Save().Dispose();
									}
								}
							}
							if (parentInfoDV != null) // Adding Item (Procedure) to DocVersion 
							{
								using (DocVersion parentItemDV = parentInfoDV.Get())
								{
									ItemInfo firstinfo = parentInfoDV.FirstChild();
									parentItemDV.MyItem = itm;// First update the parent to point to the new first child
									parentItemDV.Save().Dispose();
									if (firstinfo != null)
									{
										using (Item firstchild = firstinfo.Get())
										{
											firstchild.MyPrevious = itm;// Aim the old first child to point to the new first child.
											firstchild.Save().Dispose();
										}
									}
								}
							}

						}
					}
				}
			}
			if (parentInfo != null)
				parentInfo.MyContent.RefreshContentParts();
			if (parentInfoDV != null)
				parentInfoDV.ResetProcedures();
			return newitemid;
		}
	}
	#endregion
	#region ItemInfo
	public partial class ItemInfo:IVEDrillDownReadOnly
	{
		// put in for debugging
		//public static int CacheCountPrimaryKey
		//{ get { return _CacheByPrimaryKey.Count; } }
		//public static int CacheCountList
		//{ get { return _CacheList.Count; } }

		//public override bool Equals(object obj)
		//{
		//  ItemInfo ii = obj as ItemInfo;
		//  if (ii != null)
		//    return ii._ItemID == _ItemID;
		//  return false;
		//}
		private int _PrintBias = 0;
		public int PrintBias
		{
			get { return _PrintBias; }
			set { _PrintBias = value; }
		}
		private int _PrintLevel = 0;
		public int PrintLevel
		{
			get 
			{ 
				if (_PrintLevel != 0) return _PrintLevel;
				int _PrintBias = 0;
				_PrintLevel = GetStepLevel(ref _PrintBias);
				
				return _PrintLevel;
			}
			set { _PrintLevel = value; }
		}
		private float _MSWordPageCount = 0;
		public float MSWordPageCount
		{
			get { return _MSWordPageCount; }
			set { _MSWordPageCount = value; }
		}
		public event ItemInfoEvent OrdinalChanged;
		private void OnOrdinalChange()
		{
			if (OrdinalChanged != null) OrdinalChanged(this);
		}
		public static void OnOrdinalChange(int itemID)
		{
			ConvertListToDictionary();
			string key = itemID.ToString();
			if (_CacheByPrimaryKey.ContainsKey(key))
				foreach (ItemInfo item in _CacheByPrimaryKey[key])
					item.OnOrdinalChange();
		}
		public bool IsFirstSubStep
		{
			get
			{
				if (!IsStepPart) return false;
				if (IsHigh) return false;
				return (MyPrevious == null);
			}
		}
		public bool IsAutoTOCSection
		{
			get
			{
				if (!IsSection) return false;
				if (MyDocStyle.StructureStyle.Style == null) return false;
				return ((ActiveFormat.PlantFormat.FormatData.PurchaseOptions & E_PurchaseOptions.AutoTableOfContents) == E_PurchaseOptions.AutoTableOfContents &&
					(MyDocStyle.StructureStyle.Style & E_DocStructStyle.TableOfContents) == E_DocStructStyle.TableOfContents);
			}
		}
		#region StepLevel
		private int _StepLevel = -2;// Not yet calculated
		public int StepLevel
		{
			get 
			{
				if (_StepLevel == -2)
				{
					_StepLevel = CalcStepLevel(this);
					//ItemInfo parent = ActiveParent as ItemInfo;
					//Console.WriteLine("{0},{1},{2},{3},{4},{5},{6}",ItemID, DBSequence, _StepLevel, MyContent.Type % 10000, parent.MyContent.Type % 10000,HasCautionOrNote ? 1 : 0, parent.Cautions == null? 0 : 1);
				}
				return _StepLevel; 
			}
			set { _StepLevel = value; }
		}
		public string ToolTip
		{
			get
			{
				if (IsStep)
					return FormatStepData.StepEditData.TypeMenu.MenuItem; //FormatStepData.Type;
				else if (IsSection)
					return MyDocStyle.Name;
				return "Procedure Title";
			}
		}
		public bool HasCautionOrNote
		{
			get { return Cautions != null || Notes != null; }
		}
		private static Regex regexDBSeqPass1 = new Regex("([^.]*)[.]S([^.]*)[.]S([0-9]*)[.](.*)");
		private static Regex regexDBSeqPass2 = new Regex("[.](.)([^.]*)[.]");
		public string DBSequence
		{
			get
			{
				Match m1 = regexDBSeqPass1.Match(ShortPath);
				MatchCollection m2s = regexDBSeqPass2.Matches(m1.Groups[4].Value);
				StringBuilder retval = new StringBuilder(string.Format("\"{0}\"\t\"{1}\"\t\"{2}\"", m1.Groups[1].Value, m1.Groups[2].Value, m1.Groups[3].Value));
				string prefix = "S";
				string suffix = "";
				foreach (Match m2 in m2s)
				{
					int i = ((int) '0') + int.Parse(m2.Groups[2].Value);
					char c = (char)i;
					suffix = c.ToString();
					switch (m2.Groups[1].Value)
					{
						case "S":
							break;
						case "R":
							prefix += "$";
							suffix = "";
							break;
						case "C":
							prefix = "!";
							break;
						case "N":
							prefix = "*";
							break;
						case "T":
							prefix += "#";
							suffix = "";
							break;
						default:
							break;
					}
					retval.Append(prefix + suffix);
					prefix = "";
				}
				retval.Append(prefix + "'");
				//Volian.Base.Library.DebugText.WriteLine("'{0}','{1}','{2}'", retval, ShortPath, Path);
				return retval.ToString();
			}
		}
		private static int CalcStepLevel(ItemInfo item)
		{
			if(item == null) return 0;
			int id=0;
			// Determines the substep level.
			int level = CountLevels(item);

			// PaginateOnFirstSubstep allows orphans, first child can be separated from its parent.
			int firstInc = item.ActiveFormat.MyStepSectionLayoutData.PaginateOnFirstSubstep ? 0 : 1;
			ItemInfo parent = item.ActiveParent as ItemInfo;

			// TODO: Format flag 'TreatAsSequential':
			// The following needs to account for use of format flag 'TreatAsSequential' when doing
			// formats that have it.
			if (item.IsExactType("And") || item.IsExactType("Or") || item.IsExactType("ImplicitOr"))
				level++;
			if (parent != null && (parent.IsExactType("And") || parent.IsExactType("Or"))) 
				level++;

			// First substep, this is where it uses the orphan logic from above.
			if (!item.IsRNOPart && !item.IsHigh && item.MyPrevious == null)
				level += firstInc;
			else
				firstInc = 0;

			// Try not to paginate on a step that has Cautions & Notes, keep the Caution/Note with
			// the step.
			if (item.IsStepPart)
			{
				if (item.Cautions != null || item.Notes != null)
					level += 2;
			}
			// Paginate before first caution, not between cautions.
			else if (item.IsCautionPart)	
			{
				if (item.MyPrevious == null) level-=(1 + firstInc);
				else level++;
			}
			// Paginate before first note, if the step does not have a caution.
			// Otherwise, try to keep the notes together.
			else if (item.IsNotePart)
			{
				if (parent.Cautions == null && item.MyPrevious == null) level-=(1 + firstInc);
				else level++;
			}
			// Try not to paginate on a table.
			else if (item.IsTablePart)
			{
				level += 2;
			}
			// For an RNO to the right, make it the same level as the AER item.
			else if(item.IsRNOPart)
			{
				level = (item.ActiveParent as ItemInfo).StepLevel + item.RNOLevel - item.ColumnMode;
			}
			return level;
		}
		
		/// <summary>
		/// Count all levels, including substeps within RNOs.  Ignore RNOs that are to the right of
		/// the AER, but count those that are below higher level RNOs.
		/// </summary>
		/// <param name="item"></param>
		/// <returns></returns>
		private static int CountLevels(ItemInfo item)
		{
			int level = 0;
			if (item.IsProcedure) return 0;
			int ignoreRNOs = item.ActiveSection.ColumnMode;
			while (item != null && !item.IsHigh)
			{
				if (ignoreRNOs > 0 && item.IsRNOPart)
					ignoreRNOs--;
				else
					level++;
				item = item.ActiveParent as ItemInfo;
			}
			return level;
		}
		#endregion
		public bool HasHeader
		{
			get
			{
				if (MyHeader==null)return false;
				if (MyHeader.CleanText==null) return false;
				if (MyHeader.CleanText=="") return false;
				return true;
			}
		}
		protected void ExtensionRefreshFields(Item tmp)
		{
			_ActiveParent = null;
		}
		#region LoadAtOnce2
		public static ItemInfo GetItemAndChildren2(int? itemID)
		{
			try
			{
				ItemInfo tmp = DataPortal.Fetch<ItemInfo>(new ItemAndChildrenCriteria2(itemID));
				AddToCache(tmp);
				if (tmp.ErrorMessage == "No Record Found") tmp = null;
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on ItemInfoList.GetItemAndChildren2", ex);
			}
		}
		// Criteria to get Item and children
		[Serializable()]
		private class ItemAndChildrenCriteria2
		{
			public ItemAndChildrenCriteria2(int? itemID)
			{
				_ItemID = itemID;
			}
			private int? _ItemID;
			public int? ItemID
			{
				get { return _ItemID; }
				set { _ItemID = value; }
			}
		}
		// Data Portal to Get Item and Children
		private void DataPortal_Fetch(ItemAndChildrenCriteria2 criteria)
		{
			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					ApplicationContext.LocalContext["cn"] = cn;
					using (SqlCommand cm = cn.CreateCommand())
					{
						cm.CommandType = CommandType.StoredProcedure;
						cm.CommandText = "getItem";
						cm.Parameters.AddWithValue("@ItemID", criteria.ItemID);
						using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
						{
							if (!dr.Read())
							{
								_ErrorMessage = "No Record Found";
								return;
							}
							ReadData(dr);
						}
					}
					SpinThroughChildren();
					// removing of item only needed for local data portal
					if (ApplicationContext.ExecutionLocation == ApplicationContext.ExecutionLocations.Client)
						ApplicationContext.LocalContext.Remove("cn");
				}
			}
			catch (Exception ex)
			{
				Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
				throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
			}
			RemoveFromCache(this);
		}
		private void SpinThroughChildren()
		{
			if(MyContent.ContentPartCount > 0)
				foreach(PartInfo partInfo in MyContent.ContentParts)
					foreach (ItemInfo itemInfo in partInfo.MyItems)
						itemInfo.SpinThroughChildren();
		}
		#endregion
		#region LoadAtOnce
		// Method to Get Item and children
		public static ItemInfo GetItemAndChildren(int? itemID,int? parentID)
		{
			try
			{
				ItemInfo tmp = DataPortal.Fetch<ItemInfo>(new ItemAndChildrenCriteria(itemID,parentID));
				AddToCache(tmp);
				if (tmp.ErrorMessage == "No Record Found") tmp = null;
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on ItemInfoList.GetChildren", ex);
			}
		}
		// Criteria to get Item and children
		[Serializable()]
		private class ItemAndChildrenCriteria
		{
			public ItemAndChildrenCriteria(int? itemID, int? parentID)
			{
				_ItemID = itemID;
				_ParentID = parentID;
			}
			private int? _ItemID;
			public int? ItemID
			{
				get { return _ItemID; }
				set { _ItemID = value; }
			}
			private int? _ParentID;
			public int? ParentID
			{
				get { return _ParentID; }
				set { _ParentID = value; }
			}
		}
		// Data Portal to Get Item and Children
		private void DataPortal_Fetch(ItemAndChildrenCriteria criteria)
		{
			//ItemInfo tmp = null;
			Dictionary<int, ItemInfo> lookup = new Dictionary<int, ItemInfo>(); ;
			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cm = cn.CreateCommand())
					{
						cm.CommandType = CommandType.StoredProcedure;
						cm.CommandText = "vesp_ListItemAndChildren";
						cm.Parameters.AddWithValue("@ItemID", criteria.ItemID);
						cm.Parameters.AddWithValue("@ParentID", criteria.ParentID);
						using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
						{
							while (dr.Read())
							{
								if (dr.GetInt32("Level")==0)
								{
									//tmp = itemInfo;
									ReadData(dr);
									AddContent(dr);
									lookup[this.ItemID] = this;
								}
								else
								{
									ItemInfo itemInfo = null;
									int itemType = dr.GetInt32("Type") / 10000;
									switch (itemType)
									{
										case 0:
											itemInfo = new ProcedureInfo(dr);
											break;
										case 1:
											itemInfo = new SectionInfo(dr);
											break;
										case 2:
											itemInfo = new StepInfo(dr);
											break;
									}
									// Load Children
									itemInfo.AddContent(dr);
									ItemInfo parent = lookup[dr.GetInt32("ParentID")];
									itemInfo._ActiveParent = parent;
									itemInfo._ActiveSection = (itemInfo.IsSection ? itemInfo : parent._ActiveSection);
									parent.AddPart(dr, itemInfo);
									lookup.Add(itemInfo.ItemID, itemInfo);
								}
							}
							//Console.WriteLine("I'm here {0}",this.MyContent.ContentPartCount);
						}
					}
				}
			}
			catch (Exception ex)
			{
				Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
				throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
			}
		}
		private void AddPart(SafeDataReader dr, ItemInfo itemInfo)
		{
			// Either a new PartInfo or an existing PartInfo
			if (dr.IsDBNull(dr.GetOrdinal("PreviousID")))
			{
				//PartInfo prt = new PartInfo(dr, itemInfo);
				_MyContent.AddPart(dr, itemInfo);
			}
			else
			{
				foreach (PartInfo pi in MyContent.ContentParts)
				{
					if (dr.GetInt32("FromType") == (int)pi.PartType)
					{
						if (pi._MyItems == null)
							pi._MyItems = new ItemInfoList(itemInfo);
						else
							pi.MyItems.AddItem(itemInfo);
					}
				}
			}
		}
		#endregion
		#region IsType
		public bool IsFirstCautionPart
		{
			get
			{
				return ((ItemPartCount > 0) && (ItemParts[0].PartType == E_FromType.Caution));
			}
		}
		public bool IsFirstNotePart
		{
			get
			{
				return ((ItemPartCount > 0) && (ItemParts[0].PartType == E_FromType.Note));
			}
		}

		public bool IsCautionPart
		{
			get
			{
				return ((FirstSibling.ItemPartCount > 0) && (FirstSibling.ItemParts[0].PartType == E_FromType.Caution));
			}
		}
		public bool IsNotePart
		{
			get
			{
				return ((FirstSibling.ItemPartCount > 0) && (FirstSibling.ItemParts[0].PartType == E_FromType.Note));
			}
		}

		public bool IsType(string type)
		{
			if ((int)MyContent.Type < 20000) return false;
			int stepType = ((int)MyContent.Type) % 10000;
			StepDataList sdlist = ActiveFormat.PlantFormat.FormatData.StepDataList;
			if (stepType > sdlist.Count)
			{
				Console.WriteLine("Error getting type - contentid = {0}", MyContent.ContentID);
				return false;
			}
			StepData sd = sdlist[stepType];
			while (sd.Index != 0)
			{
				if (sd.Type == type) return true;
				sd = sdlist[sd.ParentType];
			}
			return false;
		}
		public bool IsExactType(string type)
		{
			if ((int)MyContent.Type < 20000) return false;
			int stepType = ((int)MyContent.Type) % 10000;
			StepDataList sdlist = ActiveFormat.PlantFormat.FormatData.StepDataList;
			if (stepType > sdlist.Count)
			{
				Console.WriteLine("Error getting type - contentid = {0}", MyContent.ContentID);
				return false;
			}
			StepData sd = sdlist[stepType];
			return (sd.Type == type);
		}
		public bool IsCaution
		{
			get
			{
				return IsType("Caution");
			}
		}
		public bool IsNote
		{
			get
			{
				return IsType("Note");
			}
		}
		public bool IsTable
		{
			get
			{
				return IsType("Table");
			}
		}
		public bool IsFigure
		{
			get
			{
				return IsType("Figure");
			}
		}
		public bool IsOr
		{
			get
			{
				return IsType("Or");
			}
		}
		public bool IsAnd
		{
			get
			{
				return IsType("And");
			}
		}
		public bool IsEquipmentList
		{
			get
			{
				return IsType("EquipmentList");
			}
		}
		public bool IsTitle
		{
			get
			{
				return IsType("Title");
			}
		}
		public bool IsAccPages
		{
			get
			{
				return IsType("AccPages");
			}
		}
		public bool IsParagraph
		{
			get
			{
				return IsType("Paragraph");
			}
		}
		public bool IsDefault
		{
			get
			{
				return IsType("Default");
			}
		}
		public bool IsContAcSequential
		{
			get
			{
				return IsType("ContAcSequential");
			}
		}
		public bool IsHigh
		{
			get
			{
				// check to see if ActiveParent is a section, if so it is a high level step
				if (MyContent.Type / 10000 != 2) return false;
				ItemInfo parent = ActiveParent as ItemInfo;
				if (parent == null) return false;
				if ((parent.MyContent.Type / 10000) == 1)
					return true;
				return false;
			}
		}
		public bool IsSequential
		{
			get
			{
				if ((MyContent.Type / 10000) != 2) return false;
				string tabstr = FormatStepData.TabData.IdentPrint;
				if (tabstr.Contains("{seq}")) return true;
				return false;
			}
		}
		public bool IsTablePart
		{
			get
			{
				return ((ItemPartCount > 0) && (ItemParts[0].PartType == E_FromType.Table));
			}
		}
		public bool IsRNOPart
		{
			get
			{
				return ((ItemPartCount > 0) && (ItemParts[0].PartType == E_FromType.RNO));
			}
		}
		public bool IsInRNO
		{
			get 
			{
				if (IsHigh) return false;
				if (IsRNOPart) return true;
				ItemInfo parent = ActiveParent as ItemInfo;
				if (parent == null) return false;
				return parent.IsInRNO;
			}
		}
		#endregion
		#region Level Columns Relationships
		public int RNOLevel
		{
			get
			{
				return ((IsProcedure || IsSection || IsHigh)?0:(IsRNOPart?1:0)+((ItemInfo)ActiveParent).RNOLevel);
			}
		}
		public int ColumnMode
		{
			get
			{
				// check config value on my section, if null/default use Pmode of active format
				if (ActiveSection != null)
				{
					SectionInfo si = SectionInfo.Get(ActiveSection.ItemID); //ActiveSection as SectionInfo;
					if (si != null)
					{
						// there is no longer a "default" ENUM item - SectionConfig will return format default if needed
						//if (si.SectionConfig.Section_ColumnMode != SectionConfig.SectionColumnMode.Default)
						return (int)si.SectionConfig.Section_ColumnMode - 1;
					}
				}
				return (ActiveFormat.MyStepSectionLayoutData.PMode ?? 2) -1; 
			}
		}
		/// <summary>
		/// FormatStepType - Maps to step type in format file.  All types map directly from step type in content
		/// to step type in format
		/// </summary>
		public int FormatStepType
		{
			get
			{
				return (((int)MyContent.Type) % 10000);
			}
		}
		/// <summary>
		/// returns the format's stepdata for the given content type.
		/// </summary>
		public StepData FormatStepData
		{
			get
			{
				int typ = (int)MyContent.Type - 20000;
				foreach (StepData sd in ActiveFormat.PlantFormat.FormatData.StepDataList)
				{
					if (sd.Index == typ) return sd;
				}
				return null;
			}
		}
		public ItemInfo FirstSibling
		{
			get
			{
				ItemInfo temp = this;
				while (temp.MyPrevious != null) temp = temp.MyPrevious;
				return temp;
			}
		}
		public ItemInfo LastSibling
		{
			get
			{
				ItemInfo temp = this;
				while (temp.NextItems != null && temp.NextItems.Count > 0) temp = temp.NextItems[0];
				return temp;
			}
		}
		public ItemInfo LastChild(E_FromType partType)
		{
			ItemInfoList myitems = Lookup((int)partType);
			if (myitems !=null) return myitems[myitems.Count-1];
			return null;
		}
		public ItemInfo FirstChild(E_FromType partType)
		{
			ItemInfoList myitems = Lookup((int)partType);
			if (myitems != null) return myitems[0];
			return null;
		}
		public bool HasAncestor(ItemInfo ancestor)
		{
			if (ancestor == null) return false;
			ItemInfo parent = ActiveParent as ItemInfo;
			if (parent == null) return false;
			if (ancestor.ItemID == parent.ItemID) return true;
			return parent.HasAncestor(ancestor);
		}
		#endregion
		#region More IsType
		public bool IsProcedurePart
		{
			get
			{
				return ((FirstSibling.ItemPartCount > 0) && (FirstSibling.ItemParts[0].PartType == E_FromType.Procedure));
			}
		}
		public bool IsSectionPart
		{
			get
			{
				return ((FirstSibling.ItemPartCount > 0) && (FirstSibling.ItemParts[0].PartType == E_FromType.Section));
			}
		}
		public bool IsStepPart
		{
			get
			{
				return ((FirstSibling.ItemPartCount > 0) && (FirstSibling.ItemParts[0].PartType == E_FromType.Step));
			}
		}
		public bool IsInSubStep
		{
			get
			{
				if (IsHigh) return false;
				if (IsStepPart) return true;
				ItemInfo parent = ActiveParent as ItemInfo;
				if (parent == null) return false;
				return parent.IsInSubStep;
			}
		}
		public bool IsInFirstLevelSubStep
		{
			get
			{
				ItemInfo temp = FirstSibling;
				if(temp.ActiveParent.GetType() == typeof(VEPROMS.CSLA.Library.DocVersionInfo))return false;
				if (temp.MyParent.IsSection) return false;   // already at hls
				if (temp.IsProcedure || temp.IsSection) return false; 
				while (((ItemInfo)temp.ActiveParent).IsHigh == false)
					temp = ((ItemInfo)temp.ActiveParent).FirstSibling;
				return temp.IsStepPart;
			}
		}
		public bool IsStepSection
		{
			get
			{
				if (IsSection && MyDocStyle.IsStepSection) return true;
				return false;
			}
		}
		public bool IsSection
		{
			get
			{
				if ((MyContent.Type / 10000) == 1) return true;
				return false;
			}
		}
		public bool IsDefaultSection
		{
			get
			{
				// check to see if ActiveParent is a section, if so it is a high level step
				if (MyContent.Type / 10000 != 1) return false;
				// get procedure section and then
				ItemInfo parent = (ItemInfo)ActiveParent;
				if (!parent.IsProcedure) return false;
				ProcedureConfig pc = (ProcedureConfig)parent.MyConfig;
				int sectstartid = -1;
				string ss = pc == null ? null : pc.SectionStart;
				if (ss != null) sectstartid = System.Convert.ToInt32(ss);
				else return false;
				if (ItemID == sectstartid) return true;
				return false;
			}
		}
		public bool IsProcedure
		{
			get
			{
				if ((MyContent.Type / 10000) == 0) return true;
				return false;
			}
		}
		public bool IsStep
		{
			get
			{
				if ((MyContent.Type / 10000) == 2) return true;
				return false;
			}
		}
		private E_FromType ItemType
		{
			get
			{
				if (MyContent.Type == 0) return E_FromType.Procedure;
				if (MyContent.Type < 20000) return E_FromType.Section;
				return E_FromType.Step;
			}
		}
		public Item GetByType()
		{
			Item tmp = null;
			switch (ItemType)
			{
				case E_FromType.Procedure:
					tmp = Procedure.Get(_ItemID);
					break;
				//case E_FromType.Section:
				//  itemInfo = new Section(dr);
				//  break;
				//default:
				//  itemInfo = new Step(dr);
				//  break;
			}
			return tmp;
		}
		#endregion
		#region Ordinal CslaType and Tostring
		[NonSerialized]
		private int? _Ordinal;
		public int Ordinal
		{
			get
			{
				if (_Ordinal == null)
				{
					if (MyPrevious != null)
						_Ordinal = MyPrevious.Ordinal + 1;
					else
						_Ordinal = 1;
				}
				return (int) _Ordinal;
			}
		}
		public string CslaType
		{ get { return this.GetType().FullName; } }
		public override string ToString()
		{
			//Item editable = Item.GetExistingByPrimaryKey(_ItemID);
			//return string.Format("{0}{1} {2}", (editable == null ? "" : (editable.IsDirty ? "* " : "")), 
			//  (MyContent.Type >= 20000 ? Ordinal.ToString() + "." : MyContent.Number), MyContent.Text);
			ContentInfo cont = MyContent;
			//string number = cont.Number;
			string number = DisplayNumber;
			//if (cont.Type >= 20000) number = Ordinal.ToString() + ".";
			if (cont.Type >= 20000) number = MyTab.CleanText;
			return string.Format("{0} {1}", number, DisplayText).Trim();
			//return string.Format("{0} {1}", number, cont.Text).Trim();
			//return string.Format("{0} {1}", cont.Number, cont.Text);
			//return "Now is the time for all good men to come to the aid of their country!";
		}
		//public string ToString(string str,System.IFormatProvider ifp)
		//{
		//  return ToString();
		//}
		#endregion
		#region Search
		internal string _SearchDVPath;
		public string SearchDVPath
		{
			get 
			{
				if (_SearchDVPath == null)
					_SearchDVPath = ActiveParent.SearchDVPath;
				return _SearchDVPath; 
			}
		}
		internal string _SearchPath;
		public string SearchPath
		{
			get 
			{
				if (_SearchPath==null)
				{
					if (IsProcedure)
						_SearchPath = ActiveParent.SearchPath + "\u0007" + (DisplayNumber ?? "") + "\u0011" + DisplayText ;
					else if (IsSection)
						_SearchPath = ActiveParent.SearchPath + "\u0007" + (DisplayNumber ?? "") + "\u0011" + DisplayText;
					else
					{
						PartInfo myPart = FirstSibling.ItemPartCount > 0 ? FirstSibling.ItemParts[0] : null;
						if(myPart != null)
							_SearchPath = myPart.SearchPath + (!IsHigh ? "." : "\u0007") + Ordinal.ToString();
						else
							_SearchPath = ActiveParent.SearchPath + (!IsHigh ? "." : "\u0007") + Ordinal.ToString();
					}
				}
				return _SearchPath; 
			}
		}
    public string ShortSearchPath
    {
        get { return ConvertToDisplayText(Regex.Replace(_SearchPath ?? "", "\x11.*?\x07", "\x07")); }
    }
		internal int _SearchAnnotationID;
		public int SearchAnnotationID
		{
			get { return _SearchAnnotationID; }
		}
		internal string _SearchAnnotationText;
		public string SearchAnnotationText
		{
			get { return _SearchAnnotationText; }
			set { _SearchAnnotationText = value; }
		}
		internal string _SearchAnnotationType;
		public string SearchAnnotationType
		{
			get { return _SearchAnnotationType; }
		}
		#endregion
		#region ProcedureConfig
		[NonSerialized]
		private ProcedureConfig _ProcedureConfig = null;
		public PrintChangeBar PrintChangeBar
		{
			get
			{
				if (_ProcedureConfig == null) SetProcedureConfig();
				return _ProcedureConfig.Print_ChangeBar;
			}
		}
		public PrintChangeBarLoc PrintChangeBarLoc
		{
			get
			{
				if (_ProcedureConfig == null) SetProcedureConfig();
				return _ProcedureConfig.Print_ChangeBarLoc;
			}
		}
		public PrintChangeBarText PrintChangeBarText
		{
			get
			{
				if (_ProcedureConfig == null) SetProcedureConfig();
				return _ProcedureConfig.Print_ChangeBarText;
			}
		}
		public string PrintChangeBarUsrMsg1
		{
			get
			{
				if (_ProcedureConfig == null) SetProcedureConfig();
				return _ProcedureConfig.Print_UserCBMess1;
			}
		}
		public string PrintChangeBarUsrMsg2
		{
			get
			{
				if (_ProcedureConfig == null) SetProcedureConfig();
				return _ProcedureConfig.Print_UserCBMess2;
			}
		}
		private void SetProcedureConfig()
		{
			// Walk up tree until find my procedure.  Then get its change bar (default will
			// get inherited information if not set at this level).
			// Find the procedure level and its config.
			ItemInfo tmpitm = this;
			while (tmpitm.MyContent.Type != 0)
				tmpitm = tmpitm.MyParent;

			ProcedureInfo pi = ProcedureInfo.Get(tmpitm.ItemID);
			if (pi == null) return;
			_ProcedureConfig = pi.MyConfig as ProcedureConfig;
		}
		#endregion
		#region Formatting of Text
		public string DisplayText
		{
			get { return ConvertToDisplayText(MyContent.Text); }
		}
		public string DisplayNumber
		{
			get 
			{ 
			    string str = (this.IsProcedure)?MyDocVersion.UnitSpecific(MyContent.Number,0):MyContent.Number;
			    return ConvertToDisplayText(str); 
			}
			//get { return ConvertToDisplayText(MyContent.Number); }
		}
		public static string ConvertToDisplayText(string txt)
		{
			string retval = txt;
			retval = StripRtfFormatting(retval);
			retval = StripLinks(retval);
			retval = ReplaceSpecialCharacters(retval);
			retval = retval.Replace("\u2011","-");
			retval = retval.Replace("\r\n", ";");
			retval = retval.Replace("\n", ";");	//added for consistency checking with approved version
			return retval;
		}
		public static string StripRtfFormatting(string rtf)
		{
			string retval = rtf;
			retval = Regex.Replace(retval, @"\\b0 ?", "");
			retval = Regex.Replace(retval, @"\\b ?", "");
			retval = Regex.Replace(retval, @"\\ulnone ?", "");
			retval = Regex.Replace(retval, @"\\ul0 ?", "");
			retval = Regex.Replace(retval, @"\\ul ?", "");
			retval = Regex.Replace(retval, @"\\i0 ?", "");
			retval = Regex.Replace(retval, @"\\i ?", "");
			//retval = Regex.Replace(retval, @"\\super ?", "");
			//retval = Regex.Replace(retval, @"\\sub ?", "");
			//retval = Regex.Replace(retval, @"\\nosupersub ?", "");
			retval = Regex.Replace(retval, @"\\up[320] ?", "");
			retval = Regex.Replace(retval, @"\\dn[320] ?", "");
			return retval;
		}
		public static string StripLinks(string rtf)
		{
			string retval = rtf;
			retval = Regex.Replace(retval, @"\\v.*?\\v0", "");
			retval = retval.Replace("\u252C", "");// Unicode 9516 Transition
			retval = retval.Replace("\u2566", "");// Unicode 9574 Transition
			retval = retval.Replace("\u0015", "");// Unicode 21 RO
			return retval;
		}
		private static string ReplaceSpecialCharacter(Match m)
		{
			StringBuilder sb = new StringBuilder();
			int i = int.Parse(m.ToString().Substring(2,m.ToString().Length-3));
			sb.Append((char)i);
			return sb.ToString();
		}
		private static string ReplaceSpecialHexCharacter(Match m)
		{
			StringBuilder sb = new StringBuilder();
			int i = int.Parse(m.ToString().Substring(2), System.Globalization.NumberStyles.HexNumber);
			sb.Append((char)i);
			return sb.ToString();
		}
		private static string ReplaceSpecialCharacters(string rtf)
		{
			string retval = rtf;
			retval = retval.Replace("`", "\u00B0");// Degree
			retval = Regex.Replace(retval, @"\\u[0-9]+[?]", new MatchEvaluator(ReplaceSpecialCharacter));
			retval = Regex.Replace(retval, @"\\'[0-9A-Fa-f][0-9A-Fa-f]", new MatchEvaluator(ReplaceSpecialHexCharacter));
			return retval;
		}

		public VE_Font GetItemFont()
		{
			return GetItemFont(ActiveFormat);
		}

		public VE_Font GetItemFont(FormatInfo fmt)
		{
			VE_Font font = null;
			try
			{
				FormatInfo format = (LocalFormat != null || fmt == null) ? LocalFormat : fmt;//_MyItemInfo.ActiveFormat;
				int type = (int)MyContent.Type;//_MyItemInfo.MyContent.Type;
				switch (type / 10000)
				{
					case 0:	// procedure
						font = format.PlantFormat.FormatData.Font;
						break;
					case 1: // section
						font = format.PlantFormat.FormatData.SectData.SectionHeader.Font;
						break;
					case 2: // step types
						int typindx = type - 20000;  // what to do for other types rather than steps
						font = format.PlantFormat.FormatData.StepDataList[typindx].Font;
						if (typindx == _ParagraphType) font = AdjustForTextSubFollowsTextStyle(format,typindx,font);
						break;
				}
			}
			catch (Exception ex)
			{
				Console.WriteLine("GetItemFont(): {0} - {1}", ex.GetType(), ex.Message);
			}
			return font;
		}
		private const int _ParagraphType=24;
		protected VE_Font AdjustForTextSubFollowsTextStyle(VE_Font font)
		{
			return AdjustForTextSubFollowsTextStyle(ActiveFormat, this.FormatStepType, font);
		}
		private VE_Font AdjustForTextSubFollowsTextStyle(FormatInfo format, int typindx, VE_Font font)
		{
			StepData myFormatStepData = format.PlantFormat.FormatData.StepDataList[typindx];
			if (myFormatStepData.TextSubFollowsTextStyle && ParentNoteOrCaution != null)
			{
				bool isBold = (myFormatStepData.Font.Style & E_Style.Bold) > 0;
				bool isMmBold = (myFormatStepData.Font.Style & E_Style.MmBold) > 0;
				myFormatStepData = format.PlantFormat.FormatData.StepDataList[ParentNoteOrCaution.FormatStepType];
				font = myFormatStepData.Font;
				E_Style myStyle = (E_Style) font.Style;
				myStyle ^= (myStyle & E_Style.Bold);
				myStyle ^= (myStyle & E_Style.MmBold);
				myStyle |= isBold ? E_Style.Bold : 0;
				myStyle |= isMmBold ? E_Style.MmBold : 0;
				if (myStyle != font.Style)
					font = new VE_Font(font.Family, (int)font.Size, myStyle, (float)font.CPI);
			}
			return font;
		}
		private string RemoveToken(string str, string token)
		{
			// if this token is preceeded by another token and followed by a space 
			// leave the preceeding token the ending space
			string retval = Regex.Replace(str, @"(\\[^ \\?\r\n\t]*)" + token + " ", "$1 ");
			//if (retval != str)  // Show the token replacement
			//	Console.WriteLine("Leave the preceeding token the ending space '{0}'\r\n{1}\r\n{2}",token,str,retval);
			// otherwise replace the token optionally followed by a space
			retval = Regex.Replace(retval, token + " ?", "");
			return retval;
		}
		public string RemoveRtfStyles(string rtf)
		{
			return RemoveRtfStyles(rtf, ActiveFormat);
		}
		public string RemoveRtfStyles(string rtf, FormatInfo fmt)
		{
			string retval = rtf;
			VE_Font TextFont = GetItemFont(fmt);
			if (TextFont != null)
			{
				// remove rtf commands for any styles that were added.  Note that if
				// the entire item has a style, and also contains 'pieces' of text with
				// the same style, the underlying rtf box removes the embedded rtf commands,
				// for example, if the entire step is bolded, and 'THEN' has bold on/off
				// surrounding it, the rtf box removes the bold around the 'THEN'
				// These remove the command with a following space or the command alone,
				// either case may exist, because if there are rtf commands following the
				// style command, there will be no space character following the style command.
				if (((TextFont.Style & E_Style.Bold) > 0) || ((TextFont.Style & E_Style.MmBold) > 0))
				{
					retval = RemoveToken(retval, @"\\b0");
					retval = RemoveToken(retval, @"\\b");
				}
				if ((TextFont.Style & E_Style.Underline) > 0)
				{
					retval = RemoveToken(retval, @"\\ulnone");
					retval = RemoveToken(retval, @"\\ul");
				}
				if ((TextFont.Style & E_Style.Italics) > 0)
				{
					retval = RemoveToken(retval, @"\\i0");
					retval = RemoveToken(retval, @"\\i");
				}
			}
			return retval;
		}
		#endregion
		#region Path and Parent
		public string Path
		{
			get
			{
				string number = (MyContent.Type >= 20000 ? Ordinal.ToString() + "." : ((DisplayNumber ?? "")==""? DisplayText: DisplayNumber));
				ItemInfo parent = this;
				while (parent.MyPrevious != null) parent = parent.MyPrevious;
				if (parent.ItemPartCount == 0)
					return number + ", " + DisplayText;
				else
				{
					PartInfo partInfo = parent.ItemParts[0];
					return partInfo.MyContent.ContentItems.Items[0].Path + " " + ((E_FromType)partInfo.FromType).ToString() + " " + number;
				}
			}
		}
		public string ShortPath
		{
			get
			{
				string number = (MyContent.Type >= 20000 ? Ordinal.ToString() + "." : ((DisplayNumber ?? "") == "" ? DisplayText : DisplayNumber));
				ItemInfo parent = this;
				while (parent.MyPrevious != null) parent = parent.MyPrevious;
				if (parent.ItemPartCount == 0)
					return number;
				else
				{
					PartInfo partInfo = parent.ItemParts[0];
					return partInfo.MyContent.ContentItems.Items[0].ShortPath + "." + ((E_FromType)partInfo.FromType).ToString().Substring(0,1) +  number;
				}
			}
		}
		public ContentInfo ParentContent
		{
			get
			{
				string number = (MyContent.Type >= 20000 ? Ordinal.ToString() + "." : ((MyContent.Number ?? "") == "" ? MyContent.Text : MyContent.Number));
				ItemInfo parent = this;
				while (parent.MyPrevious != null) parent = parent.MyPrevious;
				if (parent.ItemPartCount <= 0 || parent.ItemParts.Count == 0)
					return null;
				else
				{
					return parent.ItemParts[0].MyContent;
				}
			}
		}
		public ItemInfo MyParent
		{
			get
			{
				//if (ItemDocVersionCount > 0) return ItemDocVersions[0]; Need to create one interface to support Folders, DocVersions and Items				
				ContentInfo parentContent = ParentContent;
				if (parentContent == null || parentContent.ContentItemCount == 0) return null;
				return parentContent.ContentItems[0];
			}
		}
		#endregion
		#region Lookups and More Related
		private ItemInfoList Lookup(int fromType, ref ItemInfoList itemInfoList)
		{
			if (itemInfoList == null)
				itemInfoList = Lookup(fromType);
			return itemInfoList;
		}
		internal ItemInfoList Lookup(int fromType)
		{
			ItemInfoList itemInfoList = null;
			if (MyContent.ContentPartCount != 0)
				foreach (PartInfo partInfo in MyContent.ContentParts)
					if (partInfo.FromType == fromType)
					{
						itemInfoList = partInfo._MyItems = ItemInfoList.GetList(partInfo.ItemID, partInfo.FromType);
						return itemInfoList;
					}
			return null;
		}
		public static void ResetParts(int itemID)
		{
			string key = itemID.ToString();
			if (_CacheByPrimaryKey.ContainsKey(key))
			{
				bool firstContent = true;
				foreach (ItemInfo itm in _CacheByPrimaryKey[key])
				{
					itm.ResetParts();
					if (itm._MyContent != null && firstContent)
					{
						firstContent = false;// Only need to do this once.  
						//RefreshContentParts looks through ContentInfo objects
						itm._MyContent.RefreshContentParts();
					}
				}
			}
		}
		public void ResetParts()
		{
			_Procedures = null;
			_Sections = null;
			_Cautions = null;
			_Notes = null;
			_RNOs = null;
			_Steps = null;
			_Tables = null;
		}
		private ItemInfoList _Procedures;
		public ItemInfoList Procedures
		{ get { return Lookup(1,ref _Procedures); } }
		private ItemInfoList _Sections;
		public ItemInfoList Sections
		{ get { return Lookup(2,ref _Sections); } }
		private ItemInfoList _Cautions;
		public ItemInfoList Cautions
		{ get { return Lookup(3,ref _Cautions); } }
		private ItemInfoList _Notes;
		public ItemInfoList Notes
		{ get { return Lookup(4,ref _Notes); } }
		private ItemInfoList _RNOs;
		public ItemInfoList RNOs
		{ get { return Lookup(5,ref _RNOs); } }
		private ItemInfoList _Steps;
		public ItemInfoList Steps
		{ get { return Lookup(6,ref _Steps); } }
		private ItemInfoList _Tables;
		public ItemInfoList Tables
		{ get { return Lookup(7,ref _Tables); } }
		//public void ResetChildren()
		//{
		//  _Procedures = null;
		//  _Sections = null;
		//  _Steps = null;
		//  _Cautions = null;
		//  _Notes = null;
		//  _RNOs = null;
		//  _Steps = null;
		//  _Tables = null;
		//}
		//public XmlDocument ToXml()
		//{
		//  XmlDocument retval = new XmlDocument();
		//  retval.LoadXml("<root/>");
		//  return ToXml(retval.DocumentElement);
		//}
		//public void AddList(XmlNode xn,string name, ItemInfoList itemInfoList)
		//{
		//  if (itemInfoList != null)
		//  {
		//    XmlNode nd = xn.OwnerDocument.CreateElement(name);
		//    xn.AppendChild(nd);
		//    itemInfoList.ToXml(xn);
		//  }
		//}
		//public XmlDocument ToXml(XmlNode xn)
		//{
		//  XmlNode nd  = MyContent.ToXml(xn);
		//  // Now add the children
		//  AddList(nd, "Procedures", Procedures);
		//  AddList(nd, "Sections", Sections);
		//  AddList(nd, "Cautions", Cautions);
		//  AddList(nd, "Notes", Notes);
		//  AddList(nd, "RNOs", RNOs);
		//  AddList(nd, "Steps", SubItems);
		//  AddList(nd, "Tables", Tables);
		//  return xn.OwnerDocument;
		//}
		#endregion
		#region UI Tab
		public string TabToolTip
		{
			get
			{
				if (MyContent.MyEntry == null)
					return DisplayNumber + " - " + DisplayText;
				string toolTip = MyProcedure.TabToolTip + "\r\n";
				if (MyContent.Number != "")
					toolTip += DisplayNumber + " - " + DisplayText;
				else
					toolTip += DisplayText;
				DocumentInfo myDocument = MyContent.MyEntry.MyDocument;
				if (myDocument.LibTitle != "")
				{
					toolTip += string.Format("\r\n(Library Document - {0})\r\n", myDocument.LibTitle);
					toolTip += myDocument.LibraryDocumentUsage;
				}
				return toolTip;
			}
		}
		public string TabTitle
		{
			get
			{
				if (MyContent.MyEntry == null)
					if(DisplayNumber == string.Empty)
						return DisplayText.Replace("\u2011", "-").Split(" ,.;:-_".ToCharArray())[0] + "...";
					return DisplayNumber.Replace("\u2011","-");
				if (MyContent.Number != "")
					return ((MyContent.MyEntry.MyDocument.LibTitle ?? "") == "" ? "" : "\u1D38\u1D35\u1D2E ") + DisplayNumber;
				if (MyContent.MyEntry.MyDocument.LibTitle != "")
				{
					if (DisplayText.Length <= 7) return "\u1D38\u1D35\u1D2E " + DisplayText.Replace("\u2011", "-");
					return "\u1D38\u1D35\u1D2E " + DisplayText.Replace("\u2011", "-").Split(" ,.;:-_".ToCharArray())[0] + "...";
				}
				if (DisplayText.Length <= 10)
					return DisplayText.Replace("\u2011", "-");
				return DisplayText.Replace("\u2011", "-").Split(" ,.;:-_".ToCharArray())[0]+ "...";
			}
		}
		#endregion
		#region Change Bar
		public bool HasChangeBar
		{
			get
			{
				if (this.IsAccPages || this.IsProcedure || this.IsSection) return false;
				StepInfo si = this as StepInfo;
				if (si == null) return false;
				StepConfig sc = si.MyConfig as StepConfig;
				if (sc == null) return false;
				// if there is no override & return whether there was a change to the text.
				if (sc.Step_CBOverride == null)
					return (MyContent.DTS > MyProcedure.DTS);
				else   // override is on:
					return (sc.Step_CBOverride == "On");
			}
		}
		#endregion
		#region IVEReadOnlyItem
		PartInfoList _PartInfoList;
		public System.Collections.IList GetChildren()
		{
			_PartInfoList = this.MyContent.ContentParts;
			if (_PartInfoList.Count == 1 && ((IsProcedure && _PartInfoList[0].ToString() == "Sections") || _PartInfoList[0].ToString() == "Steps"))
				return _PartInfoList[0].GetChildren();
			return _PartInfoList;
		}
		public System.Collections.IList GetChildren(bool allParts)
		{
			_PartInfoList = this.MyContent.ContentParts;
			if (allParts)
			{
				if (_PartInfoList.Count == 1 && ((IsProcedure && _PartInfoList[0].ToString() == "Sections") || _PartInfoList[0].ToString() == "Steps"))

					return _PartInfoList[0].GetChildren();
				return _PartInfoList;
			}
			else // Steps and Sections only
			{
				for(int i = 0;i<_PartInfoList.Count;i++)
					if(_PartInfoList[i].ToString() == "Sections" || _PartInfoList[i].ToString() == "Steps")
						return _PartInfoList[i].GetChildren();
				return null;
			}
		}
		//public bool ChildrenAreLoaded
		//{
		//  get { return _PartInfoList == null; }
		//}
		public bool HasChildren
		{
			get { return this.MyContent.ContentPartCount > 0; }
		}
		public bool HasWordContent
		{
			get { return this.MyContent.MyEntry != null; }
		}
		public bool HasStepContent
		{
			get
			{
				if (MyContent.ContentPartCount == 0) return false;
				if (MyContent.ContentPartCount == 1 && MyContent.ContentParts[0].PartType == E_FromType.Section) return false;
				return true;
			}
		}
		public ProcedureInfo MyProcedure
		{
			get
			{
				// Walk up active parents until the parent is not an item
				ItemInfo tmp = this;
				while (tmp.ActiveParent != null && tmp.ActiveParent.GetType() != typeof(DocVersionInfo)) 
					tmp = (ItemInfo)tmp.ActiveParent;
				if (tmp is ProcedureInfo)
					return tmp as ProcedureInfo;
				return ProcedureInfo.Get(tmp.ItemID);
			}
		}
		private ItemInfo _MyHLS = null;
		public ItemInfo MyHLS
		{
			get 
			{
				if (_MyHLS == null)
				{
					if (IsHigh) _MyHLS = this;
					else
					{
						if(MyActiveParent is ItemInfo)
							_MyHLS = ((ItemInfo)MyActiveParent).MyHLS;
					}
				}
				return _MyHLS; 
			}
		}

		private DocVersionInfo _MyDocVersion = null;

		public DocVersionInfo MyDocVersion
		{
			get 
			{
				if (_MyDocVersion == null)
				{
					if (ActiveParent is DocVersionInfo)
						_MyDocVersion = ActiveParent as DocVersionInfo;
					else
						_MyDocVersion = (ActiveParent as ItemInfo).MyDocVersion;
				}
				return _MyDocVersion; 
			}
		}
		private IVEDrillDownReadOnly _ActiveParent = null;
		public IVEDrillDownReadOnly MyActiveParent { get { return _ActiveParent; } }
		public IVEDrillDownReadOnly ActiveParent
		{
			get
			{
				//if (_ActiveParent == this)_ActiveParent = null;
				if (_ActiveParent == null)
				{
					if (MyPrevious != null)
						_ActiveParent = _MyPrevious.ActiveParent;
					else
					{
						if (this.ItemDocVersions != null && this.ItemDocVersions.Count > 0)
							_ActiveParent = this.ItemDocVersions[0];
						else
						{
							//The following using command caused a cached iteminfo to be disposed.
							//using (ContentInfo parentContent = ParentContent)
							//{
							ContentInfo parentContent = ParentContent;
								if (parentContent == null)// || parentContent.ContentItemCount == 0)
									_ActiveParent = this;
								else
								{
									int itemID = 0;
									if (parentContent.ContentItems.Count == 0)
										parentContent.RefreshContentItems();
									using(ItemInfoList list = parentContent.ContentItems)
										itemID = list[0].ItemID;
									if (itemID == 0)
										_ActiveParent = this;
									else
										_ActiveParent = ItemInfo.Get(itemID);
								}
							//}
						}
					}
				}
				return _ActiveParent==this ? null : _ActiveParent;
			}
			internal set
			//set
			{
				_ActiveParent = value;
			}
		}
		private ItemInfo  _ActiveSection = null;
		/// <summary>
		/// MyActiveSection is used to determine if _ActiveSection is null or not.
		/// </summary>
		public ItemInfo MyActiveSection { get { return _ActiveSection; } }
		public ItemInfo ActiveSection
		{
			get
			{
				if (_ActiveSection == null)
				{
					if (IsSection)
						_ActiveSection = this;
					else
					{
						ItemInfo parent = ActiveParent as ItemInfo;
						if (parent != null)
							_ActiveSection = parent.ActiveSection;
						else
							_ActiveSection = this;
					}
				}
				return _ActiveSection.IsSection ? _ActiveSection : null;
			}
			set
			{
				_ActiveSection = value;
			}
		}
		//private int _PageNumForDocStyle = 0;
		//public int PageNumForDocStyle
		//{
		//    get { return _PageNumForDocStyle; }
		//    set { _PageNumForDocStyle = value; }
		//}
		private DocStyle _MyDocStyle;
		//private DocStyle _MyDocStyleOtherThanFirstPage;
		public DocStyle MyDocStyle
		{
			get
			{
				if (_MyDocStyle == null && ActiveSection != null)
				{
					int typ = (int)ActiveSection.MyContent.Type;
					int subtyp = typ % 10000;
					_MyDocStyle = ActiveFormat.PlantFormat.DocStyles.DocStyleList[subtyp];
				//    if (((MyDocStyle.StructureStyle.Where & E_DocStyleUse.UseOnFirstPage) != 0) && PageNumForDocStyle > 1)
				//    {
				//        if (_MyDocStyleOtherThanFirstPage == null)
				//        {
				//            foreach (DocStyle ds in ActiveFormat.PlantFormat.DocStyles.DocStyleList)
				//            {
				//                if ((ds.StructureStyle.Where & E_DocStyleUse.UseOnAllButFirstPage) != 0)
				//                {
				//                    _MyDocStyleOtherThanFirstPage = ds;
				//                    break;
				//                }
				//            }
				//        }
				//    }
				}
				//if (PageNumForDocStyle <= 1)
					return _MyDocStyle;
				//else
				//    return _MyDocStyleOtherThanFirstPage;
			}
		}
		private FormatInfo _ActiveFormat = null;
		public FormatInfo ActiveFormat
		{
			get
			{
				//if (_ActiveFormat == null) // jsj added check for NULL ActiveParent
					_ActiveFormat = (LocalFormat != null ? LocalFormat : (ActiveParent != null)? ActiveParent.ActiveFormat : null);
				//Console.WriteLine("Active {0}", (_ActiveFormat == null) ? "_ActiveFormat is null" : _ActiveFormat.Name);
				return _ActiveFormat;
			}
			//get { return LocalFormat != null ? LocalFormat : ActiveParent.ActiveFormat; }
		}
		public FormatInfo LocalFormat
		{
			get {
				//Console.WriteLine("Local {0}", (MyContent.MyFormat==null)?"MYformat is null": MyContent.MyFormat.Name);
				return MyContent.MyFormat; }
		}
		private bool _IsDeleted = false;
		public bool IsDeleted
		{
			get { return _IsDeleted; }
			set
			{
				_IsDeleted = value;
				if (value == true)
					UpdateCacheIsDeleted(ItemID);
			}
		}
		private static void UpdateCacheIsDeleted(int itemID)
		{
			ConvertListToDictionary();
			string key = itemID.ToString();
			if (key != null && _CacheByPrimaryKey.ContainsKey(key))
			{
				ItemInfo[] items = _CacheByPrimaryKey[key].ToArray();
				foreach (ItemInfo item in items)
					item._IsDeleted = true;
			}
		}
		private ConfigDynamicTypeDescriptor _MyConfig = null;
		public ConfigDynamicTypeDescriptor MyConfig
		{
			get 
			{
				if (_MyConfig == null)
				{
					switch (MyContent.Type / 10000)
					{
						case 0:
							_MyConfig = new ProcedureConfig(MyContent.Config);
							break;
						case 1:
							_MyConfig = new SectionConfig(MyContent.Config);
							if (ItemID == 317)
								Console.WriteLine("Myconfig: id = {0}, column mode = {1}", MyItemInfoUnique, (_MyConfig as SectionConfig).Section_ColumnMode);
							break;
						case 2:
							_MyConfig = new StepConfig(MyContent.Config);
							break;
					}
				}
				return _MyConfig; 
			}
			set
			{
				if (_MyConfig == null) return;
				_MyConfig = null;
				//MyContent.Config = value;
			}
		}
		public void RefreshConfig()
		{
			Console.WriteLine("refreshconfig: Itemid = {0}", ItemID);
			string key = ItemID.ToString();
			ConvertListToDictionary();
			if (_CacheByPrimaryKey.ContainsKey(key))
				foreach (ItemInfo tmpInfo in _CacheByPrimaryKey[key])
				{
					if (tmpInfo.ItemID == 317) Console.WriteLine("RefreshConfig: id = {0}", tmpInfo.MyItemInfoUnique);
					tmpInfo.MyConfig = null;
				}
		}
		static public void RefreshConfig(string key)
		{
			Console.WriteLine("Static refreshconfig: Itemid = {0}", key);
			ConvertListToDictionary();
			if (_CacheByPrimaryKey.ContainsKey(key))
				foreach (ItemInfo tmpInfo in _CacheByPrimaryKey[key])
				{
					if (tmpInfo.ItemID == 317) Console.WriteLine("Static RefreshConfig: id = {0}", tmpInfo.MyItemInfoUnique);
					tmpInfo.MyConfig = null;
				}
		}
		//public bool HasStandardSteps()
		//{ return MyContent.ContentItemCount > 1; }
		public Color ForeColor
		{ get { return (HasBrokenRules != null ? Color.Red : (MyContent.ContentItemCount > 1 ? Color.Blue : Color.Black)); } }
		public Color BackColor
		{ get { return (ItemAnnotationCount  > 0 ? Color.Yellow : Color.White); } }
		#endregion
		#region Constructor
		internal ItemInfo(SafeDataReader dr, bool forIRichtem)
		{
			if (_MyLog.IsDebugEnabled) _MyLog.DebugFormat("[{0}] ItemInfo.Constructor", GetHashCode());
			try
			{
				ReadData(dr);
				AddContent(dr);
			}
			catch (Exception ex)
			{
				if (_MyLog.IsErrorEnabled) _MyLog.Error("ItemInfo.Constructor", ex);
				throw new DbCslaException("ItemInfo.Constructor", ex);
			}
		}
		internal void AddContent(SafeDataReader dr)
		{
			_MyContent = new ContentInfo(dr, true);
		}
		#endregion
		#region MetaTags - Tabs, Headers, Footers
		[NonSerialized]
		protected Tab _MyTab;
		public Tab MyTab
		{
			get 
			{
				if (!_TagsSetup) SetupTags();
				return _MyTab;
			}
			set
			{
				_MyTab = value;
			}
		}
		[NonSerialized]
		protected MetaTag _MyHeader;
		public MetaTag MyHeader
		{
			get 
			{
				if (!_TagsSetup) SetupTags();
				return _MyHeader; 
			}
			set 
			{
				_MyHeader = value;
			}
		}
		[NonSerialized]
		protected MetaTag _MyFooter;
		public MetaTag MyFooter
		{
			get 
			{
				if (!_TagsSetup) SetupTags();
				return _MyFooter; 
			}
			set { _MyFooter = value; }
		}
		[NonSerialized]
		protected bool _TagsSetup = false;
		public virtual void SetupTags()
		{
			if (IsStep)
			{
				MyTab = new Tab(AdjustForTextSubFollowsTextStyle(FormatStepData.TabData.Font));
				_MyHeader = new MetaTag(FormatStepData.TabData.Font);
				_MyFooter = new MetaTag(FormatStepData.TabData.Font);
				SetTabText();
			}
			else
			{
				_MyTab = new Tab(ActiveFormat.PlantFormat.FormatData.Font);
				_MyHeader = null;
				_MyFooter = null;
				_MyTab.CleanText = DisplayNumber;
			}
			_TagsSetup = true;
		}
		protected void SetTabText()
		{
			string cltext = null;
			if (IsParagraph)
			{
				_MyTab.Text = "";
				_MyTab.CleanText = "";
				return;
			}			
			int stepType = (int)(MyContent.Type % 10000);
			string tbformat = IsInRNO ? FormatStepData.TabData.RNOIdentPrint : FormatStepData.TabData.IdentPrint;
			// rno gets parent tab
			if (IsRNOPart)
			{
				try
				{
					if ((((ItemInfo)ActiveParent).IsHigh && FormatStepData.NumberHighLevel) || ((!((ItemInfo)ActiveParent).IsHigh) && ((tbformat == null || tbformat == "") && (RNOLevel <= ColumnMode))))
					{
						_MyTab.CleanText = ((ItemInfo)ActiveParent).MyTab.CleanText;
						_MyTab.Text = ((ItemInfo)ActiveParent).MyTab.Text;
						return;
					}
				}
				catch (Exception ex)
				{
					Console.WriteLine("SetTabText IsRNO error {0}", ex.Message);
				}
			}
			if (tbformat == null)
			{
				_MyTab.Text = "";
				_MyTab.CleanText = "";
				return;
			}
			
			// account for metasection indenting/tabbing in the 'PrintLevel', i.e. if we have metasection, we may be in
			// a subsection. Index into the seqtabs array has to account for metasection level.
			int localPrintLevel = PrintLevel;
			StepSectionData sd = ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData;
			if (sd.StepSectionLayoutData.TieTabToLevel && ActiveFormat.PlantFormat.FormatData.SectData.UseMetaSections)
			{
					if (sd.StepSectionLayoutData.ShowSectionTitles
					&& !MyDocStyle.CancelSectTitle
					&& !(MyDocStyle.SpecialStepsFoldout && MyDocStyle.UseColSByLevel))
						localPrintLevel = PrintLevel + CurrentSectionLevel();
			}
			// Start with basic cases of alpha/numeric/seq:
			if (tbformat.IndexOf("{seq}") > -1)
			{
				SeqTabFmtList seqtabs = ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.SeqTabFmtList;
				int itmp = (localPrintLevel + PrintBias) % seqtabs.Count;
				tbformat = seqtabs[itmp].PrintTabFormat;  // seqtab in 16bit, i.e. '. or )' etc.
				string tbtoken = seqtabs[localPrintLevel % seqtabs.Count].TabToken;  // seqstart in 16bit, number/letter
				tbformat = tbformat.Replace("{seq}", tbtoken);
			}
			
			// If token includes 'Wpar', the parent tab prefix's the tab.
			if (localPrintLevel > 0 && (tbformat.IndexOf("{numericWpar}") > -1 || tbformat.IndexOf("{alphaWpar}") > -1 || tbformat.IndexOf("{ALPHAWpar}") > -1))
			{
				string parentTab = ((ItemInfo)(ActiveParent)).MyTab.CleanText.Trim();
				tbformat = parentTab + (parentTab.EndsWith(".") ? "" : ".") + tbformat.TrimStart();
			}
			if (tbformat.IndexOf("#2#") > -1 || tbformat.IndexOf("#1#") > -1)
			{
				string ofst = tbformat.Substring(0, 3);
				_MyTab.Offset = Convert.ToInt32(ofst.Substring(1, 1));
				cltext = tbformat.Replace("#2#", "");
				cltext = cltext.Replace("#1#", "");
			}
			// if this is a caution/note type determine where 'NOTE/CAUTION' tab goes, as tab or as 'header'
			// and also determine whether the tab itself gets converted to a bullet.
			if (IsCaution || IsNote) tbformat = CheckNoteCautionTab(tbformat);

			int ordinal = Ordinal;
			bool trimTabStart = false;
			if (!IsSection && !IsProcedure && tbformat.IndexOf("{Section Prefix}") >= 0)
			{
				// if there is a section prefix, trim any spaces from the start of this tab, so we don't have
				// a tab that looks like "1. 1"
				string tmpsectpref = SectionPrefix(tbformat) ?? string.Empty;
				if (ActiveSection.MyTab.CleanText != null && ActiveSection.MyTab.CleanText != "" && tmpsectpref != string.Empty) trimTabStart = true;
				tbformat = tbformat.Replace("{Section Prefix}", SectionPrefix(tbformat));
			}
			string alpha = AlphabeticalNumbering(ordinal);
			tbformat = tbformat.Replace("{alpha}", alpha.ToLower());
			tbformat = tbformat.Replace("{alphaWpar}", alpha.ToLower());
			tbformat = tbformat.Replace("{ALPHA}", alpha);
			tbformat = tbformat.Replace("{ALPHAWpar}", alpha);
			string roman = RomanNumbering(ordinal);
			tbformat = tbformat.Replace("{roman}", roman.ToLower());
			tbformat = tbformat.Replace("{ROMAN}", roman);
			tbformat = tbformat.Replace("{numeric}", trimTabStart ? ordinal.ToString() : ordinal.ToString().PadLeft(2));
			tbformat = tbformat.Replace("{numericWpar}", ordinal.ToString());

			if (tbformat.IndexOf("{!C0}") > -1)		// wolf creek uses this to get lines above/below step number
			{
				cltext = cltext == null ? tbformat.Replace("{!C0}", "") : cltext.Replace("{!C0}", "");
				cltext = cltext + " ";
			}

			// "{Null}" was introduced so that inheritance in format files could differentiate between an
			// empty string, and null.  And also, so that if a tab was null but it's parent had text in the
			// tab, don't inherit the parent's tab, use a null.
			if (MyPrevious != null && FormatStepData.Sep != null && FormatStepData.Sep != "{Null}")
			{
				if (_MyHeader == null) _MyHeader = new MetaTag(FormatStepData.TabData.Font);
				_MyHeader.Text = FormatStepData.Sep;
				_MyHeader.CleanText = StripRtfFormatting(_MyHeader.Text);
				_MyHeader.Justify = ContentAlignment.MiddleCenter;
			}
			#region Non Converted Plants tab TODO
			// other possible 'tokens'
			// Position offset - do this one here, so don't get background substitution below..
			// ##-3# - Offset of -3 from Parent (FNP)
			// "{Pos-3}"

			// Background/Deviation Documents - check for E_PurchaseOptions.(ENHANCEDBACKGROUNDS or ENHANCEDDEVIATIONS)
			// # - Related Caution or Note number
			// ~ - Linked Step Number
			//"{LNK C/N Num}"
			//"{LNK Step Num}"

			// Position offset
			// \257 - Indent (CALLOWAY BACKGROUNDS)
			// Newline within a tab (calbck)
			//"{indent}");
			//"{par}");

			//Macros
			// <!diamond> - draws a diamond around the stepnumber
			// <!diamond1> - A macro
			// <!asterisk>
			// <> - ignored
			// \241 - circle macro around step, same as <!circle>
			// Also note, the format files had "<>", these get converted during input in this
			// format converter code.
			//wkstr = wkstr.Replace("{!asterisk}", "\\fs10 \\b*\\b0");		// was font size 20 in 16-bit
			//wkstr = Regex.Replace(wkstr, @"{![.*?]}", @"{!$1}");
			//wkstr = wkstr.Replace("{}", "");
			//if (vefont != null && vefont.HasCircleString2()) wkstr.Insert(0,"{!C0}");

			//wkstr = wkstr.Replace("ê", @"{Box Step}");
			#endregion
			_MyTab.Text = tbformat;
			_MyTab.CleanText = cltext != null ? cltext : tbformat;
		}

		private string GetToken(string tbformat)
		{
			int stindx = tbformat.IndexOf("{");
			return (tbformat.Substring(stindx, tbformat.IndexOf("}")-stindx+1));
		}

		public int GetStepLevel(ref int bias)
		{
			int level = 0;
			ItemInfo par = this;
			ItemInfo LastRNO = null;
			while (par != null && !par.IsSection && !par.IsProcedure && !par.IsHigh)
			{
				if (par.IsRNOPart) LastRNO = par.MyParent;
				if (!par.IsRNOPart && (par.IsSequential || (!(par.IsCaution || par.IsNote)
					&& ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.CountAllSubLevels)))
					level++;
				par = par.MyParent;
			}
			bias = 0;
			if (par.FormatStepData.TabData.IdentPrint.Contains("{ALPHA}"))
				level--;

			// ImperfectStructure is used so that the sequential numbering for substeps under an RNO is not same
			// numbering (alpha vs numeric), if the HLS has substeps - WCN uses this, as well as other plants.
			if (ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.ImperfectStructure && IsSequential
				&& (LastRNO != null) && LastRNO.IsHigh && LastRNO.HasChildren
				&& LastRNO.FirstChild(E_FromType.Step) != null && LastRNO.FirstChild(E_FromType.Step).IsSequential)
			{
				level++;  // 16bit has this: I didn't and mine worked most of time.
				if (ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.ImperfectStructurePlus4) level += 2;
				if (ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.ImperfectSubstep && !ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.ImperfectStructurePlus4)
					bias = -1;
			}
			// ImperfectStructure for substeps - only good for level 1 RNOs 
			else if (ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.ImperfectSubstep && RNOLevel == 1)
			{
				par = this;
				while (!par.IsRNOPart) par = par.MyParent;  // get to the rno.
				if (par.MyParent.HasChildren)				// if parent has children?
				{
					ItemInfo tchild = par.MyParent.FirstChild(E_FromType.Step);
					if (tchild != null)
					{
						int typ = (int)tchild.MyContent.Type - 20000;
						if (ActiveFormat.PlantFormat.FormatData.StepDataList[typ].TabData.IdentPrint.Contains("{seq}"))
						{
							level++;
							if (ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.ImperfectStructurePlus4) level += 1;
							if (!ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.ImperfectStructurePlus4) bias = -1;
						}
					}
				}
			}
			return level;
		}
		public int CurrentSectionLevel()
		{
			int countlev = 0;
			if ((MyActiveSection.MyDocStyle.StructureStyle.Style ?? 0 & E_DocStructStyle.DSS_TreatAsTrueSectNum) != 0)
			{
				ItemInfo ii = ActiveSection.MyParent;
				while (!ii.IsProcedure)
				{
					if (ii.DisplayNumber != null && ii.DisplayNumber != "")
					{
						SectionConfig sc = MyActiveSection.MyConfig as SectionConfig;
						if (sc != null && sc.SubSection_AutoIndent == "Y") 
							countlev++;
					}
					ii = ii.MyParent;
				}
			}
			return countlev;
		}
		private string SectionPrefix(string tbformat)
		{
			// if not metasection/tietabtolevel, return the 'section number'.  (where the '.' may or may not exist)
			if (!ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.TieTabToLevel)
			{
				// If the Section's 'tab' is a character or has a character preceding the '.' is an alpha character, 
				//	just return the alpha (no '.')
				// If the character preceding the '. 'is a number, return the section tab up to and including the '.'
				// Otherwise, just return the section tab.
				// Before checking for anything, if the DisplayNumber starts with 'ATTACHMENT ', don't use that in the Section
				// prefix for the tabstring.
				string attNum = ActiveSection.DisplayNumber.ToUpper().StartsWith("ATTACHMENT ") ? ActiveSection.DisplayNumber.Substring(11) : ActiveSection.DisplayNumber;
				Match m = Regex.Match(attNum, @"[a-zA-Z]");  // for alpha, use non-touched displaynumber
				int indx = -1;
				if (m.Success)
				{
					indx = attNum.IndexOf(".");
					if (indx < 0) return attNum;
					return attNum.Substring(0, indx);
				}
				indx = ActiveSection.MyTab.CleanText.IndexOf(".");
				if (indx > 0) return ActiveSection.MyTab.CleanText.Substring(0, indx + 1);   // include the '.'
				return ActiveSection.MyTab.CleanText.TrimEnd();
			}

			// the rest of this is for metasections (tietabtolevel format flag)

			SectionInfo si = SectionInfo.Get(ActiveSection.ItemID);
			// A 'TrueSectionNum' must have a '.' and cannot have lettters after the '.'.
			if (si != null && si.TrueSectionNum())
			{
				string attNum = ActiveSection.DisplayNumber; // ActiveSection.DisplayNumber.ToUpper().StartsWith("ATTACHMENT ") ? ActiveSection.DisplayNumber.Substring(11) : ActiveSection.DisplayNumber;
				// If section number is of form '1.0', return '1.'
				if (attNum.Length > 1 && attNum[attNum.Length - 1] == '0' && attNum[attNum.Length - 2] == '.')
					return attNum.Substring(0, attNum.Length - 1);
				// If section number is of form '1', return '1.'
				else if (attNum.Length > 0 && attNum[attNum.Length - 1] != '.')
					return attNum + '.';
			}
			// For the docstyle flag DSS_TreatAsTrueSectNum, look for last space, and if one is
			// found, the the Section Prefix is the text after the space with a '.' appended - for
			// example, 'Attachment A' becomes 'A.'.
			if ((MyDocStyle.StructureStyle.Style ?? 0 & E_DocStructStyle.DSS_TreatAsTrueSectNum) != 0)
			{
				int lindx = ActiveSection.DisplayNumber.LastIndexOf(" ");
				if (lindx > 0)
				{
					return ActiveSection.DisplayNumber.Substring(lindx + 1) + ".";
				}
			}

			// If we're in a subsection, be sure there is a '.' at the end.
			int subsection = CurrentSectionLevel();
			if (subsection >= 1)
			{
				string tmptab = ActiveSection.MyTab.CleanText.TrimEnd();
				if (tmptab.LastIndexOf(".") != tmptab.Length - 1) tmptab = tmptab + ".";
				return tmptab;
			}
			return ActiveSection.MyTab.CleanText.TrimEnd();
		}
		
		private string CheckNoteCautionTab(string tbformat)
		{
			string prevTbFormat = null;
			string nextTbFormat = null;
			StepData nextStepData = null;
			if (MyPrevious != null)
			{
				// int prevStepType = ((int)MyPrevious.MyContent.Type) % 10000;
				StepData prevStepData = MyPrevious.FormatStepData; // ActiveFormat.PlantFormat.FormatData.StepDataList[prevStepType];
				prevTbFormat = MyPrevious.IsInRNO ? prevStepData.TabData.RNOIdentPrint : prevStepData.TabData.IdentPrint;
			}
			if (NextItem != null)
			{
				nextStepData = NextItem.FormatStepData;
				// tried to duplicate functionality from 16-bit code.
				nextTbFormat = NextItem.IsInRNO ? nextStepData.TabData.RNOIdentPrint : nextStepData.TabData.IdentPrint;
			}
			// Handle the centered tab - if this tab is centered make it a header.
			if (FormatStepData.TabData.Justify == "Center")
			{
				_MyHeader.Justify = ContentAlignment.MiddleCenter;
				_MyHeader.Text = tbformat.Trim(); ;
				_MyHeader.CleanText = StripRtfFormatting(_MyHeader.Text);
				// if there is only step in the group - no bullet is used, if more that one replace the tab
				// with a bullet.  Also, if only one in group and tab text ends with 'S', remove it:
				if (MyPrevious == null && NextItem == null)
				{
					if (_MyHeader.CleanText.ToUpper().EndsWith("S"))
					{
						string origTxt = _MyHeader.CleanText;
						_MyHeader.CleanText = _MyHeader.CleanText.Substring(0, _MyHeader.CleanText.Length - 1);
						// Text may have rtf commands:
						_MyHeader.Text = _MyHeader.Text.Replace(origTxt, _MyHeader.CleanText);
					}
					tbformat = "";
				}
				else
				{
					if (MyPrevious != null) _MyHeader = null;
					tbformat = ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.IdentB;
					TabToIdentBAdjustFont();

				}
				return tbformat;
			}

			// If this has a previous, and the tabs of this & previous match
			if (tbformat != null && MyPrevious != null && !FormatStepData.AlwaysTab && (!FormatStepData.MixCautionsAndNotes || (tbformat == prevTbFormat)))
			{
				tbformat = tbformat + ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.IdentB;
				TabToIdentBAdjustFont();
			}
			// else if this has a next 
			else if (tbformat != null && NextItem != null && !FormatStepData.AlwaysTab &&
				(!FormatStepData.MixCautionsAndNotes ||
				 (FormatStepData.TabData.UsePreviousStyle && !nextStepData.TabData.UsePreviousStyle && tbformat == nextTbFormat) ||
				 ((prevTbFormat != tbformat && (NextItem.MyContent.Type == (int)(MyContent.Type % 10000))))))
			{
				tbformat = tbformat + ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.IdentB;
				_MyTab.RemovedStyleUnderline = true;
				TabToIdentBAdjustFont();
			}
			return tbformat;
		}

		private void TabToIdentBAdjustFont()
		{
			if ((FormatStepData.TabData.Font.Style & E_Style.Underline) > 0)
			{
				FontStyle style = FontStyle.Regular;
				if ((FormatStepData.TabData.Font.Style & E_Style.Bold) > 0) style |= FontStyle.Bold;
				if ((FormatStepData.TabData.Font.Style & E_Style.Italics) > 0) style |= FontStyle.Italic;
				_MyTab.MyFont.WindowsFont = new Font(FormatStepData.TabData.Font.WindowsFont.FontFamily, FormatStepData.TabData.Font.WindowsFont.Size, style);
			}
		}
		private string AlphabeticalNumbering(int number)
		{
			string retval = string.Empty;
			if (number > 26) retval += Letter((number - 1) / 26);
			retval += Letter(1 + ((number - 1) % 26));
			return retval;
		}
		private string Letter(int number)
		{
			char c = (char)(number + 64);
			return c.ToString();
		}
		private enum RomanOffset : int
		{
			Hundreds = 2,
			Tens = 4,
			Units = 6
		}
		private string _Romans = "MDCLXVI";
		private string RomanPart(RomanOffset offset, int value)
		{
			int iFive = value / 5;
			int iUnits = value % 5;
			int iFour = iUnits / 4;
			return _Romans.Substring(((int)offset), iFour) +
				_Romans.Substring(((int)offset) - iFive - iFour, iFive | iFour) +
				"".PadRight(iUnits % 4, _Romans[((int)offset)]);
		}
		private string RomanNumbering(int number)
		{
			int thousands = number / 1000;
			int hundreds = (number % 1000) / 100;
			int tens = (number % 100) / 10;
			int units = number % 10;
			return "".PadRight(thousands, _Romans[0]) +
				RomanPart(RomanOffset.Hundreds, hundreds) +
				RomanPart(RomanOffset.Tens, tens) +
				RomanPart(RomanOffset.Units, units);
		}
		public static void ResetTabString(int itemID)
		{
			ConvertListToDictionary();
			string key = itemID.ToString();
			if (key != null && _CacheByPrimaryKey.ContainsKey(key))
			{
				ItemInfo[] items = _CacheByPrimaryKey[key].ToArray();
				foreach (ItemInfo item in items)
				{
					item._TagsSetup = false;
				}
			}
		}
		#endregion
		#region ParentNoteOrCaution
		private bool _ParentNoteOrCautionLoaded = false;
		private ItemInfo _ParentNoteOrCaution;
		public ItemInfo ParentNoteOrCaution
		{
			get 
			{
				if (!_ParentNoteOrCautionLoaded)
				{
					ItemInfo parent = ActiveParent as ItemInfo;
					if (parent != null)
					{
						if (parent.IsCautionPart || parent.IsNotePart) 
							_ParentNoteOrCaution = parent;
						else if(!parent.IsHigh)
						{
							_ParentNoteOrCaution = parent.ParentNoteOrCaution;
						}
					}
					_ParentNoteOrCautionLoaded = true;
				}
				return _ParentNoteOrCaution; 
			}
		}
		#endregion
		#region Macro List
		[NonSerialized]
		protected List<Macro> _MyMacros;
		protected bool _MacrosSetup = false;
		public List<Macro> MyMacros
		{
			get
			{
				if (!_MacrosSetup) SetupMacros();
				return _MyMacros;
			}
			set
			{
				_MyMacros = value;
			}
		}
		private void SetupMacros()
		{
			if (FormatStepData == null) return;
			// see if each macro should be printed based on its attributes and the item we're on.
			// Attributes to check are NotInRNO, i.e. only add this macro to the result list if 
			// the item is not in the RNO column.  Also, Groupings is used to only have the macro if
			// there are N or more of the type in the grouping.
			List<Macro> tmp = new List<Macro>();
			StepData myStepData = (FormatStepData.TextSubFollowsTextStyle && ParentNoteOrCaution != null) ? ParentNoteOrCaution.FormatStepData : FormatStepData;
			// foreach (Macro macro in ActiveFormat.PlantFormat.FormatData.StepDataList[FormatStepType].TabData.MacroList)
			foreach (Macro macro in myStepData.TabData.MacroList)
			{
				bool addToList = true;
				if (macro.NotInRNO && IsInRNO) addToList = false;
				if (macro.Grouping != null && macro.Grouping > 0)
				{
					int count = 0;
					ItemInfo ii = FirstSibling;
					while (ii != null)
					{
						if (ii.MyContent.Type == MyContent.Type) count++;
						ii = ii.NextItem;
					}
					if (count <= macro.Grouping) addToList = false;
				}
				if (addToList) tmp.Add(macro);
			}
			if (tmp.Count > 0) _MyMacros = tmp;
		}
		#endregion
		#region CheckOffs
		private string _SectionCheckOffHeader;
		public string SectionCheckOffHeader
		{
			get 
			{
				if (_SectionCheckOffHeader == null)
				{
					// first check if format has checkoff data, including checkoffheaders.
					ProcData pd = ActiveFormat.PlantFormat.FormatData.ProcData;
					if (pd.CheckOffData == null || pd.CheckOffData.CheckOffHeaderList == null || pd.CheckOffData.CheckOffHeaderList.Count <= 1) _SectionCheckOffHeader = string.Empty;
					else
					{
						SectionConfig sc = ActiveSection.MyConfig as SectionConfig;
						if (sc == null) _SectionCheckOffHeader = string.Empty;
						else if (sc.Section_CheckoffHeaderSelection <= 0) _SectionCheckOffHeader = string.Empty;
						else
						{
							_SectionCheckOffHeader = pd.CheckOffData.CheckOffHeaderList[sc.Section_CheckoffHeaderSelection].CheckOffHeading;
							if (_SectionCheckOffHeader.Contains("{NO HEADING}")) _SectionCheckOffHeader = string.Empty;
						}
					}
				}
				return _SectionCheckOffHeader; 
			}
		}
		public bool SectionHasCheckOffs()
		{
			// To determine if the section has a checkoff...
			//  Section won't have checkoffs if there is no checkofflist, or 
			ProcData pd = ActiveFormat.PlantFormat.FormatData.ProcData;
			if (pd.CheckOffData == null ||   pd.CheckOffData.CheckOffList == null || pd.CheckOffData.CheckOffList.Count <= 0) return false;
			if (pd.CheckOffData.CheckOffHeaderList == null || pd.CheckOffData.CheckOffHeaderList.Count <= 1) return true;
			//if (pd.CheckOffData == null || pd.CheckOffData.CheckOffHeaderList == null || pd.CheckOffData.CheckOffHeaderList.Count <= 1) return false;

			// To find whether the step has a checkoff, first check that the section
			//  has a check off header.  If it doesn't, just return -1.  
			//	if config item is set for checkoffindex, use it.  If it == 0, then use
			//	the section default.
			SectionConfig sc = ActiveSection.MyConfig as SectionConfig;
			if (sc == null) return false;
			if (sc.Section_CheckoffHeaderSelection < 0) return false;
			return true;
		}
		private int CheckOffIndex()
		{
			StepConfig stc = MyConfig as StepConfig;
			if (stc == null) return 0;   //section default.
			if (stc != null && stc.Step_CheckOffIndex == 1) return -1;   // index of 1, always means 'No Checkoff'
			return stc.Step_CheckOffIndex;
		}
		private int SectionDefaultCheckOffIndex()
		{
			ProcData pd = ActiveFormat.PlantFormat.FormatData.ProcData;
			if (pd.CheckOffData != null && pd.CheckOffData.CheckOffList != null && pd.CheckOffData.CheckOffList.Count == 2) return 0;   // if only two items, first is macro - use it.
			SectionConfig sc = ActiveSection.MyConfig as SectionConfig;
			return sc.Section_CheckoffListSelection;
		}
		public CheckOff GetCheckOffStep()
		{
			if (!IsStep || !SectionHasCheckOffs()) return null;
			int stpCoIndx = CheckOffIndex();		// this step has a checkoff defined
			if (stpCoIndx == -1) return null;
			if (stpCoIndx > 1) return ActiveFormat.PlantFormat.FormatData.ProcData.CheckOffData.CheckOffList[stpCoIndx];
			int sectCoIndx = SectionDefaultCheckOffIndex();  // no checkoff on step, see if there is a section default.
			if (sectCoIndx == -1) return null;
			if ((ActiveFormat.PlantFormat.FormatData.ProcData.CheckOffData.CheckOffOnHLSOnly && IsHigh)
				|| (!ActiveFormat.PlantFormat.FormatData.ProcData.CheckOffData.CheckOffOnHLSOnly && IsLowestLevelStep() && !RNOsHighHasCheckOff()))
				return ActiveFormat.PlantFormat.FormatData.ProcData.CheckOffData.CheckOffList[sectCoIndx];
			return null;
		}
		private bool IsLowestLevelStep()
		{
			// This test only checks if using the section default, otherwise the code above, uses what the checkoff
			// that is set in the config.
			StepConfig stc = MyConfig as StepConfig;
			if (stc != null && stc.Step_CheckOffIndex == 0)
			{
				if (!(IsCaution || IsNote || IsTable || Steps != null || MyParent.IsCaution || MyParent.IsNote)) return true;
			}
			return false;
		}
		private bool RNOsHighHasCheckOff()
		{
			// If this is a High Level Step's RNO, the checkoff would be placed on the HLS, not the RNO.
			if (IsRNOPart && MyParent.IsHigh && MyParent.CheckOffIndex() != -1) return true;
			return false;
		}
		#endregion
		#region JCB Item Status
		private bool _IsItemNew = false;
		public bool IsItemNew
		{
			get
			{
				ProcedureInfo pi = this.MyProcedure;
				if (pi != null)
					_IsItemNew = (this.DTS > pi.DTS);
				return _IsItemNew;
			}
		}
		private bool _IsItemChanged;
		public bool IsItemChanged
		{
			get
			{
				ProcedureInfo pi = this.MyProcedure;
				if (pi != null)
					_IsItemChanged = (this.MyContent.DTS > pi.DTS);
				return _IsItemChanged;
			}
		}
		#endregion
	}
	#endregion ItemInfo
	#region Tab
	public class MetaTag
	{
		public VE_Font MyFont;
		public ContentAlignment Justify = ContentAlignment.MiddleLeft;
		public string Text;				// may include tokens, such as macros for circles/diamonds, etc
		public string CleanText;		// all tokens removed
		public MetaTag()
		{
		}
		public MetaTag(VE_Font font)
		{
			MyFont = new VE_Font(font.XmlNode);
		}
	}
	public class Tab : MetaTag
	{
		private bool _RemovedStyleUnderline = false;
		public bool RemovedStyleUnderline
		{
			get { return _RemovedStyleUnderline; }
			set { _RemovedStyleUnderline = value; }
		}
		public Tab(VE_Font font)
		{
			MyFont = font;
		}
		public int Offset;
		private static Regex _ReplaceSymbols = new Regex("^[^0-9A-Za-z]*"); // trim anything that isn't an ascii alpha/numeric from the beginning
		public string CleanTextNoSymbols
		{
			get
			{
				// this trims off any symbols at the start of the tab
				return _ReplaceSymbols.Replace(CleanText, "");
			}
		}

	}
	public class Header : MetaTag
	{
	}
	#endregion
	#region ItemInfoList
	public partial class ItemInfoList
	{
		//public void ToXml(XmlNode xn)
		//{
		//  foreach (ItemInfo itemInfo in this)
		//  {
		//    itemInfo.ToXml(xn);
		//  }
		//}
		internal ItemInfoList(ItemInfo itemInfo)
		{
			AddItem(itemInfo);
		}
		public static ItemInfoList GetList(int? itemID,int type)
		{
			try
			{
				ItemInfoList tmp = DataPortal.Fetch<ItemInfoList>(new ItemListCriteria(itemID,type));
				ItemInfo.AddList(tmp);
				tmp.AddEvents();
#if (!ItemWithContent) // If ItemWithContent is set, the content is returned with the ItemInfoList
				ContentInfoList.GetList(itemID); // Performance - Load All Content 
#endif
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on ItemInfoList.GetChildren", ex);
			}
		}
		public static ItemInfoList GetListByPartType(E_FromType fromType)
		{
			try
			{
				ItemInfoList tmp = DataPortal.Fetch<ItemInfoList>(new ItemListPartTypeCriteria(fromType));
				ItemInfo.AddList(tmp);
				tmp.AddEvents();
#if (!ItemWithContent) // If ItemWithContent is set, the content is returned with the ItemInfoList
				ContentInfoList.GetList(itemID); // Performance - Load All Content 
#endif
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on ItemInfoList.GetChildren", ex);
			}
		}
		[Serializable()]
		private class ItemListCriteria
		{
			public ItemListCriteria(int? itemID,int type)
			{
				_ItemID = itemID;
				_Type = type;
			}
			private int? _ItemID;
			public int? ItemID
			{
				get { return _ItemID; }
				set { _ItemID = value; }
			}
			private int _Type;
			public int Type
			{
				get { return _Type; }
				set { _Type = value; }
			}
		}
		[Serializable()]
		private class ItemListPartTypeCriteria
		{
			public ItemListPartTypeCriteria(E_FromType type)
			{
				_Type = type;
			}
			private E_FromType _Type;
			public E_FromType Type
			{
				get { return _Type; }
				set { _Type = value; }
			}
		}
		private void DataPortal_Fetch(ItemListCriteria criteria)
		{
			this.RaiseListChangedEvents = false;
			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cm = cn.CreateCommand())
					{
						cm.CommandType = CommandType.StoredProcedure;
#if ItemWithContent
						cm.CommandText = "vesp_ListItemsAndContent"; 
#else
						cm.CommandText = "vesp_ListItems";
#endif
						cm.Parameters.AddWithValue("@ItemID", criteria.ItemID);
						using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
						{
							while (dr.Read())
							{
								ItemInfo itemInfo = null;
								switch ((E_FromType)criteria.Type)
								{
									case E_FromType.Procedure:
										itemInfo = new ProcedureInfo(dr);
										break;
									case E_FromType.Section:
										itemInfo = new SectionInfo(dr);
										break;
									default:
										itemInfo = new StepInfo(dr);
										break;
								}
								IsReadOnly = false;
								this.Add(itemInfo);
								IsReadOnly = true;
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
				throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
			}
			this.RaiseListChangedEvents = true;
		}
		private void DataPortal_Fetch(ItemListPartTypeCriteria criteria)
		{
			this.RaiseListChangedEvents = false;
			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cm = cn.CreateCommand())
					{
						cm.CommandType = CommandType.StoredProcedure;
#if ItemWithContent
						cm.CommandText = "getItemsByPartTypeAndContent"; 
#else
						cm.CommandText = "getItemsByPartType";
#endif
						cm.Parameters.AddWithValue("@FromType", (int) criteria.Type);
						using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
						{
							while (dr.Read())
							{
								ItemInfo itemInfo = null;
								switch (criteria.Type)
								{
									case E_FromType.Procedure:
										itemInfo = new ProcedureInfo(dr);
										break;
									case E_FromType.Section:
										itemInfo = new SectionInfo(dr);
										break;
									default:
										itemInfo = new StepInfo(dr);
										break;
								}
								IsReadOnly = false;
								this.Add(itemInfo);
								IsReadOnly = true;
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
				throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
			}
			this.RaiseListChangedEvents = true;
		}
		internal void AddItem(ItemInfo itemInfo)
		{
			IsReadOnly = false;
			this.Add(itemInfo);
			IsReadOnly = true;
		}
		#region Text Search
		public static ItemInfoList GetListFromTextSearch(string docVersionList, string stepTypeList, string searchString, int caseSensitive, ItemSearchIncludeLinks includeLinks, bool includeRtfFormatting, bool includeSpecialCharacters, string unitPrefix)
		{
			try
			{
				ItemInfoList tmp = DataPortal.Fetch<ItemInfoList>(new ItemListSearchCriteria(docVersionList, stepTypeList, searchString, caseSensitive, includeLinks, includeRtfFormatting, includeSpecialCharacters,unitPrefix));
				ItemInfo.AddList(tmp);
				tmp.AddEvents();
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on ItemInfoList.GetListFromTextSearch", ex);
			}
		}
		[Serializable()]
		private class ItemListSearchCriteria
		{
			private string _DocVersionList;
			public string DocVersionList
			{
				get { return _DocVersionList; }
				set { _DocVersionList = value; }
			}
			private string _StepTypeList;
			public string StepTypeList
			{
				get { return _StepTypeList; }
				set { _StepTypeList = value; }
			}
			private string _SearchString;
			public string SearchString
			{
				get { return _SearchString; }
				set { _SearchString = value; }
			}
			private int _CaseSensitive;
			public int CaseSensitive
			{
				get { return _CaseSensitive; }
				set { _CaseSensitive = value; }
			}
			private ItemSearchIncludeLinks _IncludeLinks;
			public ItemSearchIncludeLinks IncludeLinks
			{
				get { return _IncludeLinks; }
				set { _IncludeLinks = value; }
			}
			private bool _IncludeRtfFormatting;
			public bool IncludeRtfFormatting
			{
				get { return _IncludeRtfFormatting; }
				set { _IncludeRtfFormatting = value; }
			}
			private bool _IncludeSpecialCharacters;
			public bool IncludeSpecialCharacters
			{
				get { return _IncludeSpecialCharacters; }
				set { _IncludeSpecialCharacters = value; }
			}
			private string _UnitPrefix;

			public string UnitPrefix
			{
				get { return _UnitPrefix; }
				set { _UnitPrefix = value; }
			}
			public ItemListSearchCriteria(string docVersionList, string stepTypeList, string searchString, 
				int caseSensitive, ItemSearchIncludeLinks includeLinks, bool includeRtfFormatting, bool includeSpecialCharacters, string unitPrefix)
			{
				_DocVersionList = docVersionList;
				_StepTypeList = stepTypeList;
				_SearchString = searchString;
				_CaseSensitive = caseSensitive;
				_IncludeLinks = includeLinks;
				_IncludeRtfFormatting = includeRtfFormatting;
				_IncludeSpecialCharacters = includeSpecialCharacters;
				_UnitPrefix = unitPrefix;
			}
		}
		private void DataPortal_Fetch(ItemListSearchCriteria criteria)
		{
			this.RaiseListChangedEvents = false;
			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cm = cn.CreateCommand())
					{
						cm.CommandType = CommandType.StoredProcedure;
						cm.CommandText = "vesp_SearchItemAndChildrenNew";
						cm.Parameters.AddWithValue("@DocVersionList", criteria.DocVersionList);
						cm.Parameters.AddWithValue("@StepTypeList", criteria.StepTypeList);
						cm.Parameters.AddWithValue("@SearchString", criteria.SearchString);
						cm.Parameters.AddWithValue("@CaseSensitive", criteria.CaseSensitive);
						cm.Parameters.AddWithValue("@IncludeLinks", (int) criteria.IncludeLinks);
						cm.Parameters.AddWithValue("@IncludeRtfFormatting", criteria.IncludeRtfFormatting ? 1 : 0);
						cm.Parameters.AddWithValue("@IncludeSpecialCharacters", criteria.IncludeSpecialCharacters ? 1 : 0);
						cm.Parameters.AddWithValue("@UnitPrefix", criteria.UnitPrefix);
						cm.CommandTimeout = 120;
						using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
						{
							while (dr.Read())
							{
								ItemInfo itemInfo = null;
								int itemType = dr.GetInt32("Type") / 10000;
								switch (itemType)
								{
									case 0:
										itemInfo = new ProcedureInfo(dr);
										break;
									case 1:
										itemInfo = new SectionInfo(dr);
										break;
									default:
										itemInfo = new StepInfo(dr);
										break;
								}
								itemInfo.AddContent(dr);
								itemInfo._SearchDVPath = dr.GetString("DVPath");
								itemInfo._SearchPath = dr.GetString("Path");
								IsReadOnly = false;
								this.Add(itemInfo);
								IsReadOnly = true;
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
				throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
			}
			this.RaiseListChangedEvents = true;
		}
		#endregion
		#region RO Search
		public static ItemInfoList GetListFromROSearch(string docVersionList, string stepTypeList, string roSearchString, string unitPrefix)
		{
			try
			{
				ItemInfoList tmp = DataPortal.Fetch<ItemInfoList>(new ItemListROSearchCriteria(docVersionList, stepTypeList, roSearchString, unitPrefix));
				ItemInfo.AddList(tmp);
				tmp.AddEvents();
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on ItemInfoList.GetChildren", ex);
			}
		}
		[Serializable()]
		private class ItemListROSearchCriteria
		{
			private string _DocVersionList;
			public string DocVersionList
			{
				get { return _DocVersionList; }
				set { _DocVersionList = value; }
			}
			private string _StepTypeList;
			public string StepTypeList
			{
				get { return _StepTypeList; }
				set { _StepTypeList = value; }
			}
			private string _ROSearchString;
			public string ROSearchString
			{
				get { return _ROSearchString; }
				set { _ROSearchString = value; }
			}
			private string _UnitPrefix;
			public string UnitPrefix
			{
				get { return _UnitPrefix; }
				set { _UnitPrefix = value; }
			}
			public ItemListROSearchCriteria(string docVersionList, string stepTypeList, string roSearchString, string unitPrefix)
			{
				_DocVersionList = docVersionList;
				_StepTypeList = stepTypeList;
				_ROSearchString = roSearchString;
				_UnitPrefix = unitPrefix;
			}
		}
		private void DataPortal_Fetch(ItemListROSearchCriteria criteria)
		{
			this.RaiseListChangedEvents = false;
			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cm = cn.CreateCommand())
					{
						cm.CommandType = CommandType.StoredProcedure;
						cm.CommandText = "vesp_SearchROItemAndChildren";
						cm.Parameters.AddWithValue("@DocVersionList", criteria.DocVersionList);
						cm.Parameters.AddWithValue("@StepTypeList", criteria.StepTypeList);
						cm.Parameters.AddWithValue("@ROSearchString", criteria.ROSearchString);
						cm.Parameters.AddWithValue("@UnitPrefix", criteria.UnitPrefix);
						using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
						{
							while (dr.Read())
							{
								ItemInfo itemInfo = null;
								int itemType = dr.GetInt32("Type") / 10000;
								switch (itemType)
								{
									case 0:
										itemInfo = new ProcedureInfo(dr);
										break;
									case 1:
										itemInfo = new SectionInfo(dr);
										break;
									default:
										itemInfo = new StepInfo(dr);
										break;
								}
								itemInfo.AddContent(dr);
								itemInfo._SearchDVPath = dr.GetString("DVPath");
								itemInfo._SearchPath = dr.GetString("Path");
								IsReadOnly = false;
								this.Add(itemInfo);
								IsReadOnly = true;
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
				throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
			}
			this.RaiseListChangedEvents = true;
		}
		#endregion
		#region Annotation Search
		public static ItemInfoList GetListFromAnnotationSearch(string docVersionList, string stepTypeList, string annotationTypeList, string searchString, bool caseSensitive, string unitPrefix)
		{
			try
			{
				ItemInfoList tmp = DataPortal.Fetch<ItemInfoList>(new ItemListAnnotationSearchCriteria(docVersionList, stepTypeList, annotationTypeList, searchString, caseSensitive, unitPrefix));
				ItemInfo.AddList(tmp);
				tmp.AddEvents();
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on ItemInfoList.GetChildren", ex);
			}
		}
		[Serializable()]
		private class ItemListAnnotationSearchCriteria
		{
			private string _DocVersionList;
			public string DocVersionList
			{
				get { return _DocVersionList; }
				set { _DocVersionList = value; }
			}
			private string _StepTypeList;
			public string StepTypeList
			{
				get { return _StepTypeList; }
				set { _StepTypeList = value; }
			}
			private string _AnnotationTypeList;
			public string AnnotationTypeList
			{
				get { return _AnnotationTypeList; }
				set { _AnnotationTypeList = value; }
			}
			private string _SearchString;
			public string SearchString
			{
				get { return _SearchString; }
				set { _SearchString = value; }
			}
			private bool _CaseSensitive;
			public bool CaseSensitive
			{
				get { return _CaseSensitive; }
				set { _CaseSensitive = value; }
			}
			private string _UnitPrefix;
			public string UnitPrefix
			{
				get { return _UnitPrefix; }
				set { _UnitPrefix = value; }
			}

			public ItemListAnnotationSearchCriteria(string docVersionList, string stepTypeList, string annotationTypeList, string searchString, bool caseSensitive, string unitPrefix)
			{
				_DocVersionList = docVersionList;
				_StepTypeList = stepTypeList;
				_AnnotationTypeList = annotationTypeList;
				_SearchString = searchString;
				_CaseSensitive = caseSensitive;
				_UnitPrefix = unitPrefix;
			}
		}
		private void DataPortal_Fetch(ItemListAnnotationSearchCriteria criteria)
		{
			this.RaiseListChangedEvents = false;
			try
			{
				using (SqlConnection cn = Database.VEPROMS_SqlConnection)
				{
					using (SqlCommand cm = cn.CreateCommand())
					{
						cm.CommandType = CommandType.StoredProcedure;
						cm.CommandText = "vesp_SearchAnnotationItemAndChildren";
						cm.Parameters.AddWithValue("@DocVersionList", criteria.DocVersionList);
						cm.Parameters.AddWithValue("@StepTypeList", criteria.StepTypeList);
						cm.Parameters.AddWithValue("@AnnotationTypeList", criteria.AnnotationTypeList);
						cm.Parameters.AddWithValue("@SearchString", criteria.SearchString);
						cm.Parameters.AddWithValue("@CaseSensitive", criteria.CaseSensitive ? 1 : 0);
						cm.Parameters.AddWithValue("@UnitPrefix", criteria.UnitPrefix);
						using (SafeDataReader dr = new SafeDataReader(cm.ExecuteReader()))
						{
							while (dr.Read())
							{
								ItemInfo itemInfo = null;
								int itemType = dr.GetInt32("Type") / 10000;
								switch (itemType)
								{
									case 0:
										itemInfo = new ProcedureInfo(dr);
										break;
									case 1:
										itemInfo = new SectionInfo(dr);
										break;
									default:
										itemInfo = new StepInfo(dr);
										break;
								}
								itemInfo.AddContent(dr);
								itemInfo._SearchDVPath = dr.GetString("DVPath");
								itemInfo._SearchPath = dr.GetString("Path");
								itemInfo._SearchAnnotationID = dr.GetInt32("SearchAnnotationID");
								itemInfo._SearchAnnotationText = dr.GetString("SearchText");
								itemInfo._SearchAnnotationType = dr.GetString("AnnotationType");
								IsReadOnly = false;
								this.Add(itemInfo);
								IsReadOnly = true;
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				Database.LogException("ItemInfoList.DataPortal_Fetch", ex);
				throw new DbCslaException("ItemInfoList.DataPortal_Fetch", ex);
			}
			this.RaiseListChangedEvents = true;
		}
		#endregion
	}
	#endregion
	#region ProcedureInfo
	[Serializable()]
	public partial class ProcedureInfo : ItemInfo, IVEDrillDownReadOnly
	{
		public override void  SetupTags()
		{
 			 base.SetupTags();
		}
		protected override void RefreshFields(Item tmp)
		{
			base.RefreshFields(tmp);
			ExtensionRefreshFields(tmp);
		}
#if ItemWithContent
		public ProcedureInfo(SafeDataReader dr) : base(dr, true) { }
#else
		public ProcedureInfo(SafeDataReader dr) : base(dr) { }
#endif
		private ProcedureInfo() : base() { ;}
		public new static ProcedureInfo Get(int itemID)
		{
			//if (!CanGetObject())
			//    throw new System.Security.SecurityException("User not authorized to view a Item");
			try
			{
				ProcedureInfo tmp = GetCachedByPrimaryKey(itemID) as ProcedureInfo;
				if (tmp == null)
				{
					tmp = DataPortal.Fetch<ProcedureInfo>(new PKCriteria(itemID));
					AddToCache(tmp);
				}
				if (tmp.ErrorMessage == "No Record Found") tmp = null;
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on Item.Get", ex);
			}
		}
		public void MoveProcedure(IVEDrillDownReadOnly pInfo, int index)
		{
			using (Item ii = Item.Get(this.ItemID))
			{
				ii.MoveItem(pInfo, index);
			}
		}
		public new Procedure Get()
		{
			return (Procedure) (_Editable = Procedure.Get(ItemID));
		}
		#region ProcedureConfig
		[NonSerialized]
		private ProcedureConfig _ProcedureConfig;
		public ProcedureConfig ProcedureConfig
		{ get { return (_ProcedureConfig != null ? _ProcedureConfig : _ProcedureConfig = new ProcedureConfig(this)); } }
		#endregion
		public new ConfigDynamicTypeDescriptor MyConfig
		{
			get { return ProcedureConfig ; }
			set { _ProcedureConfig = null; }
		}
		public DocVersionInfo MyDocVersion
		{
			get { return ActiveParent as DocVersionInfo; }
		}
	}
	#endregion
	#region Procedure
	[Serializable()]
	public partial class Procedure : Item
	{
		public ProcedureInfo MyProcedureInfo /* Return Info version of the current Item */
		{ get { return ProcedureInfo.Get(ItemID); } }
		public new static Procedure Get(int itemID)
		{
			if (!CanGetObject())
				throw new System.Security.SecurityException("User not authorized to view a Item");
			try
			{
				Item itm = GetCachedByPrimaryKey(itemID);
				Procedure tmp = itm as Procedure;
				//Procedure tmp = (Procedure)GetExistingByPrimaryKey(itemID);
				if (tmp == null)
				{
					if (itm != null) Console.WriteLine("type = {0}", itm.GetType().Name);
					tmp = DataPortal.Fetch<Procedure>(new PKCriteria(itemID));
					AddToCache(tmp);
				}
				if (tmp.ErrorMessage == "No Record Found") tmp = null;
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on Item.Get", ex);
			}
		}
		public new Procedure Save()
		{
			return (Procedure)base.Save();
		}
		public static Procedure MakeProcedure(IVEDrillDownReadOnly parentInfo, ItemInfo previousInfo, string procNumber, string procTitle, int procType)
		{
			int newitemid = MakeNewItem(parentInfo, previousInfo, procNumber, procTitle, procType, E_FromType.Procedure);
			return Procedure.Get(newitemid);
		}
		#region ProcedureConfig
		[NonSerialized]
		private ProcedureConfig _ProcedureConfig;
		public ProcedureConfig ProcedureConfig
		{
			get
			{
				if (_ProcedureConfig == null)
				{
					_ProcedureConfig = new ProcedureConfig(this);
					_ProcedureConfig.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(_ProcedureConfig_PropertyChanged);
				}
				return _ProcedureConfig;
			}
		}
		private void _ProcedureConfig_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
		{
			MyContent.Config = _ProcedureConfig.ToString();
		}
		#endregion
	}
	#endregion
	#region SectionInfo
	[Serializable()]
	public partial class SectionInfo : ItemInfo, IVEDrillDownReadOnly
	{
		public override void SetupTags()
		{
			MyTab = new Tab(ActiveFormat.PlantFormat.FormatData.SectData.SectionNumber.Font);
			string sectTab = GetSectionTab(false);
			_MyTab.Text = sectTab;
			_MyTab.CleanText = sectTab.PadRight(20);
			MyHeader =  new MetaTag(ActiveFormat.PlantFormat.FormatData.SectData.SectionHeader.Font);
			_MyHeader.Text = null;
			MyFooter = null;
			_TagsSetup = true;
		}
		private string GetSectionTab(bool underline)
		{
			if (DisplayNumber == null || DisplayNumber == "" || !IsStepSection) return DisplayNumber;
			if (MyDocStyle.SpecialStepsFoldout) return DisplayNumber;
			if (ActiveFormat.PlantFormat.FormatData.SectData.StepSectionData.StepSectionLayoutData.TieTabToLevel)
			{
				if (underline)
					return @"\ul " + DisplayNumber + @"\ul0 ";
				else
					return DisplayNumber;
			}
			string retStr = null;
			string ch = DisplayNumber != null && DisplayNumber != "" ? DisplayNumber.Substring(0,1) : null;
			int Snum = GetSectionNum();
			if (Snum == -1)
				retStr = ch + ".";
			else {
				string tmp = DisplayNumber.IndexOf(".")>-1?DisplayNumber.Substring(0,DisplayNumber.IndexOf(".")):DisplayNumber;
				if (underline)
			        retStr = @"\ul " + tmp + "." + Snum.ToString() + @"\ul0 ";
			    else
			        retStr = tmp + "." + Snum.ToString();
			}
			return retStr;
		}

		private int GetSectionNum()
		{
			int indx = -1;
			if (DisplayNumber != null && DisplayNumber != "" && (indx = DisplayNumber.IndexOf("."))>-1)
			{
				// if there is a number after the '.', return it as a number.  For example if it is 001, return a 1:
				string tmpstr = indx+1<DisplayNumber.Length?DisplayNumber.Substring(indx+1):null;
				return tmpstr==null?0:System.Convert.ToInt32(tmpstr);
			}
			return (-1);
		}
		public bool TrueSectionNum()
		{
			int indx = DisplayNumber.IndexOf(".");
			if (indx < 0 || indx + 1 == DisplayNumber.Length) return false;
			// for it to be a 'TrueSectionNum', there can be no letters after the '.'
			for (int lindx = indx+1; lindx < DisplayNumber.Length - 1; lindx++) if (DisplayNumber[lindx] < '0' || DisplayNumber[lindx] > '9') return false;
			return true;
		}
		// the following returns the 'index' into the format's CheckOffHeaderList.
		// It returns a -1 if not set or none exist.
		public int CheckOffHeadingIndex()
		{
			if (ActiveFormat.PlantFormat.FormatData.ProcData.CheckOffData.CheckOffHeaderList == null || ActiveFormat.PlantFormat.FormatData.ProcData.CheckOffData.CheckOffHeaderList.Count == 0) return -1;
			SectionConfig sc = MyConfig as SectionConfig;
			if (sc == null) return -1;
			return sc.Section_CheckoffHeaderSelection;
		}
		protected override void RefreshFields(Item tmp)
		{
			base.RefreshFields(tmp);
			ExtensionRefreshFields(tmp);
		}
#if ItemWithContent
		public SectionInfo(SafeDataReader dr) : base(dr, true) { }
#else
		public SectionInfo(SafeDataReader dr) : base(dr) { }
#endif
		private SectionInfo() : base() { ;}
		public new static SectionInfo Get(int itemID)
		{
			//if (!CanGetObject())
			//    throw new System.Security.SecurityException("User not authorized to view a Item");
			try
			{
				SectionInfo tmp = GetCachedByPrimaryKey(itemID) as SectionInfo;
				if (tmp == null)
				{
					tmp = DataPortal.Fetch<SectionInfo>(new PKCriteria(itemID));
					AddToCache(tmp);
				}
				if (tmp.ErrorMessage == "No Record Found") tmp = null;
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on Item.Get", ex);
			}
		}
		public void MoveSection(IVEDrillDownReadOnly pInfo, int index)
		{
			using (Item ii = Item.Get(this.ItemID))
			{
				ii.MoveItem(pInfo, index);
			}
		}
		public new Section Get()
		{
			return (Section)(_Editable = Section.Get(ItemID));
		}

		#region SectionConfig
		[NonSerialized]
		private SectionConfig _SectionConfig;
		public SectionConfig SectionConfig
		{ get { return (_SectionConfig != null ? _SectionConfig : _SectionConfig = new SectionConfig(this)); } }
		#endregion
		public new ConfigDynamicTypeDescriptor MyConfig
		{
			get { return SectionConfig; }
			set { _SectionConfig = null; }
		}
	}
	#endregion
	#region Section
	[Serializable()]
	public partial class Section : Item
	{
		public SectionInfo MySectionInfo /* Return Info version of the current Item */
		{ get { return SectionInfo.Get(ItemID); } }
		public new static Section Get(int itemID)
		{
			if (!CanGetObject())
				throw new System.Security.SecurityException("User not authorized to view a Item");
			try
			{
				Section tmp = GetCachedByPrimaryKey(itemID) as Section;
				if (tmp == null)
				{
					tmp = DataPortal.Fetch<Section>(new PKCriteria(itemID));
					AddToCache(tmp);
				}
				if (tmp.ErrorMessage == "No Record Found") tmp = null;
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on Item.Get", ex);
			}
		}
		public new Section Save()
		{
			return (Section)base.Save();
		}
		public static Section MakeSection(IVEDrillDownReadOnly parentInfo, ItemInfo previousInfo, string sectNumber, string sectTitle, int sectType)
		{
			int newitemid = MakeNewItem(parentInfo, previousInfo, sectNumber, sectTitle, sectType, E_FromType.Section);
			return Section.Get(newitemid);
		}
		#region SectionConfig
		[NonSerialized]
		private SectionConfig _SectionConfig;
		public SectionConfig SectionConfig
		{
			get
			{
				if (_SectionConfig == null)
				{
					_SectionConfig = new SectionConfig(this);
					_SectionConfig.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(_SectionConfig_PropertyChanged);
				}
				return _SectionConfig;
			}
		}
		private void _SectionConfig_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
		{
			MyContent.Config = _SectionConfig.ToString();
			ItemInfo.RefreshConfig(ItemID.ToString());
		}
		#endregion
	}
	#endregion
	#region StepInfo
	[Serializable()]
	public partial class StepInfo : ItemInfo
	{
		#region Tab
		public override void SetupTags()
		{
			_TagsSetup = true;
			MyTab = new Tab(AdjustForTextSubFollowsTextStyle(FormatStepData.TabData.Font));
			MyHeader = new MetaTag(FormatStepData.TabData.Font);
			MyFooter = new MetaTag(FormatStepData.TabData.Font);
			SetTabText();
		}
		
		#endregion
		protected override void RefreshFields(Item tmp)
		{
			base.RefreshFields(tmp);
			ExtensionRefreshFields(tmp);
		}
		//public override string ToString()
		//{
		//  return "Step " + base.ToString();
		//}
#if ItemWithContent
		public StepInfo(SafeDataReader dr) : base(dr, true) { }
#else
		public StepInfo(SafeDataReader dr) : base(dr) { }
#endif
		private StepInfo() : base() { ;}
		public new static StepInfo Get(int itemID)
		{
			//if (!CanGetObject())
			//    throw new System.Security.SecurityException("User not authorized to view a Item");
			try
			{
				StepInfo tmp = GetCachedByPrimaryKey(itemID) as StepInfo;
				if (tmp == null)
				{
					tmp = DataPortal.Fetch<StepInfo>(new PKCriteria(itemID));
					AddToCache(tmp);
				}
				if (tmp.ErrorMessage == "No Record Found") tmp = null;
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on Item.Get", ex);
			}
		}
		public void MoveStep(IVEDrillDownReadOnly pInfo, int index)
		{
			using (Item ii = Item.Get(this.ItemID))
			{
				ii.MoveItem(pInfo, index);
			}
		}
		public new Step Get()
		{
			return (Step)(_Editable = Step.Get(ItemID));
		}
		//public E_FromType FromType
		//{ get { return E_FromType.Step; } }
	}

	#endregion
	#region Step
	[Serializable()]
	public partial class Step : Item
	{
		public new static Step Get(int itemID)
		{
			if (!CanGetObject())
				throw new System.Security.SecurityException("User not authorized to view a Item");
			try
			{
				Step tmp = (Step)GetCachedByPrimaryKey(itemID);
				if (tmp == null)
				{
					tmp = DataPortal.Fetch<Step>(new PKCriteria(itemID));
					AddToCache(tmp);
				}
				if (tmp.ErrorMessage == "No Record Found") tmp = null;
				return tmp;
			}
			catch (Exception ex)
			{
				throw new DbCslaException("Error on Item.Get", ex);
			}
		}
		// TODO :MakeCaution;
		// TODO :MakeNote;
		// TODO :MakeRNO;
		// TODO :MakeSection;
		// TODO :MakeSubStep;
		// TODO :MakeTable;
		public static Step MakeStep(IVEDrillDownReadOnly parentInfo, ItemInfo previousInfo, string stepNumber, string stepTitle, int stepType, E_FromType fromType)
		{
			int newitemid = MakeNewItem(parentInfo, previousInfo, stepNumber, stepTitle, stepType, fromType);
			return Step.Get(newitemid);
		}
		//#region StepConfig
		//[NonSerialized]
		//private StepConfig _StepConfig;
		//public StepConfig StepConfig
		//{
		//  get
		//  {
		//    if (_StepConfig == null)
		//    {
		//      _StepConfig = new StepConfig(this);
		//      _StepConfig.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(_StepConfig_PropertyChanged);
		//    }
		//    return _SectionConfig;
		//  }
		//}
		//private void _StepConfig_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
		//{
		//  MyContent.Config = _StepConfig.ToString();
		//}
		//#endregion
	}
	#endregion
	public enum ItemSearchIncludeLinks
	{
		Nothing = 0,
		Value = 1,
		Everything =2
	}
}